From 7cd5c7bf1ca80bdc3156f8056b8926655d373682 Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Sat, 30 Nov 2019 11:25:07 -0500 Subject: [PATCH 01/20] Add port files for crashrpt --- ports/crashrpt/CONTROL | 4 +++ ports/crashrpt/portfile.cmake | 60 +++++++++++++++++++++++++++++++++++ 2 files changed, 64 insertions(+) create mode 100644 ports/crashrpt/CONTROL create mode 100644 ports/crashrpt/portfile.cmake diff --git a/ports/crashrpt/CONTROL b/ports/crashrpt/CONTROL new file mode 100644 index 00000000000000..ce3eb3af820b0c --- /dev/null +++ b/ports/crashrpt/CONTROL @@ -0,0 +1,4 @@ +Source: crashrpt +Version: 1.4.3 +Description: A crash reporting system for Windows applications +Homepage: http://crashrpt.sourceforge.net/ \ No newline at end of file diff --git a/ports/crashrpt/portfile.cmake b/ports/crashrpt/portfile.cmake new file mode 100644 index 00000000000000..7e525a812faf5d --- /dev/null +++ b/ports/crashrpt/portfile.cmake @@ -0,0 +1,60 @@ +include(vcpkg_common_functions) + +if(NOT VCPKG_TARGET_IS_WINDOWS) + vcpkg_fail_port_install(MESSAGE "${PORT} only supports Windows platform" ALWAYS) +endif() + +vcpkg_from_git( + OUT_SOURCE_PATH SOURCE_PATH + URL https://git.code.sf.net/p/crashrpt/code + REF 4616504670be5a425a525376648d912a72ce18f2 +) + +string(COMPARE EQUAL "${VCPKG_LIBRARY_LINKAGE}" "dynamic" CRASHRPT_BUILD_SHARED_LIBS) +string(COMPARE EQUAL "${VCPKG_CRT_LINKAGE}" "dynamic" CRASHRPT_LINK_CRT_AS_DLL) + +# PREFER_NINJA is not used below since CrashSender fails to build with errors like this one: +# C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Tools\MSVC\14.23.28105\ATLMFC\include\atlconv.h(788): error C2440: 'return': cannot convert from 'LPCTSTR' to 'LPCOLESTR' +vcpkg_configure_cmake( + SOURCE_PATH ${SOURCE_PATH} + # PREFER_NINJA + OPTIONS + -DCRASHRPT_BUILD_SHARED_LIBS=${CRASHRPT_BUILD_SHARED_LIBS} + -DCRASHRPT_LINK_CRT_AS_DLL=${CRASHRPT_LINK_CRT_AS_DLL} +) + +# CrashRpt does not have an install target, so build the two targets that are needed and copy the output +vcpkg_build_cmake(TARGET CrashSender) +vcpkg_build_cmake(TARGET CrashRpt) + +file(INSTALL ${SOURCE_PATH}/include/CrashRpt.h DESTINATION ${CURRENT_PACKAGES_DIR}/include/${PORT}) + +set(DEBUG_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg") +set(RELEASE_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel") + +if(VCPKG_LIBRARY_LINKAGE STREQUAL dynamic) + file(INSTALL ${DEBUG_DIR}/lib/CrashRpt1403d.exp DESTINATION ${CURRENT_PACKAGES_DIR}/debug/lib) + file(INSTALL ${DEBUG_DIR}/lib/CrashRpt1403d.lib DESTINATION ${CURRENT_PACKAGES_DIR}/debug/lib) + file(INSTALL ${DEBUG_DIR}/bin/CrashRpt1403d.dll DESTINATION ${CURRENT_PACKAGES_DIR}/debug/bin) + + file(INSTALL ${RELEASE_DIR}/lib/CrashRpt1403.exp DESTINATION ${CURRENT_PACKAGES_DIR}/lib) + file(INSTALL ${RELEASE_DIR}/lib/CrashRpt1403.lib DESTINATION ${CURRENT_PACKAGES_DIR}/lib) + file(INSTALL ${RELEASE_DIR}/bin/CrashRpt1403.dll DESTINATION ${CURRENT_PACKAGES_DIR}/bin) +else() + file(INSTALL ${DEBUG_DIR}/lib/CrashRptLIBd.lib DESTINATION ${CURRENT_PACKAGES_DIR}/debug/lib) + + file(INSTALL ${RELEASE_DIR}/lib/CrashRptLIB.lib DESTINATION ${CURRENT_PACKAGES_DIR}/lib) +endif() + +file(INSTALL ${DEBUG_DIR}/bin/CrashSender1403d.exe DESTINATION ${CURRENT_PACKAGES_DIR}/debug/tools/${PORT}) +file(INSTALL ${RELEASE_DIR}/bin/CrashSender1403.exe DESTINATION ${CURRENT_PACKAGES_DIR}/tools/${PORT}) +file(GLOB LANG_FILES "${SOURCE_PATH}/lang_files/crashrpt_lang_*.ini") +file(INSTALL ${LANG_FILES} DESTINATION ${CURRENT_PACKAGES_DIR}/tools/${PORT}) +file(INSTALL ${SOURCE_PATH}/thirdparty/dbghelp/bin/dbghelp.dll DESTINATION ${CURRENT_PACKAGES_DIR}/tools/${PORT}) + +vcpkg_copy_tool_dependencies(${CURRENT_PACKAGES_DIR}/debug/tools/${PORT}) +vcpkg_copy_tool_dependencies(${CURRENT_PACKAGES_DIR}/tools/${PORT}) + +vcpkg_copy_pdbs() + +file(INSTALL ${SOURCE_PATH}/License.txt DESTINATION ${CURRENT_PACKAGES_DIR}/share/${PORT} RENAME copyright) From 168bd2a218c81c10c38de67ff09639372eb68806 Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Sat, 30 Nov 2019 18:12:37 -0500 Subject: [PATCH 02/20] Fix x64 output paths and fail port install if architecture is not x86 or x64 --- ports/crashrpt/portfile.cmake | 28 ++++++++++++++++++---------- 1 file changed, 18 insertions(+), 10 deletions(-) diff --git a/ports/crashrpt/portfile.cmake b/ports/crashrpt/portfile.cmake index 7e525a812faf5d..898d85d5d17df1 100644 --- a/ports/crashrpt/portfile.cmake +++ b/ports/crashrpt/portfile.cmake @@ -4,6 +4,14 @@ if(NOT VCPKG_TARGET_IS_WINDOWS) vcpkg_fail_port_install(MESSAGE "${PORT} only supports Windows platform" ALWAYS) endif() +if(VCPKG_TARGET_ARCHITECTURE STREQUAL x86) + set(ARCH_DIR "") +elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL x64) + set(ARCH_DIR "x64/") +else() + vcpkg_fail_port_install(MESSAGE "${PORT} only supports x86 and x64 architectures" ALWAYS) +endif() + vcpkg_from_git( OUT_SOURCE_PATH SOURCE_PATH URL https://git.code.sf.net/p/crashrpt/code @@ -33,21 +41,21 @@ set(DEBUG_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg") set(RELEASE_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel") if(VCPKG_LIBRARY_LINKAGE STREQUAL dynamic) - file(INSTALL ${DEBUG_DIR}/lib/CrashRpt1403d.exp DESTINATION ${CURRENT_PACKAGES_DIR}/debug/lib) - file(INSTALL ${DEBUG_DIR}/lib/CrashRpt1403d.lib DESTINATION ${CURRENT_PACKAGES_DIR}/debug/lib) - file(INSTALL ${DEBUG_DIR}/bin/CrashRpt1403d.dll DESTINATION ${CURRENT_PACKAGES_DIR}/debug/bin) + file(INSTALL ${DEBUG_DIR}/lib/${ARCH_DIR}CrashRpt1403d.exp DESTINATION ${CURRENT_PACKAGES_DIR}/debug/lib) + file(INSTALL ${DEBUG_DIR}/lib/${ARCH_DIR}CrashRpt1403d.lib DESTINATION ${CURRENT_PACKAGES_DIR}/debug/lib) + file(INSTALL ${DEBUG_DIR}/bin/${ARCH_DIR}CrashRpt1403d.dll DESTINATION ${CURRENT_PACKAGES_DIR}/debug/bin) - file(INSTALL ${RELEASE_DIR}/lib/CrashRpt1403.exp DESTINATION ${CURRENT_PACKAGES_DIR}/lib) - file(INSTALL ${RELEASE_DIR}/lib/CrashRpt1403.lib DESTINATION ${CURRENT_PACKAGES_DIR}/lib) - file(INSTALL ${RELEASE_DIR}/bin/CrashRpt1403.dll DESTINATION ${CURRENT_PACKAGES_DIR}/bin) + file(INSTALL ${RELEASE_DIR}/lib/${ARCH_DIR}CrashRpt1403.exp DESTINATION ${CURRENT_PACKAGES_DIR}/lib) + file(INSTALL ${RELEASE_DIR}/lib/${ARCH_DIR}CrashRpt1403.lib DESTINATION ${CURRENT_PACKAGES_DIR}/lib) + file(INSTALL ${RELEASE_DIR}/bin/${ARCH_DIR}CrashRpt1403.dll DESTINATION ${CURRENT_PACKAGES_DIR}/bin) else() - file(INSTALL ${DEBUG_DIR}/lib/CrashRptLIBd.lib DESTINATION ${CURRENT_PACKAGES_DIR}/debug/lib) + file(INSTALL ${DEBUG_DIR}/lib/${ARCH_DIR}CrashRptLIBd.lib DESTINATION ${CURRENT_PACKAGES_DIR}/debug/lib) - file(INSTALL ${RELEASE_DIR}/lib/CrashRptLIB.lib DESTINATION ${CURRENT_PACKAGES_DIR}/lib) + file(INSTALL ${RELEASE_DIR}/lib/${ARCH_DIR}CrashRptLIB.lib DESTINATION ${CURRENT_PACKAGES_DIR}/lib) endif() -file(INSTALL ${DEBUG_DIR}/bin/CrashSender1403d.exe DESTINATION ${CURRENT_PACKAGES_DIR}/debug/tools/${PORT}) -file(INSTALL ${RELEASE_DIR}/bin/CrashSender1403.exe DESTINATION ${CURRENT_PACKAGES_DIR}/tools/${PORT}) +file(INSTALL ${DEBUG_DIR}/bin/${ARCH_DIR}CrashSender1403d.exe DESTINATION ${CURRENT_PACKAGES_DIR}/debug/tools/${PORT}) +file(INSTALL ${RELEASE_DIR}/bin/${ARCH_DIR}CrashSender1403.exe DESTINATION ${CURRENT_PACKAGES_DIR}/tools/${PORT}) file(GLOB LANG_FILES "${SOURCE_PATH}/lang_files/crashrpt_lang_*.ini") file(INSTALL ${LANG_FILES} DESTINATION ${CURRENT_PACKAGES_DIR}/tools/${PORT}) file(INSTALL ${SOURCE_PATH}/thirdparty/dbghelp/bin/dbghelp.dll DESTINATION ${CURRENT_PACKAGES_DIR}/tools/${PORT}) From b15395b8b230594fdc1847a3a5e71037e5ee320b Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Thu, 5 Dec 2019 17:04:30 -0500 Subject: [PATCH 03/20] Use vcpkg_fail_port_install --- ports/crashrpt/portfile.cmake | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/ports/crashrpt/portfile.cmake b/ports/crashrpt/portfile.cmake index 898d85d5d17df1..06f02d90350dfe 100644 --- a/ports/crashrpt/portfile.cmake +++ b/ports/crashrpt/portfile.cmake @@ -1,8 +1,4 @@ -include(vcpkg_common_functions) - -if(NOT VCPKG_TARGET_IS_WINDOWS) - vcpkg_fail_port_install(MESSAGE "${PORT} only supports Windows platform" ALWAYS) -endif() +vcpkg_fail_port_install(ON_TARGET "OSX" "Linux" "UWP") if(VCPKG_TARGET_ARCHITECTURE STREQUAL x86) set(ARCH_DIR "") From d9442fdf6d597bb7a253448e8765b867b584f209 Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Mon, 20 Apr 2020 12:29:54 -0400 Subject: [PATCH 04/20] Add patch for CMakeLists.txt add install target for CrashRpt and CrashSender --- ports/crashrpt/001-cmake-install.patch | 72 ++++++++++++++++++++++++++ ports/crashrpt/portfile.cmake | 40 +++----------- 2 files changed, 80 insertions(+), 32 deletions(-) create mode 100644 ports/crashrpt/001-cmake-install.patch diff --git a/ports/crashrpt/001-cmake-install.patch b/ports/crashrpt/001-cmake-install.patch new file mode 100644 index 00000000000000..af4c605f1f4ffb --- /dev/null +++ b/ports/crashrpt/001-cmake-install.patch @@ -0,0 +1,72 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 44d7df0..e416a74 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -17,6 +17,9 @@ set (CRASHRPT_VER 1403) + # Build options + option(CRASHRPT_BUILD_SHARED_LIBS "If set (default), CrashRpt modules are built as dynamic-link libraries, otherwise as static libs." ON) + option(CRASHRPT_LINK_CRT_AS_DLL "If set (default), CrashRpt modules link C run-time (CRT) as multi-threaded dynamic libraries, otherwise as multi-threaded static libs." ON) ++option(CRASHRPT_BUILD_DEMOS "If set (default), CrashRpt builds the demo projects." ON) ++option(CRASHRPT_BUILD_TESTS "If set (default), CrashRpt builds the test projects." ON) ++option(CRASHRPT_BUILD_PROBE "If set (default), CrashRpt builds the CrashRptProbe projects." ON) + + # Set output directory for executable files + if(CMAKE_CL_64) +@@ -96,17 +99,23 @@ endmacro() + + # Other CMakeLists are located in project subdirectories + ++if(CRASHRPT_BUILD_DEMOS) + add_subdirectory("demos/ConsoleDemo") + add_subdirectory("demos/WTLDemo") + add_subdirectory("demos/MFCDemo") ++endif() + + add_subdirectory("reporting/crashrpt") + add_subdirectory("reporting/crashsender") + ++if(CRASHRPT_BUILD_PROBE) + add_subdirectory("processing/crashrptprobe") + add_subdirectory("processing/crprober") ++endif() + ++if(CRASHRPT_BUILD_TESTS) + add_subdirectory("tests") ++endif() + + # Set output directory for LIB files + if(CMAKE_CL_64) +diff --git a/reporting/crashrpt/CMakeLists.txt b/reporting/crashrpt/CMakeLists.txt +index 42d40e2..a335ca9 100644 +--- a/reporting/crashrpt/CMakeLists.txt ++++ b/reporting/crashrpt/CMakeLists.txt +@@ -55,3 +55,11 @@ else(CRASHRPT_BUILD_SHARED_LIBS) + RELEASE_POSTFIX LIB ) + endif(CRASHRPT_BUILD_SHARED_LIBS) + ++set_target_properties(CrashRpt PROPERTIES PUBLIC_HEADER ${CMAKE_SOURCE_DIR}/include/CrashRpt.h) ++ ++INSTALL(TARGETS CrashRpt ++ PUBLIC_HEADER DESTINATION include/crashrpt ++ LIBRARY ++ ARCHIVE ++ RUNTIME ++) +diff --git a/reporting/crashsender/CMakeLists.txt b/reporting/crashsender/CMakeLists.txt +index 9b444c5..5b4b895 100644 +--- a/reporting/crashsender/CMakeLists.txt ++++ b/reporting/crashsender/CMakeLists.txt +@@ -52,4 +52,11 @@ set_target_properties(CrashRpt PROPERTIES COMPILE_FLAGS "/Os") + + set_target_properties(CrashSender PROPERTIES + DEBUG_POSTFIX ${CRASHRPT_VER}d +- RELEASE_POSTFIX ${CRASHRPT_VER} ) +\ No newline at end of file ++ RELEASE_POSTFIX ${CRASHRPT_VER} ) ++ ++install(TARGETS CrashSender ++ RUNTIME DESTINATION tools/crashrpt ++) ++ ++file(GLOB LANG_FILES "${CMAKE_SOURCE_DIR}/lang_files/crashrpt_lang_*.ini") ++install(FILES ${LANG_FILES} DESTINATION tools/crashrpt) diff --git a/ports/crashrpt/portfile.cmake b/ports/crashrpt/portfile.cmake index 06f02d90350dfe..1a91de8dce4132 100644 --- a/ports/crashrpt/portfile.cmake +++ b/ports/crashrpt/portfile.cmake @@ -12,6 +12,8 @@ vcpkg_from_git( OUT_SOURCE_PATH SOURCE_PATH URL https://git.code.sf.net/p/crashrpt/code REF 4616504670be5a425a525376648d912a72ce18f2 + PATCHES + 001-cmake-install.patch ) string(COMPARE EQUAL "${VCPKG_LIBRARY_LINKAGE}" "dynamic" CRASHRPT_BUILD_SHARED_LIBS) @@ -25,40 +27,14 @@ vcpkg_configure_cmake( OPTIONS -DCRASHRPT_BUILD_SHARED_LIBS=${CRASHRPT_BUILD_SHARED_LIBS} -DCRASHRPT_LINK_CRT_AS_DLL=${CRASHRPT_LINK_CRT_AS_DLL} + -DCRASHRPT_BUILD_DEMOS=OFF + -DCRASHRPT_BUILD_PROBE=OFF + -DCRASHRPT_BUILD_TESTS=OFF ) -# CrashRpt does not have an install target, so build the two targets that are needed and copy the output -vcpkg_build_cmake(TARGET CrashSender) -vcpkg_build_cmake(TARGET CrashRpt) - -file(INSTALL ${SOURCE_PATH}/include/CrashRpt.h DESTINATION ${CURRENT_PACKAGES_DIR}/include/${PORT}) - -set(DEBUG_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg") -set(RELEASE_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel") - -if(VCPKG_LIBRARY_LINKAGE STREQUAL dynamic) - file(INSTALL ${DEBUG_DIR}/lib/${ARCH_DIR}CrashRpt1403d.exp DESTINATION ${CURRENT_PACKAGES_DIR}/debug/lib) - file(INSTALL ${DEBUG_DIR}/lib/${ARCH_DIR}CrashRpt1403d.lib DESTINATION ${CURRENT_PACKAGES_DIR}/debug/lib) - file(INSTALL ${DEBUG_DIR}/bin/${ARCH_DIR}CrashRpt1403d.dll DESTINATION ${CURRENT_PACKAGES_DIR}/debug/bin) - - file(INSTALL ${RELEASE_DIR}/lib/${ARCH_DIR}CrashRpt1403.exp DESTINATION ${CURRENT_PACKAGES_DIR}/lib) - file(INSTALL ${RELEASE_DIR}/lib/${ARCH_DIR}CrashRpt1403.lib DESTINATION ${CURRENT_PACKAGES_DIR}/lib) - file(INSTALL ${RELEASE_DIR}/bin/${ARCH_DIR}CrashRpt1403.dll DESTINATION ${CURRENT_PACKAGES_DIR}/bin) -else() - file(INSTALL ${DEBUG_DIR}/lib/${ARCH_DIR}CrashRptLIBd.lib DESTINATION ${CURRENT_PACKAGES_DIR}/debug/lib) - - file(INSTALL ${RELEASE_DIR}/lib/${ARCH_DIR}CrashRptLIB.lib DESTINATION ${CURRENT_PACKAGES_DIR}/lib) -endif() - -file(INSTALL ${DEBUG_DIR}/bin/${ARCH_DIR}CrashSender1403d.exe DESTINATION ${CURRENT_PACKAGES_DIR}/debug/tools/${PORT}) -file(INSTALL ${RELEASE_DIR}/bin/${ARCH_DIR}CrashSender1403.exe DESTINATION ${CURRENT_PACKAGES_DIR}/tools/${PORT}) -file(GLOB LANG_FILES "${SOURCE_PATH}/lang_files/crashrpt_lang_*.ini") -file(INSTALL ${LANG_FILES} DESTINATION ${CURRENT_PACKAGES_DIR}/tools/${PORT}) -file(INSTALL ${SOURCE_PATH}/thirdparty/dbghelp/bin/dbghelp.dll DESTINATION ${CURRENT_PACKAGES_DIR}/tools/${PORT}) - -vcpkg_copy_tool_dependencies(${CURRENT_PACKAGES_DIR}/debug/tools/${PORT}) -vcpkg_copy_tool_dependencies(${CURRENT_PACKAGES_DIR}/tools/${PORT}) - +vcpkg_install_cmake() vcpkg_copy_pdbs() +file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include") + file(INSTALL ${SOURCE_PATH}/License.txt DESTINATION ${CURRENT_PACKAGES_DIR}/share/${PORT} RENAME copyright) From ddc8c460ddcc00b73f39d7618daca3a76f13a73f Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Thu, 23 Apr 2020 18:31:34 -0400 Subject: [PATCH 05/20] Replace vendored dependencies for minizip, png, and zlib with packages from vcpkg --- ports/crashrpt/001-cmake-install.patch | 39 +- .../crashrpt/002-find-minizip-png-zlib.patch | 59481 ++++++++++++++++ ports/crashrpt/CONTROL | 3 +- ports/crashrpt/portfile.cmake | 9 +- 4 files changed, 59523 insertions(+), 9 deletions(-) create mode 100644 ports/crashrpt/002-find-minizip-png-zlib.patch diff --git a/ports/crashrpt/001-cmake-install.patch b/ports/crashrpt/001-cmake-install.patch index af4c605f1f4ffb..4748fa94129259 100644 --- a/ports/crashrpt/001-cmake-install.patch +++ b/ports/crashrpt/001-cmake-install.patch @@ -1,18 +1,17 @@ diff --git a/CMakeLists.txt b/CMakeLists.txt -index 44d7df0..e416a74 100644 +index 44d7df0..daf8352 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt -@@ -17,6 +17,9 @@ set (CRASHRPT_VER 1403) +@@ -17,6 +17,8 @@ set (CRASHRPT_VER 1403) # Build options option(CRASHRPT_BUILD_SHARED_LIBS "If set (default), CrashRpt modules are built as dynamic-link libraries, otherwise as static libs." ON) option(CRASHRPT_LINK_CRT_AS_DLL "If set (default), CrashRpt modules link C run-time (CRT) as multi-threaded dynamic libraries, otherwise as multi-threaded static libs." ON) +option(CRASHRPT_BUILD_DEMOS "If set (default), CrashRpt builds the demo projects." ON) +option(CRASHRPT_BUILD_TESTS "If set (default), CrashRpt builds the test projects." ON) -+option(CRASHRPT_BUILD_PROBE "If set (default), CrashRpt builds the CrashRptProbe projects." ON) # Set output directory for executable files if(CMAKE_CL_64) -@@ -96,17 +99,23 @@ endmacro() +@@ -96,9 +98,11 @@ endmacro() # Other CMakeLists are located in project subdirectories @@ -24,11 +23,9 @@ index 44d7df0..e416a74 100644 add_subdirectory("reporting/crashrpt") add_subdirectory("reporting/crashsender") - -+if(CRASHRPT_BUILD_PROBE) +@@ -106,7 +110,9 @@ add_subdirectory("reporting/crashsender") add_subdirectory("processing/crashrptprobe") add_subdirectory("processing/crprober") -+endif() +if(CRASHRPT_BUILD_TESTS) add_subdirectory("tests") @@ -36,6 +33,22 @@ index 44d7df0..e416a74 100644 # Set output directory for LIB files if(CMAKE_CL_64) +diff --git a/processing/crashrptprobe/CMakeLists.txt b/processing/crashrptprobe/CMakeLists.txt +index a6c692a..35e06bb 100644 +--- a/processing/crashrptprobe/CMakeLists.txt ++++ b/processing/crashrptprobe/CMakeLists.txt +@@ -58,4 +58,11 @@ else(CRASHRPT_BUILD_SHARED_LIBS) + + endif(CRASHRPT_BUILD_SHARED_LIBS) + ++set_target_properties(CrashRptProbe PROPERTIES PUBLIC_HEADER ${CMAKE_SOURCE_DIR}/include/CrashRptProbe.h) + ++INSTALL(TARGETS CrashRptProbe ++ PUBLIC_HEADER DESTINATION include/crashrpt ++ LIBRARY ++ ARCHIVE ++ RUNTIME ++) diff --git a/reporting/crashrpt/CMakeLists.txt b/reporting/crashrpt/CMakeLists.txt index 42d40e2..a335ca9 100644 --- a/reporting/crashrpt/CMakeLists.txt @@ -70,3 +83,15 @@ index 9b444c5..5b4b895 100644 + +file(GLOB LANG_FILES "${CMAKE_SOURCE_DIR}/lang_files/crashrpt_lang_*.ini") +install(FILES ${LANG_FILES} DESTINATION tools/crashrpt) +diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt +index f7bfede..402b024 100644 +--- a/tests/CMakeLists.txt ++++ b/tests/CMakeLists.txt +@@ -42,3 +42,7 @@ target_link_libraries(Tests CrashRpt CrashRptProbe) + + set_target_properties(Tests PROPERTIES DEBUG_POSTFIX d ) + #set_target_properties(Tests PROPERTIES COMPILE_FLAGS "/Zi" LINK_FLAGS "/DEBUG") ++ ++install(TARGETS Tests ++ RUNTIME DESTINATION tools/crashrpt ++) diff --git a/ports/crashrpt/002-find-minizip-png-zlib.patch b/ports/crashrpt/002-find-minizip-png-zlib.patch new file mode 100644 index 00000000000000..964f26689b68c6 --- /dev/null +++ b/ports/crashrpt/002-find-minizip-png-zlib.patch @@ -0,0 +1,59481 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index daf8352..7a20e49 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -96,6 +96,10 @@ macro(fix_default_compiler_settings_) + + endmacro() + ++find_package(ZLIB REQUIRED) ++find_package(MINIZIP REQUIRED) ++find_package(PNG REQUIRED) ++ + # Other CMakeLists are located in project subdirectories + + if(CRASHRPT_BUILD_DEMOS) +@@ -125,9 +129,9 @@ endif(CMAKE_CL_64) + + add_subdirectory("thirdparty/tinyxml") + add_subdirectory("thirdparty/jpeg") +-add_subdirectory("thirdparty/libpng") +-add_subdirectory("thirdparty/minizip") +-add_subdirectory("thirdparty/zlib") ++#add_subdirectory("thirdparty/libpng") ++#add_subdirectory("thirdparty/minizip") ++#add_subdirectory("thirdparty/zlib") + add_subdirectory("thirdparty/libogg") + add_subdirectory("thirdparty/libtheora") + +diff --git a/processing/crashrptprobe/CMakeLists.txt b/processing/crashrptprobe/CMakeLists.txt +index 35e06bb..4a54302 100644 +--- a/processing/crashrptprobe/CMakeLists.txt ++++ b/processing/crashrptprobe/CMakeLists.txt +@@ -22,8 +22,8 @@ include_directories( ${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/reporting/crashrpt + ${CMAKE_SOURCE_DIR}/reporting/crashsender + ${CMAKE_SOURCE_DIR}/thirdparty/wtl +- ${CMAKE_SOURCE_DIR}/thirdparty/zlib +- ${CMAKE_SOURCE_DIR}/thirdparty/minizip ++ ${ZLIB_INCLUDE_DIRS} ++ ${MINIZIP_INCLUDE_DIR} + ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml + ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include) + +@@ -42,7 +42,7 @@ else(CMAKE_CL_64) + target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/dbghelp.lib) + endif(CMAKE_CL_64) + +-target_link_libraries(CrashRptProbe zlib minizip tinyxml Rpcrt4.lib shell32.lib gdi32.lib version.lib psapi.lib) ++target_link_libraries(CrashRptProbe ZLIB::ZLIB minizip::minizip tinyxml Rpcrt4.lib shell32.lib gdi32.lib version.lib psapi.lib) + + if(CRASHRPT_BUILD_SHARED_LIBS) + +diff --git a/processing/crashrptprobe/CrashRptProbe.cpp b/processing/crashrptprobe/CrashRptProbe.cpp +index 8932c43..fdb8dac 100644 +--- a/processing/crashrptprobe/CrashRptProbe.cpp ++++ b/processing/crashrptprobe/CrashRptProbe.cpp +@@ -22,7 +22,7 @@ be found in the Authors.txt file in the root of the source tree. + #include "md5.h" + #include "Utility.h" + #include "strconv.h" +-#include "unzip.h" ++#include "minizip/unzip.h" + + CComAutoCriticalSection g_crp_cs; // Critical section for thread-safe accessing error messages + std::map g_crp_sErrorMsg; // Last error messages for each calling thread. +diff --git a/reporting/crashsender/CMakeLists.txt b/reporting/crashsender/CMakeLists.txt +index 5b4b895..25cd467 100644 +--- a/reporting/crashsender/CMakeLists.txt ++++ b/reporting/crashsender/CMakeLists.txt +@@ -16,6 +16,7 @@ list(APPEND source_files + + # Define _UNICODE (use wide-char encoding) + add_definitions(-D_UNICODE ) ++add_definitions(${PNG_DEFINITIONS}) + + fix_default_compiler_settings_() + +@@ -23,10 +24,10 @@ fix_default_compiler_settings_() + include_directories( ${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/reporting/CrashRpt + ${CMAKE_SOURCE_DIR}/thirdparty/wtl +- ${CMAKE_SOURCE_DIR}/thirdparty/zlib +- ${CMAKE_SOURCE_DIR}/thirdparty/minizip ++ ${ZLIB_INCLUDE_DIRS} ++ ${MINIZIP_INCLUDE_DIR} + ${CMAKE_SOURCE_DIR}/thirdparty/jpeg +- ${CMAKE_SOURCE_DIR}/thirdparty/libpng ++ ${PNG_INCLUDE_DIRS} + ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml + ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include + ${CMAKE_SOURCE_DIR}/thirdparty/libogg/include +@@ -42,7 +43,7 @@ endif(NOT CMAKE_CL_64) + add_executable(CrashSender WIN32 ${source_files} ${header_files}) + + # Add input link libraries +-target_link_libraries(CrashSender zlib minizip libjpeg libpng tinyxml libogg libtheora WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) ++target_link_libraries(CrashSender ZLIB::ZLIB minizip::minizip libjpeg PNG::PNG tinyxml libogg libtheora WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) + + # Add compiler flags (/MP for multi-processor compilation, /Os to favor small code) + set_target_properties(CrashRpt PROPERTIES COMPILE_FLAGS "/Os") +diff --git a/reporting/crashsender/ErrorReportDlg.cpp b/reporting/crashsender/ErrorReportDlg.cpp +index ab23aa0..d0d6d7f 100644 +--- a/reporting/crashsender/ErrorReportDlg.cpp ++++ b/reporting/crashsender/ErrorReportDlg.cpp +@@ -13,8 +13,8 @@ be found in the Authors.txt file in the root of the source tree. + #include "ErrorReportDlg.h" + #include "Utility.h" + #include "tinyxml.h" +-#include "zip.h" +-#include "unzip.h" ++#include "minizip/zip.h" ++#include "minizip/unzip.h" + #include "CrashInfoReader.h" + #include "strconv.h" + +diff --git a/reporting/crashsender/ErrorReportSender.cpp b/reporting/crashsender/ErrorReportSender.cpp +index ac9603c..369fd4d 100644 +--- a/reporting/crashsender/ErrorReportSender.cpp ++++ b/reporting/crashsender/ErrorReportSender.cpp +@@ -16,7 +16,7 @@ be found in the Authors.txt file in the root of the source tree. + #include "CrashRpt.h" + #include "md5.h" + #include "Utility.h" +-#include "zip.h" ++#include "minizip/zip.h" + #include "CrashInfoReader.h" + #include "strconv.h" + #include "ScreenCap.h" +diff --git a/reporting/crashsender/FilePreviewCtrl.cpp b/reporting/crashsender/FilePreviewCtrl.cpp +index e71aafc..d9f1330 100644 +--- a/reporting/crashsender/FilePreviewCtrl.cpp ++++ b/reporting/crashsender/FilePreviewCtrl.cpp +@@ -365,7 +365,7 @@ BOOL CImage::LoadBitmapFromPNGFile(LPTSTR szFileName) + if (!png_ptr) + goto cleanup; + +- if (setjmp(png_ptr->jmpbuf)) ++ if (setjmp(png_jmpbuf(png_ptr))) + goto cleanup; + + info_ptr = png_create_info_struct(png_ptr); +@@ -389,7 +389,7 @@ BOOL CImage::LoadBitmapFromPNGFile(LPTSTR szFileName) + width = png_get_image_width(png_ptr, info_ptr); + height = png_get_image_height(png_ptr, info_ptr); + +- if(info_ptr->channels==3) ++ if(png_get_channels(png_ptr, info_ptr)==3) + { + png_set_strip_16(png_ptr); + png_set_packing(png_ptr); +@@ -408,14 +408,14 @@ BOOL CImage::LoadBitmapFromPNGFile(LPTSTR szFileName) + pBMI = (BITMAPINFO*)new BYTE[sizeof(BITMAPINFO)+256*4]; + memset(pBMI, 0, sizeof(BITMAPINFO)+256*4); + pBMI->bmiHeader.biSize = sizeof(BITMAPINFO); +- pBMI->bmiHeader.biBitCount = 8*info_ptr->channels; ++ pBMI->bmiHeader.biBitCount = 8*png_get_channels(png_ptr, info_ptr); + pBMI->bmiHeader.biWidth = width; + pBMI->bmiHeader.biHeight = height; + pBMI->bmiHeader.biPlanes = 1; + pBMI->bmiHeader.biCompression = BI_RGB; + pBMI->bmiHeader.biSizeImage = rowbytes*height; + +- if( info_ptr->channels == 1 ) ++ if( png_get_channels(png_ptr, info_ptr) == 1 ) + { + RGBQUAD* palette = pBMI->bmiColors; + +@@ -431,7 +431,7 @@ BOOL CImage::LoadBitmapFromPNGFile(LPTSTR szFileName) + + for(y=height-1; y>=0; y--) + { +- png_read_rows(png_ptr, &row, png_bytepp_NULL, 1); ++ png_read_rows(png_ptr, &row, NULL, 1); + + { + CAutoLock lock(&m_csLock); +diff --git a/reporting/crashsender/ScreenCap.cpp b/reporting/crashsender/ScreenCap.cpp +index c183c19..ca26160 100644 +--- a/reporting/crashsender/ScreenCap.cpp ++++ b/reporting/crashsender/ScreenCap.cpp +@@ -11,6 +11,8 @@ be found in the Authors.txt file in the root of the source tree. + #include "stdafx.h" + #include "ScreenCap.h" + #include "Utility.h" ++#include "zlib.h" ++#include "png.h" + + // Disable warning C4611: interaction between '_setjmp' and C++ object destruction is non-portable + #pragma warning(disable:4611) +diff --git a/thirdparty/libpng/CMakeLists.txt b/thirdparty/libpng/CMakeLists.txt +deleted file mode 100644 +index b358c4e..0000000 +--- a/thirdparty/libpng/CMakeLists.txt ++++ /dev/null +@@ -1,20 +0,0 @@ +-project(libpng) +- +-# Create the list of source files +-aux_source_directory( . source_files ) +- +-# Define _UNICODE (use wide-char encoding) +-add_definitions(-D_UNICODE -D_CRT_SECURE_NO_DEPRECATE /wd4244 /wd4267) +- +-# Add include dir +-include_directories( ${CMAKE_SOURCE_DIR}/thirdparty/zlib ) +- +-fix_default_compiler_settings_() +- +-# Add library build target +-add_library(libpng STATIC ${source_files}) +- +-# Add linker input libraries +-target_link_libraries(libpng zlib) +- +-set_target_properties(libpng PROPERTIES DEBUG_POSTFIX d ) +\ No newline at end of file +diff --git a/thirdparty/libpng/LICENSE b/thirdparty/libpng/LICENSE +deleted file mode 100644 +index 6b81b55..0000000 +--- a/thirdparty/libpng/LICENSE ++++ /dev/null +@@ -1,109 +0,0 @@ +- +-This copy of the libpng notices is provided for your convenience. In case of +-any discrepancy between this copy and the notices in the file png.h that is +-included in the libpng distribution, the latter shall prevail. +- +-COPYRIGHT NOTICE, DISCLAIMER, and LICENSE: +- +-If you modify libpng you may insert additional notices immediately following +-this sentence. +- +-libpng versions 1.2.6, August 15, 2004, through 1.2.24, December 14, 2007, are +-Copyright (c) 2004, 2006-2007 Glenn Randers-Pehrson, and are +-distributed according to the same disclaimer and license as libpng-1.2.5 +-with the following individual added to the list of Contributing Authors +- +- Cosmin Truta +- +-libpng versions 1.0.7, July 1, 2000, through 1.2.5 - October 3, 2002, are +-Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are +-distributed according to the same disclaimer and license as libpng-1.0.6 +-with the following individuals added to the list of Contributing Authors +- +- Simon-Pierre Cadieux +- Eric S. Raymond +- Gilles Vollant +- +-and with the following additions to the disclaimer: +- +- There is no warranty against interference with your enjoyment of the +- library or against infringement. There is no warranty that our +- efforts or the library will fulfill any of your particular purposes +- or needs. This library is provided with all faults, and the entire +- risk of satisfactory quality, performance, accuracy, and effort is with +- the user. +- +-libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are +-Copyright (c) 1998, 1999 Glenn Randers-Pehrson, and are +-distributed according to the same disclaimer and license as libpng-0.96, +-with the following individuals added to the list of Contributing Authors: +- +- Tom Lane +- Glenn Randers-Pehrson +- Willem van Schaik +- +-libpng versions 0.89, June 1996, through 0.96, May 1997, are +-Copyright (c) 1996, 1997 Andreas Dilger +-Distributed according to the same disclaimer and license as libpng-0.88, +-with the following individuals added to the list of Contributing Authors: +- +- John Bowler +- Kevin Bracey +- Sam Bushell +- Magnus Holmgren +- Greg Roelofs +- Tom Tanner +- +-libpng versions 0.5, May 1995, through 0.88, January 1996, are +-Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc. +- +-For the purposes of this copyright and license, "Contributing Authors" +-is defined as the following set of individuals: +- +- Andreas Dilger +- Dave Martindale +- Guy Eric Schalnat +- Paul Schmidt +- Tim Wegner +- +-The PNG Reference Library is supplied "AS IS". The Contributing Authors +-and Group 42, Inc. disclaim all warranties, expressed or implied, +-including, without limitation, the warranties of merchantability and of +-fitness for any purpose. The Contributing Authors and Group 42, Inc. +-assume no liability for direct, indirect, incidental, special, exemplary, +-or consequential damages, which may result from the use of the PNG +-Reference Library, even if advised of the possibility of such damage. +- +-Permission is hereby granted to use, copy, modify, and distribute this +-source code, or portions hereof, for any purpose, without fee, subject +-to the following restrictions: +- +-1. The origin of this source code must not be misrepresented. +- +-2. Altered versions must be plainly marked as such and must not +- be misrepresented as being the original source. +- +-3. This Copyright notice may not be removed or altered from any +- source or altered source distribution. +- +-The Contributing Authors and Group 42, Inc. specifically permit, without +-fee, and encourage the use of this source code as a component to +-supporting the PNG file format in commercial products. If you use this +-source code in a product, acknowledgment is not required but would be +-appreciated. +- +- +-A "png_get_copyright" function is available, for convenient use in "about" +-boxes and the like: +- +- printf("%s",png_get_copyright(NULL)); +- +-Also, the PNG logo (in PNG format, of course) is supplied in the +-files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31). +- +-Libpng is OSI Certified Open Source Software. OSI Certified Open Source is a +-certification mark of the Open Source Initiative. +- +-Glenn Randers-Pehrson +-glennrp at users.sourceforge.net +-December 14, 2007 +diff --git a/thirdparty/libpng/libpng-1.2.24.txt b/thirdparty/libpng/libpng-1.2.24.txt +deleted file mode 100644 +index 5b8dc53..0000000 +--- a/thirdparty/libpng/libpng-1.2.24.txt ++++ /dev/null +@@ -1,2851 +0,0 @@ +-libpng.txt - A description on how to use and modify libpng +- +- libpng version 1.2.24 - December 14, 2007 +- Updated and distributed by Glenn Randers-Pehrson +- +- Copyright (c) 1998-2007 Glenn Randers-Pehrson +- For conditions of distribution and use, see copyright +- notice in png.h. +- +- based on: +- +- libpng 1.0 beta 6 version 0.96 May 28, 1997 +- Updated and distributed by Andreas Dilger +- Copyright (c) 1996, 1997 Andreas Dilger +- +- libpng 1.0 beta 2 - version 0.88 January 26, 1996 +- For conditions of distribution and use, see copyright +- notice in png.h. Copyright (c) 1995, 1996 Guy Eric +- Schalnat, Group 42, Inc. +- +- Updated/rewritten per request in the libpng FAQ +- Copyright (c) 1995, 1996 Frank J. T. Wojcik +- December 18, 1995 & January 20, 1996 +- +-I. Introduction +- +-This file describes how to use and modify the PNG reference library +-(known as libpng) for your own use. There are five sections to this +-file: introduction, structures, reading, writing, and modification and +-configuration notes for various special platforms. In addition to this +-file, example.c is a good starting point for using the library, as +-it is heavily commented and should include everything most people +-will need. We assume that libpng is already installed; see the +-INSTALL file for instructions on how to install libpng. +- +-For examples of libpng usage, see the files "example.c", "pngtest.c", +-and the files in the "contrib" directory, all of which are included in the +-libpng distribution. +- +-Libpng was written as a companion to the PNG specification, as a way +-of reducing the amount of time and effort it takes to support the PNG +-file format in application programs. +- +-The PNG specification (second edition), November 2003, is available as +-a W3C Recommendation and as an ISO Standard (ISO/IEC 15948:2003 (E)) at +- +- +-The PNG-1.0 specification is available +-as RFC 2083 and as a +-W3C Recommendation . Some +-additional chunks are described in the special-purpose public chunks +-documents at . +- +-Other information +-about PNG, and the latest version of libpng, can be found at the PNG home +-page, . +- +-Most users will not have to modify the library significantly; advanced +-users may want to modify it more. All attempts were made to make it as +-complete as possible, while keeping the code easy to understand. +-Currently, this library only supports C. Support for other languages +-is being considered. +- +-Libpng has been designed to handle multiple sessions at one time, +-to be easily modifiable, to be portable to the vast majority of +-machines (ANSI, K&R, 16-, 32-, and 64-bit) available, and to be easy +-to use. The ultimate goal of libpng is to promote the acceptance of +-the PNG file format in whatever way possible. While there is still +-work to be done (see the TODO file), libpng should cover the +-majority of the needs of its users. +- +-Libpng uses zlib for its compression and decompression of PNG files. +-Further information about zlib, and the latest version of zlib, can +-be found at the zlib home page, . +-The zlib compression utility is a general purpose utility that is +-useful for more than PNG files, and can be used without libpng. +-See the documentation delivered with zlib for more details. +-You can usually find the source files for the zlib utility wherever you +-find the libpng source files. +- +-Libpng is thread safe, provided the threads are using different +-instances of the structures. Each thread should have its own +-png_struct and png_info instances, and thus its own image. +-Libpng does not protect itself against two threads using the +-same instance of a structure. +- +-II. Structures +- +-There are two main structures that are important to libpng, png_struct +-and png_info. The first, png_struct, is an internal structure that +-will not, for the most part, be used by a user except as the first +-variable passed to every libpng function call. +- +-The png_info structure is designed to provide information about the +-PNG file. At one time, the fields of png_info were intended to be +-directly accessible to the user. However, this tended to cause problems +-with applications using dynamically loaded libraries, and as a result +-a set of interface functions for png_info (the png_get_*() and png_set_*() +-functions) was developed. The fields of png_info are still available for +-older applications, but it is suggested that applications use the new +-interfaces if at all possible. +- +-Applications that do make direct access to the members of png_struct (except +-for png_ptr->jmpbuf) must be recompiled whenever the library is updated, +-and applications that make direct access to the members of png_info must +-be recompiled if they were compiled or loaded with libpng version 1.0.6, +-in which the members were in a different order. In version 1.0.7, the +-members of the png_info structure reverted to the old order, as they were +-in versions 0.97c through 1.0.5. Starting with version 2.0.0, both +-structures are going to be hidden, and the contents of the structures will +-only be accessible through the png_get/png_set functions. +- +-The png.h header file is an invaluable reference for programming with libpng. +-And while I'm on the topic, make sure you include the libpng header file: +- +-#include +- +-III. Reading +- +-We'll now walk you through the possible functions to call when reading +-in a PNG file sequentially, briefly explaining the syntax and purpose +-of each one. See example.c and png.h for more detail. While +-progressive reading is covered in the next section, you will still +-need some of the functions discussed in this section to read a PNG +-file. +- +-Setup +- +-You will want to do the I/O initialization(*) before you get into libpng, +-so if it doesn't work, you don't have much to undo. Of course, you +-will also want to insure that you are, in fact, dealing with a PNG +-file. Libpng provides a simple check to see if a file is a PNG file. +-To use it, pass in the first 1 to 8 bytes of the file to the function +-png_sig_cmp(), and it will return 0 if the bytes match the corresponding +-bytes of the PNG signature, or nonzero otherwise. Of course, the more bytes +-you pass in, the greater the accuracy of the prediction. +- +-If you are intending to keep the file pointer open for use in libpng, +-you must ensure you don't read more than 8 bytes from the beginning +-of the file, and you also have to make a call to png_set_sig_bytes_read() +-with the number of bytes you read from the beginning. Libpng will +-then only check the bytes (if any) that your program didn't read. +- +-(*): If you are not using the standard I/O functions, you will need +-to replace them with custom functions. See the discussion under +-Customizing libpng. +- +- +- FILE *fp = fopen(file_name, "rb"); +- if (!fp) +- { +- return (ERROR); +- } +- fread(header, 1, number, fp); +- is_png = !png_sig_cmp(header, 0, number); +- if (!is_png) +- { +- return (NOT_PNG); +- } +- +- +-Next, png_struct and png_info need to be allocated and initialized. In +-order to ensure that the size of these structures is correct even with a +-dynamically linked libpng, there are functions to initialize and +-allocate the structures. We also pass the library version, optional +-pointers to error handling functions, and a pointer to a data struct for +-use by the error functions, if necessary (the pointer and functions can +-be NULL if the default error handlers are to be used). See the section +-on Changes to Libpng below regarding the old initialization functions. +-The structure allocation functions quietly return NULL if they fail to +-create the structure, so your application should check for that. +- +- png_structp png_ptr = png_create_read_struct +- (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, +- user_error_fn, user_warning_fn); +- if (!png_ptr) +- return (ERROR); +- +- png_infop info_ptr = png_create_info_struct(png_ptr); +- if (!info_ptr) +- { +- png_destroy_read_struct(&png_ptr, +- (png_infopp)NULL, (png_infopp)NULL); +- return (ERROR); +- } +- +- png_infop end_info = png_create_info_struct(png_ptr); +- if (!end_info) +- { +- png_destroy_read_struct(&png_ptr, &info_ptr, +- (png_infopp)NULL); +- return (ERROR); +- } +- +-If you want to use your own memory allocation routines, +-define PNG_USER_MEM_SUPPORTED and use +-png_create_read_struct_2() instead of png_create_read_struct(): +- +- png_structp png_ptr = png_create_read_struct_2 +- (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, +- user_error_fn, user_warning_fn, (png_voidp) +- user_mem_ptr, user_malloc_fn, user_free_fn); +- +-The error handling routines passed to png_create_read_struct() +-and the memory alloc/free routines passed to png_create_struct_2() +-are only necessary if you are not using the libpng supplied error +-handling and memory alloc/free functions. +- +-When libpng encounters an error, it expects to longjmp back +-to your routine. Therefore, you will need to call setjmp and pass +-your png_jmpbuf(png_ptr). If you read the file from different +-routines, you will need to update the jmpbuf field every time you enter +-a new routine that will call a png_*() function. +- +-See your documentation of setjmp/longjmp for your compiler for more +-information on setjmp/longjmp. See the discussion on libpng error +-handling in the Customizing Libpng section below for more information +-on the libpng error handling. If an error occurs, and libpng longjmp's +-back to your setjmp, you will want to call png_destroy_read_struct() to +-free any memory. +- +- if (setjmp(png_jmpbuf(png_ptr))) +- { +- png_destroy_read_struct(&png_ptr, &info_ptr, +- &end_info); +- fclose(fp); +- return (ERROR); +- } +- +-If you would rather avoid the complexity of setjmp/longjmp issues, +-you can compile libpng with PNG_SETJMP_NOT_SUPPORTED, in which case +-errors will result in a call to PNG_ABORT() which defaults to abort(). +- +-Now you need to set up the input code. The default for libpng is to +-use the C function fread(). If you use this, you will need to pass a +-valid FILE * in the function png_init_io(). Be sure that the file is +-opened in binary mode. If you wish to handle reading data in another +-way, you need not call the png_init_io() function, but you must then +-implement the libpng I/O methods discussed in the Customizing Libpng +-section below. +- +- png_init_io(png_ptr, fp); +- +-If you had previously opened the file and read any of the signature from +-the beginning in order to see if this was a PNG file, you need to let +-libpng know that there are some bytes missing from the start of the file. +- +- png_set_sig_bytes(png_ptr, number); +- +-Setting up callback code +- +-You can set up a callback function to handle any unknown chunks in the +-input stream. You must supply the function +- +- read_chunk_callback(png_ptr ptr, +- png_unknown_chunkp chunk); +- { +- /* The unknown chunk structure contains your +- chunk data: */ +- png_byte name[5]; +- png_byte *data; +- png_size_t size; +- /* Note that libpng has already taken care of +- the CRC handling */ +- +- /* put your code here. Return one of the +- following: */ +- +- return (-n); /* chunk had an error */ +- return (0); /* did not recognize */ +- return (n); /* success */ +- } +- +-(You can give your function another name that you like instead of +-"read_chunk_callback") +- +-To inform libpng about your function, use +- +- png_set_read_user_chunk_fn(png_ptr, user_chunk_ptr, +- read_chunk_callback); +- +-This names not only the callback function, but also a user pointer that +-you can retrieve with +- +- png_get_user_chunk_ptr(png_ptr); +- +-At this point, you can set up a callback function that will be +-called after each row has been read, which you can use to control +-a progress meter or the like. It's demonstrated in pngtest.c. +-You must supply a function +- +- void read_row_callback(png_ptr ptr, png_uint_32 row, +- int pass); +- { +- /* put your code here */ +- } +- +-(You can give it another name that you like instead of "read_row_callback") +- +-To inform libpng about your function, use +- +- png_set_read_status_fn(png_ptr, read_row_callback); +- +-Width and height limits +- +-The PNG specification allows the width and height of an image to be as +-large as 2^31-1 (0x7fffffff), or about 2.147 billion rows and columns. +-Since very few applications really need to process such large images, +-we have imposed an arbitrary 1-million limit on rows and columns. +-Larger images will be rejected immediately with a png_error() call. If +-you wish to override this limit, you can use +- +- png_set_user_limits(png_ptr, width_max, height_max); +- +-to set your own limits, or use width_max = height_max = 0x7fffffffL +-to allow all valid dimensions (libpng may reject some very large images +-anyway because of potential buffer overflow conditions). +- +-You should put this statement after you create the PNG structure and +-before calling png_read_info(), png_read_png(), or png_process_data(). +-If you need to retrieve the limits that are being applied, use +- +- width_max = png_get_user_width_max(png_ptr); +- height_max = png_get_user_height_max(png_ptr); +- +-Unknown-chunk handling +- +-Now you get to set the way the library processes unknown chunks in the +-input PNG stream. Both known and unknown chunks will be read. Normal +-behavior is that known chunks will be parsed into information in +-various info_ptr members; unknown chunks will be discarded. To change +-this, you can call: +- +- png_set_keep_unknown_chunks(png_ptr, keep, +- chunk_list, num_chunks); +- keep - 0: do not handle as unknown +- 1: do not keep +- 2: keep only if safe-to-copy +- 3: keep even if unsafe-to-copy +- You can use these definitions: +- PNG_HANDLE_CHUNK_AS_DEFAULT 0 +- PNG_HANDLE_CHUNK_NEVER 1 +- PNG_HANDLE_CHUNK_IF_SAFE 2 +- PNG_HANDLE_CHUNK_ALWAYS 3 +- chunk_list - list of chunks affected (a byte string, +- five bytes per chunk, NULL or '\0' if +- num_chunks is 0) +- num_chunks - number of chunks affected; if 0, all +- unknown chunks are affected. If nonzero, +- only the chunks in the list are affected +- +-Unknown chunks declared in this way will be saved as raw data onto a +-list of png_unknown_chunk structures. If a chunk that is normally +-known to libpng is named in the list, it will be handled as unknown, +-according to the "keep" directive. If a chunk is named in successive +-instances of png_set_keep_unknown_chunks(), the final instance will +-take precedence. The IHDR and IEND chunks should not be named in +-chunk_list; if they are, libpng will process them normally anyway. +- +-The high-level read interface +- +-At this point there are two ways to proceed; through the high-level +-read interface, or through a sequence of low-level read operations. +-You can use the high-level interface if (a) you are willing to read +-the entire image into memory, and (b) the input transformations +-you want to do are limited to the following set: +- +- PNG_TRANSFORM_IDENTITY No transformation +- PNG_TRANSFORM_STRIP_16 Strip 16-bit samples to +- 8 bits +- PNG_TRANSFORM_STRIP_ALPHA Discard the alpha channel +- PNG_TRANSFORM_PACKING Expand 1, 2 and 4-bit +- samples to bytes +- PNG_TRANSFORM_PACKSWAP Change order of packed +- pixels to LSB first +- PNG_TRANSFORM_EXPAND Perform set_expand() +- PNG_TRANSFORM_INVERT_MONO Invert monochrome images +- PNG_TRANSFORM_SHIFT Normalize pixels to the +- sBIT depth +- PNG_TRANSFORM_BGR Flip RGB to BGR, RGBA +- to BGRA +- PNG_TRANSFORM_SWAP_ALPHA Flip RGBA to ARGB or GA +- to AG +- PNG_TRANSFORM_INVERT_ALPHA Change alpha from opacity +- to transparency +- PNG_TRANSFORM_SWAP_ENDIAN Byte-swap 16-bit samples +- +-(This excludes setting a background color, doing gamma transformation, +-dithering, and setting filler.) If this is the case, simply do this: +- +- png_read_png(png_ptr, info_ptr, png_transforms, NULL) +- +-where png_transforms is an integer containing the bitwise OR of +-some set of transformation flags. This call is equivalent to png_read_info(), +-followed the set of transformations indicated by the transform mask, +-then png_read_image(), and finally png_read_end(). +- +-(The final parameter of this call is not yet used. Someday it might point +-to transformation parameters required by some future input transform.) +- +-You must use png_transforms and not call any png_set_transform() functions +-when you use png_read_png(). +- +-After you have called png_read_png(), you can retrieve the image data +-with +- +- row_pointers = png_get_rows(png_ptr, info_ptr); +- +-where row_pointers is an array of pointers to the pixel data for each row: +- +- png_bytep row_pointers[height]; +- +-If you know your image size and pixel size ahead of time, you can allocate +-row_pointers prior to calling png_read_png() with +- +- if (height > PNG_UINT_32_MAX/png_sizeof(png_byte)) +- png_error (png_ptr, +- "Image is too tall to process in memory"); +- if (width > PNG_UINT_32_MAX/pixel_size) +- png_error (png_ptr, +- "Image is too wide to process in memory"); +- row_pointers = png_malloc(png_ptr, +- height*png_sizeof(png_bytep)); +- for (int i=0; i) and +-png_get_(png_ptr, info_ptr, ...) functions return non-zero if the +-data has been read, or zero if it is missing. The parameters to the +-png_get_ are set directly if they are simple data types, or a pointer +-into the info_ptr is returned for any complex types. +- +- png_get_PLTE(png_ptr, info_ptr, &palette, +- &num_palette); +- palette - the palette for the file +- (array of png_color) +- num_palette - number of entries in the palette +- +- png_get_gAMA(png_ptr, info_ptr, &gamma); +- gamma - the gamma the file is written +- at (PNG_INFO_gAMA) +- +- png_get_sRGB(png_ptr, info_ptr, &srgb_intent); +- srgb_intent - the rendering intent (PNG_INFO_sRGB) +- The presence of the sRGB chunk +- means that the pixel data is in the +- sRGB color space. This chunk also +- implies specific values of gAMA and +- cHRM. +- +- png_get_iCCP(png_ptr, info_ptr, &name, +- &compression_type, &profile, &proflen); +- name - The profile name. +- compression - The compression type; always +- PNG_COMPRESSION_TYPE_BASE for PNG 1.0. +- You may give NULL to this argument to +- ignore it. +- profile - International Color Consortium color +- profile data. May contain NULs. +- proflen - length of profile data in bytes. +- +- png_get_sBIT(png_ptr, info_ptr, &sig_bit); +- sig_bit - the number of significant bits for +- (PNG_INFO_sBIT) each of the gray, +- red, green, and blue channels, +- whichever are appropriate for the +- given color type (png_color_16) +- +- png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, +- &trans_values); +- trans - array of transparent entries for +- palette (PNG_INFO_tRNS) +- trans_values - graylevel or color sample values of +- the single transparent color for +- non-paletted images (PNG_INFO_tRNS) +- num_trans - number of transparent entries +- (PNG_INFO_tRNS) +- +- png_get_hIST(png_ptr, info_ptr, &hist); +- (PNG_INFO_hIST) +- hist - histogram of palette (array of +- png_uint_16) +- +- png_get_tIME(png_ptr, info_ptr, &mod_time); +- mod_time - time image was last modified +- (PNG_VALID_tIME) +- +- png_get_bKGD(png_ptr, info_ptr, &background); +- background - background color (PNG_VALID_bKGD) +- valid 16-bit red, green and blue +- values, regardless of color_type +- +- num_comments = png_get_text(png_ptr, info_ptr, +- &text_ptr, &num_text); +- num_comments - number of comments +- text_ptr - array of png_text holding image +- comments +- text_ptr[i].compression - type of compression used +- on "text" PNG_TEXT_COMPRESSION_NONE +- PNG_TEXT_COMPRESSION_zTXt +- PNG_ITXT_COMPRESSION_NONE +- PNG_ITXT_COMPRESSION_zTXt +- text_ptr[i].key - keyword for comment. Must contain +- 1-79 characters. +- text_ptr[i].text - text comments for current +- keyword. Can be empty. +- text_ptr[i].text_length - length of text string, +- after decompression, 0 for iTXt +- text_ptr[i].itxt_length - length of itxt string, +- after decompression, 0 for tEXt/zTXt +- text_ptr[i].lang - language of comment (empty +- string for unknown). +- text_ptr[i].lang_key - keyword in UTF-8 +- (empty string for unknown). +- num_text - number of comments (same as +- num_comments; you can put NULL here +- to avoid the duplication) +- Note while png_set_text() will accept text, language, +- and translated keywords that can be NULL pointers, the +- structure returned by png_get_text will always contain +- regular zero-terminated C strings. They might be +- empty strings but they will never be NULL pointers. +- +- num_spalettes = png_get_sPLT(png_ptr, info_ptr, +- &palette_ptr); +- palette_ptr - array of palette structures holding +- contents of one or more sPLT chunks +- read. +- num_spalettes - number of sPLT chunks read. +- +- png_get_oFFs(png_ptr, info_ptr, &offset_x, &offset_y, +- &unit_type); +- offset_x - positive offset from the left edge +- of the screen +- offset_y - positive offset from the top edge +- of the screen +- unit_type - PNG_OFFSET_PIXEL, PNG_OFFSET_MICROMETER +- +- png_get_pHYs(png_ptr, info_ptr, &res_x, &res_y, +- &unit_type); +- res_x - pixels/unit physical resolution in +- x direction +- res_y - pixels/unit physical resolution in +- x direction +- unit_type - PNG_RESOLUTION_UNKNOWN, +- PNG_RESOLUTION_METER +- +- png_get_sCAL(png_ptr, info_ptr, &unit, &width, +- &height) +- unit - physical scale units (an integer) +- width - width of a pixel in physical scale units +- height - height of a pixel in physical scale units +- (width and height are doubles) +- +- png_get_sCAL_s(png_ptr, info_ptr, &unit, &width, +- &height) +- unit - physical scale units (an integer) +- width - width of a pixel in physical scale units +- height - height of a pixel in physical scale units +- (width and height are strings like "2.54") +- +- num_unknown_chunks = png_get_unknown_chunks(png_ptr, +- info_ptr, &unknowns) +- unknowns - array of png_unknown_chunk +- structures holding unknown chunks +- unknowns[i].name - name of unknown chunk +- unknowns[i].data - data of unknown chunk +- unknowns[i].size - size of unknown chunk's data +- unknowns[i].location - position of chunk in file +- +- The value of "i" corresponds to the order in which the +- chunks were read from the PNG file or inserted with the +- png_set_unknown_chunks() function. +- +-The data from the pHYs chunk can be retrieved in several convenient +-forms: +- +- res_x = png_get_x_pixels_per_meter(png_ptr, +- info_ptr) +- res_y = png_get_y_pixels_per_meter(png_ptr, +- info_ptr) +- res_x_and_y = png_get_pixels_per_meter(png_ptr, +- info_ptr) +- res_x = png_get_x_pixels_per_inch(png_ptr, +- info_ptr) +- res_y = png_get_y_pixels_per_inch(png_ptr, +- info_ptr) +- res_x_and_y = png_get_pixels_per_inch(png_ptr, +- info_ptr) +- aspect_ratio = png_get_pixel_aspect_ratio(png_ptr, +- info_ptr) +- +- (Each of these returns 0 [signifying "unknown"] if +- the data is not present or if res_x is 0; +- res_x_and_y is 0 if res_x != res_y) +- +-The data from the oFFs chunk can be retrieved in several convenient +-forms: +- +- x_offset = png_get_x_offset_microns(png_ptr, info_ptr); +- y_offset = png_get_y_offset_microns(png_ptr, info_ptr); +- x_offset = png_get_x_offset_inches(png_ptr, info_ptr); +- y_offset = png_get_y_offset_inches(png_ptr, info_ptr); +- +- (Each of these returns 0 [signifying "unknown" if both +- x and y are 0] if the data is not present or if the +- chunk is present but the unit is the pixel) +- +-For more information, see the png_info definition in png.h and the +-PNG specification for chunk contents. Be careful with trusting +-rowbytes, as some of the transformations could increase the space +-needed to hold a row (expand, filler, gray_to_rgb, etc.). +-See png_read_update_info(), below. +- +-A quick word about text_ptr and num_text. PNG stores comments in +-keyword/text pairs, one pair per chunk, with no limit on the number +-of text chunks, and a 2^31 byte limit on their size. While there are +-suggested keywords, there is no requirement to restrict the use to these +-strings. It is strongly suggested that keywords and text be sensible +-to humans (that's the point), so don't use abbreviations. Non-printing +-symbols are not allowed. See the PNG specification for more details. +-There is also no requirement to have text after the keyword. +- +-Keywords should be limited to 79 Latin-1 characters without leading or +-trailing spaces, but non-consecutive spaces are allowed within the +-keyword. It is possible to have the same keyword any number of times. +-The text_ptr is an array of png_text structures, each holding a +-pointer to a language string, a pointer to a keyword and a pointer to +-a text string. The text string, language code, and translated +-keyword may be empty or NULL pointers. The keyword/text +-pairs are put into the array in the order that they are received. +-However, some or all of the text chunks may be after the image, so, to +-make sure you have read all the text chunks, don't mess with these +-until after you read the stuff after the image. This will be +-mentioned again below in the discussion that goes with png_read_end(). +- +-Input transformations +- +-After you've read the header information, you can set up the library +-to handle any special transformations of the image data. The various +-ways to transform the data will be described in the order that they +-should occur. This is important, as some of these change the color +-type and/or bit depth of the data, and some others only work on +-certain color types and bit depths. Even though each transformation +-checks to see if it has data that it can do something with, you should +-make sure to only enable a transformation if it will be valid for the +-data. For example, don't swap red and blue on grayscale data. +- +-The colors used for the background and transparency values should be +-supplied in the same format/depth as the current image data. They +-are stored in the same format/depth as the image data in a bKGD or tRNS +-chunk, so this is what libpng expects for this data. The colors are +-transformed to keep in sync with the image data when an application +-calls the png_read_update_info() routine (see below). +- +-Data will be decoded into the supplied row buffers packed into bytes +-unless the library has been told to transform it into another format. +-For example, 4 bit/pixel paletted or grayscale data will be returned +-2 pixels/byte with the leftmost pixel in the high-order bits of the +-byte, unless png_set_packing() is called. 8-bit RGB data will be stored +-in RGB RGB RGB format unless png_set_filler() or png_set_add_alpha() +-is called to insert filler bytes, either before or after each RGB triplet. +-16-bit RGB data will be returned RRGGBB RRGGBB, with the most significant +-byte of the color value first, unless png_set_strip_16() is called to +-transform it to regular RGB RGB triplets, or png_set_filler() or +-png_set_add alpha() is called to insert filler bytes, either before or +-after each RRGGBB triplet. Similarly, 8-bit or 16-bit grayscale data can +-be modified with +-png_set_filler(), png_set_add_alpha(), or png_set_strip_16(). +- +-The following code transforms grayscale images of less than 8 to 8 bits, +-changes paletted images to RGB, and adds a full alpha channel if there is +-transparency information in a tRNS chunk. This is most useful on +-grayscale images with bit depths of 2 or 4 or if there is a multiple-image +-viewing application that wishes to treat all images in the same way. +- +- if (color_type == PNG_COLOR_TYPE_PALETTE) +- png_set_palette_to_rgb(png_ptr); +- +- if (color_type == PNG_COLOR_TYPE_GRAY && +- bit_depth < 8) png_set_expand_gray_1_2_4_to_8(png_ptr); +- +- if (png_get_valid(png_ptr, info_ptr, +- PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png_ptr); +- +-These three functions are actually aliases for png_set_expand(), added +-in libpng version 1.0.4, with the function names expanded to improve code +-readability. In some future version they may actually do different +-things. +- +-As of libpng version 1.2.9, png_set_expand_gray_1_2_4_to_8() was +-added. It expands the sample depth without changing tRNS to alpha. +-At the same time, png_set_gray_1_2_4_to_8() was deprecated, and it +-will be removed from a future version. +- +-PNG can have files with 16 bits per channel. If you only can handle +-8 bits per channel, this will strip the pixels down to 8 bit. +- +- if (bit_depth == 16) +- png_set_strip_16(png_ptr); +- +-If, for some reason, you don't need the alpha channel on an image, +-and you want to remove it rather than combining it with the background +-(but the image author certainly had in mind that you *would* combine +-it with the background, so that's what you should probably do): +- +- if (color_type & PNG_COLOR_MASK_ALPHA) +- png_set_strip_alpha(png_ptr); +- +-In PNG files, the alpha channel in an image +-is the level of opacity. If you need the alpha channel in an image to +-be the level of transparency instead of opacity, you can invert the +-alpha channel (or the tRNS chunk data) after it's read, so that 0 is +-fully opaque and 255 (in 8-bit or paletted images) or 65535 (in 16-bit +-images) is fully transparent, with +- +- png_set_invert_alpha(png_ptr); +- +-PNG files pack pixels of bit depths 1, 2, and 4 into bytes as small as +-they can, resulting in, for example, 8 pixels per byte for 1 bit +-files. This code expands to 1 pixel per byte without changing the +-values of the pixels: +- +- if (bit_depth < 8) +- png_set_packing(png_ptr); +- +-PNG files have possible bit depths of 1, 2, 4, 8, and 16. All pixels +-stored in a PNG image have been "scaled" or "shifted" up to the next +-higher possible bit depth (e.g. from 5 bits/sample in the range [0,31] to +-8 bits/sample in the range [0, 255]). However, it is also possible to +-convert the PNG pixel data back to the original bit depth of the image. +-This call reduces the pixels back down to the original bit depth: +- +- png_color_8p sig_bit; +- +- if (png_get_sBIT(png_ptr, info_ptr, &sig_bit)) +- png_set_shift(png_ptr, sig_bit); +- +-PNG files store 3-color pixels in red, green, blue order. This code +-changes the storage of the pixels to blue, green, red: +- +- if (color_type == PNG_COLOR_TYPE_RGB || +- color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- png_set_bgr(png_ptr); +- +-PNG files store RGB pixels packed into 3 or 6 bytes. This code expands them +-into 4 or 8 bytes for windowing systems that need them in this format: +- +- if (color_type == PNG_COLOR_TYPE_RGB) +- png_set_filler(png_ptr, filler, PNG_FILLER_BEFORE); +- +-where "filler" is the 8 or 16-bit number to fill with, and the location is +-either PNG_FILLER_BEFORE or PNG_FILLER_AFTER, depending upon whether +-you want the filler before the RGB or after. This transformation +-does not affect images that already have full alpha channels. To add an +-opaque alpha channel, use filler=0xff or 0xffff and PNG_FILLER_AFTER which +-will generate RGBA pixels. +- +-Note that png_set_filler() does not change the color type. If you want +-to do that, you can add a true alpha channel with +- +- if (color_type == PNG_COLOR_TYPE_RGB || +- color_type == PNG_COLOR_TYPE_GRAY) +- png_set_add_alpha(png_ptr, filler, PNG_FILLER_AFTER); +- +-where "filler" contains the alpha value to assign to each pixel. +-This function was added in libpng-1.2.7. +- +-If you are reading an image with an alpha channel, and you need the +-data as ARGB instead of the normal PNG format RGBA: +- +- if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- png_set_swap_alpha(png_ptr); +- +-For some uses, you may want a grayscale image to be represented as +-RGB. This code will do that conversion: +- +- if (color_type == PNG_COLOR_TYPE_GRAY || +- color_type == PNG_COLOR_TYPE_GRAY_ALPHA) +- png_set_gray_to_rgb(png_ptr); +- +-Conversely, you can convert an RGB or RGBA image to grayscale or grayscale +-with alpha. +- +- if (color_type == PNG_COLOR_TYPE_RGB || +- color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- png_set_rgb_to_gray_fixed(png_ptr, error_action, +- int red_weight, int green_weight); +- +- error_action = 1: silently do the conversion +- error_action = 2: issue a warning if the original +- image has any pixel where +- red != green or red != blue +- error_action = 3: issue an error and abort the +- conversion if the original +- image has any pixel where +- red != green or red != blue +- +- red_weight: weight of red component times 100000 +- green_weight: weight of green component times 100000 +- If either weight is negative, default +- weights (21268, 71514) are used. +- +-If you have set error_action = 1 or 2, you can +-later check whether the image really was gray, after processing +-the image rows, with the png_get_rgb_to_gray_status(png_ptr) function. +-It will return a png_byte that is zero if the image was gray or +-1 if there were any non-gray pixels. bKGD and sBIT data +-will be silently converted to grayscale, using the green channel +-data, regardless of the error_action setting. +- +-With red_weight+green_weight<=100000, +-the normalized graylevel is computed: +- +- int rw = red_weight * 65536; +- int gw = green_weight * 65536; +- int bw = 65536 - (rw + gw); +- gray = (rw*red + gw*green + bw*blue)/65536; +- +-The default values approximate those recommended in the Charles +-Poynton's Color FAQ, +-Copyright (c) 1998-01-04 Charles Poynton +- +- Y = 0.212671 * R + 0.715160 * G + 0.072169 * B +- +-Libpng approximates this with +- +- Y = 0.21268 * R + 0.7151 * G + 0.07217 * B +- +-which can be expressed with integers as +- +- Y = (6969 * R + 23434 * G + 2365 * B)/32768 +- +-The calculation is done in a linear colorspace, if the image gamma +-is known. +- +-If you have a grayscale and you are using png_set_expand_depth(), +-png_set_expand(), or png_set_gray_to_rgb to change to truecolor or to +-a higher bit-depth, you must either supply the background color as a gray +-value at the original file bit-depth (need_expand = 1) or else supply the +-background color as an RGB triplet at the final, expanded bit depth +-(need_expand = 0). Similarly, if you are reading a paletted image, you +-must either supply the background color as a palette index (need_expand = 1) +-or as an RGB triplet that may or may not be in the palette (need_expand = 0). +- +- png_color_16 my_background; +- png_color_16p image_background; +- +- if (png_get_bKGD(png_ptr, info_ptr, &image_background)) +- png_set_background(png_ptr, image_background, +- PNG_BACKGROUND_GAMMA_FILE, 1, 1.0); +- else +- png_set_background(png_ptr, &my_background, +- PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0); +- +-The png_set_background() function tells libpng to composite images +-with alpha or simple transparency against the supplied background +-color. If the PNG file contains a bKGD chunk (PNG_INFO_bKGD valid), +-you may use this color, or supply another color more suitable for +-the current display (e.g., the background color from a web page). You +-need to tell libpng whether the color is in the gamma space of the +-display (PNG_BACKGROUND_GAMMA_SCREEN for colors you supply), the file +-(PNG_BACKGROUND_GAMMA_FILE for colors from the bKGD chunk), or one +-that is neither of these gammas (PNG_BACKGROUND_GAMMA_UNIQUE - I don't +-know why anyone would use this, but it's here). +- +-To properly display PNG images on any kind of system, the application needs +-to know what the display gamma is. Ideally, the user will know this, and +-the application will allow them to set it. One method of allowing the user +-to set the display gamma separately for each system is to check for a +-SCREEN_GAMMA or DISPLAY_GAMMA environment variable, which will hopefully be +-correctly set. +- +-Note that display_gamma is the overall gamma correction required to produce +-pleasing results, which depends on the lighting conditions in the surrounding +-environment. In a dim or brightly lit room, no compensation other than +-the physical gamma exponent of the monitor is needed, while in a dark room +-a slightly smaller exponent is better. +- +- double gamma, screen_gamma; +- +- if (/* We have a user-defined screen +- gamma value */) +- { +- screen_gamma = user_defined_screen_gamma; +- } +- /* One way that applications can share the same +- screen gamma value */ +- else if ((gamma_str = getenv("SCREEN_GAMMA")) +- != NULL) +- { +- screen_gamma = (double)atof(gamma_str); +- } +- /* If we don't have another value */ +- else +- { +- screen_gamma = 2.2; /* A good guess for a +- PC monitor in a bright office or a dim room */ +- screen_gamma = 2.0; /* A good guess for a +- PC monitor in a dark room */ +- screen_gamma = 1.7 or 1.0; /* A good +- guess for Mac systems */ +- } +- +-The png_set_gamma() function handles gamma transformations of the data. +-Pass both the file gamma and the current screen_gamma. If the file does +-not have a gamma value, you can pass one anyway if you have an idea what +-it is (usually 0.45455 is a good guess for GIF images on PCs). Note +-that file gammas are inverted from screen gammas. See the discussions +-on gamma in the PNG specification for an excellent description of what +-gamma is, and why all applications should support it. It is strongly +-recommended that PNG viewers support gamma correction. +- +- if (png_get_gAMA(png_ptr, info_ptr, &gamma)) +- png_set_gamma(png_ptr, screen_gamma, gamma); +- else +- png_set_gamma(png_ptr, screen_gamma, 0.45455); +- +-If you need to reduce an RGB file to a paletted file, or if a paletted +-file has more entries then will fit on your screen, png_set_dither() +-will do that. Note that this is a simple match dither that merely +-finds the closest color available. This should work fairly well with +-optimized palettes, and fairly badly with linear color cubes. If you +-pass a palette that is larger then maximum_colors, the file will +-reduce the number of colors in the palette so it will fit into +-maximum_colors. If there is a histogram, it will use it to make +-more intelligent choices when reducing the palette. If there is no +-histogram, it may not do as good a job. +- +- if (color_type & PNG_COLOR_MASK_COLOR) +- { +- if (png_get_valid(png_ptr, info_ptr, +- PNG_INFO_PLTE)) +- { +- png_uint_16p histogram = NULL; +- +- png_get_hIST(png_ptr, info_ptr, +- &histogram); +- png_set_dither(png_ptr, palette, num_palette, +- max_screen_colors, histogram, 1); +- } +- else +- { +- png_color std_color_cube[MAX_SCREEN_COLORS] = +- { ... colors ... }; +- +- png_set_dither(png_ptr, std_color_cube, +- MAX_SCREEN_COLORS, MAX_SCREEN_COLORS, +- NULL,0); +- } +- } +- +-PNG files describe monochrome as black being zero and white being one. +-The following code will reverse this (make black be one and white be +-zero): +- +- if (bit_depth == 1 && color_type == PNG_COLOR_TYPE_GRAY) +- png_set_invert_mono(png_ptr); +- +-This function can also be used to invert grayscale and gray-alpha images: +- +- if (color_type == PNG_COLOR_TYPE_GRAY || +- color_type == PNG_COLOR_TYPE_GRAY_ALPHA) +- png_set_invert_mono(png_ptr); +- +-PNG files store 16 bit pixels in network byte order (big-endian, +-ie. most significant bits first). This code changes the storage to the +-other way (little-endian, i.e. least significant bits first, the +-way PCs store them): +- +- if (bit_depth == 16) +- png_set_swap(png_ptr); +- +-If you are using packed-pixel images (1, 2, or 4 bits/pixel), and you +-need to change the order the pixels are packed into bytes, you can use: +- +- if (bit_depth < 8) +- png_set_packswap(png_ptr); +- +-Finally, you can write your own transformation function if none of +-the existing ones meets your needs. This is done by setting a callback +-with +- +- png_set_read_user_transform_fn(png_ptr, +- read_transform_fn); +- +-You must supply the function +- +- void read_transform_fn(png_ptr ptr, row_info_ptr +- row_info, png_bytep data) +- +-See pngtest.c for a working example. Your function will be called +-after all of the other transformations have been processed. +- +-You can also set up a pointer to a user structure for use by your +-callback function, and you can inform libpng that your transform +-function will change the number of channels or bit depth with the +-function +- +- png_set_user_transform_info(png_ptr, user_ptr, +- user_depth, user_channels); +- +-The user's application, not libpng, is responsible for allocating and +-freeing any memory required for the user structure. +- +-You can retrieve the pointer via the function +-png_get_user_transform_ptr(). For example: +- +- voidp read_user_transform_ptr = +- png_get_user_transform_ptr(png_ptr); +- +-The last thing to handle is interlacing; this is covered in detail below, +-but you must call the function here if you want libpng to handle expansion +-of the interlaced image. +- +- number_of_passes = png_set_interlace_handling(png_ptr); +- +-After setting the transformations, libpng can update your png_info +-structure to reflect any transformations you've requested with this +-call. This is most useful to update the info structure's rowbytes +-field so you can use it to allocate your image memory. This function +-will also update your palette with the correct screen_gamma and +-background if these have been given with the calls above. +- +- png_read_update_info(png_ptr, info_ptr); +- +-After you call png_read_update_info(), you can allocate any +-memory you need to hold the image. The row data is simply +-raw byte data for all forms of images. As the actual allocation +-varies among applications, no example will be given. If you +-are allocating one large chunk, you will need to build an +-array of pointers to each row, as it will be needed for some +-of the functions below. +- +-Reading image data +- +-After you've allocated memory, you can read the image data. +-The simplest way to do this is in one function call. If you are +-allocating enough memory to hold the whole image, you can just +-call png_read_image() and libpng will read in all the image data +-and put it in the memory area supplied. You will need to pass in +-an array of pointers to each row. +- +-This function automatically handles interlacing, so you don't need +-to call png_set_interlace_handling() or call this function multiple +-times, or any of that other stuff necessary with png_read_rows(). +- +- png_read_image(png_ptr, row_pointers); +- +-where row_pointers is: +- +- png_bytep row_pointers[height]; +- +-You can point to void or char or whatever you use for pixels. +- +-If you don't want to read in the whole image at once, you can +-use png_read_rows() instead. If there is no interlacing (check +-interlace_type == PNG_INTERLACE_NONE), this is simple: +- +- png_read_rows(png_ptr, row_pointers, NULL, +- number_of_rows); +- +-where row_pointers is the same as in the png_read_image() call. +- +-If you are doing this just one row at a time, you can do this with +-a single row_pointer instead of an array of row_pointers: +- +- png_bytep row_pointer = row; +- png_read_row(png_ptr, row_pointer, NULL); +- +-If the file is interlaced (interlace_type != 0 in the IHDR chunk), things +-get somewhat harder. The only current (PNG Specification version 1.2) +-interlacing type for PNG is (interlace_type == PNG_INTERLACE_ADAM7) +-is a somewhat complicated 2D interlace scheme, known as Adam7, that +-breaks down an image into seven smaller images of varying size, based +-on an 8x8 grid. +- +-libpng can fill out those images or it can give them to you "as is". +-If you want them filled out, there are two ways to do that. The one +-mentioned in the PNG specification is to expand each pixel to cover +-those pixels that have not been read yet (the "rectangle" method). +-This results in a blocky image for the first pass, which gradually +-smooths out as more pixels are read. The other method is the "sparkle" +-method, where pixels are drawn only in their final locations, with the +-rest of the image remaining whatever colors they were initialized to +-before the start of the read. The first method usually looks better, +-but tends to be slower, as there are more pixels to put in the rows. +- +-If you don't want libpng to handle the interlacing details, just call +-png_read_rows() seven times to read in all seven images. Each of the +-images is a valid image by itself, or they can all be combined on an +-8x8 grid to form a single image (although if you intend to combine them +-you would be far better off using the libpng interlace handling). +- +-The first pass will return an image 1/8 as wide as the entire image +-(every 8th column starting in column 0) and 1/8 as high as the original +-(every 8th row starting in row 0), the second will be 1/8 as wide +-(starting in column 4) and 1/8 as high (also starting in row 0). The +-third pass will be 1/4 as wide (every 4th pixel starting in column 0) and +-1/8 as high (every 8th row starting in row 4), and the fourth pass will +-be 1/4 as wide and 1/4 as high (every 4th column starting in column 2, +-and every 4th row starting in row 0). The fifth pass will return an +-image 1/2 as wide, and 1/4 as high (starting at column 0 and row 2), +-while the sixth pass will be 1/2 as wide and 1/2 as high as the original +-(starting in column 1 and row 0). The seventh and final pass will be as +-wide as the original, and 1/2 as high, containing all of the odd +-numbered scanlines. Phew! +- +-If you want libpng to expand the images, call this before calling +-png_start_read_image() or png_read_update_info(): +- +- if (interlace_type == PNG_INTERLACE_ADAM7) +- number_of_passes +- = png_set_interlace_handling(png_ptr); +- +-This will return the number of passes needed. Currently, this +-is seven, but may change if another interlace type is added. +-This function can be called even if the file is not interlaced, +-where it will return one pass. +- +-If you are not going to display the image after each pass, but are +-going to wait until the entire image is read in, use the sparkle +-effect. This effect is faster and the end result of either method +-is exactly the same. If you are planning on displaying the image +-after each pass, the "rectangle" effect is generally considered the +-better looking one. +- +-If you only want the "sparkle" effect, just call png_read_rows() as +-normal, with the third parameter NULL. Make sure you make pass over +-the image number_of_passes times, and you don't change the data in the +-rows between calls. You can change the locations of the data, just +-not the data. Each pass only writes the pixels appropriate for that +-pass, and assumes the data from previous passes is still valid. +- +- png_read_rows(png_ptr, row_pointers, NULL, +- number_of_rows); +- +-If you only want the first effect (the rectangles), do the same as +-before except pass the row buffer in the third parameter, and leave +-the second parameter NULL. +- +- png_read_rows(png_ptr, NULL, row_pointers, +- number_of_rows); +- +-Finishing a sequential read +- +-After you are finished reading the image through the +-low-level interface, you can finish reading the file. If you are +-interested in comments or time, which may be stored either before or +-after the image data, you should pass the separate png_info struct if +-you want to keep the comments from before and after the image +-separate. If you are not interested, you can pass NULL. +- +- png_read_end(png_ptr, end_info); +- +-When you are done, you can free all memory allocated by libpng like this: +- +- png_destroy_read_struct(&png_ptr, &info_ptr, +- &end_info); +- +-It is also possible to individually free the info_ptr members that +-point to libpng-allocated storage with the following function: +- +- png_free_data(png_ptr, info_ptr, mask, seq) +- mask - identifies data to be freed, a mask +- containing the bitwise OR of one or +- more of +- PNG_FREE_PLTE, PNG_FREE_TRNS, +- PNG_FREE_HIST, PNG_FREE_ICCP, +- PNG_FREE_PCAL, PNG_FREE_ROWS, +- PNG_FREE_SCAL, PNG_FREE_SPLT, +- PNG_FREE_TEXT, PNG_FREE_UNKN, +- or simply PNG_FREE_ALL +- seq - sequence number of item to be freed +- (-1 for all items) +- +-This function may be safely called when the relevant storage has +-already been freed, or has not yet been allocated, or was allocated +-by the user and not by libpng, and will in those +-cases do nothing. The "seq" parameter is ignored if only one item +-of the selected data type, such as PLTE, is allowed. If "seq" is not +--1, and multiple items are allowed for the data type identified in +-the mask, such as text or sPLT, only the n'th item in the structure +-is freed, where n is "seq". +- +-The default behavior is only to free data that was allocated internally +-by libpng. This can be changed, so that libpng will not free the data, +-or so that it will free data that was allocated by the user with png_malloc() +-or png_zalloc() and passed in via a png_set_*() function, with +- +- png_data_freer(png_ptr, info_ptr, freer, mask) +- mask - which data elements are affected +- same choices as in png_free_data() +- freer - one of +- PNG_DESTROY_WILL_FREE_DATA +- PNG_SET_WILL_FREE_DATA +- PNG_USER_WILL_FREE_DATA +- +-This function only affects data that has already been allocated. +-You can call this function after reading the PNG data but before calling +-any png_set_*() functions, to control whether the user or the png_set_*() +-function is responsible for freeing any existing data that might be present, +-and again after the png_set_*() functions to control whether the user +-or png_destroy_*() is supposed to free the data. When the user assumes +-responsibility for libpng-allocated data, the application must use +-png_free() to free it, and when the user transfers responsibility to libpng +-for data that the user has allocated, the user must have used png_malloc() +-or png_zalloc() to allocate it. +- +-If you allocated your row_pointers in a single block, as suggested above in +-the description of the high level read interface, you must not transfer +-responsibility for freeing it to the png_set_rows or png_read_destroy function, +-because they would also try to free the individual row_pointers[i]. +- +-If you allocated text_ptr.text, text_ptr.lang, and text_ptr.translated_keyword +-separately, do not transfer responsibility for freeing text_ptr to libpng, +-because when libpng fills a png_text structure it combines these members with +-the key member, and png_free_data() will free only text_ptr.key. Similarly, +-if you transfer responsibility for free'ing text_ptr from libpng to your +-application, your application must not separately free those members. +- +-The png_free_data() function will turn off the "valid" flag for anything +-it frees. If you need to turn the flag off for a chunk that was freed by your +-application instead of by libpng, you can use +- +- png_set_invalid(png_ptr, info_ptr, mask); +- mask - identifies the chunks to be made invalid, +- containing the bitwise OR of one or +- more of +- PNG_INFO_gAMA, PNG_INFO_sBIT, +- PNG_INFO_cHRM, PNG_INFO_PLTE, +- PNG_INFO_tRNS, PNG_INFO_bKGD, +- PNG_INFO_hIST, PNG_INFO_pHYs, +- PNG_INFO_oFFs, PNG_INFO_tIME, +- PNG_INFO_pCAL, PNG_INFO_sRGB, +- PNG_INFO_iCCP, PNG_INFO_sPLT, +- PNG_INFO_sCAL, PNG_INFO_IDAT +- +-For a more compact example of reading a PNG image, see the file example.c. +- +-Reading PNG files progressively +- +-The progressive reader is slightly different then the non-progressive +-reader. Instead of calling png_read_info(), png_read_rows(), and +-png_read_end(), you make one call to png_process_data(), which calls +-callbacks when it has the info, a row, or the end of the image. You +-set up these callbacks with png_set_progressive_read_fn(). You don't +-have to worry about the input/output functions of libpng, as you are +-giving the library the data directly in png_process_data(). I will +-assume that you have read the section on reading PNG files above, +-so I will only highlight the differences (although I will show +-all of the code). +- +-png_structp png_ptr; +-png_infop info_ptr; +- +- /* An example code fragment of how you would +- initialize the progressive reader in your +- application. */ +- int +- initialize_png_reader() +- { +- png_ptr = png_create_read_struct +- (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, +- user_error_fn, user_warning_fn); +- if (!png_ptr) +- return (ERROR); +- info_ptr = png_create_info_struct(png_ptr); +- if (!info_ptr) +- { +- png_destroy_read_struct(&png_ptr, (png_infopp)NULL, +- (png_infopp)NULL); +- return (ERROR); +- } +- +- if (setjmp(png_jmpbuf(png_ptr))) +- { +- png_destroy_read_struct(&png_ptr, &info_ptr, +- (png_infopp)NULL); +- return (ERROR); +- } +- +- /* This one's new. You can provide functions +- to be called when the header info is valid, +- when each row is completed, and when the image +- is finished. If you aren't using all functions, +- you can specify NULL parameters. Even when all +- three functions are NULL, you need to call +- png_set_progressive_read_fn(). You can use +- any struct as the user_ptr (cast to a void pointer +- for the function call), and retrieve the pointer +- from inside the callbacks using the function +- +- png_get_progressive_ptr(png_ptr); +- +- which will return a void pointer, which you have +- to cast appropriately. +- */ +- png_set_progressive_read_fn(png_ptr, (void *)user_ptr, +- info_callback, row_callback, end_callback); +- +- return 0; +- } +- +- /* A code fragment that you call as you receive blocks +- of data */ +- int +- process_data(png_bytep buffer, png_uint_32 length) +- { +- if (setjmp(png_jmpbuf(png_ptr))) +- { +- png_destroy_read_struct(&png_ptr, &info_ptr, +- (png_infopp)NULL); +- return (ERROR); +- } +- +- /* This one's new also. Simply give it a chunk +- of data from the file stream (in order, of +- course). On machines with segmented memory +- models machines, don't give it any more than +- 64K. The library seems to run fine with sizes +- of 4K. Although you can give it much less if +- necessary (I assume you can give it chunks of +- 1 byte, I haven't tried less then 256 bytes +- yet). When this function returns, you may +- want to display any rows that were generated +- in the row callback if you don't already do +- so there. +- */ +- png_process_data(png_ptr, info_ptr, buffer, length); +- return 0; +- } +- +- /* This function is called (as set by +- png_set_progressive_read_fn() above) when enough data +- has been supplied so all of the header has been +- read. +- */ +- void +- info_callback(png_structp png_ptr, png_infop info) +- { +- /* Do any setup here, including setting any of +- the transformations mentioned in the Reading +- PNG files section. For now, you _must_ call +- either png_start_read_image() or +- png_read_update_info() after all the +- transformations are set (even if you don't set +- any). You may start getting rows before +- png_process_data() returns, so this is your +- last chance to prepare for that. +- */ +- } +- +- /* This function is called when each row of image +- data is complete */ +- void +- row_callback(png_structp png_ptr, png_bytep new_row, +- png_uint_32 row_num, int pass) +- { +- /* If the image is interlaced, and you turned +- on the interlace handler, this function will +- be called for every row in every pass. Some +- of these rows will not be changed from the +- previous pass. When the row is not changed, +- the new_row variable will be NULL. The rows +- and passes are called in order, so you don't +- really need the row_num and pass, but I'm +- supplying them because it may make your life +- easier. +- +- For the non-NULL rows of interlaced images, +- you must call png_progressive_combine_row() +- passing in the row and the old row. You can +- call this function for NULL rows (it will just +- return) and for non-interlaced images (it just +- does the memcpy for you) if it will make the +- code easier. Thus, you can just do this for +- all cases: +- */ +- +- png_progressive_combine_row(png_ptr, old_row, +- new_row); +- +- /* where old_row is what was displayed for +- previously for the row. Note that the first +- pass (pass == 0, really) will completely cover +- the old row, so the rows do not have to be +- initialized. After the first pass (and only +- for interlaced images), you will have to pass +- the current row, and the function will combine +- the old row and the new row. +- */ +- } +- +- void +- end_callback(png_structp png_ptr, png_infop info) +- { +- /* This function is called after the whole image +- has been read, including any chunks after the +- image (up to and including the IEND). You +- will usually have the same info chunk as you +- had in the header, although some data may have +- been added to the comments and time fields. +- +- Most people won't do much here, perhaps setting +- a flag that marks the image as finished. +- */ +- } +- +- +- +-IV. Writing +- +-Much of this is very similar to reading. However, everything of +-importance is repeated here, so you won't have to constantly look +-back up in the reading section to understand writing. +- +-Setup +- +-You will want to do the I/O initialization before you get into libpng, +-so if it doesn't work, you don't have anything to undo. If you are not +-using the standard I/O functions, you will need to replace them with +-custom writing functions. See the discussion under Customizing libpng. +- +- FILE *fp = fopen(file_name, "wb"); +- if (!fp) +- { +- return (ERROR); +- } +- +-Next, png_struct and png_info need to be allocated and initialized. +-As these can be both relatively large, you may not want to store these +-on the stack, unless you have stack space to spare. Of course, you +-will want to check if they return NULL. If you are also reading, +-you won't want to name your read structure and your write structure +-both "png_ptr"; you can call them anything you like, such as +-"read_ptr" and "write_ptr". Look at pngtest.c, for example. +- +- png_structp png_ptr = png_create_write_struct +- (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, +- user_error_fn, user_warning_fn); +- if (!png_ptr) +- return (ERROR); +- +- png_infop info_ptr = png_create_info_struct(png_ptr); +- if (!info_ptr) +- { +- png_destroy_write_struct(&png_ptr, +- (png_infopp)NULL); +- return (ERROR); +- } +- +-If you want to use your own memory allocation routines, +-define PNG_USER_MEM_SUPPORTED and use +-png_create_write_struct_2() instead of png_create_write_struct(): +- +- png_structp png_ptr = png_create_write_struct_2 +- (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, +- user_error_fn, user_warning_fn, (png_voidp) +- user_mem_ptr, user_malloc_fn, user_free_fn); +- +-After you have these structures, you will need to set up the +-error handling. When libpng encounters an error, it expects to +-longjmp() back to your routine. Therefore, you will need to call +-setjmp() and pass the png_jmpbuf(png_ptr). If you +-write the file from different routines, you will need to update +-the png_jmpbuf(png_ptr) every time you enter a new routine that will +-call a png_*() function. See your documentation of setjmp/longjmp +-for your compiler for more information on setjmp/longjmp. See +-the discussion on libpng error handling in the Customizing Libpng +-section below for more information on the libpng error handling. +- +- if (setjmp(png_jmpbuf(png_ptr))) +- { +- png_destroy_write_struct(&png_ptr, &info_ptr); +- fclose(fp); +- return (ERROR); +- } +- ... +- return; +- +-If you would rather avoid the complexity of setjmp/longjmp issues, +-you can compile libpng with PNG_SETJMP_NOT_SUPPORTED, in which case +-errors will result in a call to PNG_ABORT() which defaults to abort(). +- +-Now you need to set up the output code. The default for libpng is to +-use the C function fwrite(). If you use this, you will need to pass a +-valid FILE * in the function png_init_io(). Be sure that the file is +-opened in binary mode. Again, if you wish to handle writing data in +-another way, see the discussion on libpng I/O handling in the Customizing +-Libpng section below. +- +- png_init_io(png_ptr, fp); +- +-If you are embedding your PNG into a datastream such as MNG, and don't +-want libpng to write the 8-byte signature, or if you have already +-written the signature in your application, use +- +- png_set_sig_bytes(png_ptr, 8); +- +-to inform libpng that it should not write a signature. +- +-Write callbacks +- +-At this point, you can set up a callback function that will be +-called after each row has been written, which you can use to control +-a progress meter or the like. It's demonstrated in pngtest.c. +-You must supply a function +- +- void write_row_callback(png_ptr, png_uint_32 row, +- int pass); +- { +- /* put your code here */ +- } +- +-(You can give it another name that you like instead of "write_row_callback") +- +-To inform libpng about your function, use +- +- png_set_write_status_fn(png_ptr, write_row_callback); +- +-You now have the option of modifying how the compression library will +-run. The following functions are mainly for testing, but may be useful +-in some cases, like if you need to write PNG files extremely fast and +-are willing to give up some compression, or if you want to get the +-maximum possible compression at the expense of slower writing. If you +-have no special needs in this area, let the library do what it wants by +-not calling this function at all, as it has been tuned to deliver a good +-speed/compression ratio. The second parameter to png_set_filter() is +-the filter method, for which the only valid values are 0 (as of the +-July 1999 PNG specification, version 1.2) or 64 (if you are writing +-a PNG datastream that is to be embedded in a MNG datastream). The third +-parameter is a flag that indicates which filter type(s) are to be tested +-for each scanline. See the PNG specification for details on the specific filter +-types. +- +- +- /* turn on or off filtering, and/or choose +- specific filters. You can use either a single +- PNG_FILTER_VALUE_NAME or the bitwise OR of one +- or more PNG_FILTER_NAME masks. */ +- png_set_filter(png_ptr, 0, +- PNG_FILTER_NONE | PNG_FILTER_VALUE_NONE | +- PNG_FILTER_SUB | PNG_FILTER_VALUE_SUB | +- PNG_FILTER_UP | PNG_FILTER_VALUE_UP | +- PNG_FILTER_AVE | PNG_FILTER_VALUE_AVE | +- PNG_FILTER_PAETH | PNG_FILTER_VALUE_PAETH| +- PNG_ALL_FILTERS); +- +-If an application +-wants to start and stop using particular filters during compression, +-it should start out with all of the filters (to ensure that the previous +-row of pixels will be stored in case it's needed later), and then add +-and remove them after the start of compression. +- +-If you are writing a PNG datastream that is to be embedded in a MNG +-datastream, the second parameter can be either 0 or 64. +- +-The png_set_compression_*() functions interface to the zlib compression +-library, and should mostly be ignored unless you really know what you are +-doing. The only generally useful call is png_set_compression_level() +-which changes how much time zlib spends on trying to compress the image +-data. See the Compression Library (zlib.h and algorithm.txt, distributed +-with zlib) for details on the compression levels. +- +- /* set the zlib compression level */ +- png_set_compression_level(png_ptr, +- Z_BEST_COMPRESSION); +- +- /* set other zlib parameters */ +- png_set_compression_mem_level(png_ptr, 8); +- png_set_compression_strategy(png_ptr, +- Z_DEFAULT_STRATEGY); +- png_set_compression_window_bits(png_ptr, 15); +- png_set_compression_method(png_ptr, 8); +- png_set_compression_buffer_size(png_ptr, 8192) +- +-extern PNG_EXPORT(void,png_set_zbuf_size) +- +-Setting the contents of info for output +- +-You now need to fill in the png_info structure with all the data you +-wish to write before the actual image. Note that the only thing you +-are allowed to write after the image is the text chunks and the time +-chunk (as of PNG Specification 1.2, anyway). See png_write_end() and +-the latest PNG specification for more information on that. If you +-wish to write them before the image, fill them in now, and flag that +-data as being valid. If you want to wait until after the data, don't +-fill them until png_write_end(). For all the fields in png_info and +-their data types, see png.h. For explanations of what the fields +-contain, see the PNG specification. +- +-Some of the more important parts of the png_info are: +- +- png_set_IHDR(png_ptr, info_ptr, width, height, +- bit_depth, color_type, interlace_type, +- compression_type, filter_method) +- width - holds the width of the image +- in pixels (up to 2^31). +- height - holds the height of the image +- in pixels (up to 2^31). +- bit_depth - holds the bit depth of one of the +- image channels. +- (valid values are 1, 2, 4, 8, 16 +- and depend also on the +- color_type. See also significant +- bits (sBIT) below). +- color_type - describes which color/alpha +- channels are present. +- PNG_COLOR_TYPE_GRAY +- (bit depths 1, 2, 4, 8, 16) +- PNG_COLOR_TYPE_GRAY_ALPHA +- (bit depths 8, 16) +- PNG_COLOR_TYPE_PALETTE +- (bit depths 1, 2, 4, 8) +- PNG_COLOR_TYPE_RGB +- (bit_depths 8, 16) +- PNG_COLOR_TYPE_RGB_ALPHA +- (bit_depths 8, 16) +- +- PNG_COLOR_MASK_PALETTE +- PNG_COLOR_MASK_COLOR +- PNG_COLOR_MASK_ALPHA +- +- interlace_type - PNG_INTERLACE_NONE or +- PNG_INTERLACE_ADAM7 +- compression_type - (must be +- PNG_COMPRESSION_TYPE_DEFAULT) +- filter_method - (must be PNG_FILTER_TYPE_DEFAULT +- or, if you are writing a PNG to +- be embedded in a MNG datastream, +- can also be +- PNG_INTRAPIXEL_DIFFERENCING) +- +- png_set_PLTE(png_ptr, info_ptr, palette, +- num_palette); +- palette - the palette for the file +- (array of png_color) +- num_palette - number of entries in the palette +- +- png_set_gAMA(png_ptr, info_ptr, gamma); +- gamma - the gamma the image was created +- at (PNG_INFO_gAMA) +- +- png_set_sRGB(png_ptr, info_ptr, srgb_intent); +- srgb_intent - the rendering intent +- (PNG_INFO_sRGB) The presence of +- the sRGB chunk means that the pixel +- data is in the sRGB color space. +- This chunk also implies specific +- values of gAMA and cHRM. Rendering +- intent is the CSS-1 property that +- has been defined by the International +- Color Consortium +- (http://www.color.org). +- It can be one of +- PNG_sRGB_INTENT_SATURATION, +- PNG_sRGB_INTENT_PERCEPTUAL, +- PNG_sRGB_INTENT_ABSOLUTE, or +- PNG_sRGB_INTENT_RELATIVE. +- +- +- png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, +- srgb_intent); +- srgb_intent - the rendering intent +- (PNG_INFO_sRGB) The presence of the +- sRGB chunk means that the pixel +- data is in the sRGB color space. +- This function also causes gAMA and +- cHRM chunks with the specific values +- that are consistent with sRGB to be +- written. +- +- png_set_iCCP(png_ptr, info_ptr, name, compression_type, +- profile, proflen); +- name - The profile name. +- compression - The compression type; always +- PNG_COMPRESSION_TYPE_BASE for PNG 1.0. +- You may give NULL to this argument to +- ignore it. +- profile - International Color Consortium color +- profile data. May contain NULs. +- proflen - length of profile data in bytes. +- +- png_set_sBIT(png_ptr, info_ptr, sig_bit); +- sig_bit - the number of significant bits for +- (PNG_INFO_sBIT) each of the gray, red, +- green, and blue channels, whichever are +- appropriate for the given color type +- (png_color_16) +- +- png_set_tRNS(png_ptr, info_ptr, trans, num_trans, +- trans_values); +- trans - array of transparent entries for +- palette (PNG_INFO_tRNS) +- trans_values - graylevel or color sample values of +- the single transparent color for +- non-paletted images (PNG_INFO_tRNS) +- num_trans - number of transparent entries +- (PNG_INFO_tRNS) +- +- png_set_hIST(png_ptr, info_ptr, hist); +- (PNG_INFO_hIST) +- hist - histogram of palette (array of +- png_uint_16) +- +- png_set_tIME(png_ptr, info_ptr, mod_time); +- mod_time - time image was last modified +- (PNG_VALID_tIME) +- +- png_set_bKGD(png_ptr, info_ptr, background); +- background - background color (PNG_VALID_bKGD) +- +- png_set_text(png_ptr, info_ptr, text_ptr, num_text); +- text_ptr - array of png_text holding image +- comments +- text_ptr[i].compression - type of compression used +- on "text" PNG_TEXT_COMPRESSION_NONE +- PNG_TEXT_COMPRESSION_zTXt +- PNG_ITXT_COMPRESSION_NONE +- PNG_ITXT_COMPRESSION_zTXt +- text_ptr[i].key - keyword for comment. Must contain +- 1-79 characters. +- text_ptr[i].text - text comments for current +- keyword. Can be NULL or empty. +- text_ptr[i].text_length - length of text string, +- after decompression, 0 for iTXt +- text_ptr[i].itxt_length - length of itxt string, +- after decompression, 0 for tEXt/zTXt +- text_ptr[i].lang - language of comment (NULL or +- empty for unknown). +- text_ptr[i].translated_keyword - keyword in UTF-8 (NULL +- or empty for unknown). +- num_text - number of comments +- +- png_set_sPLT(png_ptr, info_ptr, &palette_ptr, +- num_spalettes); +- palette_ptr - array of png_sPLT_struct structures +- to be added to the list of palettes +- in the info structure. +- num_spalettes - number of palette structures to be +- added. +- +- png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, +- unit_type); +- offset_x - positive offset from the left +- edge of the screen +- offset_y - positive offset from the top +- edge of the screen +- unit_type - PNG_OFFSET_PIXEL, PNG_OFFSET_MICROMETER +- +- png_set_pHYs(png_ptr, info_ptr, res_x, res_y, +- unit_type); +- res_x - pixels/unit physical resolution +- in x direction +- res_y - pixels/unit physical resolution +- in y direction +- unit_type - PNG_RESOLUTION_UNKNOWN, +- PNG_RESOLUTION_METER +- +- png_set_sCAL(png_ptr, info_ptr, unit, width, height) +- unit - physical scale units (an integer) +- width - width of a pixel in physical scale units +- height - height of a pixel in physical scale units +- (width and height are doubles) +- +- png_set_sCAL_s(png_ptr, info_ptr, unit, width, height) +- unit - physical scale units (an integer) +- width - width of a pixel in physical scale units +- height - height of a pixel in physical scale units +- (width and height are strings like "2.54") +- +- png_set_unknown_chunks(png_ptr, info_ptr, &unknowns, +- num_unknowns) +- unknowns - array of png_unknown_chunk +- structures holding unknown chunks +- unknowns[i].name - name of unknown chunk +- unknowns[i].data - data of unknown chunk +- unknowns[i].size - size of unknown chunk's data +- unknowns[i].location - position to write chunk in file +- 0: do not write chunk +- PNG_HAVE_IHDR: before PLTE +- PNG_HAVE_PLTE: before IDAT +- PNG_AFTER_IDAT: after IDAT +- +-The "location" member is set automatically according to +-what part of the output file has already been written. +-You can change its value after calling png_set_unknown_chunks() +-as demonstrated in pngtest.c. Within each of the "locations", +-the chunks are sequenced according to their position in the +-structure (that is, the value of "i", which is the order in which +-the chunk was either read from the input file or defined with +-png_set_unknown_chunks). +- +-A quick word about text and num_text. text is an array of png_text +-structures. num_text is the number of valid structures in the array. +-Each png_text structure holds a language code, a keyword, a text value, +-and a compression type. +- +-The compression types have the same valid numbers as the compression +-types of the image data. Currently, the only valid number is zero. +-However, you can store text either compressed or uncompressed, unlike +-images, which always have to be compressed. So if you don't want the +-text compressed, set the compression type to PNG_TEXT_COMPRESSION_NONE. +-Because tEXt and zTXt chunks don't have a language field, if you +-specify PNG_TEXT_COMPRESSION_NONE or PNG_TEXT_COMPRESSION_zTXt +-any language code or translated keyword will not be written out. +- +-Until text gets around 1000 bytes, it is not worth compressing it. +-After the text has been written out to the file, the compression type +-is set to PNG_TEXT_COMPRESSION_NONE_WR or PNG_TEXT_COMPRESSION_zTXt_WR, +-so that it isn't written out again at the end (in case you are calling +-png_write_end() with the same struct. +- +-The keywords that are given in the PNG Specification are: +- +- Title Short (one line) title or +- caption for image +- Author Name of image's creator +- Description Description of image (possibly long) +- Copyright Copyright notice +- Creation Time Time of original image creation +- (usually RFC 1123 format, see below) +- Software Software used to create the image +- Disclaimer Legal disclaimer +- Warning Warning of nature of content +- Source Device used to create the image +- Comment Miscellaneous comment; conversion +- from other image format +- +-The keyword-text pairs work like this. Keywords should be short +-simple descriptions of what the comment is about. Some typical +-keywords are found in the PNG specification, as is some recommendations +-on keywords. You can repeat keywords in a file. You can even write +-some text before the image and some after. For example, you may want +-to put a description of the image before the image, but leave the +-disclaimer until after, so viewers working over modem connections +-don't have to wait for the disclaimer to go over the modem before +-they start seeing the image. Finally, keywords should be full +-words, not abbreviations. Keywords and text are in the ISO 8859-1 +-(Latin-1) character set (a superset of regular ASCII) and can not +-contain NUL characters, and should not contain control or other +-unprintable characters. To make the comments widely readable, stick +-with basic ASCII, and avoid machine specific character set extensions +-like the IBM-PC character set. The keyword must be present, but +-you can leave off the text string on non-compressed pairs. +-Compressed pairs must have a text string, as only the text string +-is compressed anyway, so the compression would be meaningless. +- +-PNG supports modification time via the png_time structure. Two +-conversion routines are provided, png_convert_from_time_t() for +-time_t and png_convert_from_struct_tm() for struct tm. The +-time_t routine uses gmtime(). You don't have to use either of +-these, but if you wish to fill in the png_time structure directly, +-you should provide the time in universal time (GMT) if possible +-instead of your local time. Note that the year number is the full +-year (e.g. 1998, rather than 98 - PNG is year 2000 compliant!), and +-that months start with 1. +- +-If you want to store the time of the original image creation, you should +-use a plain tEXt chunk with the "Creation Time" keyword. This is +-necessary because the "creation time" of a PNG image is somewhat vague, +-depending on whether you mean the PNG file, the time the image was +-created in a non-PNG format, a still photo from which the image was +-scanned, or possibly the subject matter itself. In order to facilitate +-machine-readable dates, it is recommended that the "Creation Time" +-tEXt chunk use RFC 1123 format dates (e.g. "22 May 1997 18:07:10 GMT"), +-although this isn't a requirement. Unlike the tIME chunk, the +-"Creation Time" tEXt chunk is not expected to be automatically changed +-by the software. To facilitate the use of RFC 1123 dates, a function +-png_convert_to_rfc1123(png_timep) is provided to convert from PNG +-time to an RFC 1123 format string. +- +-Writing unknown chunks +- +-You can use the png_set_unknown_chunks function to queue up chunks +-for writing. You give it a chunk name, raw data, and a size; that's +-all there is to it. The chunks will be written by the next following +-png_write_info_before_PLTE, png_write_info, or png_write_end function. +-Any chunks previously read into the info structure's unknown-chunk +-list will also be written out in a sequence that satisfies the PNG +-specification's ordering rules. +- +-The high-level write interface +- +-At this point there are two ways to proceed; through the high-level +-write interface, or through a sequence of low-level write operations. +-You can use the high-level interface if your image data is present +-in the info structure. All defined output +-transformations are permitted, enabled by the following masks. +- +- PNG_TRANSFORM_IDENTITY No transformation +- PNG_TRANSFORM_PACKING Pack 1, 2 and 4-bit samples +- PNG_TRANSFORM_PACKSWAP Change order of packed +- pixels to LSB first +- PNG_TRANSFORM_INVERT_MONO Invert monochrome images +- PNG_TRANSFORM_SHIFT Normalize pixels to the +- sBIT depth +- PNG_TRANSFORM_BGR Flip RGB to BGR, RGBA +- to BGRA +- PNG_TRANSFORM_SWAP_ALPHA Flip RGBA to ARGB or GA +- to AG +- PNG_TRANSFORM_INVERT_ALPHA Change alpha from opacity +- to transparency +- PNG_TRANSFORM_SWAP_ENDIAN Byte-swap 16-bit samples +- PNG_TRANSFORM_STRIP_FILLER Strip out filler bytes. +- +-If you have valid image data in the info structure (you can use +-png_set_rows() to put image data in the info structure), simply do this: +- +- png_write_png(png_ptr, info_ptr, png_transforms, NULL) +- +-where png_transforms is an integer containing the bitwise OR of some set of +-transformation flags. This call is equivalent to png_write_info(), +-followed the set of transformations indicated by the transform mask, +-then png_write_image(), and finally png_write_end(). +- +-(The final parameter of this call is not yet used. Someday it might point +-to transformation parameters required by some future output transform.) +- +-You must use png_transforms and not call any png_set_transform() functions +-when you use png_write_png(). +- +-The low-level write interface +- +-If you are going the low-level route instead, you are now ready to +-write all the file information up to the actual image data. You do +-this with a call to png_write_info(). +- +- png_write_info(png_ptr, info_ptr); +- +-Note that there is one transformation you may need to do before +-png_write_info(). In PNG files, the alpha channel in an image is the +-level of opacity. If your data is supplied as a level of +-transparency, you can invert the alpha channel before you write it, so +-that 0 is fully transparent and 255 (in 8-bit or paletted images) or +-65535 (in 16-bit images) is fully opaque, with +- +- png_set_invert_alpha(png_ptr); +- +-This must appear before png_write_info() instead of later with the +-other transformations because in the case of paletted images the tRNS +-chunk data has to be inverted before the tRNS chunk is written. If +-your image is not a paletted image, the tRNS data (which in such cases +-represents a single color to be rendered as transparent) won't need to +-be changed, and you can safely do this transformation after your +-png_write_info() call. +- +-If you need to write a private chunk that you want to appear before +-the PLTE chunk when PLTE is present, you can write the PNG info in +-two steps, and insert code to write your own chunk between them: +- +- png_write_info_before_PLTE(png_ptr, info_ptr); +- png_set_unknown_chunks(png_ptr, info_ptr, ...); +- png_write_info(png_ptr, info_ptr); +- +-After you've written the file information, you can set up the library +-to handle any special transformations of the image data. The various +-ways to transform the data will be described in the order that they +-should occur. This is important, as some of these change the color +-type and/or bit depth of the data, and some others only work on +-certain color types and bit depths. Even though each transformation +-checks to see if it has data that it can do something with, you should +-make sure to only enable a transformation if it will be valid for the +-data. For example, don't swap red and blue on grayscale data. +- +-PNG files store RGB pixels packed into 3 or 6 bytes. This code tells +-the library to strip input data that has 4 or 8 bytes per pixel down +-to 3 or 6 bytes (or strip 2 or 4-byte grayscale+filler data to 1 or 2 +-bytes per pixel). +- +- png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); +- +-where the 0 is unused, and the location is either PNG_FILLER_BEFORE or +-PNG_FILLER_AFTER, depending upon whether the filler byte in the pixel +-is stored XRGB or RGBX. +- +-PNG files pack pixels of bit depths 1, 2, and 4 into bytes as small as +-they can, resulting in, for example, 8 pixels per byte for 1 bit files. +-If the data is supplied at 1 pixel per byte, use this code, which will +-correctly pack the pixels into a single byte: +- +- png_set_packing(png_ptr); +- +-PNG files reduce possible bit depths to 1, 2, 4, 8, and 16. If your +-data is of another bit depth, you can write an sBIT chunk into the +-file so that decoders can recover the original data if desired. +- +- /* Set the true bit depth of the image data */ +- if (color_type & PNG_COLOR_MASK_COLOR) +- { +- sig_bit.red = true_bit_depth; +- sig_bit.green = true_bit_depth; +- sig_bit.blue = true_bit_depth; +- } +- else +- { +- sig_bit.gray = true_bit_depth; +- } +- if (color_type & PNG_COLOR_MASK_ALPHA) +- { +- sig_bit.alpha = true_bit_depth; +- } +- +- png_set_sBIT(png_ptr, info_ptr, &sig_bit); +- +-If the data is stored in the row buffer in a bit depth other than +-one supported by PNG (e.g. 3 bit data in the range 0-7 for a 4-bit PNG), +-this will scale the values to appear to be the correct bit depth as +-is required by PNG. +- +- png_set_shift(png_ptr, &sig_bit); +- +-PNG files store 16 bit pixels in network byte order (big-endian, +-ie. most significant bits first). This code would be used if they are +-supplied the other way (little-endian, i.e. least significant bits +-first, the way PCs store them): +- +- if (bit_depth > 8) +- png_set_swap(png_ptr); +- +-If you are using packed-pixel images (1, 2, or 4 bits/pixel), and you +-need to change the order the pixels are packed into bytes, you can use: +- +- if (bit_depth < 8) +- png_set_packswap(png_ptr); +- +-PNG files store 3 color pixels in red, green, blue order. This code +-would be used if they are supplied as blue, green, red: +- +- png_set_bgr(png_ptr); +- +-PNG files describe monochrome as black being zero and white being +-one. This code would be used if the pixels are supplied with this reversed +-(black being one and white being zero): +- +- png_set_invert_mono(png_ptr); +- +-Finally, you can write your own transformation function if none of +-the existing ones meets your needs. This is done by setting a callback +-with +- +- png_set_write_user_transform_fn(png_ptr, +- write_transform_fn); +- +-You must supply the function +- +- void write_transform_fn(png_ptr ptr, row_info_ptr +- row_info, png_bytep data) +- +-See pngtest.c for a working example. Your function will be called +-before any of the other transformations are processed. +- +-You can also set up a pointer to a user structure for use by your +-callback function. +- +- png_set_user_transform_info(png_ptr, user_ptr, 0, 0); +- +-The user_channels and user_depth parameters of this function are ignored +-when writing; you can set them to zero as shown. +- +-You can retrieve the pointer via the function png_get_user_transform_ptr(). +-For example: +- +- voidp write_user_transform_ptr = +- png_get_user_transform_ptr(png_ptr); +- +-It is possible to have libpng flush any pending output, either manually, +-or automatically after a certain number of lines have been written. To +-flush the output stream a single time call: +- +- png_write_flush(png_ptr); +- +-and to have libpng flush the output stream periodically after a certain +-number of scanlines have been written, call: +- +- png_set_flush(png_ptr, nrows); +- +-Note that the distance between rows is from the last time png_write_flush() +-was called, or the first row of the image if it has never been called. +-So if you write 50 lines, and then png_set_flush 25, it will flush the +-output on the next scanline, and every 25 lines thereafter, unless +-png_write_flush() is called before 25 more lines have been written. +-If nrows is too small (less than about 10 lines for a 640 pixel wide +-RGB image) the image compression may decrease noticeably (although this +-may be acceptable for real-time applications). Infrequent flushing will +-only degrade the compression performance by a few percent over images +-that do not use flushing. +- +-Writing the image data +- +-That's it for the transformations. Now you can write the image data. +-The simplest way to do this is in one function call. If you have the +-whole image in memory, you can just call png_write_image() and libpng +-will write the image. You will need to pass in an array of pointers to +-each row. This function automatically handles interlacing, so you don't +-need to call png_set_interlace_handling() or call this function multiple +-times, or any of that other stuff necessary with png_write_rows(). +- +- png_write_image(png_ptr, row_pointers); +- +-where row_pointers is: +- +- png_byte *row_pointers[height]; +- +-You can point to void or char or whatever you use for pixels. +- +-If you don't want to write the whole image at once, you can +-use png_write_rows() instead. If the file is not interlaced, +-this is simple: +- +- png_write_rows(png_ptr, row_pointers, +- number_of_rows); +- +-row_pointers is the same as in the png_write_image() call. +- +-If you are just writing one row at a time, you can do this with +-a single row_pointer instead of an array of row_pointers: +- +- png_bytep row_pointer = row; +- +- png_write_row(png_ptr, row_pointer); +- +-When the file is interlaced, things can get a good deal more +-complicated. The only currently (as of the PNG Specification +-version 1.2, dated July 1999) defined interlacing scheme for PNG files +-is the "Adam7" interlace scheme, that breaks down an +-image into seven smaller images of varying size. libpng will build +-these images for you, or you can do them yourself. If you want to +-build them yourself, see the PNG specification for details of which +-pixels to write when. +- +-If you don't want libpng to handle the interlacing details, just +-use png_set_interlace_handling() and call png_write_rows() the +-correct number of times to write all seven sub-images. +- +-If you want libpng to build the sub-images, call this before you start +-writing any rows: +- +- number_of_passes = +- png_set_interlace_handling(png_ptr); +- +-This will return the number of passes needed. Currently, this +-is seven, but may change if another interlace type is added. +- +-Then write the complete image number_of_passes times. +- +- png_write_rows(png_ptr, row_pointers, +- number_of_rows); +- +-As some of these rows are not used, and thus return immediately, +-you may want to read about interlacing in the PNG specification, +-and only update the rows that are actually used. +- +-Finishing a sequential write +- +-After you are finished writing the image, you should finish writing +-the file. If you are interested in writing comments or time, you should +-pass an appropriately filled png_info pointer. If you are not interested, +-you can pass NULL. +- +- png_write_end(png_ptr, info_ptr); +- +-When you are done, you can free all memory used by libpng like this: +- +- png_destroy_write_struct(&png_ptr, &info_ptr); +- +-It is also possible to individually free the info_ptr members that +-point to libpng-allocated storage with the following function: +- +- png_free_data(png_ptr, info_ptr, mask, seq) +- mask - identifies data to be freed, a mask +- containing the bitwise OR of one or +- more of +- PNG_FREE_PLTE, PNG_FREE_TRNS, +- PNG_FREE_HIST, PNG_FREE_ICCP, +- PNG_FREE_PCAL, PNG_FREE_ROWS, +- PNG_FREE_SCAL, PNG_FREE_SPLT, +- PNG_FREE_TEXT, PNG_FREE_UNKN, +- or simply PNG_FREE_ALL +- seq - sequence number of item to be freed +- (-1 for all items) +- +-This function may be safely called when the relevant storage has +-already been freed, or has not yet been allocated, or was allocated +-by the user and not by libpng, and will in those +-cases do nothing. The "seq" parameter is ignored if only one item +-of the selected data type, such as PLTE, is allowed. If "seq" is not +--1, and multiple items are allowed for the data type identified in +-the mask, such as text or sPLT, only the n'th item in the structure +-is freed, where n is "seq". +- +-If you allocated data such as a palette that you passed +-in to libpng with png_set_*, you must not free it until just before the call to +-png_destroy_write_struct(). +- +-The default behavior is only to free data that was allocated internally +-by libpng. This can be changed, so that libpng will not free the data, +-or so that it will free data that was allocated by the user with png_malloc() +-or png_zalloc() and passed in via a png_set_*() function, with +- +- png_data_freer(png_ptr, info_ptr, freer, mask) +- mask - which data elements are affected +- same choices as in png_free_data() +- freer - one of +- PNG_DESTROY_WILL_FREE_DATA +- PNG_SET_WILL_FREE_DATA +- PNG_USER_WILL_FREE_DATA +- +-For example, to transfer responsibility for some data from a read structure +-to a write structure, you could use +- +- png_data_freer(read_ptr, read_info_ptr, +- PNG_USER_WILL_FREE_DATA, +- PNG_FREE_PLTE|PNG_FREE_tRNS|PNG_FREE_hIST) +- png_data_freer(write_ptr, write_info_ptr, +- PNG_DESTROY_WILL_FREE_DATA, +- PNG_FREE_PLTE|PNG_FREE_tRNS|PNG_FREE_hIST) +- +-thereby briefly reassigning responsibility for freeing to the user but +-immediately afterwards reassigning it once more to the write_destroy +-function. Having done this, it would then be safe to destroy the read +-structure and continue to use the PLTE, tRNS, and hIST data in the write +-structure. +- +-This function only affects data that has already been allocated. +-You can call this function before calling after the png_set_*() functions +-to control whether the user or png_destroy_*() is supposed to free the data. +-When the user assumes responsibility for libpng-allocated data, the +-application must use +-png_free() to free it, and when the user transfers responsibility to libpng +-for data that the user has allocated, the user must have used png_malloc() +-or png_zalloc() to allocate it. +- +-If you allocated text_ptr.text, text_ptr.lang, and text_ptr.translated_keyword +-separately, do not transfer responsibility for freeing text_ptr to libpng, +-because when libpng fills a png_text structure it combines these members with +-the key member, and png_free_data() will free only text_ptr.key. Similarly, +-if you transfer responsibility for free'ing text_ptr from libpng to your +-application, your application must not separately free those members. +-For a more compact example of writing a PNG image, see the file example.c. +- +-V. Modifying/Customizing libpng: +- +-There are two issues here. The first is changing how libpng does +-standard things like memory allocation, input/output, and error handling. +-The second deals with more complicated things like adding new chunks, +-adding new transformations, and generally changing how libpng works. +-Both of those are compile-time issues; that is, they are generally +-determined at the time the code is written, and there is rarely a need +-to provide the user with a means of changing them. +- +-Memory allocation, input/output, and error handling +- +-All of the memory allocation, input/output, and error handling in libpng +-goes through callbacks that are user-settable. The default routines are +-in pngmem.c, pngrio.c, pngwio.c, and pngerror.c, respectively. To change +-these functions, call the appropriate png_set_*_fn() function. +- +-Memory allocation is done through the functions png_malloc() +-and png_free(). These currently just call the standard C functions. If +-your pointers can't access more then 64K at a time, you will want to set +-MAXSEG_64K in zlib.h. Since it is unlikely that the method of handling +-memory allocation on a platform will change between applications, these +-functions must be modified in the library at compile time. If you prefer +-to use a different method of allocating and freeing data, you can use +-png_create_read_struct_2() or png_create_write_struct_2() to register +-your own functions as described above. +-These functions also provide a void pointer that can be retrieved via +- +- mem_ptr=png_get_mem_ptr(png_ptr); +- +-Your replacement memory functions must have prototypes as follows: +- +- png_voidp malloc_fn(png_structp png_ptr, +- png_size_t size); +- void free_fn(png_structp png_ptr, png_voidp ptr); +- +-Your malloc_fn() must return NULL in case of failure. The png_malloc() +-function will normally call png_error() if it receives a NULL from the +-system memory allocator or from your replacement malloc_fn(). +- +-Input/Output in libpng is done through png_read() and png_write(), +-which currently just call fread() and fwrite(). The FILE * is stored in +-png_struct and is initialized via png_init_io(). If you wish to change +-the method of I/O, the library supplies callbacks that you can set +-through the function png_set_read_fn() and png_set_write_fn() at run +-time, instead of calling the png_init_io() function. These functions +-also provide a void pointer that can be retrieved via the function +-png_get_io_ptr(). For example: +- +- png_set_read_fn(png_structp read_ptr, +- voidp read_io_ptr, png_rw_ptr read_data_fn) +- +- png_set_write_fn(png_structp write_ptr, +- voidp write_io_ptr, png_rw_ptr write_data_fn, +- png_flush_ptr output_flush_fn); +- +- voidp read_io_ptr = png_get_io_ptr(read_ptr); +- voidp write_io_ptr = png_get_io_ptr(write_ptr); +- +-The replacement I/O functions must have prototypes as follows: +- +- void user_read_data(png_structp png_ptr, +- png_bytep data, png_size_t length); +- void user_write_data(png_structp png_ptr, +- png_bytep data, png_size_t length); +- void user_flush_data(png_structp png_ptr); +- +-Supplying NULL for the read, write, or flush functions sets them back +-to using the default C stream functions. It is an error to read from +-a write stream, and vice versa. +- +-Error handling in libpng is done through png_error() and png_warning(). +-Errors handled through png_error() are fatal, meaning that png_error() +-should never return to its caller. Currently, this is handled via +-setjmp() and longjmp() (unless you have compiled libpng with +-PNG_SETJMP_NOT_SUPPORTED, in which case it is handled via PNG_ABORT()), +-but you could change this to do things like exit() if you should wish. +- +-On non-fatal errors, png_warning() is called +-to print a warning message, and then control returns to the calling code. +-By default png_error() and png_warning() print a message on stderr via +-fprintf() unless the library is compiled with PNG_NO_CONSOLE_IO defined +-(because you don't want the messages) or PNG_NO_STDIO defined (because +-fprintf() isn't available). If you wish to change the behavior of the error +-functions, you will need to set up your own message callbacks. These +-functions are normally supplied at the time that the png_struct is created. +-It is also possible to redirect errors and warnings to your own replacement +-functions after png_create_*_struct() has been called by calling: +- +- png_set_error_fn(png_structp png_ptr, +- png_voidp error_ptr, png_error_ptr error_fn, +- png_error_ptr warning_fn); +- +- png_voidp error_ptr = png_get_error_ptr(png_ptr); +- +-If NULL is supplied for either error_fn or warning_fn, then the libpng +-default function will be used, calling fprintf() and/or longjmp() if a +-problem is encountered. The replacement error functions should have +-parameters as follows: +- +- void user_error_fn(png_structp png_ptr, +- png_const_charp error_msg); +- void user_warning_fn(png_structp png_ptr, +- png_const_charp warning_msg); +- +-The motivation behind using setjmp() and longjmp() is the C++ throw and +-catch exception handling methods. This makes the code much easier to write, +-as there is no need to check every return code of every function call. +-However, there are some uncertainties about the status of local variables +-after a longjmp, so the user may want to be careful about doing anything after +-setjmp returns non-zero besides returning itself. Consult your compiler +-documentation for more details. For an alternative approach, you may wish +-to use the "cexcept" facility (see http://cexcept.sourceforge.net). +- +-Custom chunks +- +-If you need to read or write custom chunks, you may need to get deeper +-into the libpng code. The library now has mechanisms for storing +-and writing chunks of unknown type; you can even declare callbacks +-for custom chunks. However, this may not be good enough if the +-library code itself needs to know about interactions between your +-chunk and existing `intrinsic' chunks. +- +-If you need to write a new intrinsic chunk, first read the PNG +-specification. Acquire a first level of +-understanding of how it works. Pay particular attention to the +-sections that describe chunk names, and look at how other chunks were +-designed, so you can do things similarly. Second, check out the +-sections of libpng that read and write chunks. Try to find a chunk +-that is similar to yours and use it as a template. More details can +-be found in the comments inside the code. It is best to handle unknown +-chunks in a generic method, via callback functions, instead of by +-modifying libpng functions. +- +-If you wish to write your own transformation for the data, look through +-the part of the code that does the transformations, and check out some of +-the simpler ones to get an idea of how they work. Try to find a similar +-transformation to the one you want to add and copy off of it. More details +-can be found in the comments inside the code itself. +- +-Configuring for 16 bit platforms +- +-You will want to look into zconf.h to tell zlib (and thus libpng) that +-it cannot allocate more then 64K at a time. Even if you can, the memory +-won't be accessible. So limit zlib and libpng to 64K by defining MAXSEG_64K. +- +-Configuring for DOS +- +-For DOS users who only have access to the lower 640K, you will +-have to limit zlib's memory usage via a png_set_compression_mem_level() +-call. See zlib.h or zconf.h in the zlib library for more information. +- +-Configuring for Medium Model +- +-Libpng's support for medium model has been tested on most of the popular +-compilers. Make sure MAXSEG_64K gets defined, USE_FAR_KEYWORD gets +-defined, and FAR gets defined to far in pngconf.h, and you should be +-all set. Everything in the library (except for zlib's structure) is +-expecting far data. You must use the typedefs with the p or pp on +-the end for pointers (or at least look at them and be careful). Make +-note that the rows of data are defined as png_bytepp, which is an +-unsigned char far * far *. +- +-Configuring for gui/windowing platforms: +- +-You will need to write new error and warning functions that use the GUI +-interface, as described previously, and set them to be the error and +-warning functions at the time that png_create_*_struct() is called, +-in order to have them available during the structure initialization. +-They can be changed later via png_set_error_fn(). On some compilers, +-you may also have to change the memory allocators (png_malloc, etc.). +- +-Configuring for compiler xxx: +- +-All includes for libpng are in pngconf.h. If you need to add/change/delete +-an include, this is the place to do it. The includes that are not +-needed outside libpng are protected by the PNG_INTERNAL definition, +-which is only defined for those routines inside libpng itself. The +-files in libpng proper only include png.h, which includes pngconf.h. +- +-Configuring zlib: +- +-There are special functions to configure the compression. Perhaps the +-most useful one changes the compression level, which currently uses +-input compression values in the range 0 - 9. The library normally +-uses the default compression level (Z_DEFAULT_COMPRESSION = 6). Tests +-have shown that for a large majority of images, compression values in +-the range 3-6 compress nearly as well as higher levels, and do so much +-faster. For online applications it may be desirable to have maximum speed +-(Z_BEST_SPEED = 1). With versions of zlib after v0.99, you can also +-specify no compression (Z_NO_COMPRESSION = 0), but this would create +-files larger than just storing the raw bitmap. You can specify the +-compression level by calling: +- +- png_set_compression_level(png_ptr, level); +- +-Another useful one is to reduce the memory level used by the library. +-The memory level defaults to 8, but it can be lowered if you are +-short on memory (running DOS, for example, where you only have 640K). +-Note that the memory level does have an effect on compression; among +-other things, lower levels will result in sections of incompressible +-data being emitted in smaller stored blocks, with a correspondingly +-larger relative overhead of up to 15% in the worst case. +- +- png_set_compression_mem_level(png_ptr, level); +- +-The other functions are for configuring zlib. They are not recommended +-for normal use and may result in writing an invalid PNG file. See +-zlib.h for more information on what these mean. +- +- png_set_compression_strategy(png_ptr, +- strategy); +- png_set_compression_window_bits(png_ptr, +- window_bits); +- png_set_compression_method(png_ptr, method); +- png_set_compression_buffer_size(png_ptr, size); +- +-Controlling row filtering +- +-If you want to control whether libpng uses filtering or not, which +-filters are used, and how it goes about picking row filters, you +-can call one of these functions. The selection and configuration +-of row filters can have a significant impact on the size and +-encoding speed and a somewhat lesser impact on the decoding speed +-of an image. Filtering is enabled by default for RGB and grayscale +-images (with and without alpha), but not for paletted images nor +-for any images with bit depths less than 8 bits/pixel. +- +-The 'method' parameter sets the main filtering method, which is +-currently only '0' in the PNG 1.2 specification. The 'filters' +-parameter sets which filter(s), if any, should be used for each +-scanline. Possible values are PNG_ALL_FILTERS and PNG_NO_FILTERS +-to turn filtering on and off, respectively. +- +-Individual filter types are PNG_FILTER_NONE, PNG_FILTER_SUB, +-PNG_FILTER_UP, PNG_FILTER_AVG, PNG_FILTER_PAETH, which can be bitwise +-ORed together with '|' to specify one or more filters to use. +-These filters are described in more detail in the PNG specification. +-If you intend to change the filter type during the course of writing +-the image, you should start with flags set for all of the filters +-you intend to use so that libpng can initialize its internal +-structures appropriately for all of the filter types. (Note that this +-means the first row must always be adaptively filtered, because libpng +-currently does not allocate the filter buffers until png_write_row() +-is called for the first time.) +- +- filters = PNG_FILTER_NONE | PNG_FILTER_SUB +- PNG_FILTER_UP | PNG_FILTER_AVE | +- PNG_FILTER_PAETH | PNG_ALL_FILTERS; +- +- png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, +- filters); +- The second parameter can also be +- PNG_INTRAPIXEL_DIFFERENCING if you are +- writing a PNG to be embedded in a MNG +- datastream. This parameter must be the +- same as the value of filter_method used +- in png_set_IHDR(). +- +-It is also possible to influence how libpng chooses from among the +-available filters. This is done in one or both of two ways - by +-telling it how important it is to keep the same filter for successive +-rows, and by telling it the relative computational costs of the filters. +- +- double weights[3] = {1.5, 1.3, 1.1}, +- costs[PNG_FILTER_VALUE_LAST] = +- {1.0, 1.3, 1.3, 1.5, 1.7}; +- +- png_set_filter_heuristics(png_ptr, +- PNG_FILTER_HEURISTIC_WEIGHTED, 3, +- weights, costs); +- +-The weights are multiplying factors that indicate to libpng that the +-row filter should be the same for successive rows unless another row filter +-is that many times better than the previous filter. In the above example, +-if the previous 3 filters were SUB, SUB, NONE, the SUB filter could have a +-"sum of absolute differences" 1.5 x 1.3 times higher than other filters +-and still be chosen, while the NONE filter could have a sum 1.1 times +-higher than other filters and still be chosen. Unspecified weights are +-taken to be 1.0, and the specified weights should probably be declining +-like those above in order to emphasize recent filters over older filters. +- +-The filter costs specify for each filter type a relative decoding cost +-to be considered when selecting row filters. This means that filters +-with higher costs are less likely to be chosen over filters with lower +-costs, unless their "sum of absolute differences" is that much smaller. +-The costs do not necessarily reflect the exact computational speeds of +-the various filters, since this would unduly influence the final image +-size. +- +-Note that the numbers above were invented purely for this example and +-are given only to help explain the function usage. Little testing has +-been done to find optimum values for either the costs or the weights. +- +-Removing unwanted object code +- +-There are a bunch of #define's in pngconf.h that control what parts of +-libpng are compiled. All the defines end in _SUPPORTED. If you are +-never going to use a capability, you can change the #define to #undef +-before recompiling libpng and save yourself code and data space, or +-you can turn off individual capabilities with defines that begin with +-PNG_NO_. +- +-You can also turn all of the transforms and ancillary chunk capabilities +-off en masse with compiler directives that define +-PNG_NO_READ[or WRITE]_TRANSFORMS, or PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS, +-or all four, +-along with directives to turn on any of the capabilities that you do +-want. The PNG_NO_READ[or WRITE]_TRANSFORMS directives disable +-the extra transformations but still leave the library fully capable of reading +-and writing PNG files with all known public chunks +-Use of the PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS directive +-produces a library that is incapable of reading or writing ancillary chunks. +-If you are not using the progressive reading capability, you can +-turn that off with PNG_NO_PROGRESSIVE_READ (don't confuse +-this with the INTERLACING capability, which you'll still have). +- +-All the reading and writing specific code are in separate files, so the +-linker should only grab the files it needs. However, if you want to +-make sure, or if you are building a stand alone library, all the +-reading files start with pngr and all the writing files start with +-pngw. The files that don't match either (like png.c, pngtrans.c, etc.) +-are used for both reading and writing, and always need to be included. +-The progressive reader is in pngpread.c +- +-If you are creating or distributing a dynamically linked library (a .so +-or DLL file), you should not remove or disable any parts of the library, +-as this will cause applications linked with different versions of the +-library to fail if they call functions not available in your library. +-The size of the library itself should not be an issue, because only +-those sections that are actually used will be loaded into memory. +- +-Requesting debug printout +- +-The macro definition PNG_DEBUG can be used to request debugging +-printout. Set it to an integer value in the range 0 to 3. Higher +-numbers result in increasing amounts of debugging information. The +-information is printed to the "stderr" file, unless another file +-name is specified in the PNG_DEBUG_FILE macro definition. +- +-When PNG_DEBUG > 0, the following functions (macros) become available: +- +- png_debug(level, message) +- png_debug1(level, message, p1) +- png_debug2(level, message, p1, p2) +- +-in which "level" is compared to PNG_DEBUG to decide whether to print +-the message, "message" is the formatted string to be printed, +-and p1 and p2 are parameters that are to be embedded in the string +-according to printf-style formatting directives. For example, +- +- png_debug1(2, "foo=%d\n", foo); +- +-is expanded to +- +- if(PNG_DEBUG > 2) +- fprintf(PNG_DEBUG_FILE, "foo=%d\n", foo); +- +-When PNG_DEBUG is defined but is zero, the macros aren't defined, but you +-can still use PNG_DEBUG to control your own debugging: +- +- #ifdef PNG_DEBUG +- fprintf(stderr, ... +- #endif +- +-When PNG_DEBUG = 1, the macros are defined, but only png_debug statements +-having level = 0 will be printed. There aren't any such statements in +-this version of libpng, but if you insert some they will be printed. +- +-VII. MNG support +- +-The MNG specification (available at http://www.libpng.org/pub/mng) allows +-certain extensions to PNG for PNG images that are embedded in MNG datastreams. +-Libpng can support some of these extensions. To enable them, use the +-png_permit_mng_features() function: +- +- feature_set = png_permit_mng_features(png_ptr, mask) +- mask is a png_uint_32 containing the bitwise OR of the +- features you want to enable. These include +- PNG_FLAG_MNG_EMPTY_PLTE +- PNG_FLAG_MNG_FILTER_64 +- PNG_ALL_MNG_FEATURES +- feature_set is a png_uint_32 that is the bitwise AND of +- your mask with the set of MNG features that is +- supported by the version of libpng that you are using. +- +-It is an error to use this function when reading or writing a standalone +-PNG file with the PNG 8-byte signature. The PNG datastream must be wrapped +-in a MNG datastream. As a minimum, it must have the MNG 8-byte signature +-and the MHDR and MEND chunks. Libpng does not provide support for these +-or any other MNG chunks; your application must provide its own support for +-them. You may wish to consider using libmng (available at +-http://www.libmng.com) instead. +- +-VIII. Changes to Libpng from version 0.88 +- +-It should be noted that versions of libpng later than 0.96 are not +-distributed by the original libpng author, Guy Schalnat, nor by +-Andreas Dilger, who had taken over from Guy during 1996 and 1997, and +-distributed versions 0.89 through 0.96, but rather by another member +-of the original PNG Group, Glenn Randers-Pehrson. Guy and Andreas are +-still alive and well, but they have moved on to other things. +- +-The old libpng functions png_read_init(), png_write_init(), +-png_info_init(), png_read_destroy(), and png_write_destroy() have been +-moved to PNG_INTERNAL in version 0.95 to discourage their use. These +-functions will be removed from libpng version 2.0.0. +- +-The preferred method of creating and initializing the libpng structures is +-via the png_create_read_struct(), png_create_write_struct(), and +-png_create_info_struct() because they isolate the size of the structures +-from the application, allow version error checking, and also allow the +-use of custom error handling routines during the initialization, which +-the old functions do not. The functions png_read_destroy() and +-png_write_destroy() do not actually free the memory that libpng +-allocated for these structs, but just reset the data structures, so they +-can be used instead of png_destroy_read_struct() and +-png_destroy_write_struct() if you feel there is too much system overhead +-allocating and freeing the png_struct for each image read. +- +-Setting the error callbacks via png_set_message_fn() before +-png_read_init() as was suggested in libpng-0.88 is no longer supported +-because this caused applications that do not use custom error functions +-to fail if the png_ptr was not initialized to zero. It is still possible +-to set the error callbacks AFTER png_read_init(), or to change them with +-png_set_error_fn(), which is essentially the same function, but with a new +-name to force compilation errors with applications that try to use the old +-method. +- +-Starting with version 1.0.7, you can find out which version of the library +-you are using at run-time: +- +- png_uint_32 libpng_vn = png_access_version_number(); +- +-The number libpng_vn is constructed from the major version, minor +-version with leading zero, and release number with leading zero, +-(e.g., libpng_vn for version 1.0.7 is 10007). +- +-You can also check which version of png.h you used when compiling your +-application: +- +- png_uint_32 application_vn = PNG_LIBPNG_VER; +- +-IX. Y2K Compliance in libpng +- +-December 14, 2007 +- +-Since the PNG Development group is an ad-hoc body, we can't make +-an official declaration. +- +-This is your unofficial assurance that libpng from version 0.71 and +-upward through 1.2.24 are Y2K compliant. It is my belief that earlier +-versions were also Y2K compliant. +- +-Libpng only has three year fields. One is a 2-byte unsigned integer that +-will hold years up to 65535. The other two hold the date in text +-format, and will hold years up to 9999. +- +-The integer is +- "png_uint_16 year" in png_time_struct. +- +-The strings are +- "png_charp time_buffer" in png_struct and +- "near_time_buffer", which is a local character string in png.c. +- +-There are seven time-related functions: +- +- png_convert_to_rfc_1123() in png.c +- (formerly png_convert_to_rfc_1152() in error) +- png_convert_from_struct_tm() in pngwrite.c, called +- in pngwrite.c +- png_convert_from_time_t() in pngwrite.c +- png_get_tIME() in pngget.c +- png_handle_tIME() in pngrutil.c, called in pngread.c +- png_set_tIME() in pngset.c +- png_write_tIME() in pngwutil.c, called in pngwrite.c +- +-All appear to handle dates properly in a Y2K environment. The +-png_convert_from_time_t() function calls gmtime() to convert from system +-clock time, which returns (year - 1900), which we properly convert to +-the full 4-digit year. There is a possibility that applications using +-libpng are not passing 4-digit years into the png_convert_to_rfc_1123() +-function, or that they are incorrectly passing only a 2-digit year +-instead of "year - 1900" into the png_convert_from_struct_tm() function, +-but this is not under our control. The libpng documentation has always +-stated that it works with 4-digit years, and the APIs have been +-documented as such. +- +-The tIME chunk itself is also Y2K compliant. It uses a 2-byte unsigned +-integer to hold the year, and can hold years as large as 65535. +- +-zlib, upon which libpng depends, is also Y2K compliant. It contains +-no date-related code. +- +- +- Glenn Randers-Pehrson +- libpng maintainer +- PNG Development Group +diff --git a/thirdparty/libpng/libpng_vs2010.vcxproj b/thirdparty/libpng/libpng_vs2010.vcxproj +deleted file mode 100644 +index 6f4a6c0..0000000 +--- a/thirdparty/libpng/libpng_vs2010.vcxproj ++++ /dev/null +@@ -1,246 +0,0 @@ +- +- +- +- +- Debug +- Win32 +- +- +- Debug +- x64 +- +- +- Release LIB +- Win32 +- +- +- Release LIB +- x64 +- +- +- Release +- Win32 +- +- +- Release +- x64 +- +- +- +- {71DADA6A-5801-4188-8793-A4A48BAC164B} +- libpng +- Win32Proj +- libpng +- +- +- +- StaticLibrary +- Unicode +- true +- +- +- StaticLibrary +- Unicode +- true +- +- +- StaticLibrary +- Unicode +- true +- +- +- StaticLibrary +- Unicode +- true +- +- +- StaticLibrary +- Unicode +- +- +- StaticLibrary +- Unicode +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- <_ProjectFileVersion>10.0.30319.1 +- $(SolutionDir)\thirdparty\lib\ +- $(SolutionDir)\thirdparty\lib\$(Platform)\ +- $(Configuration)\ +- $(SolutionDir)\thirdparty\lib\ +- $(SolutionDir)\thirdparty\lib\$(Platform)\ +- $(Configuration)\ +- $(SolutionDir)\thirdparty\lib\ +- $(SolutionDir)\thirdparty\lib\$(Platform)\ +- $(Configuration)\ +- $(Configuration)\ +- AllRules.ruleset +- AllRules.ruleset +- +- +- +- +- AllRules.ruleset +- AllRules.ruleset +- +- +- +- +- AllRules.ruleset +- AllRules.ruleset +- +- +- +- +- libpngd +- libpngd +- libpng +- libpng +- libpng +- libpng +- +- +- +- Disabled +- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) +- WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions) +- EnableFastChecks +- MultiThreadedDebugDLL +- +- +- Level3 +- EditAndContinue +- 4267;4996;%(DisableSpecificWarnings) +- true +- +- +- +- +- +- Disabled +- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) +- _WIN64;_DEBUG;_LIB;%(PreprocessorDefinitions) +- EnableFastChecks +- MultiThreadedDebugDLL +- +- +- Level3 +- ProgramDatabase +- 4267;4996;%(DisableSpecificWarnings) +- true +- +- +- +- +- +- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) +- WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions) +- MultiThreadedDLL +- +- +- Level3 +- ProgramDatabase +- 4267;4996;%(DisableSpecificWarnings) +- MinSpace +- Size +- true +- +- +- +- +- +- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) +- WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions) +- MultiThreadedDLL +- +- +- Level3 +- ProgramDatabase +- 4267;4996;%(DisableSpecificWarnings) +- MinSpace +- Size +- true +- +- +- +- +- +- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) +- WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions) +- MultiThreaded +- +- +- Level3 +- ProgramDatabase +- 4267;4996;%(DisableSpecificWarnings) +- MinSpace +- Size +- true +- +- +- +- +- +- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) +- WIN64;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions) +- MultiThreaded +- +- +- Level3 +- ProgramDatabase +- 4267;4996;%(DisableSpecificWarnings) +- true +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +\ No newline at end of file +diff --git a/thirdparty/libpng/png.c b/thirdparty/libpng/png.c +deleted file mode 100644 +index 4baa697..0000000 +--- a/thirdparty/libpng/png.c ++++ /dev/null +@@ -1,826 +0,0 @@ +- +-/* png.c - location for general purpose libpng functions +- * +- * libpng version 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- */ +- +-#define PNG_INTERNAL +-#define PNG_NO_EXTERN +-#include "png.h" +- +-/* Generate a compiler error if there is an old png.h in the search path. */ +-typedef version_1_2_7 Your_png_h_is_not_version_1_2_7; +- +-/* Version information for C files. This had better match the version +- * string defined in png.h. */ +- +-#ifdef PNG_USE_GLOBAL_ARRAYS +-/* png_libpng_ver was changed to a function in version 1.0.5c */ +-const char png_libpng_ver[18] = PNG_LIBPNG_VER_STRING; +- +-/* png_sig was changed to a function in version 1.0.5c */ +-/* Place to hold the signature string for a PNG file. */ +-const png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10}; +- +-/* Invoke global declarations for constant strings for known chunk types */ +-PNG_IHDR; +-PNG_IDAT; +-PNG_IEND; +-PNG_PLTE; +-PNG_bKGD; +-PNG_cHRM; +-PNG_gAMA; +-PNG_hIST; +-PNG_iCCP; +-PNG_iTXt; +-PNG_oFFs; +-PNG_pCAL; +-PNG_sCAL; +-PNG_pHYs; +-PNG_sBIT; +-PNG_sPLT; +-PNG_sRGB; +-PNG_tEXt; +-PNG_tIME; +-PNG_tRNS; +-PNG_zTXt; +- +-/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ +- +-/* start of interlace block */ +-const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; +- +-/* offset to next interlace block */ +-const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; +- +-/* start of interlace block in the y direction */ +-const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; +- +-/* offset to next interlace block in the y direction */ +-const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; +- +-/* width of interlace block (used in assembler routines only) */ +-#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW +-const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; +-#endif +- +-/* Height of interlace block. This is not currently used - if you need +- * it, uncomment it here and in png.h +-const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; +-*/ +- +-/* Mask to determine which pixels are valid in a pass */ +-const int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; +- +-/* Mask to determine which pixels to overwrite while displaying */ +-const int FARDATA png_pass_dsp_mask[] +- = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; +- +-#endif +- +-/* Tells libpng that we have already handled the first "num_bytes" bytes +- * of the PNG file signature. If the PNG data is embedded into another +- * stream we can set num_bytes = 8 so that libpng will not attempt to read +- * or write any of the magic bytes before it starts on the IHDR. +- */ +- +-void PNGAPI +-png_set_sig_bytes(png_structp png_ptr, int num_bytes) +-{ +- png_debug(1, "in png_set_sig_bytes\n"); +- if (num_bytes > 8) +- png_error(png_ptr, "Too many bytes for PNG signature."); +- +- png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes); +-} +- +-/* Checks whether the supplied bytes match the PNG signature. We allow +- * checking less than the full 8-byte signature so that those apps that +- * already read the first few bytes of a file to determine the file type +- * can simply check the remaining bytes for extra assurance. Returns +- * an integer less than, equal to, or greater than zero if sig is found, +- * respectively, to be less than, to match, or be greater than the correct +- * PNG signature (this is the same behaviour as strcmp, memcmp, etc). +- */ +-int PNGAPI +-png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check) +-{ +- png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; +- if (num_to_check > 8) +- num_to_check = 8; +- else if (num_to_check < 1) +- return (0); +- +- if (start > 7) +- return (0); +- +- if (start + num_to_check > 8) +- num_to_check = 8 - start; +- +- return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check))); +-} +- +-/* (Obsolete) function to check signature bytes. It does not allow one +- * to check a partial signature. This function might be removed in the +- * future - use png_sig_cmp(). Returns true (nonzero) if the file is a PNG. +- */ +-int PNGAPI +-png_check_sig(png_bytep sig, int num) +-{ +- return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num)); +-} +- +-/* Function to allocate memory for zlib and clear it to 0. */ +-#ifdef PNG_1_0_X +-voidpf PNGAPI +-#else +-voidpf /* private */ +-#endif +-png_zalloc(voidpf png_ptr, uInt items, uInt size) +-{ +- png_voidp ptr; +- png_structp p=png_ptr; +- png_uint_32 save_flags=p->flags; +- png_uint_32 num_bytes; +- +- if (items > PNG_UINT_32_MAX/size) +- { +- png_warning (png_ptr, "Potential overflow in png_zalloc()"); +- return (NULL); +- } +- num_bytes = (png_uint_32)items * size; +- +- p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; +- ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes); +- p->flags=save_flags; +- +-#if defined(PNG_1_0_X) && !defined(PNG_NO_ZALLOC_ZERO) +- if (ptr == NULL) +- return ((voidpf)ptr); +- +- if (num_bytes > (png_uint_32)0x8000L) +- { +- png_memset(ptr, 0, (png_size_t)0x8000L); +- png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0, +- (png_size_t)(num_bytes - (png_uint_32)0x8000L)); +- } +- else +- { +- png_memset(ptr, 0, (png_size_t)num_bytes); +- } +-#endif +- return ((voidpf)ptr); +-} +- +-/* function to free memory for zlib */ +-#ifdef PNG_1_0_X +-void PNGAPI +-#else +-void /* private */ +-#endif +-png_zfree(voidpf png_ptr, voidpf ptr) +-{ +- png_free((png_structp)png_ptr, (png_voidp)ptr); +-} +- +-/* Reset the CRC variable to 32 bits of 1's. Care must be taken +- * in case CRC is > 32 bits to leave the top bits 0. +- */ +-void /* PRIVATE */ +-png_reset_crc(png_structp png_ptr) +-{ +- png_ptr->crc = crc32(0, Z_NULL, 0); +-} +- +-/* Calculate the CRC over a section of data. We can only pass as +- * much data to this routine as the largest single buffer size. We +- * also check that this data will actually be used before going to the +- * trouble of calculating it. +- */ +-void /* PRIVATE */ +-png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length) +-{ +- int need_crc = 1; +- +- if (png_ptr->chunk_name[0] & 0x20) /* ancillary */ +- { +- if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == +- (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) +- need_crc = 0; +- } +- else /* critical */ +- { +- if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) +- need_crc = 0; +- } +- +- if (need_crc) +- png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length); +-} +- +-/* Allocate the memory for an info_struct for the application. We don't +- * really need the png_ptr, but it could potentially be useful in the +- * future. This should be used in favour of malloc(png_sizeof(png_info)) +- * and png_info_init() so that applications that want to use a shared +- * libpng don't have to be recompiled if png_info changes size. +- */ +-png_infop PNGAPI +-png_create_info_struct(png_structp png_ptr) +-{ +- png_infop info_ptr; +- +- png_debug(1, "in png_create_info_struct\n"); +- if(png_ptr == NULL) return (NULL); +-#ifdef PNG_USER_MEM_SUPPORTED +- info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO, +- png_ptr->malloc_fn, png_ptr->mem_ptr); +-#else +- info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); +-#endif +- if (info_ptr != NULL) +- png_info_init_3(&info_ptr, png_sizeof(png_info)); +- +- return (info_ptr); +-} +- +-/* This function frees the memory associated with a single info struct. +- * Normally, one would use either png_destroy_read_struct() or +- * png_destroy_write_struct() to free an info struct, but this may be +- * useful for some applications. +- */ +-void PNGAPI +-png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr) +-{ +- png_infop info_ptr = NULL; +- +- png_debug(1, "in png_destroy_info_struct\n"); +- if (info_ptr_ptr != NULL) +- info_ptr = *info_ptr_ptr; +- +- if (info_ptr != NULL) +- { +- png_info_destroy(png_ptr, info_ptr); +- +-#ifdef PNG_USER_MEM_SUPPORTED +- png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn, +- png_ptr->mem_ptr); +-#else +- png_destroy_struct((png_voidp)info_ptr); +-#endif +- *info_ptr_ptr = NULL; +- } +-} +- +-/* Initialize the info structure. This is now an internal function (0.89) +- * and applications using it are urged to use png_create_info_struct() +- * instead. +- */ +-#undef png_info_init +-void PNGAPI +-png_info_init(png_infop info_ptr) +-{ +- /* We only come here via pre-1.0.12-compiled applications */ +- png_info_init_3(&info_ptr, 0); +-} +- +-void PNGAPI +-png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size) +-{ +- png_infop info_ptr = *ptr_ptr; +- +- png_debug(1, "in png_info_init_3\n"); +- +- if(png_sizeof(png_info) > png_info_struct_size) +- { +- png_destroy_struct(info_ptr); +- info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); +- *ptr_ptr = info_ptr; +- } +- +- /* set everything to 0 */ +- png_memset(info_ptr, 0, png_sizeof (png_info)); +-} +- +-#ifdef PNG_FREE_ME_SUPPORTED +-void PNGAPI +-png_data_freer(png_structp png_ptr, png_infop info_ptr, +- int freer, png_uint_32 mask) +-{ +- png_debug(1, "in png_data_freer\n"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- if(freer == PNG_DESTROY_WILL_FREE_DATA) +- info_ptr->free_me |= mask; +- else if(freer == PNG_USER_WILL_FREE_DATA) +- info_ptr->free_me &= ~mask; +- else +- png_warning(png_ptr, +- "Unknown freer parameter in png_data_freer."); +-} +-#endif +- +-void PNGAPI +-png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, +- int num) +-{ +- png_debug(1, "in png_free_data\n"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +-#if defined(PNG_TEXT_SUPPORTED) +-/* free text item num or (if num == -1) all text items */ +-#ifdef PNG_FREE_ME_SUPPORTED +-if ((mask & PNG_FREE_TEXT) & info_ptr->free_me) +-#else +-if (mask & PNG_FREE_TEXT) +-#endif +-{ +- if (num != -1) +- { +- if (info_ptr->text && info_ptr->text[num].key) +- { +- png_free(png_ptr, info_ptr->text[num].key); +- info_ptr->text[num].key = NULL; +- } +- } +- else +- { +- int i; +- for (i = 0; i < info_ptr->num_text; i++) +- png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i); +- png_free(png_ptr, info_ptr->text); +- info_ptr->text = NULL; +- info_ptr->num_text=0; +- } +-} +-#endif +- +-#if defined(PNG_tRNS_SUPPORTED) +-/* free any tRNS entry */ +-#ifdef PNG_FREE_ME_SUPPORTED +-if ((mask & PNG_FREE_TRNS) & info_ptr->free_me) +-#else +-if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS)) +-#endif +-{ +- png_free(png_ptr, info_ptr->trans); +- info_ptr->valid &= ~PNG_INFO_tRNS; +-#ifndef PNG_FREE_ME_SUPPORTED +- png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; +-#endif +- info_ptr->trans = NULL; +-} +-#endif +- +-#if defined(PNG_sCAL_SUPPORTED) +-/* free any sCAL entry */ +-#ifdef PNG_FREE_ME_SUPPORTED +-if ((mask & PNG_FREE_SCAL) & info_ptr->free_me) +-#else +-if (mask & PNG_FREE_SCAL) +-#endif +-{ +-#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) +- png_free(png_ptr, info_ptr->scal_s_width); +- png_free(png_ptr, info_ptr->scal_s_height); +- info_ptr->scal_s_width = NULL; +- info_ptr->scal_s_height = NULL; +-#endif +- info_ptr->valid &= ~PNG_INFO_sCAL; +-} +-#endif +- +-#if defined(PNG_pCAL_SUPPORTED) +-/* free any pCAL entry */ +-#ifdef PNG_FREE_ME_SUPPORTED +-if ((mask & PNG_FREE_PCAL) & info_ptr->free_me) +-#else +-if (mask & PNG_FREE_PCAL) +-#endif +-{ +- png_free(png_ptr, info_ptr->pcal_purpose); +- png_free(png_ptr, info_ptr->pcal_units); +- info_ptr->pcal_purpose = NULL; +- info_ptr->pcal_units = NULL; +- if (info_ptr->pcal_params != NULL) +- { +- int i; +- for (i = 0; i < (int)info_ptr->pcal_nparams; i++) +- { +- png_free(png_ptr, info_ptr->pcal_params[i]); +- info_ptr->pcal_params[i]=NULL; +- } +- png_free(png_ptr, info_ptr->pcal_params); +- info_ptr->pcal_params = NULL; +- } +- info_ptr->valid &= ~PNG_INFO_pCAL; +-} +-#endif +- +-#if defined(PNG_iCCP_SUPPORTED) +-/* free any iCCP entry */ +-#ifdef PNG_FREE_ME_SUPPORTED +-if ((mask & PNG_FREE_ICCP) & info_ptr->free_me) +-#else +-if (mask & PNG_FREE_ICCP) +-#endif +-{ +- png_free(png_ptr, info_ptr->iccp_name); +- png_free(png_ptr, info_ptr->iccp_profile); +- info_ptr->iccp_name = NULL; +- info_ptr->iccp_profile = NULL; +- info_ptr->valid &= ~PNG_INFO_iCCP; +-} +-#endif +- +-#if defined(PNG_sPLT_SUPPORTED) +-/* free a given sPLT entry, or (if num == -1) all sPLT entries */ +-#ifdef PNG_FREE_ME_SUPPORTED +-if ((mask & PNG_FREE_SPLT) & info_ptr->free_me) +-#else +-if (mask & PNG_FREE_SPLT) +-#endif +-{ +- if (num != -1) +- { +- if(info_ptr->splt_palettes) +- { +- png_free(png_ptr, info_ptr->splt_palettes[num].name); +- png_free(png_ptr, info_ptr->splt_palettes[num].entries); +- info_ptr->splt_palettes[num].name = NULL; +- info_ptr->splt_palettes[num].entries = NULL; +- } +- } +- else +- { +- if(info_ptr->splt_palettes_num) +- { +- int i; +- for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) +- png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i); +- +- png_free(png_ptr, info_ptr->splt_palettes); +- info_ptr->splt_palettes = NULL; +- info_ptr->splt_palettes_num = 0; +- } +- info_ptr->valid &= ~PNG_INFO_sPLT; +- } +-} +-#endif +- +-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +-#ifdef PNG_FREE_ME_SUPPORTED +-if ((mask & PNG_FREE_UNKN) & info_ptr->free_me) +-#else +-if (mask & PNG_FREE_UNKN) +-#endif +-{ +- if (num != -1) +- { +- if(info_ptr->unknown_chunks) +- { +- png_free(png_ptr, info_ptr->unknown_chunks[num].data); +- info_ptr->unknown_chunks[num].data = NULL; +- } +- } +- else +- { +- int i; +- +- if(info_ptr->unknown_chunks_num) +- { +- for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++) +- png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i); +- +- png_free(png_ptr, info_ptr->unknown_chunks); +- info_ptr->unknown_chunks = NULL; +- info_ptr->unknown_chunks_num = 0; +- } +- } +-} +-#endif +- +-#if defined(PNG_hIST_SUPPORTED) +-/* free any hIST entry */ +-#ifdef PNG_FREE_ME_SUPPORTED +-if ((mask & PNG_FREE_HIST) & info_ptr->free_me) +-#else +-if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST)) +-#endif +-{ +- png_free(png_ptr, info_ptr->hist); +- info_ptr->hist = NULL; +- info_ptr->valid &= ~PNG_INFO_hIST; +-#ifndef PNG_FREE_ME_SUPPORTED +- png_ptr->flags &= ~PNG_FLAG_FREE_HIST; +-#endif +-} +-#endif +- +-/* free any PLTE entry that was internally allocated */ +-#ifdef PNG_FREE_ME_SUPPORTED +-if ((mask & PNG_FREE_PLTE) & info_ptr->free_me) +-#else +-if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE)) +-#endif +-{ +- png_zfree(png_ptr, info_ptr->palette); +- info_ptr->palette = NULL; +- info_ptr->valid &= ~PNG_INFO_PLTE; +-#ifndef PNG_FREE_ME_SUPPORTED +- png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; +-#endif +- info_ptr->num_palette = 0; +-} +- +-#if defined(PNG_INFO_IMAGE_SUPPORTED) +-/* free any image bits attached to the info structure */ +-#ifdef PNG_FREE_ME_SUPPORTED +-if ((mask & PNG_FREE_ROWS) & info_ptr->free_me) +-#else +-if (mask & PNG_FREE_ROWS) +-#endif +-{ +- if(info_ptr->row_pointers) +- { +- int row; +- for (row = 0; row < (int)info_ptr->height; row++) +- { +- png_free(png_ptr, info_ptr->row_pointers[row]); +- info_ptr->row_pointers[row]=NULL; +- } +- png_free(png_ptr, info_ptr->row_pointers); +- info_ptr->row_pointers=NULL; +- } +- info_ptr->valid &= ~PNG_INFO_IDAT; +-} +-#endif +- +-#ifdef PNG_FREE_ME_SUPPORTED +- if(num == -1) +- info_ptr->free_me &= ~mask; +- else +- info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL); +-#endif +-} +- +-/* This is an internal routine to free any memory that the info struct is +- * pointing to before re-using it or freeing the struct itself. Recall +- * that png_free() checks for NULL pointers for us. +- */ +-void /* PRIVATE */ +-png_info_destroy(png_structp png_ptr, png_infop info_ptr) +-{ +- png_debug(1, "in png_info_destroy\n"); +- +- png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); +- +-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +- if (png_ptr->num_chunk_list) +- { +- png_free(png_ptr, png_ptr->chunk_list); +- png_ptr->chunk_list=NULL; +- png_ptr->num_chunk_list=0; +- } +-#endif +- +- png_info_init_3(&info_ptr, png_sizeof(png_info)); +-} +- +-/* This function returns a pointer to the io_ptr associated with the user +- * functions. The application should free any memory associated with this +- * pointer before png_write_destroy() or png_read_destroy() are called. +- */ +-png_voidp PNGAPI +-png_get_io_ptr(png_structp png_ptr) +-{ +- return (png_ptr->io_ptr); +-} +- +-#if !defined(PNG_NO_STDIO) +-/* Initialize the default input/output functions for the PNG file. If you +- * use your own read or write routines, you can call either png_set_read_fn() +- * or png_set_write_fn() instead of png_init_io(). If you have defined +- * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't +- * necessarily available. +- */ +-void PNGAPI +-png_init_io(png_structp png_ptr, png_FILE_p fp) +-{ +- png_debug(1, "in png_init_io\n"); +- png_ptr->io_ptr = (png_voidp)fp; +-} +-#endif +- +-#if defined(PNG_TIME_RFC1123_SUPPORTED) +-/* Convert the supplied time into an RFC 1123 string suitable for use in +- * a "Creation Time" or other text-based time string. +- */ +-png_charp PNGAPI +-png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime) +-{ +- static PNG_CONST char short_months[12][4] = +- {"Jan", "Feb", "Mar", "Apr", "May", "Jun", +- "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; +- +- if (png_ptr->time_buffer == NULL) +- { +- png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29* +- png_sizeof(char))); +- } +- +-#if defined(_WIN32_WCE) +- { +- wchar_t time_buf[29]; +- wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"), +- ptime->day % 32, short_months[(ptime->month - 1) % 12], +- ptime->year, ptime->hour % 24, ptime->minute % 60, +- ptime->second % 61); +- WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29, +- NULL, NULL); +- } +-#else +-#ifdef USE_FAR_KEYWORD +- { +- char near_time_buf[29]; +- sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000", +- ptime->day % 32, short_months[(ptime->month - 1) % 12], +- ptime->year, ptime->hour % 24, ptime->minute % 60, +- ptime->second % 61); +- png_memcpy(png_ptr->time_buffer, near_time_buf, +- 29*png_sizeof(char)); +- } +-#else +- sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000", +- ptime->day % 32, short_months[(ptime->month - 1) % 12], +- ptime->year, ptime->hour % 24, ptime->minute % 60, +- ptime->second % 61); +-#endif +-#endif /* _WIN32_WCE */ +- return ((png_charp)png_ptr->time_buffer); +-} +-#endif /* PNG_TIME_RFC1123_SUPPORTED */ +- +-#if 0 +-/* Signature string for a PNG file. */ +-png_bytep PNGAPI +-png_sig_bytes(void) +-{ +- return ((png_bytep)"\211\120\116\107\015\012\032\012"); +-} +-#endif +- +-png_charp PNGAPI +-png_get_copyright(png_structp png_ptr) +-{ +- if (&png_ptr != NULL) /* silence compiler warning about unused png_ptr */ +- return ((png_charp) "\n libpng version 1.2.7 - September 12, 2004\n\ +- Copyright (c) 1998-2004 Glenn Randers-Pehrson\n\ +- Copyright (c) 1996-1997 Andreas Dilger\n\ +- Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n"); +- return ((png_charp) ""); +-} +- +-/* The following return the library version as a short string in the +- * format 1.0.0 through 99.99.99zz. To get the version of *.h files +- * used with your application, print out PNG_LIBPNG_VER_STRING, which +- * is defined in png.h. +- * Note: now there is no difference between png_get_libpng_ver() and +- * png_get_header_ver(). Due to the version_nn_nn_nn typedef guard, +- * it is guaranteed that png.c uses the correct version of png.h. +- */ +-png_charp PNGAPI +-png_get_libpng_ver(png_structp png_ptr) +-{ +- /* Version of *.c files used when building libpng */ +- if (&png_ptr != NULL) /* silence compiler warning about unused png_ptr */ +- return ((png_charp) PNG_LIBPNG_VER_STRING); +- return ((png_charp) ""); +-} +- +-png_charp PNGAPI +-png_get_header_ver(png_structp png_ptr) +-{ +- /* Version of *.h files used when building libpng */ +- if (&png_ptr != NULL) /* silence compiler warning about unused png_ptr */ +- return ((png_charp) PNG_LIBPNG_VER_STRING); +- return ((png_charp) ""); +-} +- +-png_charp PNGAPI +-png_get_header_version(png_structp png_ptr) +-{ +- /* Returns longer string containing both version and date */ +- if (&png_ptr != NULL) /* silence compiler warning about unused png_ptr */ +- return ((png_charp) PNG_HEADER_VERSION_STRING); +- return ((png_charp) ""); +-} +- +-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +-int PNGAPI +-png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name) +-{ +- /* check chunk_name and return "keep" value if it's on the list, else 0 */ +- int i; +- png_bytep p; +- if((png_ptr == NULL && chunk_name == NULL) || png_ptr->num_chunk_list<=0) +- return 0; +- p=png_ptr->chunk_list+png_ptr->num_chunk_list*5-5; +- for (i = png_ptr->num_chunk_list; i; i--, p-=5) +- if (!png_memcmp(chunk_name, p, 4)) +- return ((int)*(p+4)); +- return 0; +-} +-#endif +- +-/* This function, added to libpng-1.0.6g, is untested. */ +-int PNGAPI +-png_reset_zstream(png_structp png_ptr) +-{ +- return (inflateReset(&png_ptr->zstream)); +-} +- +-/* This function was added to libpng-1.0.7 */ +-png_uint_32 PNGAPI +-png_access_version_number(void) +-{ +- /* Version of *.c files used when building libpng */ +- return((png_uint_32) PNG_LIBPNG_VER); +-} +- +- +-#if !defined(PNG_1_0_X) +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +- /* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */ +-/* this INTERNAL function was added to libpng 1.2.0 */ +-void /* PRIVATE */ +-png_init_mmx_flags (png_structp png_ptr) +-{ +- png_ptr->mmx_rowbytes_threshold = 0; +- png_ptr->mmx_bitdepth_threshold = 0; +- +-# if (defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD)) +- +- png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_COMPILED; +- +- if (png_mmx_support() > 0) { +- png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU +-# ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW +- | PNG_ASM_FLAG_MMX_READ_COMBINE_ROW +-# endif +-# ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE +- | PNG_ASM_FLAG_MMX_READ_INTERLACE +-# endif +-# ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW +- ; +-# else +- | PNG_ASM_FLAG_MMX_READ_FILTER_SUB +- | PNG_ASM_FLAG_MMX_READ_FILTER_UP +- | PNG_ASM_FLAG_MMX_READ_FILTER_AVG +- | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ; +- +- png_ptr->mmx_rowbytes_threshold = PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT; +- png_ptr->mmx_bitdepth_threshold = PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT; +-# endif +- } else { +- png_ptr->asm_flags &= ~( PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU +- | PNG_MMX_READ_FLAGS +- | PNG_MMX_WRITE_FLAGS ); +- } +- +-# else /* !((PNGVCRD || PNGGCCRD) && PNG_ASSEMBLER_CODE_SUPPORTED)) */ +- +- /* clear all MMX flags; no support is compiled in */ +- png_ptr->asm_flags &= ~( PNG_MMX_FLAGS ); +- +-# endif /* ?(PNGVCRD || PNGGCCRD) */ +-} +- +-#endif /* !(PNG_ASSEMBLER_CODE_SUPPORTED) */ +- +-/* this function was added to libpng 1.2.0 */ +-#if !defined(PNG_USE_PNGGCCRD) && \ +- !(defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD)) +-int PNGAPI +-png_mmx_support(void) +-{ +- return -1; +-} +-#endif +-#endif /* PNG_1_0_X */ +- +-#ifdef PNG_SIZE_T +-/* Added at libpng version 1.2.6 */ +- PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size)); +-png_size_t PNGAPI +-png_convert_size(size_t size) +-{ +- if (size > (png_size_t)-1) +- PNG_ABORT(); /* We haven't got access to png_ptr, so no png_error() */ +- return ((png_size_t)size); +-} +-#endif /* PNG_SIZE_T */ +diff --git a/thirdparty/libpng/png.h b/thirdparty/libpng/png.h +deleted file mode 100644 +index 6209cb6..0000000 +--- a/thirdparty/libpng/png.h ++++ /dev/null +@@ -1,3361 +0,0 @@ +-/* png.h - header file for PNG reference library +- * +- * libpng version 1.2.7 - September 12, 2004 +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- * +- * Authors and maintainers: +- * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat +- * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger +- * libpng versions 0.97, January 1998, through 1.2.7 - September 12, 2004: Glenn +- * See also "Contributing Authors", below. +- * +- * Note about libpng version numbers: +- * +- * Due to various miscommunications, unforeseen code incompatibilities +- * and occasional factors outside the authors' control, version numbering +- * on the library has not always been consistent and straightforward. +- * The following table summarizes matters since version 0.89c, which was +- * the first widely used release: +- * +- * source png.h png.h shared-lib +- * version string int version +- * ------- ------ ----- ---------- +- * 0.89c "1.0 beta 3" 0.89 89 1.0.89 +- * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90] +- * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95] +- * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96] +- * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97] +- * 0.97c 0.97 97 2.0.97 +- * 0.98 0.98 98 2.0.98 +- * 0.99 0.99 98 2.0.99 +- * 0.99a-m 0.99 99 2.0.99 +- * 1.00 1.00 100 2.1.0 [100 should be 10000] +- * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000] +- * 1.0.1 png.h string is 10001 2.1.0 +- * 1.0.1a-e identical to the 10002 from here on, the shared library +- * 1.0.2 source version) 10002 is 2.V where V is the source code +- * 1.0.2a-b 10003 version, except as noted. +- * 1.0.3 10003 +- * 1.0.3a-d 10004 +- * 1.0.4 10004 +- * 1.0.4a-f 10005 +- * 1.0.5 (+ 2 patches) 10005 +- * 1.0.5a-d 10006 +- * 1.0.5e-r 10100 (not source compatible) +- * 1.0.5s-v 10006 (not binary compatible) +- * 1.0.6 (+ 3 patches) 10006 (still binary incompatible) +- * 1.0.6d-f 10007 (still binary incompatible) +- * 1.0.6g 10007 +- * 1.0.6h 10007 10.6h (testing xy.z so-numbering) +- * 1.0.6i 10007 10.6i +- * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0) +- * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible) +- * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible) +- * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible) +- * 1.0.7 1 10007 (still compatible) +- * 1.0.8beta1-4 1 10008 2.1.0.8beta1-4 +- * 1.0.8rc1 1 10008 2.1.0.8rc1 +- * 1.0.8 1 10008 2.1.0.8 +- * 1.0.9beta1-6 1 10009 2.1.0.9beta1-6 +- * 1.0.9rc1 1 10009 2.1.0.9rc1 +- * 1.0.9beta7-10 1 10009 2.1.0.9beta7-10 +- * 1.0.9rc2 1 10009 2.1.0.9rc2 +- * 1.0.9 1 10009 2.1.0.9 +- * 1.0.10beta1 1 10010 2.1.0.10beta1 +- * 1.0.10rc1 1 10010 2.1.0.10rc1 +- * 1.0.10 1 10010 2.1.0.10 +- * 1.0.11beta1-3 1 10011 2.1.0.11beta1-3 +- * 1.0.11rc1 1 10011 2.1.0.11rc1 +- * 1.0.11 1 10011 2.1.0.11 +- * 1.0.12beta1-2 2 10012 2.1.0.12beta1-2 +- * 1.0.12rc1 2 10012 2.1.0.12rc1 +- * 1.0.12 2 10012 2.1.0.12 +- * 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned) +- * 1.2.0beta1-2 2 10200 2.1.2.0beta1-2 +- * 1.2.0beta3-5 3 10200 3.1.2.0beta3-5 +- * 1.2.0rc1 3 10200 3.1.2.0rc1 +- * 1.2.0 3 10200 3.1.2.0 +- * 1.2.1beta1-4 3 10201 3.1.2.1beta1-4 +- * 1.2.1rc1-2 3 10201 3.1.2.1rc1-2 +- * 1.2.1 3 10201 3.1.2.1 +- * 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6 +- * 1.0.13beta1 10 10013 10.so.0.1.0.13beta1 +- * 1.0.13rc1 10 10013 10.so.0.1.0.13rc1 +- * 1.2.2rc1 12 10202 12.so.0.1.2.2rc1 +- * 1.0.13 10 10013 10.so.0.1.0.13 +- * 1.2.2 12 10202 12.so.0.1.2.2 +- * 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6 +- * 1.2.3 12 10203 12.so.0.1.2.3 +- * 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3 +- * 1.0.14rc1 13 10014 10.so.0.1.0.14rc1 +- * 1.2.4rc1 13 10204 12.so.0.1.2.4rc1 +- * 1.0.14 10 10014 10.so.0.1.0.14 +- * 1.2.4 13 10204 12.so.0.1.2.4 +- * 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2 +- * 1.0.15rc1-3 10 10015 10.so.0.1.0.15rc1-3 +- * 1.2.5rc1-3 13 10205 12.so.0.1.2.5rc1-3 +- * 1.0.15 10 10015 10.so.0.1.0.15 +- * 1.2.5 13 10205 12.so.0.1.2.5 +- * 1.2.6beta1-4 13 10206 12.so.0.1.2.6beta1-4 +- * 1.0.16 10 10016 10.so.0.1.0.16 +- * 1.2.6 13 10206 12.so.0.1.2.6 +- * 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2 +- * 1.0.17rc1 10 10017 12.so.0.1.0.17rc1 +- * 1.2.7rc1 13 10207 12.so.0.1.2.7rc1 +- * 1.0.17 10 10017 12.so.0.1.0.17 +- * 1.2.7 13 10207 12.so.0.1.2.7 +- * +- * Henceforth the source version will match the shared-library major +- * and minor numbers; the shared-library major version number will be +- * used for changes in backward compatibility, as it is intended. The +- * PNG_LIBPNG_VER macro, which is not used within libpng but is available +- * for applications, is an unsigned integer of the form xyyzz corresponding +- * to the source version x.y.z (leading zeros in y and z). Beta versions +- * were given the previous public release number plus a letter, until +- * version 1.0.6j; from then on they were given the upcoming public +- * release number plus "betaNN" or "rcN". +- * +- * Binary incompatibility exists only when applications make direct access +- * to the info_ptr or png_ptr members through png.h, and the compiled +- * application is loaded with a different version of the library. +- * +- * DLLNUM will change each time there are forward or backward changes +- * in binary compatibility (e.g., when a new feature is added). +- * +- * See libpng.txt or libpng.3 for more information. The PNG specification +- * is available as a W3C Recommendation and as an ISO Specification, +- * defines should NOT be changed. +- */ +-#define PNG_INFO_gAMA 0x0001 +-#define PNG_INFO_sBIT 0x0002 +-#define PNG_INFO_cHRM 0x0004 +-#define PNG_INFO_PLTE 0x0008 +-#define PNG_INFO_tRNS 0x0010 +-#define PNG_INFO_bKGD 0x0020 +-#define PNG_INFO_hIST 0x0040 +-#define PNG_INFO_pHYs 0x0080 +-#define PNG_INFO_oFFs 0x0100 +-#define PNG_INFO_tIME 0x0200 +-#define PNG_INFO_pCAL 0x0400 +-#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ +-#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ +-#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ +-#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ +-#define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */ +- +-/* This is used for the transformation routines, as some of them +- * change these values for the row. It also should enable using +- * the routines for other purposes. +- */ +-typedef struct png_row_info_struct +-{ +- png_uint_32 width; /* width of row */ +- png_uint_32 rowbytes; /* number of bytes in row */ +- png_byte color_type; /* color type of row */ +- png_byte bit_depth; /* bit depth of row */ +- png_byte channels; /* number of channels (1, 2, 3, or 4) */ +- png_byte pixel_depth; /* bits per pixel (depth * channels) */ +-} png_row_info; +- +-typedef png_row_info FAR * png_row_infop; +-typedef png_row_info FAR * FAR * png_row_infopp; +- +-/* These are the function types for the I/O functions and for the functions +- * that allow the user to override the default I/O functions with his or her +- * own. The png_error_ptr type should match that of user-supplied warning +- * and error functions, while the png_rw_ptr type should match that of the +- * user read/write data functions. +- */ +-typedef struct png_struct_def png_struct; +-typedef png_struct FAR * png_structp; +- +-typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp)); +-typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t)); +-typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp)); +-typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32, +- int)); +-typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32, +- int)); +- +-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +-typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop)); +-typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop)); +-typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep, +- png_uint_32, int)); +-#endif +- +-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_LEGACY_SUPPORTED) +-typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp, +- png_row_infop, png_bytep)); +-#endif +- +-#if defined(PNG_USER_CHUNKS_SUPPORTED) +-typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp)); +-#endif +-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +-typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp)); +-#endif +- +-/* Transform masks for the high-level interface */ +-#define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */ +-#define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */ +-#define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */ +-#define PNG_TRANSFORM_PACKING 0x0004 /* read and write */ +-#define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */ +-#define PNG_TRANSFORM_EXPAND 0x0010 /* read only */ +-#define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */ +-#define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */ +-#define PNG_TRANSFORM_BGR 0x0080 /* read and write */ +-#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ +-#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ +-#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ +-#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* WRITE only */ +- +-/* Flags for MNG supported features */ +-#define PNG_FLAG_MNG_EMPTY_PLTE 0x01 +-#define PNG_FLAG_MNG_FILTER_64 0x04 +-#define PNG_ALL_MNG_FEATURES 0x05 +- +-typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t)); +-typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp)); +- +-/* The structure that holds the information to read and write PNG files. +- * The only people who need to care about what is inside of this are the +- * people who will be modifying the library for their own special needs. +- * It should NOT be accessed directly by an application, except to store +- * the jmp_buf. +- */ +- +-struct png_struct_def +-{ +-#ifdef PNG_SETJMP_SUPPORTED +- jmp_buf jmpbuf; /* used in png_error */ +-#endif +- png_error_ptr error_fn; /* function for printing errors and aborting */ +- png_error_ptr warning_fn; /* function for printing warnings */ +- png_voidp error_ptr; /* user supplied struct for error functions */ +- png_rw_ptr write_data_fn; /* function for writing output data */ +- png_rw_ptr read_data_fn; /* function for reading input data */ +- png_voidp io_ptr; /* ptr to application struct for I/O functions */ +- +-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) +- png_user_transform_ptr read_user_transform_fn; /* user read transform */ +-#endif +- +-#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +- png_user_transform_ptr write_user_transform_fn; /* user write transform */ +-#endif +- +-/* These were added in libpng-1.0.2 */ +-#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) +-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +- png_voidp user_transform_ptr; /* user supplied struct for user transform */ +- png_byte user_transform_depth; /* bit depth of user transformed pixels */ +- png_byte user_transform_channels; /* channels in user transformed pixels */ +-#endif +-#endif +- +- png_uint_32 mode; /* tells us where we are in the PNG file */ +- png_uint_32 flags; /* flags indicating various things to libpng */ +- png_uint_32 transformations; /* which transformations to perform */ +- +- z_stream zstream; /* pointer to decompression structure (below) */ +- png_bytep zbuf; /* buffer for zlib */ +- png_size_t zbuf_size; /* size of zbuf */ +- int zlib_level; /* holds zlib compression level */ +- int zlib_method; /* holds zlib compression method */ +- int zlib_window_bits; /* holds zlib compression window bits */ +- int zlib_mem_level; /* holds zlib compression memory level */ +- int zlib_strategy; /* holds zlib compression strategy */ +- +- png_uint_32 width; /* width of image in pixels */ +- png_uint_32 height; /* height of image in pixels */ +- png_uint_32 num_rows; /* number of rows in current pass */ +- png_uint_32 usr_width; /* width of row at start of write */ +- png_uint_32 rowbytes; /* size of row in bytes */ +- png_uint_32 irowbytes; /* size of current interlaced row in bytes */ +- png_uint_32 iwidth; /* width of current interlaced row in pixels */ +- png_uint_32 row_number; /* current row in interlace pass */ +- png_bytep prev_row; /* buffer to save previous (unfiltered) row */ +- png_bytep row_buf; /* buffer to save current (unfiltered) row */ +- png_bytep sub_row; /* buffer to save "sub" row when filtering */ +- png_bytep up_row; /* buffer to save "up" row when filtering */ +- png_bytep avg_row; /* buffer to save "avg" row when filtering */ +- png_bytep paeth_row; /* buffer to save "Paeth" row when filtering */ +- png_row_info row_info; /* used for transformation routines */ +- +- png_uint_32 idat_size; /* current IDAT size for read */ +- png_uint_32 crc; /* current chunk CRC value */ +- png_colorp palette; /* palette from the input file */ +- png_uint_16 num_palette; /* number of color entries in palette */ +- png_uint_16 num_trans; /* number of transparency values */ +- png_byte chunk_name[5]; /* null-terminated name of current chunk */ +- png_byte compression; /* file compression type (always 0) */ +- png_byte filter; /* file filter type (always 0) */ +- png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ +- png_byte pass; /* current interlace pass (0 - 6) */ +- png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */ +- png_byte color_type; /* color type of file */ +- png_byte bit_depth; /* bit depth of file */ +- png_byte usr_bit_depth; /* bit depth of users row */ +- png_byte pixel_depth; /* number of bits per pixel */ +- png_byte channels; /* number of channels in file */ +- png_byte usr_channels; /* channels at start of write */ +- png_byte sig_bytes; /* magic bytes read/written from start of file */ +- +-#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +-#ifdef PNG_LEGACY_SUPPORTED +- png_byte filler; /* filler byte for pixel expansion */ +-#else +- png_uint_16 filler; /* filler bytes for pixel expansion */ +-#endif +-#endif +- +-#if defined(PNG_bKGD_SUPPORTED) +- png_byte background_gamma_type; +-# ifdef PNG_FLOATING_POINT_SUPPORTED +- float background_gamma; +-# endif +- png_color_16 background; /* background color in screen gamma space */ +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- png_color_16 background_1; /* background normalized to gamma 1.0 */ +-#endif +-#endif /* PNG_bKGD_SUPPORTED */ +- +-#if defined(PNG_WRITE_FLUSH_SUPPORTED) +- png_flush_ptr output_flush_fn;/* Function for flushing output */ +- png_uint_32 flush_dist; /* how many rows apart to flush, 0 - no flush */ +- png_uint_32 flush_rows; /* number of rows written since last flush */ +-#endif +- +-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +- int gamma_shift; /* number of "insignificant" bits 16-bit gamma */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- float gamma; /* file gamma value */ +- float screen_gamma; /* screen gamma value (display_exponent) */ +-#endif +-#endif +- +-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +- png_bytep gamma_table; /* gamma table for 8-bit depth files */ +- png_bytep gamma_from_1; /* converts from 1.0 to screen */ +- png_bytep gamma_to_1; /* converts from file to 1.0 */ +- png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */ +- png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */ +- png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */ +-#endif +- +-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED) +- png_color_8 sig_bit; /* significant bits in each available channel */ +-#endif +- +-#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) +- png_color_8 shift; /* shift for significant bit tranformation */ +-#endif +- +-#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \ +- || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +- png_bytep trans; /* transparency values for paletted files */ +- png_color_16 trans_values; /* transparency values for non-paletted files */ +-#endif +- +- png_read_status_ptr read_row_fn; /* called after each row is decoded */ +- png_write_status_ptr write_row_fn; /* called after each row is encoded */ +-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +- png_progressive_info_ptr info_fn; /* called after header data fully read */ +- png_progressive_row_ptr row_fn; /* called after each prog. row is decoded */ +- png_progressive_end_ptr end_fn; /* called after image is complete */ +- png_bytep save_buffer_ptr; /* current location in save_buffer */ +- png_bytep save_buffer; /* buffer for previously read data */ +- png_bytep current_buffer_ptr; /* current location in current_buffer */ +- png_bytep current_buffer; /* buffer for recently used data */ +- png_uint_32 push_length; /* size of current input chunk */ +- png_uint_32 skip_length; /* bytes to skip in input data */ +- png_size_t save_buffer_size; /* amount of data now in save_buffer */ +- png_size_t save_buffer_max; /* total size of save_buffer */ +- png_size_t buffer_size; /* total amount of available input data */ +- png_size_t current_buffer_size; /* amount of data now in current_buffer */ +- int process_mode; /* what push library is currently doing */ +- int cur_palette; /* current push library palette index */ +- +-# if defined(PNG_TEXT_SUPPORTED) +- png_size_t current_text_size; /* current size of text input data */ +- png_size_t current_text_left; /* how much text left to read in input */ +- png_charp current_text; /* current text chunk buffer */ +- png_charp current_text_ptr; /* current location in current_text */ +-# endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_TEXT_SUPPORTED */ +- +-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ +- +-#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) +-/* for the Borland special 64K segment handler */ +- png_bytepp offset_table_ptr; +- png_bytep offset_table; +- png_uint_16 offset_table_number; +- png_uint_16 offset_table_count; +- png_uint_16 offset_table_count_free; +-#endif +- +-#if defined(PNG_READ_DITHER_SUPPORTED) +- png_bytep palette_lookup; /* lookup table for dithering */ +- png_bytep dither_index; /* index translation for palette files */ +-#endif +- +-#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED) +- png_uint_16p hist; /* histogram */ +-#endif +- +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) +- png_byte heuristic_method; /* heuristic for row filter selection */ +- png_byte num_prev_filters; /* number of weights for previous rows */ +- png_bytep prev_filters; /* filter type(s) of previous row(s) */ +- png_uint_16p filter_weights; /* weight(s) for previous line(s) */ +- png_uint_16p inv_filter_weights; /* 1/weight(s) for previous line(s) */ +- png_uint_16p filter_costs; /* relative filter calculation cost */ +- png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */ +-#endif +- +-#if defined(PNG_TIME_RFC1123_SUPPORTED) +- png_charp time_buffer; /* String to hold RFC 1123 time text */ +-#endif +- +-/* New members added in libpng-1.0.6 */ +- +-#ifdef PNG_FREE_ME_SUPPORTED +- png_uint_32 free_me; /* flags items libpng is responsible for freeing */ +-#endif +- +-#if defined(PNG_USER_CHUNKS_SUPPORTED) +- png_voidp user_chunk_ptr; +- png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */ +-#endif +- +-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +- int num_chunk_list; +- png_bytep chunk_list; +-#endif +- +-/* New members added in libpng-1.0.3 */ +-#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +- png_byte rgb_to_gray_status; +- /* These were changed from png_byte in libpng-1.0.6 */ +- png_uint_16 rgb_to_gray_red_coeff; +- png_uint_16 rgb_to_gray_green_coeff; +- png_uint_16 rgb_to_gray_blue_coeff; +-#endif +- +-/* New member added in libpng-1.0.4 (renamed in 1.0.9) */ +-#if defined(PNG_MNG_FEATURES_SUPPORTED) || \ +- defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ +- defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) +-/* changed from png_byte to png_uint_32 at version 1.2.0 */ +-#ifdef PNG_1_0_X +- png_byte mng_features_permitted; +-#else +- png_uint_32 mng_features_permitted; +-#endif /* PNG_1_0_X */ +-#endif +- +-/* New member added in libpng-1.0.7 */ +-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +- png_fixed_point int_gamma; +-#endif +- +-/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */ +-#if defined(PNG_MNG_FEATURES_SUPPORTED) +- png_byte filter_type; +-#endif +- +-#if defined(PNG_1_0_X) || (defined(PNG_DEBUG) && defined(PNG_USE_PNGGCCRD)) +-/* New member added in libpng-1.0.10, ifdef'ed out in 1.2.0 */ +- png_uint_32 row_buf_size; +-#endif +- +-/* New members added in libpng-1.2.0 */ +-#if !defined(PNG_1_0_X) && defined(PNG_ASSEMBLER_CODE_SUPPORTED) +- png_byte mmx_bitdepth_threshold; +- png_uint_32 mmx_rowbytes_threshold; +- png_uint_32 asm_flags; +-#endif +- +-/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */ +-#ifdef PNG_USER_MEM_SUPPORTED +- png_voidp mem_ptr; /* user supplied struct for mem functions */ +- png_malloc_ptr malloc_fn; /* function for allocating memory */ +- png_free_ptr free_fn; /* function for freeing memory */ +-#endif +- +-/* New member added in libpng-1.0.13 and 1.2.0 */ +- png_bytep big_row_buf; /* buffer to save current (unfiltered) row */ +- +-#if defined(PNG_READ_DITHER_SUPPORTED) +-/* The following three members were added at version 1.0.14 and 1.2.4 */ +- png_bytep dither_sort; /* working sort array */ +- png_bytep index_to_palette; /* where the original index currently is */ +- /* in the palette */ +- png_bytep palette_to_index; /* which original index points to this */ +- /* palette color */ +-#endif +- +-/* New members added in libpng-1.0.16 and 1.2.6 */ +- png_byte compression_type; +- +-#ifdef PNG_SET_USER_LIMITS_SUPPORTED +- png_uint_32 user_width_max; +- png_uint_32 user_height_max; +-#endif +- +-}; +- +- +-/* This triggers a compiler error in png.c, if png.c and png.h +- * do not agree upon the version number. +- */ +-typedef png_structp version_1_2_7; +- +-typedef png_struct FAR * FAR * png_structpp; +- +-/* Here are the function definitions most commonly used. This is not +- * the place to find out how to use libpng. See libpng.txt for the +- * full explanation, see example.c for the summary. This just provides +- * a simple one line description of the use of each function. +- */ +- +-/* Returns the version number of the library */ +-extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void)); +- +-/* Tell lib we have already handled the first magic bytes. +- * Handling more than 8 bytes from the beginning of the file is an error. +- */ +-extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr, +- int num_bytes)); +- +-/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a +- * PNG file. Returns zero if the supplied bytes match the 8-byte PNG +- * signature, and non-zero otherwise. Having num_to_check == 0 or +- * start > 7 will always fail (ie return non-zero). +- */ +-extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start, +- png_size_t num_to_check)); +- +-/* Simple signature checking function. This is the same as calling +- * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). +- */ +-extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num)); +- +-/* Allocate and initialize png_ptr struct for reading, and any other memory. */ +-extern PNG_EXPORT(png_structp,png_create_read_struct) +- PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn)); +- +-/* Allocate and initialize png_ptr struct for writing, and any other memory */ +-extern PNG_EXPORT(png_structp,png_create_write_struct) +- PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn)); +- +-#ifdef PNG_WRITE_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_get_compression_buffer_size) +- PNGARG((png_structp png_ptr)); +-#endif +- +-#ifdef PNG_WRITE_SUPPORTED +-extern PNG_EXPORT(void,png_set_compression_buffer_size) +- PNGARG((png_structp png_ptr, png_uint_32 size)); +-#endif +- +-/* Reset the compression stream */ +-extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr)); +- +-/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ +-#ifdef PNG_USER_MEM_SUPPORTED +-extern PNG_EXPORT(png_structp,png_create_read_struct_2) +- PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, +- png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +-extern PNG_EXPORT(png_structp,png_create_write_struct_2) +- PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, +- png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +-#endif +- +-/* Write a PNG chunk - size, type, (optional) data, CRC. */ +-extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr, +- png_bytep chunk_name, png_bytep data, png_size_t length)); +- +-/* Write the start of a PNG chunk - length and chunk name. */ +-extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr, +- png_bytep chunk_name, png_uint_32 length)); +- +-/* Write the data of a PNG chunk started with png_write_chunk_start(). */ +-extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr, +- png_bytep data, png_size_t length)); +- +-/* Finish a chunk started with png_write_chunk_start() (includes CRC). */ +-extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr)); +- +-/* Allocate and initialize the info structure */ +-extern PNG_EXPORT(png_infop,png_create_info_struct) +- PNGARG((png_structp png_ptr)); +- +-/* Initialize the info structure (old interface - DEPRECATED) */ +-extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr)); +-#undef png_info_init +-#define png_info_init(info_ptr) png_info_init_3(&info_ptr,\ +- png_sizeof(png_info)); +-extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr, +- png_size_t png_info_struct_size)); +- +-/* Writes all the PNG information before the image. */ +-extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +-extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +- +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +-/* read the information before the actual image data. */ +-extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +-#endif +- +-#if defined(PNG_TIME_RFC1123_SUPPORTED) +-extern PNG_EXPORT(png_charp,png_convert_to_rfc1123) +- PNGARG((png_structp png_ptr, png_timep ptime)); +-#endif +- +-#if !defined(_WIN32_WCE) +-/* "time.h" functions are not supported on WindowsCE */ +-#if defined(PNG_WRITE_tIME_SUPPORTED) +-/* convert from a struct tm to png_time */ +-extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime, +- struct tm FAR * ttime)); +- +-/* convert from time_t to png_time. Uses gmtime() */ +-extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime, +- time_t ttime)); +-#endif /* PNG_WRITE_tIME_SUPPORTED */ +-#endif /* _WIN32_WCE */ +- +-#if defined(PNG_READ_EXPAND_SUPPORTED) +-/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ +-extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr)); +-extern PNG_EXPORT(void,png_set_gray_1_2_4_to_8) PNGARG((png_structp png_ptr)); +-extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr)); +-extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr)); +-#endif +- +-#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +-/* Use blue, green, red order for pixels. */ +-extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr)); +-#endif +- +-#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +-/* Expand the grayscale to 24-bit RGB if necessary. */ +-extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr)); +-#endif +- +-#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +-/* Reduce RGB to grayscale. */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr, +- int error_action, double red, double green )); +-#endif +-extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr, +- int error_action, png_fixed_point red, png_fixed_point green )); +-extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp +- png_ptr)); +-#endif +- +-extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth, +- png_colorp palette)); +- +-#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +-extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr)); +-#endif +- +-#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ +- defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +-extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr)); +-#endif +- +-#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ +- defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +-extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr)); +-#endif +- +-#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +-/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */ +-extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr, +- png_uint_32 filler, int flags)); +-/* The values of the PNG_FILLER_ defines should NOT be changed */ +-#define PNG_FILLER_BEFORE 0 +-#define PNG_FILLER_AFTER 1 +-/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */ +-#if !defined(PNG_1_0_X) +-extern PNG_EXPORT(void,png_set_add_alpha) PNGARG((png_structp png_ptr, +- png_uint_32 filler, int flags)); +-#endif +-#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ +- +-#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +-/* Swap bytes in 16-bit depth files. */ +-extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr)); +-#endif +- +-#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) +-/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ +-extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr)); +-#endif +- +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) +-/* Swap packing order of pixels in bytes. */ +-extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr)); +-#endif +- +-#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) +-/* Converts files to legal bit depths. */ +-extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr, +- png_color_8p true_bits)); +-#endif +- +-#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ +- defined(PNG_WRITE_INTERLACING_SUPPORTED) +-/* Have the code handle the interlacing. Returns the number of passes. */ +-extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr)); +-#endif +- +-#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +-/* Invert monochrome files */ +-extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr)); +-#endif +- +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) +-/* Handle alpha and tRNS by replacing with a background color. */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr, +- png_color_16p background_color, int background_gamma_code, +- int need_expand, double background_gamma)); +-#endif +-#define PNG_BACKGROUND_GAMMA_UNKNOWN 0 +-#define PNG_BACKGROUND_GAMMA_SCREEN 1 +-#define PNG_BACKGROUND_GAMMA_FILE 2 +-#define PNG_BACKGROUND_GAMMA_UNIQUE 3 +-#endif +- +-#if defined(PNG_READ_16_TO_8_SUPPORTED) +-/* strip the second byte of information from a 16-bit depth file. */ +-extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr)); +-#endif +- +-#if defined(PNG_READ_DITHER_SUPPORTED) +-/* Turn on dithering, and reduce the palette to the number of colors available. */ +-extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr, +- png_colorp palette, int num_palette, int maximum_colors, +- png_uint_16p histogram, int full_dither)); +-#endif +- +-#if defined(PNG_READ_GAMMA_SUPPORTED) +-/* Handle gamma correction. Screen_gamma=(display_exponent) */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr, +- double screen_gamma, double default_file_gamma)); +-#endif +-#endif +- +-#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ +- defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) +-/* Permit or disallow empty PLTE (0: not permitted, 1: permitted) */ +-/* Deprecated and will be removed. Use png_permit_mng_features() instead. */ +-extern PNG_EXPORT(void,png_permit_empty_plte) PNGARG((png_structp png_ptr, +- int empty_plte_permitted)); +-#endif +- +-#if defined(PNG_WRITE_FLUSH_SUPPORTED) +-/* Set how many lines between output flushes - 0 for no flushing */ +-extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows)); +-/* Flush the current PNG output buffer */ +-extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr)); +-#endif +- +-/* optional update palette with requested transformations */ +-extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr)); +- +-/* optional call to update the users info structure */ +-extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +- +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +-/* read one or more rows of image data. */ +-extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr, +- png_bytepp row, png_bytepp display_row, png_uint_32 num_rows)); +-#endif +- +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +-/* read a row of data. */ +-extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr, +- png_bytep row, +- png_bytep display_row)); +-#endif +- +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +-/* read the whole image into memory at once. */ +-extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr, +- png_bytepp image)); +-#endif +- +-/* write a row of image data */ +-extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr, +- png_bytep row)); +- +-/* write a few rows of image data */ +-extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr, +- png_bytepp row, png_uint_32 num_rows)); +- +-/* write the image data */ +-extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr, +- png_bytepp image)); +- +-/* writes the end of the PNG file. */ +-extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +- +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +-/* read the end of the PNG file. */ +-extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +-#endif +- +-/* free any memory associated with the png_info_struct */ +-extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr, +- png_infopp info_ptr_ptr)); +- +-/* free any memory associated with the png_struct and the png_info_structs */ +-extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp +- png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); +- +-/* free all memory used by the read (old method - NOT DLL EXPORTED) */ +-extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_infop end_info_ptr)); +- +-/* free any memory associated with the png_struct and the png_info_structs */ +-extern PNG_EXPORT(void,png_destroy_write_struct) +- PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)); +- +-/* free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */ +-extern void png_write_destroy PNGARG((png_structp png_ptr)); +- +-/* set the libpng method of handling chunk CRC errors */ +-extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr, +- int crit_action, int ancil_action)); +- +-/* Values for png_set_crc_action() to say how to handle CRC errors in +- * ancillary and critical chunks, and whether to use the data contained +- * therein. Note that it is impossible to "discard" data in a critical +- * chunk. For versions prior to 0.90, the action was always error/quit, +- * whereas in version 0.90 and later, the action for CRC errors in ancillary +- * chunks is warn/discard. These values should NOT be changed. +- * +- * value action:critical action:ancillary +- */ +-#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */ +-#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */ +-#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */ +-#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */ +-#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ +-#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ +- +-/* These functions give the user control over the scan-line filtering in +- * libpng and the compression methods used by zlib. These functions are +- * mainly useful for testing, as the defaults should work with most users. +- * Those users who are tight on memory or want faster performance at the +- * expense of compression can modify them. See the compression library +- * header file (zlib.h) for an explination of the compression functions. +- */ +- +-/* set the filtering method(s) used by libpng. Currently, the only valid +- * value for "method" is 0. +- */ +-extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, +- int filters)); +- +-/* Flags for png_set_filter() to say which filters to use. The flags +- * are chosen so that they don't conflict with real filter types +- * below, in case they are supplied instead of the #defined constants. +- * These values should NOT be changed. +- */ +-#define PNG_NO_FILTERS 0x00 +-#define PNG_FILTER_NONE 0x08 +-#define PNG_FILTER_SUB 0x10 +-#define PNG_FILTER_UP 0x20 +-#define PNG_FILTER_AVG 0x40 +-#define PNG_FILTER_PAETH 0x80 +-#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ +- PNG_FILTER_AVG | PNG_FILTER_PAETH) +- +-/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. +- * These defines should NOT be changed. +- */ +-#define PNG_FILTER_VALUE_NONE 0 +-#define PNG_FILTER_VALUE_SUB 1 +-#define PNG_FILTER_VALUE_UP 2 +-#define PNG_FILTER_VALUE_AVG 3 +-#define PNG_FILTER_VALUE_PAETH 4 +-#define PNG_FILTER_VALUE_LAST 5 +- +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* EXPERIMENTAL */ +-/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_ +- * defines, either the default (minimum-sum-of-absolute-differences), or +- * the experimental method (weighted-minimum-sum-of-absolute-differences). +- * +- * Weights are factors >= 1.0, indicating how important it is to keep the +- * filter type consistent between rows. Larger numbers mean the current +- * filter is that many times as likely to be the same as the "num_weights" +- * previous filters. This is cumulative for each previous row with a weight. +- * There needs to be "num_weights" values in "filter_weights", or it can be +- * NULL if the weights aren't being specified. Weights have no influence on +- * the selection of the first row filter. Well chosen weights can (in theory) +- * improve the compression for a given image. +- * +- * Costs are factors >= 1.0 indicating the relative decoding costs of a +- * filter type. Higher costs indicate more decoding expense, and are +- * therefore less likely to be selected over a filter with lower computational +- * costs. There needs to be a value in "filter_costs" for each valid filter +- * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't +- * setting the costs. Costs try to improve the speed of decompression without +- * unduly increasing the compressed image size. +- * +- * A negative weight or cost indicates the default value is to be used, and +- * values in the range [0.0, 1.0) indicate the value is to remain unchanged. +- * The default values for both weights and costs are currently 1.0, but may +- * change if good general weighting/cost heuristics can be found. If both +- * the weights and costs are set to 1.0, this degenerates the WEIGHTED method +- * to the UNWEIGHTED method, but with added encoding time/computation. +- */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr, +- int heuristic_method, int num_weights, png_doublep filter_weights, +- png_doublep filter_costs)); +-#endif +-#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ +- +-/* Heuristic used for row filter selection. These defines should NOT be +- * changed. +- */ +-#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */ +-#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */ +-#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ +-#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ +- +-/* Set the library compression level. Currently, valid values range from +- * 0 - 9, corresponding directly to the zlib compression levels 0 - 9 +- * (0 - no compression, 9 - "maximal" compression). Note that tests have +- * shown that zlib compression levels 3-6 usually perform as well as level 9 +- * for PNG images, and do considerably fewer caclulations. In the future, +- * these values may not correspond directly to the zlib compression levels. +- */ +-extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr, +- int level)); +- +-extern PNG_EXPORT(void,png_set_compression_mem_level) +- PNGARG((png_structp png_ptr, int mem_level)); +- +-extern PNG_EXPORT(void,png_set_compression_strategy) +- PNGARG((png_structp png_ptr, int strategy)); +- +-extern PNG_EXPORT(void,png_set_compression_window_bits) +- PNGARG((png_structp png_ptr, int window_bits)); +- +-extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr, +- int method)); +- +-/* These next functions are called for input/output, memory, and error +- * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, +- * and call standard C I/O routines such as fread(), fwrite(), and +- * fprintf(). These functions can be made to use other I/O routines +- * at run time for those applications that need to handle I/O in a +- * different manner by calling png_set_???_fn(). See libpng.txt for +- * more information. +- */ +- +-#if !defined(PNG_NO_STDIO) +-/* Initialize the input/output for the PNG file to the default functions. */ +-extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp)); +-#endif +- +-/* Replace the (error and abort), and warning functions with user +- * supplied functions. If no messages are to be printed you must still +- * write and use replacement functions. The replacement error_fn should +- * still do a longjmp to the last setjmp location if you are using this +- * method of error handling. If error_fn or warning_fn is NULL, the +- * default function will be used. +- */ +- +-extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr, +- png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); +- +-/* Return the user pointer associated with the error functions */ +-extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr)); +- +-/* Replace the default data output functions with a user supplied one(s). +- * If buffered output is not used, then output_flush_fn can be set to NULL. +- * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time +- * output_flush_fn will be ignored (and thus can be NULL). +- */ +-extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr, +- png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); +- +-/* Replace the default data input function with a user supplied one. */ +-extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr, +- png_voidp io_ptr, png_rw_ptr read_data_fn)); +- +-/* Return the user pointer associated with the I/O functions */ +-extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr)); +- +-extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr, +- png_read_status_ptr read_row_fn)); +- +-extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr, +- png_write_status_ptr write_row_fn)); +- +-#ifdef PNG_USER_MEM_SUPPORTED +-/* Replace the default memory allocation functions with user supplied one(s). */ +-extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr, +- png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +-/* Return the user pointer associated with the memory functions */ +-extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr)); +-#endif +- +-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_LEGACY_SUPPORTED) +-extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp +- png_ptr, png_user_transform_ptr read_user_transform_fn)); +-#endif +- +-#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_LEGACY_SUPPORTED) +-extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp +- png_ptr, png_user_transform_ptr write_user_transform_fn)); +-#endif +- +-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_LEGACY_SUPPORTED) +-extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp +- png_ptr, png_voidp user_transform_ptr, int user_transform_depth, +- int user_transform_channels)); +-/* Return the user pointer associated with the user transform functions */ +-extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr) +- PNGARG((png_structp png_ptr)); +-#endif +- +-#ifdef PNG_USER_CHUNKS_SUPPORTED +-extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr, +- png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); +-extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp +- png_ptr)); +-#endif +- +-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +-/* Sets the function callbacks for the push reader, and a pointer to a +- * user-defined structure available to the callback functions. +- */ +-extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr, +- png_voidp progressive_ptr, +- png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, +- png_progressive_end_ptr end_fn)); +- +-/* returns the user pointer associated with the push read functions */ +-extern PNG_EXPORT(png_voidp,png_get_progressive_ptr) +- PNGARG((png_structp png_ptr)); +- +-/* function to be called when data becomes available */ +-extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_bytep buffer, png_size_t buffer_size)); +- +-/* function that combines rows. Not very much different than the +- * png_combine_row() call. Is this even used????? +- */ +-extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr, +- png_bytep old_row, png_bytep new_row)); +-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ +- +-extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr, +- png_uint_32 size)); +- +-#if defined(PNG_1_0_X) +-# define png_malloc_warn png_malloc +-#else +-/* Added at libpng version 1.2.4 */ +-extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr, +- png_uint_32 size)); +-#endif +- +-/* frees a pointer allocated by png_malloc() */ +-extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr)); +- +-#if defined(PNG_1_0_X) +-/* Function to allocate memory for zlib. */ +-extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items, +- uInt size)); +- +-/* Function to free memory for zlib */ +-extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr)); +-#endif +- +-/* Free data that was allocated internally */ +-extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 free_me, int num)); +-#ifdef PNG_FREE_ME_SUPPORTED +-/* Reassign responsibility for freeing existing data, whether allocated +- * by libpng or by the application */ +-extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int freer, png_uint_32 mask)); +-#endif +-/* assignments for png_data_freer */ +-#define PNG_DESTROY_WILL_FREE_DATA 1 +-#define PNG_SET_WILL_FREE_DATA 1 +-#define PNG_USER_WILL_FREE_DATA 2 +-/* Flags for png_ptr->free_me and info_ptr->free_me */ +-#define PNG_FREE_HIST 0x0008 +-#define PNG_FREE_ICCP 0x0010 +-#define PNG_FREE_SPLT 0x0020 +-#define PNG_FREE_ROWS 0x0040 +-#define PNG_FREE_PCAL 0x0080 +-#define PNG_FREE_SCAL 0x0100 +-#define PNG_FREE_UNKN 0x0200 +-#define PNG_FREE_LIST 0x0400 +-#define PNG_FREE_PLTE 0x1000 +-#define PNG_FREE_TRNS 0x2000 +-#define PNG_FREE_TEXT 0x4000 +-#define PNG_FREE_ALL 0x7fff +-#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ +- +-#ifdef PNG_USER_MEM_SUPPORTED +-extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr, +- png_uint_32 size)); +-extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr, +- png_voidp ptr)); +-#endif +- +-extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr, +- png_voidp s1, png_voidp s2, png_uint_32 size)); +- +-extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr, +- png_voidp s1, int value, png_uint_32 size)); +- +-#if defined(USE_FAR_KEYWORD) /* memory model conversion function */ +-extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr, +- int check)); +-#endif /* USE_FAR_KEYWORD */ +- +-/* Fatal error in PNG image of libpng - can't continue */ +-extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr, +- png_const_charp error_message)); +- +-/* The same, but the chunk name is prepended to the error string. */ +-extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr, +- png_const_charp error_message)); +- +-/* Non-fatal error in libpng. Can continue, but may have a problem. */ +-extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr, +- png_const_charp warning_message)); +- +-/* Non-fatal error in libpng, chunk name is prepended to message. */ +-extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr, +- png_const_charp warning_message)); +- +-/* The png_set_ functions are for storing values in the png_info_struct. +- * Similarly, the png_get_ calls are used to read values from the +- * png_info_struct, either storing the parameters in the passed variables, or +- * setting pointers into the png_info_struct where the data is stored. The +- * png_get_ functions return a non-zero value if the data was available +- * in info_ptr, or return zero and do not change any of the parameters if the +- * data was not available. +- * +- * These functions should be used instead of directly accessing png_info +- * to avoid problems with future changes in the size and internal layout of +- * png_info_struct. +- */ +-/* Returns "flag" if chunk data is valid in info_ptr. */ +-extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr, +-png_infop info_ptr, png_uint_32 flag)); +- +-/* Returns number of bytes needed to hold a transformed row. */ +-extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr, +-png_infop info_ptr)); +- +-#if defined(PNG_INFO_IMAGE_SUPPORTED) +-/* Returns row_pointers, which is an array of pointers to scanlines that was +-returned from png_read_png(). */ +-extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr, +-png_infop info_ptr)); +-/* Set row_pointers, which is an array of pointers to scanlines for use +-by png_write_png(). */ +-extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_bytepp row_pointers)); +-#endif +- +-/* Returns number of color channels in image. */ +-extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr, +-png_infop info_ptr)); +- +-#ifdef PNG_EASY_ACCESS_SUPPORTED +-/* Returns image width in pixels. */ +-extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +- +-/* Returns image height in pixels. */ +-extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +- +-/* Returns image bit_depth. */ +-extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +- +-/* Returns image color_type. */ +-extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +- +-/* Returns image filter_type. */ +-extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +- +-/* Returns image interlace_type. */ +-extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +- +-/* Returns image compression_type. */ +-extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +- +-/* Returns image resolution in pixels per meter, from pHYs chunk data. */ +-extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +-extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +-extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +- +-/* Returns pixel aspect ratio, computed from pHYs chunk data. */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +-#endif +- +-/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ +-extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +-extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +-extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +-extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +- +-#endif /* PNG_EASY_ACCESS_SUPPORTED */ +- +-/* Returns pointer to signature string read from PNG header */ +-extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr, +-png_infop info_ptr)); +- +-#if defined(PNG_bKGD_SUPPORTED) +-extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_color_16p *background)); +-#endif +- +-#if defined(PNG_bKGD_SUPPORTED) +-extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_color_16p background)); +-#endif +- +-#if defined(PNG_cHRM_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr, +- png_infop info_ptr, double *white_x, double *white_y, double *red_x, +- double *red_y, double *green_x, double *green_y, double *blue_x, +- double *blue_y)); +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point +- *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y, +- png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point +- *int_blue_x, png_fixed_point *int_blue_y)); +-#endif +-#endif +- +-#if defined(PNG_cHRM_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr, +- png_infop info_ptr, double white_x, double white_y, double red_x, +- double red_y, double green_x, double green_y, double blue_x, double blue_y)); +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y, +- png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point +- int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, +- png_fixed_point int_blue_y)); +-#endif +-#endif +- +-#if defined(PNG_gAMA_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr, +- png_infop info_ptr, double *file_gamma)); +-#endif +-extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_fixed_point *int_file_gamma)); +-#endif +- +-#if defined(PNG_gAMA_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr, +- png_infop info_ptr, double file_gamma)); +-#endif +-extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_fixed_point int_file_gamma)); +-#endif +- +-#if defined(PNG_hIST_SUPPORTED) +-extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_16p *hist)); +-#endif +- +-#if defined(PNG_hIST_SUPPORTED) +-extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_16p hist)); +-#endif +- +-extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 *width, png_uint_32 *height, +- int *bit_depth, int *color_type, int *interlace_method, +- int *compression_method, int *filter_method)); +- +-extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, +- int color_type, int interlace_method, int compression_method, +- int filter_method)); +- +-#if defined(PNG_oFFs_SUPPORTED) +-extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, +- int *unit_type)); +-#endif +- +-#if defined(PNG_oFFs_SUPPORTED) +-extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y, +- int unit_type)); +-#endif +- +-#if defined(PNG_pCAL_SUPPORTED) +-extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1, +- int *type, int *nparams, png_charp *units, png_charpp *params)); +-#endif +- +-#if defined(PNG_pCAL_SUPPORTED) +-extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, +- int type, int nparams, png_charp units, png_charpp params)); +-#endif +- +-#if defined(PNG_pHYs_SUPPORTED) +-extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); +-#endif +- +-#if defined(PNG_pHYs_SUPPORTED) +-extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); +-#endif +- +-extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_colorp *palette, int *num_palette)); +- +-extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_colorp palette, int num_palette)); +- +-#if defined(PNG_sBIT_SUPPORTED) +-extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_color_8p *sig_bit)); +-#endif +- +-#if defined(PNG_sBIT_SUPPORTED) +-extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_color_8p sig_bit)); +-#endif +- +-#if defined(PNG_sRGB_SUPPORTED) +-extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int *intent)); +-#endif +- +-#if defined(PNG_sRGB_SUPPORTED) +-extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int intent)); +-extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int intent)); +-#endif +- +-#if defined(PNG_iCCP_SUPPORTED) +-extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_charpp name, int *compression_type, +- png_charpp profile, png_uint_32 *proflen)); +- /* Note to maintainer: profile should be png_bytepp */ +-#endif +- +-#if defined(PNG_iCCP_SUPPORTED) +-extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_charp name, int compression_type, +- png_charp profile, png_uint_32 proflen)); +- /* Note to maintainer: profile should be png_bytep */ +-#endif +- +-#if defined(PNG_sPLT_SUPPORTED) +-extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_sPLT_tpp entries)); +-#endif +- +-#if defined(PNG_sPLT_SUPPORTED) +-extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_sPLT_tp entries, int nentries)); +-#endif +- +-#if defined(PNG_TEXT_SUPPORTED) +-/* png_get_text also returns the number of text chunks in *num_text */ +-extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_textp *text_ptr, int *num_text)); +-#endif +- +-/* +- * Note while png_set_text() will accept a structure whose text, +- * language, and translated keywords are NULL pointers, the structure +- * returned by png_get_text will always contain regular +- * zero-terminated C strings. They might be empty strings but +- * they will never be NULL pointers. +- */ +- +-#if defined(PNG_TEXT_SUPPORTED) +-extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_textp text_ptr, int num_text)); +-#endif +- +-#if defined(PNG_tIME_SUPPORTED) +-extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_timep *mod_time)); +-#endif +- +-#if defined(PNG_tIME_SUPPORTED) +-extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_timep mod_time)); +-#endif +- +-#if defined(PNG_tRNS_SUPPORTED) +-extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_bytep *trans, int *num_trans, +- png_color_16p *trans_values)); +-#endif +- +-#if defined(PNG_tRNS_SUPPORTED) +-extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_bytep trans, int num_trans, +- png_color_16p trans_values)); +-#endif +- +-#if defined(PNG_tRNS_SUPPORTED) +-#endif +- +-#if defined(PNG_sCAL_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int *unit, double *width, double *height)); +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight)); +-#endif +-#endif +-#endif /* PNG_sCAL_SUPPORTED */ +- +-#if defined(PNG_sCAL_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int unit, double width, double height)); +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int unit, png_charp swidth, png_charp sheight)); +-#endif +-#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */ +- +-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +-/* provide a list of chunks and how they are to be handled, if the built-in +- handling or default unknown chunk handling is not desired. Any chunks not +- listed will be handled in the default manner. The IHDR and IEND chunks +- must not be listed. +- keep = 0: follow default behavour +- = 1: do not keep +- = 2: keep only if safe-to-copy +- = 3: keep even if unsafe-to-copy +-*/ +-extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp +- png_ptr, int keep, png_bytep chunk_list, int num_chunks)); +-extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)); +-extern PNG_EXPORT(void, png_set_unknown_chunk_location) +- PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location)); +-extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp +- png_ptr, png_infop info_ptr, png_unknown_chunkpp entries)); +-#endif +-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +-PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep +- chunk_name)); +-#endif +- +-/* Png_free_data() will turn off the "valid" flag for anything it frees. +- If you need to turn it off for a chunk that your application has freed, +- you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); */ +-extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int mask)); +- +-#if defined(PNG_INFO_IMAGE_SUPPORTED) +-/* The "params" pointer is currently not used and is for future expansion. */ +-extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr, +- png_infop info_ptr, +- int transforms, +- png_voidp params)); +-extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr, +- png_infop info_ptr, +- int transforms, +- png_voidp params)); +-#endif +- +-/* Define PNG_DEBUG at compile time for debugging information. Higher +- * numbers for PNG_DEBUG mean more debugging information. This has +- * only been added since version 0.95 so it is not implemented throughout +- * libpng yet, but more support will be added as needed. +- */ +-#ifdef PNG_DEBUG +-#if (PNG_DEBUG > 0) +-#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER) +-#include +-#if (PNG_DEBUG > 1) +-#define png_debug(l,m) _RPT0(_CRT_WARN,m) +-#define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m,p1) +-#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m,p1,p2) +-#endif +-#else /* PNG_DEBUG_FILE || !_MSC_VER */ +-#ifndef PNG_DEBUG_FILE +-#define PNG_DEBUG_FILE stderr +-#endif /* PNG_DEBUG_FILE */ +-#if (PNG_DEBUG > 1) +-#define png_debug(l,m) \ +-{ \ +- int num_tabs=l; \ +- fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ +- (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \ +-} +-#define png_debug1(l,m,p1) \ +-{ \ +- int num_tabs=l; \ +- fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ +- (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \ +-} +-#define png_debug2(l,m,p1,p2) \ +-{ \ +- int num_tabs=l; \ +- fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ +- (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \ +-} +-#endif /* (PNG_DEBUG > 1) */ +-#endif /* _MSC_VER */ +-#endif /* (PNG_DEBUG > 0) */ +-#endif /* PNG_DEBUG */ +-#ifndef png_debug +-#define png_debug(l, m) +-#endif +-#ifndef png_debug1 +-#define png_debug1(l, m, p1) +-#endif +-#ifndef png_debug2 +-#define png_debug2(l, m, p1, p2) +-#endif +- +-extern PNG_EXPORT(png_bytep,png_sig_bytes) PNGARG((void)); +- +-extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr)); +-extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr)); +-extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr)); +-extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr)); +- +-#ifdef PNG_MNG_FEATURES_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp +- png_ptr, png_uint_32 mng_features_permitted)); +-#endif +- +-/* For use in png_set_keep_unknown, added to version 1.2.6 */ +-#define PNG_HANDLE_CHUNK_AS_DEFAULT 0 +-#define PNG_HANDLE_CHUNK_NEVER 1 +-#define PNG_HANDLE_CHUNK_IF_SAFE 2 +-#define PNG_HANDLE_CHUNK_ALWAYS 3 +- +-/* Added to version 1.2.0 */ +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +-#define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED 0x01 /* not user-settable */ +-#define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU 0x02 /* not user-settable */ +-#define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW 0x04 +-#define PNG_ASM_FLAG_MMX_READ_INTERLACE 0x08 +-#define PNG_ASM_FLAG_MMX_READ_FILTER_SUB 0x10 +-#define PNG_ASM_FLAG_MMX_READ_FILTER_UP 0x20 +-#define PNG_ASM_FLAG_MMX_READ_FILTER_AVG 0x40 +-#define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80 +-#define PNG_ASM_FLAGS_INITIALIZED 0x80000000 /* not user-settable */ +- +-#define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \ +- | PNG_ASM_FLAG_MMX_READ_INTERLACE \ +- | PNG_ASM_FLAG_MMX_READ_FILTER_SUB \ +- | PNG_ASM_FLAG_MMX_READ_FILTER_UP \ +- | PNG_ASM_FLAG_MMX_READ_FILTER_AVG \ +- | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ) +-#define PNG_MMX_WRITE_FLAGS ( 0 ) +- +-#define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED \ +- | PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU \ +- | PNG_MMX_READ_FLAGS \ +- | PNG_MMX_WRITE_FLAGS ) +- +-#define PNG_SELECT_READ 1 +-#define PNG_SELECT_WRITE 2 +- +-#if !defined(PNG_1_0_X) +-/* pngget.c */ +-extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask) +- PNGARG((int flag_select, int *compilerID)); +- +-/* pngget.c */ +-extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask) +- PNGARG((int flag_select)); +- +-/* pngget.c */ +-extern PNG_EXPORT(png_uint_32,png_get_asm_flags) +- PNGARG((png_structp png_ptr)); +- +-/* pngget.c */ +-extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold) +- PNGARG((png_structp png_ptr)); +- +-/* pngget.c */ +-extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold) +- PNGARG((png_structp png_ptr)); +- +-/* pngset.c */ +-extern PNG_EXPORT(void,png_set_asm_flags) +- PNGARG((png_structp png_ptr, png_uint_32 asm_flags)); +- +-/* pngset.c */ +-extern PNG_EXPORT(void,png_set_mmx_thresholds) +- PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold, +- png_uint_32 mmx_rowbytes_threshold)); +- +-#endif /* PNG_1_0_X */ +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ +- +-#if !defined(PNG_1_0_X) +-/* png.c, pnggccrd.c, or pngvcrd.c */ +-extern PNG_EXPORT(int,png_mmx_support) PNGARG((void)); +- +-/* Strip the prepended error numbers ("#nnn ") from error and warning +- * messages before passing them to the error or warning handler. */ +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +-extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp +- png_ptr, png_uint_32 strip_mode)); +-#endif +- +-#endif /* PNG_1_0_X */ +- +-/* Added at libpng-1.2.6 */ +-#ifdef PNG_SET_USER_LIMITS_SUPPORTED +-extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp +- png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max)); +-extern PNG_EXPORT(png_uint_32,png_get_user_width_max) PNGARG((png_structp +- png_ptr)); +-extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp +- png_ptr)); +-#endif +- +-/* Maintainer: Put new public prototypes here ^, in libpng.3, and project defs */ +- +-#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED +-/* With these routines we avoid an integer divide, which will be slower on +- * most machines. However, it does take more operations than the corresponding +- * divide method, so it may be slower on a few RISC systems. There are two +- * shifts (by 8 or 16 bits) and an addition, versus a single integer divide. +- * +- * Note that the rounding factors are NOT supposed to be the same! 128 and +- * 32768 are correct for the NODIV code; 127 and 32767 are correct for the +- * standard method. +- * +- * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] +- */ +- +- /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ +- +-# define png_composite(composite, fg, alpha, bg) \ +- { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \ +- + (png_uint_16)(bg)*(png_uint_16)(255 - \ +- (png_uint_16)(alpha)) + (png_uint_16)128); \ +- (composite) = (png_byte)((temp + (temp >> 8)) >> 8); } +- +-# define png_composite_16(composite, fg, alpha, bg) \ +- { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \ +- + (png_uint_32)(bg)*(png_uint_32)(65535L - \ +- (png_uint_32)(alpha)) + (png_uint_32)32768L); \ +- (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } +- +-#else /* standard method using integer division */ +- +-# define png_composite(composite, fg, alpha, bg) \ +- (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ +- (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ +- (png_uint_16)127) / 255) +- +-# define png_composite_16(composite, fg, alpha, bg) \ +- (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ +- (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \ +- (png_uint_32)32767) / (png_uint_32)65535L) +- +-#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ +- +-/* These next functions are used internally in the code. They generally +- * shouldn't be used unless you are writing code to add or replace some +- * functionality in libpng. More information about most functions can +- * be found in the files where the functions are located. +- */ +- +-#if defined(PNG_INTERNAL) +- +-/* Various modes of operation. Note that after an init, mode is set to +- * zero automatically when the structure is created. +- */ +-#define PNG_HAVE_IHDR 0x01 +-#define PNG_HAVE_PLTE 0x02 +-#define PNG_HAVE_IDAT 0x04 +-#define PNG_AFTER_IDAT 0x08 +-#define PNG_HAVE_IEND 0x10 +-#define PNG_HAVE_gAMA 0x20 +-#define PNG_HAVE_cHRM 0x40 +-#define PNG_HAVE_sRGB 0x80 +-#define PNG_HAVE_CHUNK_HEADER 0x100 +-#define PNG_WROTE_tIME 0x200 +-#define PNG_WROTE_INFO_BEFORE_PLTE 0x400 +-#define PNG_BACKGROUND_IS_GRAY 0x800 +-#define PNG_HAVE_PNG_SIGNATURE 0x1000 +- +-/* flags for the transformations the PNG library does on the image data */ +-#define PNG_BGR 0x0001 +-#define PNG_INTERLACE 0x0002 +-#define PNG_PACK 0x0004 +-#define PNG_SHIFT 0x0008 +-#define PNG_SWAP_BYTES 0x0010 +-#define PNG_INVERT_MONO 0x0020 +-#define PNG_DITHER 0x0040 +-#define PNG_BACKGROUND 0x0080 +-#define PNG_BACKGROUND_EXPAND 0x0100 +- /* 0x0200 unused */ +-#define PNG_16_TO_8 0x0400 +-#define PNG_RGBA 0x0800 +-#define PNG_EXPAND 0x1000 +-#define PNG_GAMMA 0x2000 +-#define PNG_GRAY_TO_RGB 0x4000 +-#define PNG_FILLER 0x8000L +-#define PNG_PACKSWAP 0x10000L +-#define PNG_SWAP_ALPHA 0x20000L +-#define PNG_STRIP_ALPHA 0x40000L +-#define PNG_INVERT_ALPHA 0x80000L +-#define PNG_USER_TRANSFORM 0x100000L +-#define PNG_RGB_TO_GRAY_ERR 0x200000L +-#define PNG_RGB_TO_GRAY_WARN 0x400000L +-#define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */ +-#define PNG_ADD_ALPHA 0x1000000L /* Added to libpng-1.2.7 */ +- +-/* flags for png_create_struct */ +-#define PNG_STRUCT_PNG 0x0001 +-#define PNG_STRUCT_INFO 0x0002 +- +-/* Scaling factor for filter heuristic weighting calculations */ +-#define PNG_WEIGHT_SHIFT 8 +-#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT)) +-#define PNG_COST_SHIFT 3 +-#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT)) +- +-/* flags for the png_ptr->flags rather than declaring a byte for each one */ +-#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001 +-#define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002 +-#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004 +-#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008 +-#define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010 +-#define PNG_FLAG_ZLIB_FINISHED 0x0020 +-#define PNG_FLAG_ROW_INIT 0x0040 +-#define PNG_FLAG_FILLER_AFTER 0x0080 +-#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100 +-#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200 +-#define PNG_FLAG_CRC_CRITICAL_USE 0x0400 +-#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800 +-#define PNG_FLAG_FREE_PLTE 0x1000 +-#define PNG_FLAG_FREE_TRNS 0x2000 +-#define PNG_FLAG_FREE_HIST 0x4000 +-#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L +-#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L +-#define PNG_FLAG_LIBRARY_MISMATCH 0x20000L +-#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L +-#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L +-#define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L +- +-#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \ +- PNG_FLAG_CRC_ANCILLARY_NOWARN) +- +-#define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \ +- PNG_FLAG_CRC_CRITICAL_IGNORE) +- +-#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \ +- PNG_FLAG_CRC_CRITICAL_MASK) +- +-/* save typing and make code easier to understand */ +- +-#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \ +- abs((int)((c1).green) - (int)((c2).green)) + \ +- abs((int)((c1).blue) - (int)((c2).blue))) +- +-/* Added to libpng-1.2.6 JB */ +-#define PNG_ROWBYTES(pixel_bits, width) \ +- ((pixel_bits) >= 8 ? \ +- ((width) * (((png_uint_32)(pixel_bits)) >> 3)) : \ +- (( ((width) * ((png_uint_32)(pixel_bits))) + 7) >> 3) ) +- +-/* PNG_OUT_OF_RANGE returns true if value is outside the range +- ideal-delta..ideal+delta. Each argument is evaluated twice. +- "ideal" and "delta" should be constants, normally simple +- integers, "value" a variable. Added to libpng-1.2.6 JB */ +-#define PNG_OUT_OF_RANGE(value, ideal, delta) \ +- ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) ) +- +-/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */ +-#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) +-/* place to hold the signature string for a PNG file. */ +-#ifdef PNG_USE_GLOBAL_ARRAYS +- PNG_EXPORT_VAR (const png_byte FARDATA) png_sig[8]; +-#else +-#define png_sig png_sig_bytes(NULL) +-#endif +-#endif /* PNG_NO_EXTERN */ +- +-/* Constant strings for known chunk types. If you need to add a chunk, +- * define the name here, and add an invocation of the macro in png.c and +- * wherever it's needed. +- */ +-#define PNG_IHDR const png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'} +-#define PNG_IDAT const png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'} +-#define PNG_IEND const png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'} +-#define PNG_PLTE const png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'} +-#define PNG_bKGD const png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'} +-#define PNG_cHRM const png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'} +-#define PNG_gAMA const png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'} +-#define PNG_hIST const png_byte png_hIST[5] = {104, 73, 83, 84, '\0'} +-#define PNG_iCCP const png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'} +-#define PNG_iTXt const png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'} +-#define PNG_oFFs const png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'} +-#define PNG_pCAL const png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'} +-#define PNG_sCAL const png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'} +-#define PNG_pHYs const png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'} +-#define PNG_sBIT const png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'} +-#define PNG_sPLT const png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'} +-#define PNG_sRGB const png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'} +-#define PNG_tEXt const png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'} +-#define PNG_tIME const png_byte png_tIME[5] = {116, 73, 77, 69, '\0'} +-#define PNG_tRNS const png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'} +-#define PNG_zTXt const png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'} +- +-#ifdef PNG_USE_GLOBAL_ARRAYS +-PNG_EXPORT_VAR (const png_byte FARDATA) png_IHDR[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_IDAT[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_IEND[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_PLTE[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_bKGD[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_cHRM[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_gAMA[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_hIST[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_iCCP[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_iTXt[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_oFFs[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_pCAL[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_sCAL[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_pHYs[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_sBIT[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_sPLT[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_sRGB[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_tEXt[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_tIME[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_tRNS[5]; +-PNG_EXPORT_VAR (const png_byte FARDATA) png_zTXt[5]; +-#endif /* PNG_USE_GLOBAL_ARRAYS */ +- +- +-/* Inline macros to do direct reads of bytes from the input buffer. These +- * require that you are using an architecture that uses PNG byte ordering +- * (MSB first) and supports unaligned data storage. I think that PowerPC +- * in big-endian mode and 680x0 are the only ones that will support this. +- * The x86 line of processors definitely do not. The png_get_int_32() +- * routine also assumes we are using two's complement format for negative +- * values, which is almost certainly true. +- */ +-#if defined(PNG_READ_BIG_ENDIAN_SUPPORTED) +-# if defined(PNG_pCAL_SUPPORTED) || defined(PNG_oFFs_SUPPORTED) +-# define png_get_int_32(buf) ( *((png_int_32p) (buf))) +-# endif +-# define png_get_uint_32(buf) ( *((png_uint_32p) (buf))) +-# define png_get_uint_16(buf) ( *((png_uint_16p) (buf))) +-#else +-# if defined(PNG_pCAL_SUPPORTED) || defined(PNG_oFFs_SUPPORTED) +-PNG_EXTERN png_int_32 png_get_int_32 PNGARG((png_bytep buf)); +-# endif +-PNG_EXTERN png_uint_32 png_get_uint_32 PNGARG((png_bytep buf)); +-PNG_EXTERN png_uint_16 png_get_uint_16 PNGARG((png_bytep buf)); +-#endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */ +-PNG_EXTERN png_uint_32 png_get_uint_31 PNGARG((png_structp png_ptr, +- png_bytep buf)); +- +-/* Initialize png_ptr struct for reading, and allocate any other memory. +- * (old interface - DEPRECATED - use png_create_read_struct instead). +- */ +-extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr)); +-#undef png_read_init +-#define png_read_init(png_ptr) png_read_init_3(&png_ptr, \ +- PNG_LIBPNG_VER_STRING, png_sizeof(png_struct)); +-extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr, +- png_const_charp user_png_ver, png_size_t png_struct_size)); +-extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr, +- png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t +- png_info_size)); +- +-/* Initialize png_ptr struct for writing, and allocate any other memory. +- * (old interface - DEPRECATED - use png_create_write_struct instead). +- */ +-extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr)); +-#undef png_write_init +-#define png_write_init(png_ptr) png_write_init_3(&png_ptr, \ +- PNG_LIBPNG_VER_STRING, png_sizeof(png_struct)); +-extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr, +- png_const_charp user_png_ver, png_size_t png_struct_size)); +-extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr, +- png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t +- png_info_size)); +- +-/* Allocate memory for an internal libpng struct */ +-PNG_EXTERN png_voidp png_create_struct PNGARG((int type)); +- +-/* Free memory from internal libpng struct */ +-PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr)); +- +-PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr +- malloc_fn, png_voidp mem_ptr)); +-PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr, +- png_free_ptr free_fn, png_voidp mem_ptr)); +- +-/* Free any memory that info_ptr points to and reset struct. */ +-PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +- +-#ifndef PNG_1_0_X +-/* Function to allocate memory for zlib. */ +-PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size)); +- +-/* Function to free memory for zlib */ +-PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)); +- +-#ifdef PNG_SIZE_T +-/* Function to convert a sizeof an item to png_sizeof item */ +- PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size)); +-#endif +- +-/* Next four functions are used internally as callbacks. PNGAPI is required +- * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3. */ +- +-PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr, +- png_bytep data, png_size_t length)); +- +-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +-PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr, +- png_bytep buffer, png_size_t length)); +-#endif +- +-PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr, +- png_bytep data, png_size_t length)); +- +-#if defined(PNG_WRITE_FLUSH_SUPPORTED) +-#if !defined(PNG_NO_STDIO) +-PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr)); +-#endif +-#endif +-#else /* PNG_1_0_X */ +-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +-PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr, +- png_bytep buffer, png_size_t length)); +-#endif +-#endif /* PNG_1_0_X */ +- +-/* Reset the CRC variable */ +-PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr)); +- +-/* Write the "data" buffer to whatever output you are using. */ +-PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data, +- png_size_t length)); +- +-/* Read data from whatever input you are using into the "data" buffer */ +-PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data, +- png_size_t length)); +- +-/* Read bytes into buf, and update png_ptr->crc */ +-PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf, +- png_size_t length)); +- +-/* Decompress data in a chunk that uses compression */ +-#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \ +- defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) +-PNG_EXTERN png_charp png_decompress_chunk PNGARG((png_structp png_ptr, +- int comp_type, png_charp chunkdata, png_size_t chunklength, +- png_size_t prefix_length, png_size_t *data_length)); +-#endif +- +-/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */ +-PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip)); +- +-/* Read the CRC from the file and compare it to the libpng calculated CRC */ +-PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr)); +- +-/* Calculate the CRC over a section of data. Note that we are only +- * passing a maximum of 64K on systems that have this as a memory limit, +- * since this is the maximum buffer size we can specify. +- */ +-PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr, +- png_size_t length)); +- +-#if defined(PNG_WRITE_FLUSH_SUPPORTED) +-PNG_EXTERN void png_flush PNGARG((png_structp png_ptr)); +-#endif +- +- +-/* Place a 32-bit number into a buffer in PNG byte order (big-endian). +- * The only currently known PNG chunks that use signed numbers are +- * the ancillary extension chunks, oFFs and pCAL. +- */ +-PNG_EXTERN void png_save_uint_32 PNGARG((png_bytep buf, png_uint_32 i)); +- +-#if defined(PNG_WRITE_pCAL_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED) +-PNG_EXTERN void png_save_int_32 PNGARG((png_bytep buf, png_int_32 i)); +-#endif +- +-/* Place a 16-bit number into a buffer in PNG byte order. +- * The parameter is declared unsigned int, not png_uint_16, +- * just to avoid potential problems on pre-ANSI C compilers. +- */ +-PNG_EXTERN void png_save_uint_16 PNGARG((png_bytep buf, unsigned int i)); +- +-/* simple function to write the signature */ +-PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr)); +- +-/* write various chunks */ +- +-/* Write the IHDR chunk, and update the png_struct with the necessary +- * information. +- */ +-PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width, +- png_uint_32 height, +- int bit_depth, int color_type, int compression_method, int filter_method, +- int interlace_method)); +- +-PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette, +- png_uint_32 num_pal)); +- +-PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data, +- png_size_t length)); +- +-PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr)); +- +-#if defined(PNG_WRITE_gAMA_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma)); +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +-PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, png_fixed_point +- file_gamma)); +-#endif +-#endif +- +-#if defined(PNG_WRITE_sBIT_SUPPORTED) +-PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit, +- int color_type)); +-#endif +- +-#if defined(PNG_WRITE_cHRM_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr, +- double white_x, double white_y, +- double red_x, double red_y, double green_x, double green_y, +- double blue_x, double blue_y)); +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +-PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr, +- png_fixed_point int_white_x, png_fixed_point int_white_y, +- png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point +- int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, +- png_fixed_point int_blue_y)); +-#endif +-#endif +- +-#if defined(PNG_WRITE_sRGB_SUPPORTED) +-PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr, +- int intent)); +-#endif +- +-#if defined(PNG_WRITE_iCCP_SUPPORTED) +-PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr, +- png_charp name, int compression_type, +- png_charp profile, int proflen)); +- /* Note to maintainer: profile should be png_bytep */ +-#endif +- +-#if defined(PNG_WRITE_sPLT_SUPPORTED) +-PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr, +- png_sPLT_tp palette)); +-#endif +- +-#if defined(PNG_WRITE_tRNS_SUPPORTED) +-PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans, +- png_color_16p values, int number, int color_type)); +-#endif +- +-#if defined(PNG_WRITE_bKGD_SUPPORTED) +-PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr, +- png_color_16p values, int color_type)); +-#endif +- +-#if defined(PNG_WRITE_hIST_SUPPORTED) +-PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist, +- int num_hist)); +-#endif +- +-#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ +- defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) +-PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr, +- png_charp key, png_charpp new_key)); +-#endif +- +-#if defined(PNG_WRITE_tEXt_SUPPORTED) +-PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key, +- png_charp text, png_size_t text_len)); +-#endif +- +-#if defined(PNG_WRITE_zTXt_SUPPORTED) +-PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key, +- png_charp text, png_size_t text_len, int compression)); +-#endif +- +-#if defined(PNG_WRITE_iTXt_SUPPORTED) +-PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr, +- int compression, png_charp key, png_charp lang, png_charp lang_key, +- png_charp text)); +-#endif +- +-#if defined(PNG_TEXT_SUPPORTED) /* Added at version 1.0.14 and 1.2.4 */ +-PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_textp text_ptr, int num_text)); +-#endif +- +-#if defined(PNG_WRITE_oFFs_SUPPORTED) +-PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr, +- png_int_32 x_offset, png_int_32 y_offset, int unit_type)); +-#endif +- +-#if defined(PNG_WRITE_pCAL_SUPPORTED) +-PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose, +- png_int_32 X0, png_int_32 X1, int type, int nparams, +- png_charp units, png_charpp params)); +-#endif +- +-#if defined(PNG_WRITE_pHYs_SUPPORTED) +-PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr, +- png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, +- int unit_type)); +-#endif +- +-#if defined(PNG_WRITE_tIME_SUPPORTED) +-PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr, +- png_timep mod_time)); +-#endif +- +-#if defined(PNG_WRITE_sCAL_SUPPORTED) +-#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) +-PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr, +- int unit, double width, double height)); +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +-PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr, +- int unit, png_charp width, png_charp height)); +-#endif +-#endif +-#endif +- +-/* Called when finished processing a row of data */ +-PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr)); +- +-/* Internal use only. Called before first row of data */ +-PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr)); +- +-#if defined(PNG_READ_GAMMA_SUPPORTED) +-PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr)); +-#endif +- +-/* combine a row of data, dealing with alpha, etc. if requested */ +-PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row, +- int mask)); +- +-#if defined(PNG_READ_INTERLACING_SUPPORTED) +-/* expand an interlaced row */ +-/* OLD pre-1.0.9 interface: +-PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info, +- png_bytep row, int pass, png_uint_32 transformations)); +- */ +-PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr)); +-#endif +- +-/* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */ +- +-#if defined(PNG_WRITE_INTERLACING_SUPPORTED) +-/* grab pixels out of a row for an interlaced pass */ +-PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info, +- png_bytep row, int pass)); +-#endif +- +-/* unfilter a row */ +-PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr, +- png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter)); +- +-/* Choose the best filter to use and filter the row data */ +-PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr, +- png_row_infop row_info)); +- +-/* Write out the filtered row. */ +-PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr, +- png_bytep filtered_row)); +-/* finish a row while reading, dealing with interlacing passes, etc. */ +-PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr)); +- +-/* initialize the row buffers, etc. */ +-PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr)); +-/* optional call to update the users info structure */ +-PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +- +-/* these are the functions that do the transformations */ +-#if defined(PNG_READ_FILLER_SUPPORTED) +-PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info, +- png_bytep row, png_uint_32 filler, png_uint_32 flags)); +-#endif +- +-#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) +-PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info, +- png_bytep row)); +-#endif +- +-#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +-PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info, +- png_bytep row)); +-#endif +- +-#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) +-PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info, +- png_bytep row)); +-#endif +- +-#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +-PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info, +- png_bytep row)); +-#endif +- +-#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ +- defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +-PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info, +- png_bytep row, png_uint_32 flags)); +-#endif +- +-#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +-PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row)); +-#endif +- +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) +-PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row)); +-#endif +- +-#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +-PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop +- row_info, png_bytep row)); +-#endif +- +-#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +-PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info, +- png_bytep row)); +-#endif +- +-#if defined(PNG_READ_PACK_SUPPORTED) +-PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row)); +-#endif +- +-#if defined(PNG_READ_SHIFT_SUPPORTED) +-PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row, +- png_color_8p sig_bits)); +-#endif +- +-#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +-PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row)); +-#endif +- +-#if defined(PNG_READ_16_TO_8_SUPPORTED) +-PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row)); +-#endif +- +-#if defined(PNG_READ_DITHER_SUPPORTED) +-PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info, +- png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup)); +- +-# if defined(PNG_CORRECT_PALETTE_SUPPORTED) +-PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr, +- png_colorp palette, int num_palette)); +-# endif +-#endif +- +-#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +-PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row)); +-#endif +- +-#if defined(PNG_WRITE_PACK_SUPPORTED) +-PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info, +- png_bytep row, png_uint_32 bit_depth)); +-#endif +- +-#if defined(PNG_WRITE_SHIFT_SUPPORTED) +-PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row, +- png_color_8p bit_depth)); +-#endif +- +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) +-#if defined(PNG_READ_GAMMA_SUPPORTED) +-PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, +- png_color_16p trans_values, png_color_16p background, +- png_color_16p background_1, +- png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, +- png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, +- png_uint_16pp gamma_16_to_1, int gamma_shift)); +-#else +-PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, +- png_color_16p trans_values, png_color_16p background)); +-#endif +-#endif +- +-#if defined(PNG_READ_GAMMA_SUPPORTED) +-PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row, +- png_bytep gamma_table, png_uint_16pp gamma_16_table, +- int gamma_shift)); +-#endif +- +-#if defined(PNG_READ_EXPAND_SUPPORTED) +-PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info, +- png_bytep row, png_colorp palette, png_bytep trans, int num_trans)); +-PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info, +- png_bytep row, png_color_16p trans_value)); +-#endif +- +-/* The following decodes the appropriate chunks, and does error correction, +- * then calls the appropriate callback for the chunk if it is valid. +- */ +- +-/* decode the IHDR chunk */ +-PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +- +-#if defined(PNG_READ_bKGD_SUPPORTED) +-PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif +- +-#if defined(PNG_READ_cHRM_SUPPORTED) +-PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif +- +-#if defined(PNG_READ_gAMA_SUPPORTED) +-PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif +- +-#if defined(PNG_READ_hIST_SUPPORTED) +-PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif +- +-#if defined(PNG_READ_iCCP_SUPPORTED) +-extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif /* PNG_READ_iCCP_SUPPORTED */ +- +-#if defined(PNG_READ_iTXt_SUPPORTED) +-PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif +- +-#if defined(PNG_READ_oFFs_SUPPORTED) +-PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif +- +-#if defined(PNG_READ_pCAL_SUPPORTED) +-PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif +- +-#if defined(PNG_READ_pHYs_SUPPORTED) +-PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif +- +-#if defined(PNG_READ_sBIT_SUPPORTED) +-PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif +- +-#if defined(PNG_READ_sCAL_SUPPORTED) +-PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif +- +-#if defined(PNG_READ_sPLT_SUPPORTED) +-extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif /* PNG_READ_sPLT_SUPPORTED */ +- +-#if defined(PNG_READ_sRGB_SUPPORTED) +-PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif +- +-#if defined(PNG_READ_tEXt_SUPPORTED) +-PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif +- +-#if defined(PNG_READ_tIME_SUPPORTED) +-PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif +- +-#if defined(PNG_READ_tRNS_SUPPORTED) +-PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif +- +-#if defined(PNG_READ_zTXt_SUPPORTED) +-PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif +- +-PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 length)); +- +-PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr, +- png_bytep chunk_name)); +- +-/* handle the transformations for reading and writing */ +-PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr)); +-PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr)); +- +-PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr)); +- +-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +-PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +-PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +-PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr)); +-PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr, +- png_uint_32 length)); +-PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr)); +-PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr)); +-PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr, +- png_bytep buffer, png_size_t buffer_length)); +-PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr)); +-PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr, +- png_bytep buffer, png_size_t buffer_length)); +-PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr)); +-PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 length)); +-PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +-PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +-PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row)); +-PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +-PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +-PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr)); +-#if defined(PNG_READ_tEXt_SUPPORTED) +-PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 length)); +-PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +-#endif +-#if defined(PNG_READ_zTXt_SUPPORTED) +-PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 length)); +-PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +-#endif +-#if defined(PNG_READ_iTXt_SUPPORTED) +-PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 length)); +-PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +-#endif +- +-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ +- +-#ifdef PNG_MNG_FEATURES_SUPPORTED +-PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info, +- png_bytep row)); +-PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info, +- png_bytep row)); +-#endif +- +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +-/* png.c */ /* PRIVATE */ +-PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr)); +-#endif +-/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ +- +-#endif /* PNG_INTERNAL */ +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif /* PNG_VERSION_INFO_ONLY */ +-/* do not put anything past this line */ +-#endif /* PNG_H */ +diff --git a/thirdparty/libpng/pngconf.h b/thirdparty/libpng/pngconf.h +deleted file mode 100644 +index b0aedb4..0000000 +--- a/thirdparty/libpng/pngconf.h ++++ /dev/null +@@ -1,1376 +0,0 @@ +- +-/* pngconf.h - machine configurable file for libpng +- * +- * libpng version 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- */ +- +-/* Any machine specific code is near the front of this file, so if you +- * are configuring libpng for a machine, you may want to read the section +- * starting here down to where it starts to typedef png_color, png_text, +- * and png_info. +- */ +- +-#ifndef PNGCONF_H +-#define PNGCONF_H +- +-#ifdef PNG_USER_CONFIG +-#include "pngusr.h" +-#endif +- +-/* This is the size of the compression buffer, and thus the size of +- * an IDAT chunk. Make this whatever size you feel is best for your +- * machine. One of these will be allocated per png_struct. When this +- * is full, it writes the data to the disk, and does some other +- * calculations. Making this an extremely small size will slow +- * the library down, but you may want to experiment to determine +- * where it becomes significant, if you are concerned with memory +- * usage. Note that zlib allocates at least 32Kb also. For readers, +- * this describes the size of the buffer available to read the data in. +- * Unless this gets smaller than the size of a row (compressed), +- * it should not make much difference how big this is. +- */ +- +-#ifndef PNG_ZBUF_SIZE +-# define PNG_ZBUF_SIZE 8192 +-#endif +- +-/* Enable if you want a write-only libpng */ +- +-#ifndef PNG_NO_READ_SUPPORTED +-# define PNG_READ_SUPPORTED +-#endif +- +-/* Enable if you want a read-only libpng */ +- +-#ifndef PNG_NO_WRITE_SUPPORTED +-# define PNG_WRITE_SUPPORTED +-#endif +- +-/* Enabled by default in 1.2.0. You can disable this if you don't need to +- support PNGs that are embedded in MNG datastreams */ +-#if !defined(PNG_1_0_X) && !defined(PNG_NO_MNG_FEATURES) +-# ifndef PNG_MNG_FEATURES_SUPPORTED +-# define PNG_MNG_FEATURES_SUPPORTED +-# endif +-#endif +- +-#ifndef PNG_NO_FLOATING_POINT_SUPPORTED +-# ifndef PNG_FLOATING_POINT_SUPPORTED +-# define PNG_FLOATING_POINT_SUPPORTED +-# endif +-#endif +- +-/* If you are running on a machine where you cannot allocate more +- * than 64K of memory at once, uncomment this. While libpng will not +- * normally need that much memory in a chunk (unless you load up a very +- * large file), zlib needs to know how big of a chunk it can use, and +- * libpng thus makes sure to check any memory allocation to verify it +- * will fit into memory. +-#define PNG_MAX_MALLOC_64K +- */ +-#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) +-# define PNG_MAX_MALLOC_64K +-#endif +- +-/* Special munging to support doing things the 'cygwin' way: +- * 'Normal' png-on-win32 defines/defaults: +- * PNG_BUILD_DLL -- building dll +- * PNG_USE_DLL -- building an application, linking to dll +- * (no define) -- building static library, or building an +- * application and linking to the static lib +- * 'Cygwin' defines/defaults: +- * PNG_BUILD_DLL -- (ignored) building the dll +- * (no define) -- (ignored) building an application, linking to the dll +- * PNG_STATIC -- (ignored) building the static lib, or building an +- * application that links to the static lib. +- * ALL_STATIC -- (ignored) building various static libs, or building an +- * application that links to the static libs. +- * Thus, +- * a cygwin user should define either PNG_BUILD_DLL or PNG_STATIC, and +- * this bit of #ifdefs will define the 'correct' config variables based on +- * that. If a cygwin user *wants* to define 'PNG_USE_DLL' that's okay, but +- * unnecessary. +- * +- * Also, the precedence order is: +- * ALL_STATIC (since we can't #undef something outside our namespace) +- * PNG_BUILD_DLL +- * PNG_STATIC +- * (nothing) == PNG_USE_DLL +- * +- * CYGWIN (2002-01-20): The preceding is now obsolete. With the advent +- * of auto-import in binutils, we no longer need to worry about +- * __declspec(dllexport) / __declspec(dllimport) and friends. Therefore, +- * we don't need to worry about PNG_STATIC or ALL_STATIC when it comes +- * to __declspec() stuff. However, we DO need to worry about +- * PNG_BUILD_DLL and PNG_STATIC because those change some defaults +- * such as CONSOLE_IO and whether GLOBAL_ARRAYS are allowed. +- */ +-#if defined(__CYGWIN__) +-# if defined(ALL_STATIC) +-# if defined(PNG_BUILD_DLL) +-# undef PNG_BUILD_DLL +-# endif +-# if defined(PNG_USE_DLL) +-# undef PNG_USE_DLL +-# endif +-# if defined(PNG_DLL) +-# undef PNG_DLL +-# endif +-# if !defined(PNG_STATIC) +-# define PNG_STATIC +-# endif +-# else +-# if defined (PNG_BUILD_DLL) +-# if defined(PNG_STATIC) +-# undef PNG_STATIC +-# endif +-# if defined(PNG_USE_DLL) +-# undef PNG_USE_DLL +-# endif +-# if !defined(PNG_DLL) +-# define PNG_DLL +-# endif +-# else +-# if defined(PNG_STATIC) +-# if defined(PNG_USE_DLL) +-# undef PNG_USE_DLL +-# endif +-# if defined(PNG_DLL) +-# undef PNG_DLL +-# endif +-# else +-# if !defined(PNG_USE_DLL) +-# define PNG_USE_DLL +-# endif +-# if !defined(PNG_DLL) +-# define PNG_DLL +-# endif +-# endif +-# endif +-# endif +-#endif +- +-/* This protects us against compilers that run on a windowing system +- * and thus don't have or would rather us not use the stdio types: +- * stdin, stdout, and stderr. The only one currently used is stderr +- * in png_error() and png_warning(). #defining PNG_NO_CONSOLE_IO will +- * prevent these from being compiled and used. #defining PNG_NO_STDIO +- * will also prevent these, plus will prevent the entire set of stdio +- * macros and functions (FILE *, printf, etc.) from being compiled and used, +- * unless (PNG_DEBUG > 0) has been #defined. +- * +- * #define PNG_NO_CONSOLE_IO +- * #define PNG_NO_STDIO +- */ +- +-#if defined(_WIN32_WCE) +-# include +- /* Console I/O functions are not supported on WindowsCE */ +-# define PNG_NO_CONSOLE_IO +-# ifdef PNG_DEBUG +-# undef PNG_DEBUG +-# endif +-#endif +- +-#ifdef PNG_BUILD_DLL +-# ifndef PNG_CONSOLE_IO_SUPPORTED +-# ifndef PNG_NO_CONSOLE_IO +-# define PNG_NO_CONSOLE_IO +-# endif +-# endif +-#endif +- +-# ifdef PNG_NO_STDIO +-# ifndef PNG_NO_CONSOLE_IO +-# define PNG_NO_CONSOLE_IO +-# endif +-# ifdef PNG_DEBUG +-# if (PNG_DEBUG > 0) +-# include +-# endif +-# endif +-# else +-# if !defined(_WIN32_WCE) +-/* "stdio.h" functions are not supported on WindowsCE */ +-# include +-# endif +-# endif +- +-/* This macro protects us against machines that don't have function +- * prototypes (ie K&R style headers). If your compiler does not handle +- * function prototypes, define this macro and use the included ansi2knr. +- * I've always been able to use _NO_PROTO as the indicator, but you may +- * need to drag the empty declaration out in front of here, or change the +- * ifdef to suit your own needs. +- */ +-#ifndef PNGARG +- +-#ifdef OF /* zlib prototype munger */ +-# define PNGARG(arglist) OF(arglist) +-#else +- +-#ifdef _NO_PROTO +-# define PNGARG(arglist) () +-# ifndef PNG_TYPECAST_NULL +-# define PNG_TYPECAST_NULL +-# endif +-#else +-# define PNGARG(arglist) arglist +-#endif /* _NO_PROTO */ +- +-#endif /* OF */ +- +-#endif /* PNGARG */ +- +-/* Try to determine if we are compiling on a Mac. Note that testing for +- * just __MWERKS__ is not good enough, because the Codewarrior is now used +- * on non-Mac platforms. +- */ +-#ifndef MACOS +-# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \ +- defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC) +-# define MACOS +-# endif +-#endif +- +-/* enough people need this for various reasons to include it here */ +-#if !defined(MACOS) && !defined(RISCOS) && !defined(_WIN32_WCE) +-# include +-#endif +- +-#if !defined(PNG_SETJMP_NOT_SUPPORTED) && !defined(PNG_NO_SETJMP_SUPPORTED) +-# define PNG_SETJMP_SUPPORTED +-#endif +- +-#ifdef PNG_SETJMP_SUPPORTED +-/* This is an attempt to force a single setjmp behaviour on Linux. If +- * the X config stuff didn't define _BSD_SOURCE we wouldn't need this. +- */ +- +-# ifdef __linux__ +-# ifdef _BSD_SOURCE +-# define PNG_SAVE_BSD_SOURCE +-# undef _BSD_SOURCE +-# endif +-# ifdef _SETJMP_H +- /* If you encounter a compiler error here, see the explanation +- * near the end of INSTALL. +- */ +- __png.h__ already includes setjmp.h; +- __dont__ include it again.; +-# endif +-# endif /* __linux__ */ +- +- /* include setjmp.h for error handling */ +-# include +- +-# ifdef __linux__ +-# ifdef PNG_SAVE_BSD_SOURCE +-# define _BSD_SOURCE +-# undef PNG_SAVE_BSD_SOURCE +-# endif +-# endif /* __linux__ */ +-#endif /* PNG_SETJMP_SUPPORTED */ +- +-#ifdef BSD +-# include +-#else +-# include +-#endif +- +-/* Other defines for things like memory and the like can go here. */ +-#ifdef PNG_INTERNAL +- +-#include +- +-/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which +- * aren't usually used outside the library (as far as I know), so it is +- * debatable if they should be exported at all. In the future, when it is +- * possible to have run-time registry of chunk-handling functions, some of +- * these will be made available again. +-#define PNG_EXTERN extern +- */ +-#define PNG_EXTERN +- +-/* Other defines specific to compilers can go here. Try to keep +- * them inside an appropriate ifdef/endif pair for portability. +- */ +- +-#if defined(PNG_FLOATING_POINT_SUPPORTED) +-# if defined(MACOS) +- /* We need to check that hasn't already been included earlier +- * as it seems it doesn't agree with , yet we should really use +- * if possible. +- */ +-# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__) +-# include +-# endif +-# else +-# include +-# endif +-# if defined(_AMIGA) && defined(__SASC) && defined(_M68881) +- /* Amiga SAS/C: We must include builtin FPU functions when compiling using +- * MATH=68881 +- */ +-# include +-# endif +-#endif +- +-/* Codewarrior on NT has linking problems without this. */ +-#if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__) +-# define PNG_ALWAYS_EXTERN +-#endif +- +-/* This provides the non-ANSI (far) memory allocation routines. */ +-#if defined(__TURBOC__) && defined(__MSDOS__) +-# include +-# include +-#endif +- +-/* I have no idea why is this necessary... */ +-#if defined(_MSC_VER) && (defined(WIN32) || defined(_Windows) || \ +- defined(_WINDOWS) || defined(_WIN32) || defined(__WIN32__)) +-# include +-#endif +- +-/* This controls how fine the dithering gets. As this allocates +- * a largish chunk of memory (32K), those who are not as concerned +- * with dithering quality can decrease some or all of these. +- */ +-#ifndef PNG_DITHER_RED_BITS +-# define PNG_DITHER_RED_BITS 5 +-#endif +-#ifndef PNG_DITHER_GREEN_BITS +-# define PNG_DITHER_GREEN_BITS 5 +-#endif +-#ifndef PNG_DITHER_BLUE_BITS +-# define PNG_DITHER_BLUE_BITS 5 +-#endif +- +-/* This controls how fine the gamma correction becomes when you +- * are only interested in 8 bits anyway. Increasing this value +- * results in more memory being used, and more pow() functions +- * being called to fill in the gamma tables. Don't set this value +- * less then 8, and even that may not work (I haven't tested it). +- */ +- +-#ifndef PNG_MAX_GAMMA_8 +-# define PNG_MAX_GAMMA_8 11 +-#endif +- +-/* This controls how much a difference in gamma we can tolerate before +- * we actually start doing gamma conversion. +- */ +-#ifndef PNG_GAMMA_THRESHOLD +-# define PNG_GAMMA_THRESHOLD 0.05 +-#endif +- +-#endif /* PNG_INTERNAL */ +- +-/* The following uses const char * instead of char * for error +- * and warning message functions, so some compilers won't complain. +- * If you do not want to use const, define PNG_NO_CONST here. +- */ +- +-#ifndef PNG_NO_CONST +-# define PNG_CONST const +-#else +-# define PNG_CONST +-#endif +- +-/* The following defines give you the ability to remove code from the +- * library that you will not be using. I wish I could figure out how to +- * automate this, but I can't do that without making it seriously hard +- * on the users. So if you are not using an ability, change the #define +- * to and #undef, and that part of the library will not be compiled. If +- * your linker can't find a function, you may want to make sure the +- * ability is defined here. Some of these depend upon some others being +- * defined. I haven't figured out all the interactions here, so you may +- * have to experiment awhile to get everything to compile. If you are +- * creating or using a shared library, you probably shouldn't touch this, +- * as it will affect the size of the structures, and this will cause bad +- * things to happen if the library and/or application ever change. +- */ +- +-/* Any features you will not be using can be undef'ed here */ +- +-/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user +- * to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS +- * on the compile line, then pick and choose which ones to define without +- * having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED +- * if you only want to have a png-compliant reader/writer but don't need +- * any of the extra transformations. This saves about 80 kbytes in a +- * typical installation of the library. (PNG_NO_* form added in version +- * 1.0.1c, for consistency) +- */ +- +-/* The size of the png_text structure changed in libpng-1.0.6 when +- * iTXt is supported. It is turned off by default, to support old apps +- * that malloc the png_text structure instead of calling png_set_text() +- * and letting libpng malloc it. It will be turned on by default in +- * libpng-1.3.0. +- */ +- +-#ifndef PNG_iTXt_SUPPORTED +-# if !defined(PNG_READ_iTXt_SUPPORTED) && !defined(PNG_NO_READ_iTXt) +-# define PNG_NO_READ_iTXt +-# endif +-# if !defined(PNG_WRITE_iTXt_SUPPORTED) && !defined(PNG_NO_WRITE_iTXt) +-# define PNG_NO_WRITE_iTXt +-# endif +-#endif +- +-/* The following support, added after version 1.0.0, can be turned off here en +- * masse by defining PNG_LEGACY_SUPPORTED in case you need binary compatibility +- * with old applications that require the length of png_struct and png_info +- * to remain unchanged. +- */ +- +-#ifdef PNG_LEGACY_SUPPORTED +-# define PNG_NO_FREE_ME +-# define PNG_NO_READ_UNKNOWN_CHUNKS +-# define PNG_NO_WRITE_UNKNOWN_CHUNKS +-# define PNG_NO_READ_USER_CHUNKS +-# define PNG_NO_READ_iCCP +-# define PNG_NO_WRITE_iCCP +-# define PNG_NO_READ_iTXt +-# define PNG_NO_WRITE_iTXt +-# define PNG_NO_READ_sCAL +-# define PNG_NO_WRITE_sCAL +-# define PNG_NO_READ_sPLT +-# define PNG_NO_WRITE_sPLT +-# define PNG_NO_INFO_IMAGE +-# define PNG_NO_READ_RGB_TO_GRAY +-# define PNG_NO_READ_USER_TRANSFORM +-# define PNG_NO_WRITE_USER_TRANSFORM +-# define PNG_NO_USER_MEM +-# define PNG_NO_READ_EMPTY_PLTE +-# define PNG_NO_MNG_FEATURES +-# define PNG_NO_FIXED_POINT_SUPPORTED +-#endif +- +-/* Ignore attempt to turn off both floating and fixed point support */ +-#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \ +- !defined(PNG_NO_FIXED_POINT_SUPPORTED) +-# define PNG_FIXED_POINT_SUPPORTED +-#endif +- +-#ifndef PNG_NO_FREE_ME +-# define PNG_FREE_ME_SUPPORTED +-#endif +- +-#if defined(PNG_READ_SUPPORTED) +- +-#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \ +- !defined(PNG_NO_READ_TRANSFORMS) +-# define PNG_READ_TRANSFORMS_SUPPORTED +-#endif +- +-#ifdef PNG_READ_TRANSFORMS_SUPPORTED +-# ifndef PNG_NO_READ_EXPAND +-# define PNG_READ_EXPAND_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_SHIFT +-# define PNG_READ_SHIFT_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_PACK +-# define PNG_READ_PACK_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_BGR +-# define PNG_READ_BGR_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_SWAP +-# define PNG_READ_SWAP_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_PACKSWAP +-# define PNG_READ_PACKSWAP_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_INVERT +-# define PNG_READ_INVERT_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_DITHER +-# define PNG_READ_DITHER_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_BACKGROUND +-# define PNG_READ_BACKGROUND_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_16_TO_8 +-# define PNG_READ_16_TO_8_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_FILLER +-# define PNG_READ_FILLER_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_GAMMA +-# define PNG_READ_GAMMA_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_GRAY_TO_RGB +-# define PNG_READ_GRAY_TO_RGB_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_SWAP_ALPHA +-# define PNG_READ_SWAP_ALPHA_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_INVERT_ALPHA +-# define PNG_READ_INVERT_ALPHA_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_STRIP_ALPHA +-# define PNG_READ_STRIP_ALPHA_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_USER_TRANSFORM +-# define PNG_READ_USER_TRANSFORM_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_RGB_TO_GRAY +-# define PNG_READ_RGB_TO_GRAY_SUPPORTED +-# endif +-#endif /* PNG_READ_TRANSFORMS_SUPPORTED */ +- +-#if !defined(PNG_NO_PROGRESSIVE_READ) && \ +- !defined(PNG_PROGRESSIVE_READ_NOT_SUPPORTED) /* if you don't do progressive */ +-# define PNG_PROGRESSIVE_READ_SUPPORTED /* reading. This is not talking */ +-#endif /* about interlacing capability! You'll */ +- /* still have interlacing unless you change the following line: */ +- +-#define PNG_READ_INTERLACING_SUPPORTED /* required for PNG-compliant decoders */ +- +-#ifndef PNG_NO_READ_COMPOSITE_NODIV +-# ifndef PNG_NO_READ_COMPOSITED_NODIV /* libpng-1.0.x misspelling */ +-# define PNG_READ_COMPOSITE_NODIV_SUPPORTED /* well tested on Intel, SGI */ +-# endif +-#endif +- +-/* Deprecated, will be removed from version 2.0.0. +- Use PNG_MNG_FEATURES_SUPPORTED instead. */ +-#ifndef PNG_NO_READ_EMPTY_PLTE +-# define PNG_READ_EMPTY_PLTE_SUPPORTED +-#endif +- +-#endif /* PNG_READ_SUPPORTED */ +- +-#if defined(PNG_WRITE_SUPPORTED) +- +-# if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \ +- !defined(PNG_NO_WRITE_TRANSFORMS) +-# define PNG_WRITE_TRANSFORMS_SUPPORTED +-#endif +- +-#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED +-# ifndef PNG_NO_WRITE_SHIFT +-# define PNG_WRITE_SHIFT_SUPPORTED +-# endif +-# ifndef PNG_NO_WRITE_PACK +-# define PNG_WRITE_PACK_SUPPORTED +-# endif +-# ifndef PNG_NO_WRITE_BGR +-# define PNG_WRITE_BGR_SUPPORTED +-# endif +-# ifndef PNG_NO_WRITE_SWAP +-# define PNG_WRITE_SWAP_SUPPORTED +-# endif +-# ifndef PNG_NO_WRITE_PACKSWAP +-# define PNG_WRITE_PACKSWAP_SUPPORTED +-# endif +-# ifndef PNG_NO_WRITE_INVERT +-# define PNG_WRITE_INVERT_SUPPORTED +-# endif +-# ifndef PNG_NO_WRITE_FILLER +-# define PNG_WRITE_FILLER_SUPPORTED /* same as WRITE_STRIP_ALPHA */ +-# endif +-# ifndef PNG_NO_WRITE_SWAP_ALPHA +-# define PNG_WRITE_SWAP_ALPHA_SUPPORTED +-# endif +-# ifndef PNG_NO_WRITE_INVERT_ALPHA +-# define PNG_WRITE_INVERT_ALPHA_SUPPORTED +-# endif +-# ifndef PNG_NO_WRITE_USER_TRANSFORM +-# define PNG_WRITE_USER_TRANSFORM_SUPPORTED +-# endif +-#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */ +- +-#define PNG_WRITE_INTERLACING_SUPPORTED /* not required for PNG-compliant +- encoders, but can cause trouble +- if left undefined */ +- +-#if !defined(PNG_NO_WRITE_WEIGHTED_FILTER) && \ +- defined(PNG_FLOATING_POINT_SUPPORTED) +-# define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +-#endif +- +-#ifndef PNG_NO_WRITE_FLUSH +-# define PNG_WRITE_FLUSH_SUPPORTED +-#endif +- +-/* Deprecated, see PNG_MNG_FEATURES_SUPPORTED, above */ +-#ifndef PNG_NO_WRITE_EMPTY_PLTE +-# define PNG_WRITE_EMPTY_PLTE_SUPPORTED +-#endif +- +-#endif /* PNG_WRITE_SUPPORTED */ +- +-#ifndef PNG_1_0_X +-# ifndef PNG_NO_ERROR_NUMBERS +-# define PNG_ERROR_NUMBERS_SUPPORTED +-# endif +-#endif /* PNG_1_0_X */ +- +-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +-# ifndef PNG_NO_USER_TRANSFORM_PTR +-# define PNG_USER_TRANSFORM_PTR_SUPPORTED +-# endif +-#endif +- +-#ifndef PNG_NO_STDIO +-# define PNG_TIME_RFC1123_SUPPORTED +-#endif +- +-/* This adds extra functions in pngget.c for accessing data from the +- * info pointer (added in version 0.99) +- * png_get_image_width() +- * png_get_image_height() +- * png_get_bit_depth() +- * png_get_color_type() +- * png_get_compression_type() +- * png_get_filter_type() +- * png_get_interlace_type() +- * png_get_pixel_aspect_ratio() +- * png_get_pixels_per_meter() +- * png_get_x_offset_pixels() +- * png_get_y_offset_pixels() +- * png_get_x_offset_microns() +- * png_get_y_offset_microns() +- */ +-#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED) +-# define PNG_EASY_ACCESS_SUPPORTED +-#endif +- +-/* PNG_ASSEMBLER_CODE was enabled by default in version 1.2.0 +- even when PNG_USE_PNGVCRD or PNG_USE_PNGGCCRD is not defined */ +-#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_ASSEMBLER_CODE) +-# ifndef PNG_ASSEMBLER_CODE_SUPPORTED +-# define PNG_ASSEMBLER_CODE_SUPPORTED +-# endif +-# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) +-# define PNG_MMX_CODE_SUPPORTED +-# endif +-#endif +- +-/* If you are sure that you don't need thread safety and you are compiling +- with PNG_USE_PNGCCRD for an MMX application, you can define this for +- faster execution. See pnggccrd.c. +-#define PNG_THREAD_UNSAFE_OK +-*/ +- +-#if !defined(PNG_1_0_X) +-#if !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED) +-# define PNG_USER_MEM_SUPPORTED +-#endif +-#endif /* PNG_1_0_X */ +- +-/* Added at libpng-1.2.6 */ +-#if !defined(PNG_1_0_X) +-#ifndef PNG_SET_USER_LIMITS_SUPPORTED +-#if !defined(PNG_NO_SET_USER_LIMITS) && !defined(PNG_SET_USER_LIMITS_SUPPORTED) +-# define PNG_SET_USER_LIMITS_SUPPORTED +-#endif +-#endif +-#endif /* PNG_1_0_X */ +- +-/* Added at libpng-1.0.16 and 1.2.6. To accept all valid PNGS no matter +- * how large, set these limits to 0x7fffffffL +- */ +-#ifndef PNG_USER_WIDTH_MAX +-# define PNG_USER_WIDTH_MAX 1000000L +-#endif +-#ifndef PNG_USER_HEIGHT_MAX +-# define PNG_USER_HEIGHT_MAX 1000000L +-#endif +- +-/* These are currently experimental features, define them if you want */ +- +-/* very little testing */ +-/* +-#ifdef PNG_READ_SUPPORTED +-# ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED +-# define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED +-# endif +-#endif +-*/ +- +-/* This is only for PowerPC big-endian and 680x0 systems */ +-/* some testing */ +-/* +-#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED +-# define PNG_READ_BIG_ENDIAN_SUPPORTED +-#endif +-*/ +- +-/* Buggy compilers (e.g., gcc 2.7.2.2) need this */ +-/* +-#define PNG_NO_POINTER_INDEXING +-*/ +- +-/* These functions are turned off by default, as they will be phased out. */ +-/* +-#define PNG_USELESS_TESTS_SUPPORTED +-#define PNG_CORRECT_PALETTE_SUPPORTED +-*/ +- +-/* Any chunks you are not interested in, you can undef here. The +- * ones that allocate memory may be expecially important (hIST, +- * tEXt, zTXt, tRNS, pCAL). Others will just save time and make png_info +- * a bit smaller. +- */ +- +-#if defined(PNG_READ_SUPPORTED) && \ +- !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ +- !defined(PNG_NO_READ_ANCILLARY_CHUNKS) +-# define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED +-#endif +- +-#if defined(PNG_WRITE_SUPPORTED) && \ +- !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ +- !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS) +-# define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED +-#endif +- +-#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED +- +-#ifdef PNG_NO_READ_TEXT +-# define PNG_NO_READ_iTXt +-# define PNG_NO_READ_tEXt +-# define PNG_NO_READ_zTXt +-#endif +-#ifndef PNG_NO_READ_bKGD +-# define PNG_READ_bKGD_SUPPORTED +-# define PNG_bKGD_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_cHRM +-# define PNG_READ_cHRM_SUPPORTED +-# define PNG_cHRM_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_gAMA +-# define PNG_READ_gAMA_SUPPORTED +-# define PNG_gAMA_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_hIST +-# define PNG_READ_hIST_SUPPORTED +-# define PNG_hIST_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_iCCP +-# define PNG_READ_iCCP_SUPPORTED +-# define PNG_iCCP_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_iTXt +-# ifndef PNG_READ_iTXt_SUPPORTED +-# define PNG_READ_iTXt_SUPPORTED +-# endif +-# ifndef PNG_iTXt_SUPPORTED +-# define PNG_iTXt_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_READ_oFFs +-# define PNG_READ_oFFs_SUPPORTED +-# define PNG_oFFs_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_pCAL +-# define PNG_READ_pCAL_SUPPORTED +-# define PNG_pCAL_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_sCAL +-# define PNG_READ_sCAL_SUPPORTED +-# define PNG_sCAL_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_pHYs +-# define PNG_READ_pHYs_SUPPORTED +-# define PNG_pHYs_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_sBIT +-# define PNG_READ_sBIT_SUPPORTED +-# define PNG_sBIT_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_sPLT +-# define PNG_READ_sPLT_SUPPORTED +-# define PNG_sPLT_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_sRGB +-# define PNG_READ_sRGB_SUPPORTED +-# define PNG_sRGB_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_tEXt +-# define PNG_READ_tEXt_SUPPORTED +-# define PNG_tEXt_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_tIME +-# define PNG_READ_tIME_SUPPORTED +-# define PNG_tIME_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_tRNS +-# define PNG_READ_tRNS_SUPPORTED +-# define PNG_tRNS_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_zTXt +-# define PNG_READ_zTXt_SUPPORTED +-# define PNG_zTXt_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_UNKNOWN_CHUNKS +-# define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED +-# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED +-# define PNG_UNKNOWN_CHUNKS_SUPPORTED +-# endif +-# ifndef PNG_NO_HANDLE_AS_UNKNOWN +-# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +-# endif +-#endif +-#if !defined(PNG_NO_READ_USER_CHUNKS) && \ +- defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) +-# define PNG_READ_USER_CHUNKS_SUPPORTED +-# define PNG_USER_CHUNKS_SUPPORTED +-# ifdef PNG_NO_READ_UNKNOWN_CHUNKS +-# undef PNG_NO_READ_UNKNOWN_CHUNKS +-# endif +-# ifdef PNG_NO_HANDLE_AS_UNKNOWN +-# undef PNG_NO_HANDLE_AS_UNKNOWN +-# endif +-#endif +-#ifndef PNG_NO_READ_OPT_PLTE +-# define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the */ +-#endif /* optional PLTE chunk in RGB and RGBA images */ +-#if defined(PNG_READ_iTXt_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) || \ +- defined(PNG_READ_zTXt_SUPPORTED) +-# define PNG_READ_TEXT_SUPPORTED +-# define PNG_TEXT_SUPPORTED +-#endif +- +-#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */ +- +-#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED +- +-#ifdef PNG_NO_WRITE_TEXT +-# define PNG_NO_WRITE_iTXt +-# define PNG_NO_WRITE_tEXt +-# define PNG_NO_WRITE_zTXt +-#endif +-#ifndef PNG_NO_WRITE_bKGD +-# define PNG_WRITE_bKGD_SUPPORTED +-# ifndef PNG_bKGD_SUPPORTED +-# define PNG_bKGD_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_cHRM +-# define PNG_WRITE_cHRM_SUPPORTED +-# ifndef PNG_cHRM_SUPPORTED +-# define PNG_cHRM_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_gAMA +-# define PNG_WRITE_gAMA_SUPPORTED +-# ifndef PNG_gAMA_SUPPORTED +-# define PNG_gAMA_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_hIST +-# define PNG_WRITE_hIST_SUPPORTED +-# ifndef PNG_hIST_SUPPORTED +-# define PNG_hIST_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_iCCP +-# define PNG_WRITE_iCCP_SUPPORTED +-# ifndef PNG_iCCP_SUPPORTED +-# define PNG_iCCP_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_iTXt +-# ifndef PNG_WRITE_iTXt_SUPPORTED +-# define PNG_WRITE_iTXt_SUPPORTED +-# endif +-# ifndef PNG_iTXt_SUPPORTED +-# define PNG_iTXt_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_oFFs +-# define PNG_WRITE_oFFs_SUPPORTED +-# ifndef PNG_oFFs_SUPPORTED +-# define PNG_oFFs_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_pCAL +-# define PNG_WRITE_pCAL_SUPPORTED +-# ifndef PNG_pCAL_SUPPORTED +-# define PNG_pCAL_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_sCAL +-# define PNG_WRITE_sCAL_SUPPORTED +-# ifndef PNG_sCAL_SUPPORTED +-# define PNG_sCAL_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_pHYs +-# define PNG_WRITE_pHYs_SUPPORTED +-# ifndef PNG_pHYs_SUPPORTED +-# define PNG_pHYs_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_sBIT +-# define PNG_WRITE_sBIT_SUPPORTED +-# ifndef PNG_sBIT_SUPPORTED +-# define PNG_sBIT_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_sPLT +-# define PNG_WRITE_sPLT_SUPPORTED +-# ifndef PNG_sPLT_SUPPORTED +-# define PNG_sPLT_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_sRGB +-# define PNG_WRITE_sRGB_SUPPORTED +-# ifndef PNG_sRGB_SUPPORTED +-# define PNG_sRGB_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_tEXt +-# define PNG_WRITE_tEXt_SUPPORTED +-# ifndef PNG_tEXt_SUPPORTED +-# define PNG_tEXt_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_tIME +-# define PNG_WRITE_tIME_SUPPORTED +-# ifndef PNG_tIME_SUPPORTED +-# define PNG_tIME_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_tRNS +-# define PNG_WRITE_tRNS_SUPPORTED +-# ifndef PNG_tRNS_SUPPORTED +-# define PNG_tRNS_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_zTXt +-# define PNG_WRITE_zTXt_SUPPORTED +-# ifndef PNG_zTXt_SUPPORTED +-# define PNG_zTXt_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS +-# define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED +-# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED +-# define PNG_UNKNOWN_CHUNKS_SUPPORTED +-# endif +-# ifndef PNG_NO_HANDLE_AS_UNKNOWN +-# ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +-# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +-# endif +-# endif +-#endif +-#if defined(PNG_WRITE_iTXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \ +- defined(PNG_WRITE_zTXt_SUPPORTED) +-# define PNG_WRITE_TEXT_SUPPORTED +-# ifndef PNG_TEXT_SUPPORTED +-# define PNG_TEXT_SUPPORTED +-# endif +-#endif +- +-#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */ +- +-/* Turn this off to disable png_read_png() and +- * png_write_png() and leave the row_pointers member +- * out of the info structure. +- */ +-#ifndef PNG_NO_INFO_IMAGE +-# define PNG_INFO_IMAGE_SUPPORTED +-#endif +- +-/* need the time information for reading tIME chunks */ +-#if defined(PNG_tIME_SUPPORTED) +-# if !defined(_WIN32_WCE) +- /* "time.h" functions are not supported on WindowsCE */ +-# include +-# endif +-#endif +- +-/* Some typedefs to get us started. These should be safe on most of the +- * common platforms. The typedefs should be at least as large as the +- * numbers suggest (a png_uint_32 must be at least 32 bits long), but they +- * don't have to be exactly that size. Some compilers dislike passing +- * unsigned shorts as function parameters, so you may be better off using +- * unsigned int for png_uint_16. Likewise, for 64-bit systems, you may +- * want to have unsigned int for png_uint_32 instead of unsigned long. +- */ +- +-typedef unsigned long png_uint_32; +-typedef long png_int_32; +-typedef unsigned short png_uint_16; +-typedef short png_int_16; +-typedef unsigned char png_byte; +- +-/* This is usually size_t. It is typedef'ed just in case you need it to +- change (I'm not sure if you will or not, so I thought I'd be safe) */ +-#ifdef PNG_SIZE_T +- typedef PNG_SIZE_T png_size_t; +-# define png_sizeof(x) png_convert_size(sizeof (x)) +-#else +- typedef size_t png_size_t; +-# define png_sizeof(x) sizeof (x) +-#endif +- +-/* The following is needed for medium model support. It cannot be in the +- * PNG_INTERNAL section. Needs modification for other compilers besides +- * MSC. Model independent support declares all arrays and pointers to be +- * large using the far keyword. The zlib version used must also support +- * model independent data. As of version zlib 1.0.4, the necessary changes +- * have been made in zlib. The USE_FAR_KEYWORD define triggers other +- * changes that are needed. (Tim Wegner) +- */ +- +-/* Separate compiler dependencies (problem here is that zlib.h always +- defines FAR. (SJT) */ +-#ifdef __BORLANDC__ +-# if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__) +-# define LDATA 1 +-# else +-# define LDATA 0 +-# endif +- /* GRR: why is Cygwin in here? Cygwin is not Borland C... */ +-# if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__) +-# define PNG_MAX_MALLOC_64K +-# if (LDATA != 1) +-# ifndef FAR +-# define FAR __far +-# endif +-# define USE_FAR_KEYWORD +-# endif /* LDATA != 1 */ +- /* Possibly useful for moving data out of default segment. +- * Uncomment it if you want. Could also define FARDATA as +- * const if your compiler supports it. (SJT) +-# define FARDATA FAR +- */ +-# endif /* __WIN32__, __FLAT__, __CYGWIN__ */ +-#endif /* __BORLANDC__ */ +- +- +-/* Suggest testing for specific compiler first before testing for +- * FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM, +- * making reliance oncertain keywords suspect. (SJT) +- */ +- +-/* MSC Medium model */ +-#if defined(FAR) +-# if defined(M_I86MM) +-# define USE_FAR_KEYWORD +-# define FARDATA FAR +-# include +-# endif +-#endif +- +-/* SJT: default case */ +-#ifndef FAR +-# define FAR +-#endif +- +-/* At this point FAR is always defined */ +-#ifndef FARDATA +-# define FARDATA +-#endif +- +-/* Typedef for floating-point numbers that are converted +- to fixed-point with a multiple of 100,000, e.g., int_gamma */ +-typedef png_int_32 png_fixed_point; +- +-/* Add typedefs for pointers */ +-typedef void FAR * png_voidp; +-typedef png_byte FAR * png_bytep; +-typedef png_uint_32 FAR * png_uint_32p; +-typedef png_int_32 FAR * png_int_32p; +-typedef png_uint_16 FAR * png_uint_16p; +-typedef png_int_16 FAR * png_int_16p; +-typedef PNG_CONST char FAR * png_const_charp; +-typedef char FAR * png_charp; +-typedef png_fixed_point FAR * png_fixed_point_p; +- +-#ifndef PNG_NO_STDIO +-#if defined(_WIN32_WCE) +-typedef HANDLE png_FILE_p; +-#else +-typedef FILE * png_FILE_p; +-#endif +-#endif +- +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-typedef double FAR * png_doublep; +-#endif +- +-/* Pointers to pointers; i.e. arrays */ +-typedef png_byte FAR * FAR * png_bytepp; +-typedef png_uint_32 FAR * FAR * png_uint_32pp; +-typedef png_int_32 FAR * FAR * png_int_32pp; +-typedef png_uint_16 FAR * FAR * png_uint_16pp; +-typedef png_int_16 FAR * FAR * png_int_16pp; +-typedef PNG_CONST char FAR * FAR * png_const_charpp; +-typedef char FAR * FAR * png_charpp; +-typedef png_fixed_point FAR * FAR * png_fixed_point_pp; +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-typedef double FAR * FAR * png_doublepp; +-#endif +- +-/* Pointers to pointers to pointers; i.e., pointer to array */ +-typedef char FAR * FAR * FAR * png_charppp; +- +-/* libpng typedefs for types in zlib. If zlib changes +- * or another compression library is used, then change these. +- * Eliminates need to change all the source files. +- */ +-typedef charf * png_zcharp; +-typedef charf * FAR * png_zcharpp; +-typedef z_stream FAR * png_zstreamp; +- +-/* +- * Define PNG_BUILD_DLL if the module being built is a Windows +- * LIBPNG DLL. +- * +- * Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL. +- * It is equivalent to Microsoft predefined macro _DLL that is +- * automatically defined when you compile using the share +- * version of the CRT (C Run-Time library) +- * +- * The cygwin mods make this behavior a little different: +- * Define PNG_BUILD_DLL if you are building a dll for use with cygwin +- * Define PNG_STATIC if you are building a static library for use with cygwin, +- * -or- if you are building an application that you want to link to the +- * static library. +- * PNG_USE_DLL is defined by default (no user action needed) unless one of +- * the other flags is defined. +- */ +- +-#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL)) +-# define PNG_DLL +-#endif +-/* If CYGWIN, then disallow GLOBAL ARRAYS unless building a static lib. +- * When building a static lib, default to no GLOBAL ARRAYS, but allow +- * command-line override +- */ +-#if defined(__CYGWIN__) +-# if !defined(PNG_STATIC) +-# if defined(PNG_USE_GLOBAL_ARRAYS) +-# undef PNG_USE_GLOBAL_ARRAYS +-# endif +-# if !defined(PNG_USE_LOCAL_ARRAYS) +-# define PNG_USE_LOCAL_ARRAYS +-# endif +-# else +-# if defined(PNG_USE_LOCAL_ARRAYS) || defined(PNG_NO_GLOBAL_ARRAYS) +-# if defined(PNG_USE_GLOBAL_ARRAYS) +-# undef PNG_USE_GLOBAL_ARRAYS +-# endif +-# endif +-# endif +-# if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) +-# define PNG_USE_LOCAL_ARRAYS +-# endif +-#endif +- +-/* Do not use global arrays (helps with building DLL's) +- * They are no longer used in libpng itself, since version 1.0.5c, +- * but might be required for some pre-1.0.5c applications. +- */ +-#if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) +-# if defined(PNG_NO_GLOBAL_ARRAYS) || (defined(__GNUC__) && defined(PNG_DLL)) +-# define PNG_USE_LOCAL_ARRAYS +-# else +-# define PNG_USE_GLOBAL_ARRAYS +-# endif +-#endif +- +-#if defined(__CYGWIN__) +-# undef PNGAPI +-# define PNGAPI __cdecl +-# undef PNG_IMPEXP +-# define PNG_IMPEXP +-#endif +- +-/* If you define PNGAPI, e.g., with compiler option "-DPNGAPI=__stdcall", +- * you may get warnings regarding the linkage of png_zalloc and png_zfree. +- * Don't ignore those warnings; you must also reset the default calling +- * convention in your compiler to match your PNGAPI, and you must build +- * zlib and your applications the same way you build libpng. +- */ +- +-#if defined(__MINGW32__) && !defined(PNG_MODULEDEF) +-# ifndef PNG_NO_MODULEDEF +-# define PNG_NO_MODULEDEF +-# endif +-#endif +- +-#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF) +-# define PNG_IMPEXP +-#endif +- +-#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \ +- (( defined(_Windows) || defined(_WINDOWS) || \ +- defined(WIN32) || defined(_WIN32) || defined(__WIN32__) )) +- +-# ifndef PNGAPI +-# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800)) +-# define PNGAPI __cdecl +-# else +-# define PNGAPI _cdecl +-# endif +-# endif +- +-# if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \ +- 0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */) +-# define PNG_IMPEXP +-# endif +- +-# if !defined(PNG_IMPEXP) +- +-# define PNG_EXPORT_TYPE1(type,symbol) PNG_IMPEXP type PNGAPI symbol +-# define PNG_EXPORT_TYPE2(type,symbol) type PNG_IMPEXP PNGAPI symbol +- +- /* Borland/Microsoft */ +-# if defined(_MSC_VER) || defined(__BORLANDC__) +-# if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500) +-# define PNG_EXPORT PNG_EXPORT_TYPE1 +-# else +-# define PNG_EXPORT PNG_EXPORT_TYPE2 +-# if defined(PNG_BUILD_DLL) +-# define PNG_IMPEXP __export +-# else +-# define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in +- VC++ */ +-# endif /* Exists in Borland C++ for +- C++ classes (== huge) */ +-# endif +-# endif +- +-# if !defined(PNG_IMPEXP) +-# if defined(PNG_BUILD_DLL) +-# define PNG_IMPEXP __declspec(dllexport) +-# else +-# define PNG_IMPEXP __declspec(dllimport) +-# endif +-# endif +-# endif /* PNG_IMPEXP */ +-#else /* !(DLL || non-cygwin WINDOWS) */ +-# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__) +-# ifndef PNGAPI +-# define PNGAPI _System +-# endif +-# else +-# if 0 /* ... other platforms, with other meanings */ +-# endif +-# endif +-#endif +- +-#ifndef PNGAPI +-# define PNGAPI +-#endif +-#ifndef PNG_IMPEXP +-# define PNG_IMPEXP +-#endif +- +-#ifndef PNG_EXPORT +-# define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol +-#endif +- +-#ifdef PNG_USE_GLOBAL_ARRAYS +-# ifndef PNG_EXPORT_VAR +-# define PNG_EXPORT_VAR(type) extern PNG_IMPEXP type +-# endif +-#endif +- +-/* User may want to use these so they are not in PNG_INTERNAL. Any library +- * functions that are passed far data must be model independent. +- */ +- +-#ifndef PNG_ABORT +-# define PNG_ABORT() abort() +-#endif +- +-#ifdef PNG_SETJMP_SUPPORTED +-# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf) +-#else +-# define png_jmpbuf(png_ptr) \ +- (LIBPNG_WAS_COMPILED_WITH__PNG_SETJMP_NOT_SUPPORTED) +-#endif +- +-#if defined(USE_FAR_KEYWORD) /* memory model independent fns */ +-/* use this to make far-to-near assignments */ +-# define CHECK 1 +-# define NOCHECK 0 +-# define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK)) +-# define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK)) +-# define png_strcpy _fstrcpy +-# define png_strncpy _fstrncpy /* Added to v 1.2.6 */ +-# define png_strlen _fstrlen +-# define png_memcmp _fmemcmp /* SJT: added */ +-# define png_memcpy _fmemcpy +-# define png_memset _fmemset +-#else /* use the usual functions */ +-# define CVT_PTR(ptr) (ptr) +-# define CVT_PTR_NOCHECK(ptr) (ptr) +-# define png_strcpy strcpy +-# define png_strncpy strncpy /* Added to v 1.2.6 */ +-# define png_strlen strlen +-# define png_memcmp memcmp /* SJT: added */ +-# define png_memcpy memcpy +-# define png_memset memset +-#endif +-/* End of memory model independent support */ +- +-/* Just a little check that someone hasn't tried to define something +- * contradictory. +- */ +-#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K) +-# undef PNG_ZBUF_SIZE +-# define PNG_ZBUF_SIZE 65536L +-#endif +- +-#ifdef PNG_READ_SUPPORTED +-/* Prior to libpng-1.0.9, this block was in pngasmrd.h */ +-#if defined(PNG_INTERNAL) +- +-/* These are the default thresholds before the MMX code kicks in; if either +- * rowbytes or bitdepth is below the threshold, plain C code is used. These +- * can be overridden at runtime via the png_set_mmx_thresholds() call in +- * libpng 1.2.0 and later. The values below were chosen by Intel. +- */ +- +-#ifndef PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT +-# define PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT 128 /* >= */ +-#endif +-#ifndef PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT +-# define PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT 9 /* >= */ +-#endif +- +-/* Set this in the makefile for VC++ on Pentium, not here. */ +-/* Platform must be Pentium. Makefile must assemble and load pngvcrd.c . +- * MMX will be detected at run time and used if present. +- */ +-#ifdef PNG_USE_PNGVCRD +-# define PNG_HAVE_ASSEMBLER_COMBINE_ROW +-# define PNG_HAVE_ASSEMBLER_READ_INTERLACE +-# define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW +-#endif +- +-/* Set this in the makefile for gcc/as on Pentium, not here. */ +-/* Platform must be Pentium. Makefile must assemble and load pnggccrd.c . +- * MMX will be detected at run time and used if present. +- */ +-#ifdef PNG_USE_PNGGCCRD +-# define PNG_HAVE_ASSEMBLER_COMBINE_ROW +-# define PNG_HAVE_ASSEMBLER_READ_INTERLACE +-# define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW +-#endif +-/* - see pnggccrd.c for info about what is currently enabled */ +- +-#endif /* PNG_INTERNAL */ +-#endif /* PNG_READ_SUPPORTED */ +- +-#endif /* PNGCONF_H */ +- +diff --git a/thirdparty/libpng/pngerror.c b/thirdparty/libpng/pngerror.c +deleted file mode 100644 +index 4ba395b..0000000 +--- a/thirdparty/libpng/pngerror.c ++++ /dev/null +@@ -1,295 +0,0 @@ +- +-/* pngerror.c - stub functions for i/o and memory allocation +- * +- * libpng version 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- * +- * This file provides a location for all error handling. Users who +- * need special error handling are expected to write replacement functions +- * and use png_set_error_fn() to use those functions. See the instructions +- * at each function. +- */ +- +-#define PNG_INTERNAL +-#include "png.h" +- +-static void /* PRIVATE */ +-png_default_error PNGARG((png_structp png_ptr, +- png_const_charp error_message)); +-static void /* PRIVATE */ +-png_default_warning PNGARG((png_structp png_ptr, +- png_const_charp warning_message)); +- +-/* This function is called whenever there is a fatal error. This function +- * should not be changed. If there is a need to handle errors differently, +- * you should supply a replacement error function and use png_set_error_fn() +- * to replace the error function at run-time. +- */ +-void PNGAPI +-png_error(png_structp png_ptr, png_const_charp error_message) +-{ +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +- char msg[16]; +- if (png_ptr->flags&(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) +- { +- if (*error_message == '#') +- { +- int offset; +- for (offset=1; offset<15; offset++) +- if (*(error_message+offset) == ' ') +- break; +- if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT) +- { +- int i; +- for (i=0; iflags&PNG_FLAG_STRIP_ERROR_TEXT) +- { +- msg[0]='0'; +- msg[1]='\0'; +- error_message=msg; +- } +- } +- } +-#endif +- if (png_ptr != NULL && png_ptr->error_fn != NULL) +- (*(png_ptr->error_fn))(png_ptr, error_message); +- +- /* If the custom handler doesn't exist, or if it returns, +- use the default handler, which will not return. */ +- png_default_error(png_ptr, error_message); +-} +- +-/* This function is called whenever there is a non-fatal error. This function +- * should not be changed. If there is a need to handle warnings differently, +- * you should supply a replacement warning function and use +- * png_set_error_fn() to replace the warning function at run-time. +- */ +-void PNGAPI +-png_warning(png_structp png_ptr, png_const_charp warning_message) +-{ +- int offset = 0; +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +- if (png_ptr->flags&(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) +-#endif +- { +- if (*warning_message == '#') +- { +- for (offset=1; offset<15; offset++) +- if (*(warning_message+offset) == ' ') +- break; +- } +- } +- if (png_ptr != NULL && png_ptr->warning_fn != NULL) +- (*(png_ptr->warning_fn))(png_ptr, warning_message+offset); +- else +- png_default_warning(png_ptr, warning_message+offset); +-} +- +-/* These utilities are used internally to build an error message that relates +- * to the current chunk. The chunk name comes from png_ptr->chunk_name, +- * this is used to prefix the message. The message is limited in length +- * to 63 bytes, the name characters are output as hex digits wrapped in [] +- * if the character is invalid. +- */ +-#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97)) +-static PNG_CONST char png_digit[16] = { +- '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', +- 'A', 'B', 'C', 'D', 'E', 'F' +-}; +- +-static void /* PRIVATE */ +-png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp +- error_message) +-{ +- int iout = 0, iin = 0; +- +- while (iin < 4) +- { +- int c = png_ptr->chunk_name[iin++]; +- if (isnonalpha(c)) +- { +- buffer[iout++] = '['; +- buffer[iout++] = png_digit[(c & 0xf0) >> 4]; +- buffer[iout++] = png_digit[c & 0x0f]; +- buffer[iout++] = ']'; +- } +- else +- { +- buffer[iout++] = (png_byte)c; +- } +- } +- +- if (error_message == NULL) +- buffer[iout] = 0; +- else +- { +- buffer[iout++] = ':'; +- buffer[iout++] = ' '; +- png_strncpy(buffer+iout, error_message, 63); +- buffer[iout+63] = 0; +- } +-} +- +-void PNGAPI +-png_chunk_error(png_structp png_ptr, png_const_charp error_message) +-{ +- char msg[18+64]; +- png_format_buffer(png_ptr, msg, error_message); +- png_error(png_ptr, msg); +-} +- +-void PNGAPI +-png_chunk_warning(png_structp png_ptr, png_const_charp warning_message) +-{ +- char msg[18+64]; +- png_format_buffer(png_ptr, msg, warning_message); +- png_warning(png_ptr, msg); +-} +- +-/* This is the default error handling function. Note that replacements for +- * this function MUST NOT RETURN, or the program will likely crash. This +- * function is used by default, or if the program supplies NULL for the +- * error function pointer in png_set_error_fn(). +- */ +-static void /* PRIVATE */ +-png_default_error(png_structp png_ptr, png_const_charp error_message) +-{ +-#ifndef PNG_NO_CONSOLE_IO +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +- if (*error_message == '#') +- { +- int offset; +- char error_number[16]; +- for (offset=0; offset<15; offset++) +- { +- error_number[offset] = *(error_message+offset+1); +- if (*(error_message+offset) == ' ') +- break; +- } +- if((offset > 1) && (offset < 15)) +- { +- error_number[offset-1]='\0'; +- fprintf(stderr, "libpng error no. %s: %s\n", error_number, +- error_message+offset); +- } +- else +- fprintf(stderr, "libpng error: %s, offset=%d\n", error_message,offset); +- } +- else +-#endif +- fprintf(stderr, "libpng error: %s\n", error_message); +-#endif +- +-#ifdef PNG_SETJMP_SUPPORTED +-# ifdef USE_FAR_KEYWORD +- { +- jmp_buf jmpbuf; +- png_memcpy(jmpbuf,png_ptr->jmpbuf,png_sizeof(jmp_buf)); +- longjmp(jmpbuf, 1); +- } +-# else +- longjmp(png_ptr->jmpbuf, 1); +-# endif +-#else +- /* make compiler happy */ ; +- if (png_ptr) +- PNG_ABORT(); +-#endif +-#ifdef PNG_NO_CONSOLE_IO +- /* make compiler happy */ ; +- if (&error_message != NULL) +- return; +-#endif +-} +- +-/* This function is called when there is a warning, but the library thinks +- * it can continue anyway. Replacement functions don't have to do anything +- * here if you don't want them to. In the default configuration, png_ptr is +- * not used, but it is passed in case it may be useful. +- */ +-static void /* PRIVATE */ +-png_default_warning(png_structp png_ptr, png_const_charp warning_message) +-{ +-#ifndef PNG_NO_CONSOLE_IO +-# ifdef PNG_ERROR_NUMBERS_SUPPORTED +- if (*warning_message == '#') +- { +- int offset; +- char warning_number[16]; +- for (offset=0; offset<15; offset++) +- { +- warning_number[offset]=*(warning_message+offset+1); +- if (*(warning_message+offset) == ' ') +- break; +- } +- if((offset > 1) && (offset < 15)) +- { +- warning_number[offset-1]='\0'; +- fprintf(stderr, "libpng warning no. %s: %s\n", warning_number, +- warning_message+offset); +- } +- else +- fprintf(stderr, "libpng warning: %s\n", warning_message); +- } +- else +-# endif +- fprintf(stderr, "libpng warning: %s\n", warning_message); +-#else +- /* make compiler happy */ ; +- if (warning_message) +- return; +-#endif +- /* make compiler happy */ ; +- if (png_ptr) +- return; +-} +- +-/* This function is called when the application wants to use another method +- * of handling errors and warnings. Note that the error function MUST NOT +- * return to the calling routine or serious problems will occur. The return +- * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1) +- */ +-void PNGAPI +-png_set_error_fn(png_structp png_ptr, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warning_fn) +-{ +- png_ptr->error_ptr = error_ptr; +- png_ptr->error_fn = error_fn; +- png_ptr->warning_fn = warning_fn; +-} +- +- +-/* This function returns a pointer to the error_ptr associated with the user +- * functions. The application should free any memory associated with this +- * pointer before png_write_destroy and png_read_destroy are called. +- */ +-png_voidp PNGAPI +-png_get_error_ptr(png_structp png_ptr) +-{ +- return ((png_voidp)png_ptr->error_ptr); +-} +- +- +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +-void PNGAPI +-png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode) +-{ +- if(png_ptr != NULL) +- { +- png_ptr->flags &= +- ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode); +- } +-} +-#endif +diff --git a/thirdparty/libpng/pnggccrd.c b/thirdparty/libpng/pnggccrd.c +deleted file mode 100644 +index 73d3bd8..0000000 +--- a/thirdparty/libpng/pnggccrd.c ++++ /dev/null +@@ -1,5408 +0,0 @@ +-/* pnggccrd.c - mixed C/assembler version of utilities to read a PNG file +- * +- * For Intel x86 CPU (Pentium-MMX or later) and GNU C compiler. +- * +- * See http://www.intel.com/drg/pentiumII/appnotes/916/916.htm +- * and http://www.intel.com/drg/pentiumII/appnotes/923/923.htm +- * for Intel's performance analysis of the MMX vs. non-MMX code. +- * +- * libpng version 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * Copyright (c) 1998, Intel Corporation +- * +- * Based on MSVC code contributed by Nirav Chhatrapati, Intel Corp., 1998. +- * Interface to libpng contributed by Gilles Vollant, 1999. +- * GNU C port by Greg Roelofs, 1999-2001. +- * +- * Lines 2350-4300 converted in place with intel2gas 1.3.1: +- * +- * intel2gas -mdI pnggccrd.c.partially-msvc -o pnggccrd.c +- * +- * and then cleaned up by hand. See http://hermes.terminal.at/intel2gas/ . +- * +- * NOTE: A sufficiently recent version of GNU as (or as.exe under DOS/Windows) +- * is required to assemble the newer MMX instructions such as movq. +- * For djgpp, see +- * +- * ftp://ftp.simtel.net/pub/simtelnet/gnu/djgpp/v2gnu/bnu281b.zip +- * +- * (or a later version in the same directory). For Linux, check your +- * distribution's web site(s) or try these links: +- * +- * http://rufus.w3.org/linux/RPM/binutils.html +- * http://www.debian.org/Packages/stable/devel/binutils.html +- * ftp://ftp.slackware.com/pub/linux/slackware/slackware/slakware/d1/ +- * binutils.tgz +- * +- * For other platforms, see the main GNU site: +- * +- * ftp://ftp.gnu.org/pub/gnu/binutils/ +- * +- * Version 2.5.2l.15 is definitely too old... +- */ +- +-/* +- * TEMPORARY PORTING NOTES AND CHANGELOG (mostly by Greg Roelofs) +- * ===================================== +- * +- * 19991006: +- * - fixed sign error in post-MMX cleanup code (16- & 32-bit cases) +- * +- * 19991007: +- * - additional optimizations (possible or definite): +- * x [DONE] write MMX code for 64-bit case (pixel_bytes == 8) [not tested] +- * - write MMX code for 48-bit case (pixel_bytes == 6) +- * - figure out what's up with 24-bit case (pixel_bytes == 3): +- * why subtract 8 from width_mmx in the pass 4/5 case? +- * (only width_mmx case) (near line 1606) +- * x [DONE] replace pixel_bytes within each block with the true +- * constant value (or are compilers smart enough to do that?) +- * - rewrite all MMX interlacing code so it's aligned with +- * the *beginning* of the row buffer, not the end. This +- * would not only allow one to eliminate half of the memory +- * writes for odd passes (that is, pass == odd), it may also +- * eliminate some unaligned-data-access exceptions (assuming +- * there's a penalty for not aligning 64-bit accesses on +- * 64-bit boundaries). The only catch is that the "leftover" +- * pixel(s) at the end of the row would have to be saved, +- * but there are enough unused MMX registers in every case, +- * so this is not a problem. A further benefit is that the +- * post-MMX cleanup code (C code) in at least some of the +- * cases could be done within the assembler block. +- * x [DONE] the "v3 v2 v1 v0 v7 v6 v5 v4" comments are confusing, +- * inconsistent, and don't match the MMX Programmer's Reference +- * Manual conventions anyway. They should be changed to +- * "b7 b6 b5 b4 b3 b2 b1 b0," where b0 indicates the byte that +- * was lowest in memory (e.g., corresponding to a left pixel) +- * and b7 is the byte that was highest (e.g., a right pixel). +- * +- * 19991016: +- * - Brennan's Guide notwithstanding, gcc under Linux does *not* +- * want globals prefixed by underscores when referencing them-- +- * i.e., if the variable is const4, then refer to it as const4, +- * not _const4. This seems to be a djgpp-specific requirement. +- * Also, such variables apparently *must* be declared outside +- * of functions; neither static nor automatic variables work if +- * defined within the scope of a single function, but both +- * static and truly global (multi-module) variables work fine. +- * +- * 19991023: +- * - fixed png_combine_row() non-MMX replication bug (odd passes only?) +- * - switched from string-concatenation-with-macros to cleaner method of +- * renaming global variables for djgpp--i.e., always use prefixes in +- * inlined assembler code (== strings) and conditionally rename the +- * variables, not the other way around. Hence _const4, _mask8_0, etc. +- * +- * 19991024: +- * - fixed mmxsupport()/png_do_read_interlace() first-row bug +- * This one was severely weird: even though mmxsupport() doesn't touch +- * ebx (where "row" pointer was stored), it nevertheless managed to zero +- * the register (even in static/non-fPIC code--see below), which in turn +- * caused png_do_read_interlace() to return prematurely on the first row of +- * interlaced images (i.e., without expanding the interlaced pixels). +- * Inspection of the generated assembly code didn't turn up any clues, +- * although it did point at a minor optimization (i.e., get rid of +- * mmx_supported_local variable and just use eax). Possibly the CPUID +- * instruction is more destructive than it looks? (Not yet checked.) +- * - "info gcc" was next to useless, so compared fPIC and non-fPIC assembly +- * listings... Apparently register spillage has to do with ebx, since +- * it's used to index the global offset table. Commenting it out of the +- * input-reg lists in png_combine_row() eliminated compiler barfage, so +- * ifdef'd with __PIC__ macro: if defined, use a global for unmask +- * +- * 19991107: +- * - verified CPUID clobberage: 12-char string constant ("GenuineIntel", +- * "AuthenticAMD", etc.) placed in ebx:ecx:edx. Still need to polish. +- * +- * 19991120: +- * - made "diff" variable (now "_dif") global to simplify conversion of +- * filtering routines (running out of regs, sigh). "diff" is still used +- * in interlacing routines, however. +- * - fixed up both versions of mmxsupport() (ORIG_THAT_USED_TO_CLOBBER_EBX +- * macro determines which is used); original not yet tested. +- * +- * 20000213: +- * - when compiling with gcc, be sure to use -fomit-frame-pointer +- * +- * 20000319: +- * - fixed a register-name typo in png_do_read_interlace(), default (MMX) case, +- * pass == 4 or 5, that caused visible corruption of interlaced images +- * +- * 20000623: +- * - Various problems were reported with gcc 2.95.2 in the Cygwin environment, +- * many of the form "forbidden register 0 (ax) was spilled for class AREG." +- * This is explained at http://gcc.gnu.org/fom_serv/cache/23.html, and +- * Chuck Wilson supplied a patch involving dummy output registers. See +- * http://sourceforge.net/bugs/?func=detailbug&bug_id=108741&group_id=5624 +- * for the original (anonymous) SourceForge bug report. +- * +- * 20000706: +- * - Chuck Wilson passed along these remaining gcc 2.95.2 errors: +- * pnggccrd.c: In function `png_combine_row': +- * pnggccrd.c:525: more than 10 operands in `asm' +- * pnggccrd.c:669: more than 10 operands in `asm' +- * pnggccrd.c:828: more than 10 operands in `asm' +- * pnggccrd.c:994: more than 10 operands in `asm' +- * pnggccrd.c:1177: more than 10 operands in `asm' +- * They are all the same problem and can be worked around by using the +- * global _unmask variable unconditionally, not just in the -fPIC case. +- * Reportedly earlier versions of gcc also have the problem with more than +- * 10 operands; they just don't report it. Much strangeness ensues, etc. +- * +- * 20000729: +- * - enabled png_read_filter_row_mmx_up() (shortest remaining unconverted +- * MMX routine); began converting png_read_filter_row_mmx_sub() +- * - to finish remaining sections: +- * - clean up indentation and comments +- * - preload local variables +- * - add output and input regs (order of former determines numerical +- * mapping of latter) +- * - avoid all usage of ebx (including bx, bh, bl) register [20000823] +- * - remove "$" from addressing of Shift and Mask variables [20000823] +- * +- * 20000731: +- * - global union vars causing segfaults in png_read_filter_row_mmx_sub()? +- * +- * 20000822: +- * - ARGH, stupid png_read_filter_row_mmx_sub() segfault only happens with +- * shared-library (-fPIC) version! Code works just fine as part of static +- * library. Damn damn damn damn damn, should have tested that sooner. +- * ebx is getting clobbered again (explicitly this time); need to save it +- * on stack or rewrite asm code to avoid using it altogether. Blargh! +- * +- * 20000823: +- * - first section was trickiest; all remaining sections have ebx -> edx now. +- * (-fPIC works again.) Also added missing underscores to various Shift* +- * and *Mask* globals and got rid of leading "$" signs. +- * +- * 20000826: +- * - added visual separators to help navigate microscopic printed copies +- * (http://pobox.com/~newt/code/gpr-latest.zip, mode 10); started working +- * on png_read_filter_row_mmx_avg() +- * +- * 20000828: +- * - finished png_read_filter_row_mmx_avg(): only Paeth left! (930 lines...) +- * What the hell, did png_read_filter_row_mmx_paeth(), too. Comments not +- * cleaned up/shortened in either routine, but functionality is complete +- * and seems to be working fine. +- * +- * 20000829: +- * - ahhh, figured out last(?) bit of gcc/gas asm-fu: if register is listed +- * as an input reg (with dummy output variables, etc.), then it *cannot* +- * also appear in the clobber list or gcc 2.95.2 will barf. The solution +- * is simple enough... +- * +- * 20000914: +- * - bug in png_read_filter_row_mmx_avg(): 16-bit grayscale not handled +- * correctly (but 48-bit RGB just fine) +- * +- * 20000916: +- * - fixed bug in png_read_filter_row_mmx_avg(), bpp == 2 case; three errors: +- * - "_ShiftBpp.use = 24;" should have been "_ShiftBpp.use = 16;" +- * - "_ShiftRem.use = 40;" should have been "_ShiftRem.use = 48;" +- * - "psllq _ShiftRem, %%mm2" should have been "psrlq _ShiftRem, %%mm2" +- * +- * 20010101: +- * - added new png_init_mmx_flags() function (here only because it needs to +- * call mmxsupport(), which should probably become global png_mmxsupport()); +- * modified other MMX routines to run conditionally (png_ptr->asm_flags) +- * +- * 20010103: +- * - renamed mmxsupport() to png_mmx_support(), with auto-set of mmx_supported, +- * and made it public; moved png_init_mmx_flags() to png.c as internal func +- * +- * 20010104: +- * - removed dependency on png_read_filter_row_c() (C code already duplicated +- * within MMX version of png_read_filter_row()) so no longer necessary to +- * compile it into pngrutil.o +- * +- * 20010310: +- * - fixed buffer-overrun bug in png_combine_row() C code (non-MMX) +- * +- * 20020304: +- * - eliminated incorrect use of width_mmx in pixel_bytes == 8 case +- * +- * 20040724: +- * - more tinkering with clobber list at lines 4529 and 5033, to get +- * it to compile on gcc-3.4. +- * +- * STILL TO DO: +- * - test png_do_read_interlace() 64-bit case (pixel_bytes == 8) +- * - write MMX code for 48-bit case (pixel_bytes == 6) +- * - figure out what's up with 24-bit case (pixel_bytes == 3): +- * why subtract 8 from width_mmx in the pass 4/5 case? +- * (only width_mmx case) (near line 1606) +- * - rewrite all MMX interlacing code so it's aligned with beginning +- * of the row buffer, not the end (see 19991007 for details) +- * x pick one version of mmxsupport() and get rid of the other +- * - add error messages to any remaining bogus default cases +- * - enable pixel_depth == 8 cases in png_read_filter_row()? (test speed) +- * x add support for runtime enable/disable/query of various MMX routines +- */ +- +-#define PNG_INTERNAL +-#include "png.h" +- +-#if defined(PNG_USE_PNGGCCRD) +- +-int PNGAPI png_mmx_support(void); +- +-#ifdef PNG_USE_LOCAL_ARRAYS +-static const int FARDATA png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; +-static const int FARDATA png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; +-static const int FARDATA png_pass_width[7] = {8, 4, 4, 2, 2, 1, 1}; +-#endif +- +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +-/* djgpp, Win32, and Cygwin add their own underscores to global variables, +- * so define them without: */ +-#if defined(__DJGPP__) || defined(WIN32) || defined(__CYGWIN__) +-# define _mmx_supported mmx_supported +-# define _const4 const4 +-# define _const6 const6 +-# define _mask8_0 mask8_0 +-# define _mask16_1 mask16_1 +-# define _mask16_0 mask16_0 +-# define _mask24_2 mask24_2 +-# define _mask24_1 mask24_1 +-# define _mask24_0 mask24_0 +-# define _mask32_3 mask32_3 +-# define _mask32_2 mask32_2 +-# define _mask32_1 mask32_1 +-# define _mask32_0 mask32_0 +-# define _mask48_5 mask48_5 +-# define _mask48_4 mask48_4 +-# define _mask48_3 mask48_3 +-# define _mask48_2 mask48_2 +-# define _mask48_1 mask48_1 +-# define _mask48_0 mask48_0 +-# define _LBCarryMask LBCarryMask +-# define _HBClearMask HBClearMask +-# define _ActiveMask ActiveMask +-# define _ActiveMask2 ActiveMask2 +-# define _ActiveMaskEnd ActiveMaskEnd +-# define _ShiftBpp ShiftBpp +-# define _ShiftRem ShiftRem +-#ifdef PNG_THREAD_UNSAFE_OK +-# define _unmask unmask +-# define _FullLength FullLength +-# define _MMXLength MMXLength +-# define _dif dif +-# define _patemp patemp +-# define _pbtemp pbtemp +-# define _pctemp pctemp +-#endif +-#endif +- +- +-/* These constants are used in the inlined MMX assembly code. +- Ignore gcc's "At top level: defined but not used" warnings. */ +- +-/* GRR 20000706: originally _unmask was needed only when compiling with -fPIC, +- * since that case uses the %ebx register for indexing the Global Offset Table +- * and there were no other registers available. But gcc 2.95 and later emit +- * "more than 10 operands in `asm'" errors when %ebx is used to preload unmask +- * in the non-PIC case, so we'll just use the global unconditionally now. +- */ +-#ifdef PNG_THREAD_UNSAFE_OK +-static int _unmask; +-#endif +- +-static unsigned long long _mask8_0 = 0x0102040810204080LL; +- +-static unsigned long long _mask16_1 = 0x0101020204040808LL; +-static unsigned long long _mask16_0 = 0x1010202040408080LL; +- +-static unsigned long long _mask24_2 = 0x0101010202020404LL; +-static unsigned long long _mask24_1 = 0x0408080810101020LL; +-static unsigned long long _mask24_0 = 0x2020404040808080LL; +- +-static unsigned long long _mask32_3 = 0x0101010102020202LL; +-static unsigned long long _mask32_2 = 0x0404040408080808LL; +-static unsigned long long _mask32_1 = 0x1010101020202020LL; +-static unsigned long long _mask32_0 = 0x4040404080808080LL; +- +-static unsigned long long _mask48_5 = 0x0101010101010202LL; +-static unsigned long long _mask48_4 = 0x0202020204040404LL; +-static unsigned long long _mask48_3 = 0x0404080808080808LL; +-static unsigned long long _mask48_2 = 0x1010101010102020LL; +-static unsigned long long _mask48_1 = 0x2020202040404040LL; +-static unsigned long long _mask48_0 = 0x4040808080808080LL; +- +-static unsigned long long _const4 = 0x0000000000FFFFFFLL; +-//static unsigned long long _const5 = 0x000000FFFFFF0000LL; // NOT USED +-static unsigned long long _const6 = 0x00000000000000FFLL; +- +-// These are used in the row-filter routines and should/would be local +-// variables if not for gcc addressing limitations. +-// WARNING: Their presence probably defeats the thread safety of libpng. +- +-#ifdef PNG_THREAD_UNSAFE_OK +-static png_uint_32 _FullLength; +-static png_uint_32 _MMXLength; +-static int _dif; +-static int _patemp; // temp variables for Paeth routine +-static int _pbtemp; +-static int _pctemp; +-#endif +- +-void /* PRIVATE */ +-png_squelch_warnings(void) +-{ +-#ifdef PNG_THREAD_UNSAFE_OK +- _dif = _dif; +- _patemp = _patemp; +- _pbtemp = _pbtemp; +- _pctemp = _pctemp; +- _MMXLength = _MMXLength; +-#endif +- _const4 = _const4; +- _const6 = _const6; +- _mask8_0 = _mask8_0; +- _mask16_1 = _mask16_1; +- _mask16_0 = _mask16_0; +- _mask24_2 = _mask24_2; +- _mask24_1 = _mask24_1; +- _mask24_0 = _mask24_0; +- _mask32_3 = _mask32_3; +- _mask32_2 = _mask32_2; +- _mask32_1 = _mask32_1; +- _mask32_0 = _mask32_0; +- _mask48_5 = _mask48_5; +- _mask48_4 = _mask48_4; +- _mask48_3 = _mask48_3; +- _mask48_2 = _mask48_2; +- _mask48_1 = _mask48_1; +- _mask48_0 = _mask48_0; +-} +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ +- +- +-static int _mmx_supported = 2; +- +-/*===========================================================================*/ +-/* */ +-/* P N G _ C O M B I N E _ R O W */ +-/* */ +-/*===========================================================================*/ +- +-#if defined(PNG_HAVE_ASSEMBLER_COMBINE_ROW) +- +-#define BPP2 2 +-#define BPP3 3 /* bytes per pixel (a.k.a. pixel_bytes) */ +-#define BPP4 4 +-#define BPP6 6 /* (defined only to help avoid cut-and-paste errors) */ +-#define BPP8 8 +- +-/* Combines the row recently read in with the previous row. +- This routine takes care of alpha and transparency if requested. +- This routine also handles the two methods of progressive display +- of interlaced images, depending on the mask value. +- The mask value describes which pixels are to be combined with +- the row. The pattern always repeats every 8 pixels, so just 8 +- bits are needed. A one indicates the pixel is to be combined; a +- zero indicates the pixel is to be skipped. This is in addition +- to any alpha or transparency value associated with the pixel. +- If you want all pixels to be combined, pass 0xff (255) in mask. */ +- +-/* Use this routine for the x86 platform - it uses a faster MMX routine +- if the machine supports MMX. */ +- +-void /* PRIVATE */ +-png_combine_row(png_structp png_ptr, png_bytep row, int mask) +-{ +- png_debug(1, "in png_combine_row (pnggccrd.c)\n"); +- +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +- if (_mmx_supported == 2) { +-#if !defined(PNG_1_0_X) +- /* this should have happened in png_init_mmx_flags() already */ +- png_warning(png_ptr, "asm_flags may not have been initialized"); +-#endif +- png_mmx_support(); +- } +-#endif +- +- if (mask == 0xff) +- { +- png_debug(2,"mask == 0xff: doing single png_memcpy()\n"); +- png_memcpy(row, png_ptr->row_buf + 1, +- (png_size_t)PNG_ROWBYTES(png_ptr->row_info.pixel_depth,png_ptr->width)); +- } +- else /* (png_combine_row() is never called with mask == 0) */ +- { +- switch (png_ptr->row_info.pixel_depth) +- { +- case 1: /* png_ptr->row_info.pixel_depth */ +- { +- png_bytep sp; +- png_bytep dp; +- int s_inc, s_start, s_end; +- int m; +- int shift; +- png_uint_32 i; +- +- sp = png_ptr->row_buf + 1; +- dp = row; +- m = 0x80; +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_PACKSWAP) +- { +- s_start = 0; +- s_end = 7; +- s_inc = 1; +- } +- else +-#endif +- { +- s_start = 7; +- s_end = 0; +- s_inc = -1; +- } +- +- shift = s_start; +- +- for (i = 0; i < png_ptr->width; i++) +- { +- if (m & mask) +- { +- int value; +- +- value = (*sp >> shift) & 0x1; +- *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); +- *dp |= (png_byte)(value << shift); +- } +- +- if (shift == s_end) +- { +- shift = s_start; +- sp++; +- dp++; +- } +- else +- shift += s_inc; +- +- if (m == 1) +- m = 0x80; +- else +- m >>= 1; +- } +- break; +- } +- +- case 2: /* png_ptr->row_info.pixel_depth */ +- { +- png_bytep sp; +- png_bytep dp; +- int s_start, s_end, s_inc; +- int m; +- int shift; +- png_uint_32 i; +- int value; +- +- sp = png_ptr->row_buf + 1; +- dp = row; +- m = 0x80; +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_PACKSWAP) +- { +- s_start = 0; +- s_end = 6; +- s_inc = 2; +- } +- else +-#endif +- { +- s_start = 6; +- s_end = 0; +- s_inc = -2; +- } +- +- shift = s_start; +- +- for (i = 0; i < png_ptr->width; i++) +- { +- if (m & mask) +- { +- value = (*sp >> shift) & 0x3; +- *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); +- *dp |= (png_byte)(value << shift); +- } +- +- if (shift == s_end) +- { +- shift = s_start; +- sp++; +- dp++; +- } +- else +- shift += s_inc; +- if (m == 1) +- m = 0x80; +- else +- m >>= 1; +- } +- break; +- } +- +- case 4: /* png_ptr->row_info.pixel_depth */ +- { +- png_bytep sp; +- png_bytep dp; +- int s_start, s_end, s_inc; +- int m; +- int shift; +- png_uint_32 i; +- int value; +- +- sp = png_ptr->row_buf + 1; +- dp = row; +- m = 0x80; +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_PACKSWAP) +- { +- s_start = 0; +- s_end = 4; +- s_inc = 4; +- } +- else +-#endif +- { +- s_start = 4; +- s_end = 0; +- s_inc = -4; +- } +- shift = s_start; +- +- for (i = 0; i < png_ptr->width; i++) +- { +- if (m & mask) +- { +- value = (*sp >> shift) & 0xf; +- *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); +- *dp |= (png_byte)(value << shift); +- } +- +- if (shift == s_end) +- { +- shift = s_start; +- sp++; +- dp++; +- } +- else +- shift += s_inc; +- if (m == 1) +- m = 0x80; +- else +- m >>= 1; +- } +- break; +- } +- +- case 8: /* png_ptr->row_info.pixel_depth */ +- { +- png_bytep srcptr; +- png_bytep dstptr; +- +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) +- /* && _mmx_supported */ ) +-#else +- if (_mmx_supported) +-#endif +- { +- png_uint_32 len; +- int diff; +- int dummy_value_a; // fix 'forbidden register spilled' error +- int dummy_value_d; +- int dummy_value_c; +- int dummy_value_S; +- int dummy_value_D; +- _unmask = ~mask; // global variable for -fPIC version +- srcptr = png_ptr->row_buf + 1; +- dstptr = row; +- len = png_ptr->width &~7; // reduce to multiple of 8 +- diff = (int) (png_ptr->width & 7); // amount lost +- +- __asm__ __volatile__ ( +- "movd _unmask, %%mm7 \n\t" // load bit pattern +- "psubb %%mm6, %%mm6 \n\t" // zero mm6 +- "punpcklbw %%mm7, %%mm7 \n\t" +- "punpcklwd %%mm7, %%mm7 \n\t" +- "punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks +- +- "movq _mask8_0, %%mm0 \n\t" +- "pand %%mm7, %%mm0 \n\t" // nonzero if keep byte +- "pcmpeqb %%mm6, %%mm0 \n\t" // zeros->1s, v versa +- +-// preload "movl len, %%ecx \n\t" // load length of line +-// preload "movl srcptr, %%esi \n\t" // load source +-// preload "movl dstptr, %%edi \n\t" // load dest +- +- "cmpl $0, %%ecx \n\t" // len == 0 ? +- "je mainloop8end \n\t" +- +- "mainloop8: \n\t" +- "movq (%%esi), %%mm4 \n\t" // *srcptr +- "pand %%mm0, %%mm4 \n\t" +- "movq %%mm0, %%mm6 \n\t" +- "pandn (%%edi), %%mm6 \n\t" // *dstptr +- "por %%mm6, %%mm4 \n\t" +- "movq %%mm4, (%%edi) \n\t" +- "addl $8, %%esi \n\t" // inc by 8 bytes processed +- "addl $8, %%edi \n\t" +- "subl $8, %%ecx \n\t" // dec by 8 pixels processed +- "ja mainloop8 \n\t" +- +- "mainloop8end: \n\t" +-// preload "movl diff, %%ecx \n\t" // (diff is in eax) +- "movl %%eax, %%ecx \n\t" +- "cmpl $0, %%ecx \n\t" +- "jz end8 \n\t" +-// preload "movl mask, %%edx \n\t" +- "sall $24, %%edx \n\t" // make low byte, high byte +- +- "secondloop8: \n\t" +- "sall %%edx \n\t" // move high bit to CF +- "jnc skip8 \n\t" // if CF = 0 +- "movb (%%esi), %%al \n\t" +- "movb %%al, (%%edi) \n\t" +- +- "skip8: \n\t" +- "incl %%esi \n\t" +- "incl %%edi \n\t" +- "decl %%ecx \n\t" +- "jnz secondloop8 \n\t" +- +- "end8: \n\t" +- "EMMS \n\t" // DONE +- +- : "=a" (dummy_value_a), // output regs (dummy) +- "=d" (dummy_value_d), +- "=c" (dummy_value_c), +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "3" (srcptr), // esi // input regs +- "4" (dstptr), // edi +- "0" (diff), // eax +-// was (unmask) "b" RESERVED // ebx // Global Offset Table idx +- "2" (len), // ecx +- "1" (mask) // edx +- +-#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm4", "%mm6", "%mm7" // clobber list +-#endif +- ); +- } +- else /* mmx _not supported - Use modified C routine */ +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ +- { +- register png_uint_32 i; +- png_uint_32 initial_val = png_pass_start[png_ptr->pass]; +- /* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ +- register int stride = png_pass_inc[png_ptr->pass]; +- /* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ +- register int rep_bytes = png_pass_width[png_ptr->pass]; +- /* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ +- png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ +- int diff = (int) (png_ptr->width & 7); /* amount lost */ +- register png_uint_32 final_val = len; /* GRR bugfix */ +- +- srcptr = png_ptr->row_buf + 1 + initial_val; +- dstptr = row + initial_val; +- +- for (i = initial_val; i < final_val; i += stride) +- { +- png_memcpy(dstptr, srcptr, rep_bytes); +- srcptr += stride; +- dstptr += stride; +- } +- if (diff) /* number of leftover pixels: 3 for pngtest */ +- { +- final_val+=diff /* *BPP1 */ ; +- for (; i < final_val; i += stride) +- { +- if (rep_bytes > (int)(final_val-i)) +- rep_bytes = (int)(final_val-i); +- png_memcpy(dstptr, srcptr, rep_bytes); +- srcptr += stride; +- dstptr += stride; +- } +- } +- +- } /* end of else (_mmx_supported) */ +- +- break; +- } /* end 8 bpp */ +- +- case 16: /* png_ptr->row_info.pixel_depth */ +- { +- png_bytep srcptr; +- png_bytep dstptr; +- +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) +- /* && _mmx_supported */ ) +-#else +- if (_mmx_supported) +-#endif +- { +- png_uint_32 len; +- int diff; +- int dummy_value_a; // fix 'forbidden register spilled' error +- int dummy_value_d; +- int dummy_value_c; +- int dummy_value_S; +- int dummy_value_D; +- _unmask = ~mask; // global variable for -fPIC version +- srcptr = png_ptr->row_buf + 1; +- dstptr = row; +- len = png_ptr->width &~7; // reduce to multiple of 8 +- diff = (int) (png_ptr->width & 7); // amount lost // +- +- __asm__ __volatile__ ( +- "movd _unmask, %%mm7 \n\t" // load bit pattern +- "psubb %%mm6, %%mm6 \n\t" // zero mm6 +- "punpcklbw %%mm7, %%mm7 \n\t" +- "punpcklwd %%mm7, %%mm7 \n\t" +- "punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks +- +- "movq _mask16_0, %%mm0 \n\t" +- "movq _mask16_1, %%mm1 \n\t" +- +- "pand %%mm7, %%mm0 \n\t" +- "pand %%mm7, %%mm1 \n\t" +- +- "pcmpeqb %%mm6, %%mm0 \n\t" +- "pcmpeqb %%mm6, %%mm1 \n\t" +- +-// preload "movl len, %%ecx \n\t" // load length of line +-// preload "movl srcptr, %%esi \n\t" // load source +-// preload "movl dstptr, %%edi \n\t" // load dest +- +- "cmpl $0, %%ecx \n\t" +- "jz mainloop16end \n\t" +- +- "mainloop16: \n\t" +- "movq (%%esi), %%mm4 \n\t" +- "pand %%mm0, %%mm4 \n\t" +- "movq %%mm0, %%mm6 \n\t" +- "movq (%%edi), %%mm7 \n\t" +- "pandn %%mm7, %%mm6 \n\t" +- "por %%mm6, %%mm4 \n\t" +- "movq %%mm4, (%%edi) \n\t" +- +- "movq 8(%%esi), %%mm5 \n\t" +- "pand %%mm1, %%mm5 \n\t" +- "movq %%mm1, %%mm7 \n\t" +- "movq 8(%%edi), %%mm6 \n\t" +- "pandn %%mm6, %%mm7 \n\t" +- "por %%mm7, %%mm5 \n\t" +- "movq %%mm5, 8(%%edi) \n\t" +- +- "addl $16, %%esi \n\t" // inc by 16 bytes processed +- "addl $16, %%edi \n\t" +- "subl $8, %%ecx \n\t" // dec by 8 pixels processed +- "ja mainloop16 \n\t" +- +- "mainloop16end: \n\t" +-// preload "movl diff, %%ecx \n\t" // (diff is in eax) +- "movl %%eax, %%ecx \n\t" +- "cmpl $0, %%ecx \n\t" +- "jz end16 \n\t" +-// preload "movl mask, %%edx \n\t" +- "sall $24, %%edx \n\t" // make low byte, high byte +- +- "secondloop16: \n\t" +- "sall %%edx \n\t" // move high bit to CF +- "jnc skip16 \n\t" // if CF = 0 +- "movw (%%esi), %%ax \n\t" +- "movw %%ax, (%%edi) \n\t" +- +- "skip16: \n\t" +- "addl $2, %%esi \n\t" +- "addl $2, %%edi \n\t" +- "decl %%ecx \n\t" +- "jnz secondloop16 \n\t" +- +- "end16: \n\t" +- "EMMS \n\t" // DONE +- +- : "=a" (dummy_value_a), // output regs (dummy) +- "=c" (dummy_value_c), +- "=d" (dummy_value_d), +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "0" (diff), // eax // input regs +-// was (unmask) " " RESERVED // ebx // Global Offset Table idx +- "1" (len), // ecx +- "2" (mask), // edx +- "3" (srcptr), // esi +- "4" (dstptr) // edi +- +-#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm1", "%mm4" // clobber list +- , "%mm5", "%mm6", "%mm7" +-#endif +- ); +- } +- else /* mmx _not supported - Use modified C routine */ +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ +- { +- register png_uint_32 i; +- png_uint_32 initial_val = BPP2 * png_pass_start[png_ptr->pass]; +- /* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ +- register int stride = BPP2 * png_pass_inc[png_ptr->pass]; +- /* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ +- register int rep_bytes = BPP2 * png_pass_width[png_ptr->pass]; +- /* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ +- png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ +- int diff = (int) (png_ptr->width & 7); /* amount lost */ +- register png_uint_32 final_val = BPP2 * len; /* GRR bugfix */ +- +- srcptr = png_ptr->row_buf + 1 + initial_val; +- dstptr = row + initial_val; +- +- for (i = initial_val; i < final_val; i += stride) +- { +- png_memcpy(dstptr, srcptr, rep_bytes); +- srcptr += stride; +- dstptr += stride; +- } +- if (diff) /* number of leftover pixels: 3 for pngtest */ +- { +- final_val+=diff*BPP2; +- for (; i < final_val; i += stride) +- { +- if (rep_bytes > (int)(final_val-i)) +- rep_bytes = (int)(final_val-i); +- png_memcpy(dstptr, srcptr, rep_bytes); +- srcptr += stride; +- dstptr += stride; +- } +- } +- } /* end of else (_mmx_supported) */ +- +- break; +- } /* end 16 bpp */ +- +- case 24: /* png_ptr->row_info.pixel_depth */ +- { +- png_bytep srcptr; +- png_bytep dstptr; +- +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) +- /* && _mmx_supported */ ) +-#else +- if (_mmx_supported) +-#endif +- { +- png_uint_32 len; +- int diff; +- int dummy_value_a; // fix 'forbidden register spilled' error +- int dummy_value_d; +- int dummy_value_c; +- int dummy_value_S; +- int dummy_value_D; +- _unmask = ~mask; // global variable for -fPIC version +- srcptr = png_ptr->row_buf + 1; +- dstptr = row; +- len = png_ptr->width &~7; // reduce to multiple of 8 +- diff = (int) (png_ptr->width & 7); // amount lost // +- +- __asm__ __volatile__ ( +- "movd _unmask, %%mm7 \n\t" // load bit pattern +- "psubb %%mm6, %%mm6 \n\t" // zero mm6 +- "punpcklbw %%mm7, %%mm7 \n\t" +- "punpcklwd %%mm7, %%mm7 \n\t" +- "punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks +- +- "movq _mask24_0, %%mm0 \n\t" +- "movq _mask24_1, %%mm1 \n\t" +- "movq _mask24_2, %%mm2 \n\t" +- +- "pand %%mm7, %%mm0 \n\t" +- "pand %%mm7, %%mm1 \n\t" +- "pand %%mm7, %%mm2 \n\t" +- +- "pcmpeqb %%mm6, %%mm0 \n\t" +- "pcmpeqb %%mm6, %%mm1 \n\t" +- "pcmpeqb %%mm6, %%mm2 \n\t" +- +-// preload "movl len, %%ecx \n\t" // load length of line +-// preload "movl srcptr, %%esi \n\t" // load source +-// preload "movl dstptr, %%edi \n\t" // load dest +- +- "cmpl $0, %%ecx \n\t" +- "jz mainloop24end \n\t" +- +- "mainloop24: \n\t" +- "movq (%%esi), %%mm4 \n\t" +- "pand %%mm0, %%mm4 \n\t" +- "movq %%mm0, %%mm6 \n\t" +- "movq (%%edi), %%mm7 \n\t" +- "pandn %%mm7, %%mm6 \n\t" +- "por %%mm6, %%mm4 \n\t" +- "movq %%mm4, (%%edi) \n\t" +- +- "movq 8(%%esi), %%mm5 \n\t" +- "pand %%mm1, %%mm5 \n\t" +- "movq %%mm1, %%mm7 \n\t" +- "movq 8(%%edi), %%mm6 \n\t" +- "pandn %%mm6, %%mm7 \n\t" +- "por %%mm7, %%mm5 \n\t" +- "movq %%mm5, 8(%%edi) \n\t" +- +- "movq 16(%%esi), %%mm6 \n\t" +- "pand %%mm2, %%mm6 \n\t" +- "movq %%mm2, %%mm4 \n\t" +- "movq 16(%%edi), %%mm7 \n\t" +- "pandn %%mm7, %%mm4 \n\t" +- "por %%mm4, %%mm6 \n\t" +- "movq %%mm6, 16(%%edi) \n\t" +- +- "addl $24, %%esi \n\t" // inc by 24 bytes processed +- "addl $24, %%edi \n\t" +- "subl $8, %%ecx \n\t" // dec by 8 pixels processed +- +- "ja mainloop24 \n\t" +- +- "mainloop24end: \n\t" +-// preload "movl diff, %%ecx \n\t" // (diff is in eax) +- "movl %%eax, %%ecx \n\t" +- "cmpl $0, %%ecx \n\t" +- "jz end24 \n\t" +-// preload "movl mask, %%edx \n\t" +- "sall $24, %%edx \n\t" // make low byte, high byte +- +- "secondloop24: \n\t" +- "sall %%edx \n\t" // move high bit to CF +- "jnc skip24 \n\t" // if CF = 0 +- "movw (%%esi), %%ax \n\t" +- "movw %%ax, (%%edi) \n\t" +- "xorl %%eax, %%eax \n\t" +- "movb 2(%%esi), %%al \n\t" +- "movb %%al, 2(%%edi) \n\t" +- +- "skip24: \n\t" +- "addl $3, %%esi \n\t" +- "addl $3, %%edi \n\t" +- "decl %%ecx \n\t" +- "jnz secondloop24 \n\t" +- +- "end24: \n\t" +- "EMMS \n\t" // DONE +- +- : "=a" (dummy_value_a), // output regs (dummy) +- "=d" (dummy_value_d), +- "=c" (dummy_value_c), +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "3" (srcptr), // esi // input regs +- "4" (dstptr), // edi +- "0" (diff), // eax +-// was (unmask) "b" RESERVED // ebx // Global Offset Table idx +- "2" (len), // ecx +- "1" (mask) // edx +- +-#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm1", "%mm2" // clobber list +- , "%mm4", "%mm5", "%mm6", "%mm7" +-#endif +- ); +- } +- else /* mmx _not supported - Use modified C routine */ +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ +- { +- register png_uint_32 i; +- png_uint_32 initial_val = BPP3 * png_pass_start[png_ptr->pass]; +- /* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ +- register int stride = BPP3 * png_pass_inc[png_ptr->pass]; +- /* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ +- register int rep_bytes = BPP3 * png_pass_width[png_ptr->pass]; +- /* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ +- png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ +- int diff = (int) (png_ptr->width & 7); /* amount lost */ +- register png_uint_32 final_val = BPP3 * len; /* GRR bugfix */ +- +- srcptr = png_ptr->row_buf + 1 + initial_val; +- dstptr = row + initial_val; +- +- for (i = initial_val; i < final_val; i += stride) +- { +- png_memcpy(dstptr, srcptr, rep_bytes); +- srcptr += stride; +- dstptr += stride; +- } +- if (diff) /* number of leftover pixels: 3 for pngtest */ +- { +- final_val+=diff*BPP3; +- for (; i < final_val; i += stride) +- { +- if (rep_bytes > (int)(final_val-i)) +- rep_bytes = (int)(final_val-i); +- png_memcpy(dstptr, srcptr, rep_bytes); +- srcptr += stride; +- dstptr += stride; +- } +- } +- } /* end of else (_mmx_supported) */ +- +- break; +- } /* end 24 bpp */ +- +- case 32: /* png_ptr->row_info.pixel_depth */ +- { +- png_bytep srcptr; +- png_bytep dstptr; +- +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) +- /* && _mmx_supported */ ) +-#else +- if (_mmx_supported) +-#endif +- { +- png_uint_32 len; +- int diff; +- int dummy_value_a; // fix 'forbidden register spilled' error +- int dummy_value_d; +- int dummy_value_c; +- int dummy_value_S; +- int dummy_value_D; +- _unmask = ~mask; // global variable for -fPIC version +- srcptr = png_ptr->row_buf + 1; +- dstptr = row; +- len = png_ptr->width &~7; // reduce to multiple of 8 +- diff = (int) (png_ptr->width & 7); // amount lost // +- +- __asm__ __volatile__ ( +- "movd _unmask, %%mm7 \n\t" // load bit pattern +- "psubb %%mm6, %%mm6 \n\t" // zero mm6 +- "punpcklbw %%mm7, %%mm7 \n\t" +- "punpcklwd %%mm7, %%mm7 \n\t" +- "punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks +- +- "movq _mask32_0, %%mm0 \n\t" +- "movq _mask32_1, %%mm1 \n\t" +- "movq _mask32_2, %%mm2 \n\t" +- "movq _mask32_3, %%mm3 \n\t" +- +- "pand %%mm7, %%mm0 \n\t" +- "pand %%mm7, %%mm1 \n\t" +- "pand %%mm7, %%mm2 \n\t" +- "pand %%mm7, %%mm3 \n\t" +- +- "pcmpeqb %%mm6, %%mm0 \n\t" +- "pcmpeqb %%mm6, %%mm1 \n\t" +- "pcmpeqb %%mm6, %%mm2 \n\t" +- "pcmpeqb %%mm6, %%mm3 \n\t" +- +-// preload "movl len, %%ecx \n\t" // load length of line +-// preload "movl srcptr, %%esi \n\t" // load source +-// preload "movl dstptr, %%edi \n\t" // load dest +- +- "cmpl $0, %%ecx \n\t" // lcr +- "jz mainloop32end \n\t" +- +- "mainloop32: \n\t" +- "movq (%%esi), %%mm4 \n\t" +- "pand %%mm0, %%mm4 \n\t" +- "movq %%mm0, %%mm6 \n\t" +- "movq (%%edi), %%mm7 \n\t" +- "pandn %%mm7, %%mm6 \n\t" +- "por %%mm6, %%mm4 \n\t" +- "movq %%mm4, (%%edi) \n\t" +- +- "movq 8(%%esi), %%mm5 \n\t" +- "pand %%mm1, %%mm5 \n\t" +- "movq %%mm1, %%mm7 \n\t" +- "movq 8(%%edi), %%mm6 \n\t" +- "pandn %%mm6, %%mm7 \n\t" +- "por %%mm7, %%mm5 \n\t" +- "movq %%mm5, 8(%%edi) \n\t" +- +- "movq 16(%%esi), %%mm6 \n\t" +- "pand %%mm2, %%mm6 \n\t" +- "movq %%mm2, %%mm4 \n\t" +- "movq 16(%%edi), %%mm7 \n\t" +- "pandn %%mm7, %%mm4 \n\t" +- "por %%mm4, %%mm6 \n\t" +- "movq %%mm6, 16(%%edi) \n\t" +- +- "movq 24(%%esi), %%mm7 \n\t" +- "pand %%mm3, %%mm7 \n\t" +- "movq %%mm3, %%mm5 \n\t" +- "movq 24(%%edi), %%mm4 \n\t" +- "pandn %%mm4, %%mm5 \n\t" +- "por %%mm5, %%mm7 \n\t" +- "movq %%mm7, 24(%%edi) \n\t" +- +- "addl $32, %%esi \n\t" // inc by 32 bytes processed +- "addl $32, %%edi \n\t" +- "subl $8, %%ecx \n\t" // dec by 8 pixels processed +- "ja mainloop32 \n\t" +- +- "mainloop32end: \n\t" +-// preload "movl diff, %%ecx \n\t" // (diff is in eax) +- "movl %%eax, %%ecx \n\t" +- "cmpl $0, %%ecx \n\t" +- "jz end32 \n\t" +-// preload "movl mask, %%edx \n\t" +- "sall $24, %%edx \n\t" // low byte => high byte +- +- "secondloop32: \n\t" +- "sall %%edx \n\t" // move high bit to CF +- "jnc skip32 \n\t" // if CF = 0 +- "movl (%%esi), %%eax \n\t" +- "movl %%eax, (%%edi) \n\t" +- +- "skip32: \n\t" +- "addl $4, %%esi \n\t" +- "addl $4, %%edi \n\t" +- "decl %%ecx \n\t" +- "jnz secondloop32 \n\t" +- +- "end32: \n\t" +- "EMMS \n\t" // DONE +- +- : "=a" (dummy_value_a), // output regs (dummy) +- "=d" (dummy_value_d), +- "=c" (dummy_value_c), +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "3" (srcptr), // esi // input regs +- "4" (dstptr), // edi +- "0" (diff), // eax +-// was (unmask) "b" RESERVED // ebx // Global Offset Table idx +- "2" (len), // ecx +- "1" (mask) // edx +- +-#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm1", "%mm2", "%mm3" // clobber list +- , "%mm4", "%mm5", "%mm6", "%mm7" +-#endif +- ); +- } +- else /* mmx _not supported - Use modified C routine */ +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ +- { +- register png_uint_32 i; +- png_uint_32 initial_val = BPP4 * png_pass_start[png_ptr->pass]; +- /* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ +- register int stride = BPP4 * png_pass_inc[png_ptr->pass]; +- /* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ +- register int rep_bytes = BPP4 * png_pass_width[png_ptr->pass]; +- /* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ +- png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ +- int diff = (int) (png_ptr->width & 7); /* amount lost */ +- register png_uint_32 final_val = BPP4 * len; /* GRR bugfix */ +- +- srcptr = png_ptr->row_buf + 1 + initial_val; +- dstptr = row + initial_val; +- +- for (i = initial_val; i < final_val; i += stride) +- { +- png_memcpy(dstptr, srcptr, rep_bytes); +- srcptr += stride; +- dstptr += stride; +- } +- if (diff) /* number of leftover pixels: 3 for pngtest */ +- { +- final_val+=diff*BPP4; +- for (; i < final_val; i += stride) +- { +- if (rep_bytes > (int)(final_val-i)) +- rep_bytes = (int)(final_val-i); +- png_memcpy(dstptr, srcptr, rep_bytes); +- srcptr += stride; +- dstptr += stride; +- } +- } +- } /* end of else (_mmx_supported) */ +- +- break; +- } /* end 32 bpp */ +- +- case 48: /* png_ptr->row_info.pixel_depth */ +- { +- png_bytep srcptr; +- png_bytep dstptr; +- +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) +- /* && _mmx_supported */ ) +-#else +- if (_mmx_supported) +-#endif +- { +- png_uint_32 len; +- int diff; +- int dummy_value_a; // fix 'forbidden register spilled' error +- int dummy_value_d; +- int dummy_value_c; +- int dummy_value_S; +- int dummy_value_D; +- _unmask = ~mask; // global variable for -fPIC version +- srcptr = png_ptr->row_buf + 1; +- dstptr = row; +- len = png_ptr->width &~7; // reduce to multiple of 8 +- diff = (int) (png_ptr->width & 7); // amount lost // +- +- __asm__ __volatile__ ( +- "movd _unmask, %%mm7 \n\t" // load bit pattern +- "psubb %%mm6, %%mm6 \n\t" // zero mm6 +- "punpcklbw %%mm7, %%mm7 \n\t" +- "punpcklwd %%mm7, %%mm7 \n\t" +- "punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks +- +- "movq _mask48_0, %%mm0 \n\t" +- "movq _mask48_1, %%mm1 \n\t" +- "movq _mask48_2, %%mm2 \n\t" +- "movq _mask48_3, %%mm3 \n\t" +- "movq _mask48_4, %%mm4 \n\t" +- "movq _mask48_5, %%mm5 \n\t" +- +- "pand %%mm7, %%mm0 \n\t" +- "pand %%mm7, %%mm1 \n\t" +- "pand %%mm7, %%mm2 \n\t" +- "pand %%mm7, %%mm3 \n\t" +- "pand %%mm7, %%mm4 \n\t" +- "pand %%mm7, %%mm5 \n\t" +- +- "pcmpeqb %%mm6, %%mm0 \n\t" +- "pcmpeqb %%mm6, %%mm1 \n\t" +- "pcmpeqb %%mm6, %%mm2 \n\t" +- "pcmpeqb %%mm6, %%mm3 \n\t" +- "pcmpeqb %%mm6, %%mm4 \n\t" +- "pcmpeqb %%mm6, %%mm5 \n\t" +- +-// preload "movl len, %%ecx \n\t" // load length of line +-// preload "movl srcptr, %%esi \n\t" // load source +-// preload "movl dstptr, %%edi \n\t" // load dest +- +- "cmpl $0, %%ecx \n\t" +- "jz mainloop48end \n\t" +- +- "mainloop48: \n\t" +- "movq (%%esi), %%mm7 \n\t" +- "pand %%mm0, %%mm7 \n\t" +- "movq %%mm0, %%mm6 \n\t" +- "pandn (%%edi), %%mm6 \n\t" +- "por %%mm6, %%mm7 \n\t" +- "movq %%mm7, (%%edi) \n\t" +- +- "movq 8(%%esi), %%mm6 \n\t" +- "pand %%mm1, %%mm6 \n\t" +- "movq %%mm1, %%mm7 \n\t" +- "pandn 8(%%edi), %%mm7 \n\t" +- "por %%mm7, %%mm6 \n\t" +- "movq %%mm6, 8(%%edi) \n\t" +- +- "movq 16(%%esi), %%mm6 \n\t" +- "pand %%mm2, %%mm6 \n\t" +- "movq %%mm2, %%mm7 \n\t" +- "pandn 16(%%edi), %%mm7 \n\t" +- "por %%mm7, %%mm6 \n\t" +- "movq %%mm6, 16(%%edi) \n\t" +- +- "movq 24(%%esi), %%mm7 \n\t" +- "pand %%mm3, %%mm7 \n\t" +- "movq %%mm3, %%mm6 \n\t" +- "pandn 24(%%edi), %%mm6 \n\t" +- "por %%mm6, %%mm7 \n\t" +- "movq %%mm7, 24(%%edi) \n\t" +- +- "movq 32(%%esi), %%mm6 \n\t" +- "pand %%mm4, %%mm6 \n\t" +- "movq %%mm4, %%mm7 \n\t" +- "pandn 32(%%edi), %%mm7 \n\t" +- "por %%mm7, %%mm6 \n\t" +- "movq %%mm6, 32(%%edi) \n\t" +- +- "movq 40(%%esi), %%mm7 \n\t" +- "pand %%mm5, %%mm7 \n\t" +- "movq %%mm5, %%mm6 \n\t" +- "pandn 40(%%edi), %%mm6 \n\t" +- "por %%mm6, %%mm7 \n\t" +- "movq %%mm7, 40(%%edi) \n\t" +- +- "addl $48, %%esi \n\t" // inc by 48 bytes processed +- "addl $48, %%edi \n\t" +- "subl $8, %%ecx \n\t" // dec by 8 pixels processed +- +- "ja mainloop48 \n\t" +- +- "mainloop48end: \n\t" +-// preload "movl diff, %%ecx \n\t" // (diff is in eax) +- "movl %%eax, %%ecx \n\t" +- "cmpl $0, %%ecx \n\t" +- "jz end48 \n\t" +-// preload "movl mask, %%edx \n\t" +- "sall $24, %%edx \n\t" // make low byte, high byte +- +- "secondloop48: \n\t" +- "sall %%edx \n\t" // move high bit to CF +- "jnc skip48 \n\t" // if CF = 0 +- "movl (%%esi), %%eax \n\t" +- "movl %%eax, (%%edi) \n\t" +- +- "skip48: \n\t" +- "addl $4, %%esi \n\t" +- "addl $4, %%edi \n\t" +- "decl %%ecx \n\t" +- "jnz secondloop48 \n\t" +- +- "end48: \n\t" +- "EMMS \n\t" // DONE +- +- : "=a" (dummy_value_a), // output regs (dummy) +- "=d" (dummy_value_d), +- "=c" (dummy_value_c), +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "3" (srcptr), // esi // input regs +- "4" (dstptr), // edi +- "0" (diff), // eax +-// was (unmask) "b" RESERVED // ebx // Global Offset Table idx +- "2" (len), // ecx +- "1" (mask) // edx +- +-#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm1", "%mm2", "%mm3" // clobber list +- , "%mm4", "%mm5", "%mm6", "%mm7" +-#endif +- ); +- } +- else /* mmx _not supported - Use modified C routine */ +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ +- { +- register png_uint_32 i; +- png_uint_32 initial_val = BPP6 * png_pass_start[png_ptr->pass]; +- /* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ +- register int stride = BPP6 * png_pass_inc[png_ptr->pass]; +- /* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ +- register int rep_bytes = BPP6 * png_pass_width[png_ptr->pass]; +- /* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ +- png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ +- int diff = (int) (png_ptr->width & 7); /* amount lost */ +- register png_uint_32 final_val = BPP6 * len; /* GRR bugfix */ +- +- srcptr = png_ptr->row_buf + 1 + initial_val; +- dstptr = row + initial_val; +- +- for (i = initial_val; i < final_val; i += stride) +- { +- png_memcpy(dstptr, srcptr, rep_bytes); +- srcptr += stride; +- dstptr += stride; +- } +- if (diff) /* number of leftover pixels: 3 for pngtest */ +- { +- final_val+=diff*BPP6; +- for (; i < final_val; i += stride) +- { +- if (rep_bytes > (int)(final_val-i)) +- rep_bytes = (int)(final_val-i); +- png_memcpy(dstptr, srcptr, rep_bytes); +- srcptr += stride; +- dstptr += stride; +- } +- } +- } /* end of else (_mmx_supported) */ +- +- break; +- } /* end 48 bpp */ +- +- case 64: /* png_ptr->row_info.pixel_depth */ +- { +- png_bytep srcptr; +- png_bytep dstptr; +- register png_uint_32 i; +- png_uint_32 initial_val = BPP8 * png_pass_start[png_ptr->pass]; +- /* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ +- register int stride = BPP8 * png_pass_inc[png_ptr->pass]; +- /* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ +- register int rep_bytes = BPP8 * png_pass_width[png_ptr->pass]; +- /* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ +- png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ +- int diff = (int) (png_ptr->width & 7); /* amount lost */ +- register png_uint_32 final_val = BPP8 * len; /* GRR bugfix */ +- +- srcptr = png_ptr->row_buf + 1 + initial_val; +- dstptr = row + initial_val; +- +- for (i = initial_val; i < final_val; i += stride) +- { +- png_memcpy(dstptr, srcptr, rep_bytes); +- srcptr += stride; +- dstptr += stride; +- } +- if (diff) /* number of leftover pixels: 3 for pngtest */ +- { +- final_val+=diff*BPP8; +- for (; i < final_val; i += stride) +- { +- if (rep_bytes > (int)(final_val-i)) +- rep_bytes = (int)(final_val-i); +- png_memcpy(dstptr, srcptr, rep_bytes); +- srcptr += stride; +- dstptr += stride; +- } +- } +- +- break; +- } /* end 64 bpp */ +- +- default: /* png_ptr->row_info.pixel_depth != 1,2,4,8,16,24,32,48,64 */ +- { +- /* this should never happen */ +- png_warning(png_ptr, "Invalid row_info.pixel_depth in pnggccrd"); +- break; +- } +- } /* end switch (png_ptr->row_info.pixel_depth) */ +- +- } /* end if (non-trivial mask) */ +- +-} /* end png_combine_row() */ +- +-#endif /* PNG_HAVE_ASSEMBLER_COMBINE_ROW */ +- +- +- +- +-/*===========================================================================*/ +-/* */ +-/* P N G _ D O _ R E A D _ I N T E R L A C E */ +-/* */ +-/*===========================================================================*/ +- +-#if defined(PNG_READ_INTERLACING_SUPPORTED) +-#if defined(PNG_HAVE_ASSEMBLER_READ_INTERLACE) +- +-/* png_do_read_interlace() is called after any 16-bit to 8-bit conversion +- * has taken place. [GRR: what other steps come before and/or after?] +- */ +- +-void /* PRIVATE */ +-png_do_read_interlace(png_structp png_ptr) +-{ +- png_row_infop row_info = &(png_ptr->row_info); +- png_bytep row = png_ptr->row_buf + 1; +- int pass = png_ptr->pass; +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- png_uint_32 transformations = png_ptr->transformations; +-#endif +- +- png_debug(1, "in png_do_read_interlace (pnggccrd.c)\n"); +- +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +- if (_mmx_supported == 2) { +-#if !defined(PNG_1_0_X) +- /* this should have happened in png_init_mmx_flags() already */ +- png_warning(png_ptr, "asm_flags may not have been initialized"); +-#endif +- png_mmx_support(); +- } +-#endif +- +- if (row != NULL && row_info != NULL) +- { +- png_uint_32 final_width; +- +- final_width = row_info->width * png_pass_inc[pass]; +- +- switch (row_info->pixel_depth) +- { +- case 1: +- { +- png_bytep sp, dp; +- int sshift, dshift; +- int s_start, s_end, s_inc; +- png_byte v; +- png_uint_32 i; +- int j; +- +- sp = row + (png_size_t)((row_info->width - 1) >> 3); +- dp = row + (png_size_t)((final_width - 1) >> 3); +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (transformations & PNG_PACKSWAP) +- { +- sshift = (int)((row_info->width + 7) & 7); +- dshift = (int)((final_width + 7) & 7); +- s_start = 7; +- s_end = 0; +- s_inc = -1; +- } +- else +-#endif +- { +- sshift = 7 - (int)((row_info->width + 7) & 7); +- dshift = 7 - (int)((final_width + 7) & 7); +- s_start = 0; +- s_end = 7; +- s_inc = 1; +- } +- +- for (i = row_info->width; i; i--) +- { +- v = (png_byte)((*sp >> sshift) & 0x1); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff); +- *dp |= (png_byte)(v << dshift); +- if (dshift == s_end) +- { +- dshift = s_start; +- dp--; +- } +- else +- dshift += s_inc; +- } +- if (sshift == s_end) +- { +- sshift = s_start; +- sp--; +- } +- else +- sshift += s_inc; +- } +- break; +- } +- +- case 2: +- { +- png_bytep sp, dp; +- int sshift, dshift; +- int s_start, s_end, s_inc; +- png_uint_32 i; +- +- sp = row + (png_size_t)((row_info->width - 1) >> 2); +- dp = row + (png_size_t)((final_width - 1) >> 2); +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (transformations & PNG_PACKSWAP) +- { +- sshift = (png_size_t)(((row_info->width + 3) & 3) << 1); +- dshift = (png_size_t)(((final_width + 3) & 3) << 1); +- s_start = 6; +- s_end = 0; +- s_inc = -2; +- } +- else +-#endif +- { +- sshift = (png_size_t)((3 - ((row_info->width + 3) & 3)) << 1); +- dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1); +- s_start = 0; +- s_end = 6; +- s_inc = 2; +- } +- +- for (i = row_info->width; i; i--) +- { +- png_byte v; +- int j; +- +- v = (png_byte)((*sp >> sshift) & 0x3); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff); +- *dp |= (png_byte)(v << dshift); +- if (dshift == s_end) +- { +- dshift = s_start; +- dp--; +- } +- else +- dshift += s_inc; +- } +- if (sshift == s_end) +- { +- sshift = s_start; +- sp--; +- } +- else +- sshift += s_inc; +- } +- break; +- } +- +- case 4: +- { +- png_bytep sp, dp; +- int sshift, dshift; +- int s_start, s_end, s_inc; +- png_uint_32 i; +- +- sp = row + (png_size_t)((row_info->width - 1) >> 1); +- dp = row + (png_size_t)((final_width - 1) >> 1); +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (transformations & PNG_PACKSWAP) +- { +- sshift = (png_size_t)(((row_info->width + 1) & 1) << 2); +- dshift = (png_size_t)(((final_width + 1) & 1) << 2); +- s_start = 4; +- s_end = 0; +- s_inc = -4; +- } +- else +-#endif +- { +- sshift = (png_size_t)((1 - ((row_info->width + 1) & 1)) << 2); +- dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2); +- s_start = 0; +- s_end = 4; +- s_inc = 4; +- } +- +- for (i = row_info->width; i; i--) +- { +- png_byte v; +- int j; +- +- v = (png_byte)((*sp >> sshift) & 0xf); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff); +- *dp |= (png_byte)(v << dshift); +- if (dshift == s_end) +- { +- dshift = s_start; +- dp--; +- } +- else +- dshift += s_inc; +- } +- if (sshift == s_end) +- { +- sshift = s_start; +- sp--; +- } +- else +- sshift += s_inc; +- } +- break; +- } +- +- /*====================================================================*/ +- +- default: /* 8-bit or larger (this is where the routine is modified) */ +- { +-#if 0 +-// static unsigned long long _const4 = 0x0000000000FFFFFFLL; no good +-// static unsigned long long const4 = 0x0000000000FFFFFFLL; no good +-// unsigned long long _const4 = 0x0000000000FFFFFFLL; no good +-// unsigned long long const4 = 0x0000000000FFFFFFLL; no good +-#endif +- png_bytep sptr, dp; +- png_uint_32 i; +- png_size_t pixel_bytes; +- int width = (int)row_info->width; +- +- pixel_bytes = (row_info->pixel_depth >> 3); +- +- /* point sptr at the last pixel in the pre-expanded row: */ +- sptr = row + (width - 1) * pixel_bytes; +- +- /* point dp at the last pixel position in the expanded row: */ +- dp = row + (final_width - 1) * pixel_bytes; +- +- /* New code by Nirav Chhatrapati - Intel Corporation */ +- +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE) +- /* && _mmx_supported */ ) +-#else +- if (_mmx_supported) +-#endif +- { +- //-------------------------------------------------------------- +- if (pixel_bytes == 3) +- { +- if (((pass == 0) || (pass == 1)) && width) +- { +- int dummy_value_c; // fix 'forbidden register spilled' +- int dummy_value_S; +- int dummy_value_D; +- +- __asm__ __volatile__ ( +- "subl $21, %%edi \n\t" +- // (png_pass_inc[pass] - 1)*pixel_bytes +- +- ".loop3_pass0: \n\t" +- "movd (%%esi), %%mm0 \n\t" // x x x x x 2 1 0 +- "pand _const4, %%mm0 \n\t" // z z z z z 2 1 0 +- "movq %%mm0, %%mm1 \n\t" // z z z z z 2 1 0 +- "psllq $16, %%mm0 \n\t" // z z z 2 1 0 z z +- "movq %%mm0, %%mm2 \n\t" // z z z 2 1 0 z z +- "psllq $24, %%mm0 \n\t" // 2 1 0 z z z z z +- "psrlq $8, %%mm1 \n\t" // z z z z z z 2 1 +- "por %%mm2, %%mm0 \n\t" // 2 1 0 2 1 0 z z +- "por %%mm1, %%mm0 \n\t" // 2 1 0 2 1 0 2 1 +- "movq %%mm0, %%mm3 \n\t" // 2 1 0 2 1 0 2 1 +- "psllq $16, %%mm0 \n\t" // 0 2 1 0 2 1 z z +- "movq %%mm3, %%mm4 \n\t" // 2 1 0 2 1 0 2 1 +- "punpckhdq %%mm0, %%mm3 \n\t" // 0 2 1 0 2 1 0 2 +- "movq %%mm4, 16(%%edi) \n\t" +- "psrlq $32, %%mm0 \n\t" // z z z z 0 2 1 0 +- "movq %%mm3, 8(%%edi) \n\t" +- "punpckldq %%mm4, %%mm0 \n\t" // 1 0 2 1 0 2 1 0 +- "subl $3, %%esi \n\t" +- "movq %%mm0, (%%edi) \n\t" +- "subl $24, %%edi \n\t" +- "decl %%ecx \n\t" +- "jnz .loop3_pass0 \n\t" +- "EMMS \n\t" // DONE +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "1" (sptr), // esi // input regs +- "2" (dp), // edi +- "0" (width), // ecx +- "rim" (_const4) // %1(?) (0x0000000000FFFFFFLL) +- +-#if 0 /* %mm0, ..., %mm4 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm1", "%mm2" // clobber list +- , "%mm3", "%mm4" +-#endif +- ); +- } +- else if (((pass == 2) || (pass == 3)) && width) +- { +- int dummy_value_c; // fix 'forbidden register spilled' +- int dummy_value_S; +- int dummy_value_D; +- +- __asm__ __volatile__ ( +- "subl $9, %%edi \n\t" +- // (png_pass_inc[pass] - 1)*pixel_bytes +- +- ".loop3_pass2: \n\t" +- "movd (%%esi), %%mm0 \n\t" // x x x x x 2 1 0 +- "pand _const4, %%mm0 \n\t" // z z z z z 2 1 0 +- "movq %%mm0, %%mm1 \n\t" // z z z z z 2 1 0 +- "psllq $16, %%mm0 \n\t" // z z z 2 1 0 z z +- "movq %%mm0, %%mm2 \n\t" // z z z 2 1 0 z z +- "psllq $24, %%mm0 \n\t" // 2 1 0 z z z z z +- "psrlq $8, %%mm1 \n\t" // z z z z z z 2 1 +- "por %%mm2, %%mm0 \n\t" // 2 1 0 2 1 0 z z +- "por %%mm1, %%mm0 \n\t" // 2 1 0 2 1 0 2 1 +- "movq %%mm0, 4(%%edi) \n\t" +- "psrlq $16, %%mm0 \n\t" // z z 2 1 0 2 1 0 +- "subl $3, %%esi \n\t" +- "movd %%mm0, (%%edi) \n\t" +- "subl $12, %%edi \n\t" +- "decl %%ecx \n\t" +- "jnz .loop3_pass2 \n\t" +- "EMMS \n\t" // DONE +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "1" (sptr), // esi // input regs +- "2" (dp), // edi +- "0" (width), // ecx +- "rim" (_const4) // (0x0000000000FFFFFFLL) +- +-#if 0 /* %mm0, ..., %mm2 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm1", "%mm2" // clobber list +-#endif +- ); +- } +- else if (width) /* && ((pass == 4) || (pass == 5)) */ +- { +- int width_mmx = ((width >> 1) << 1) - 8; // GRR: huh? +- if (width_mmx < 0) +- width_mmx = 0; +- width -= width_mmx; // 8 or 9 pix, 24 or 27 bytes +- if (width_mmx) +- { +- // png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; +- // sptr points at last pixel in pre-expanded row +- // dp points at last pixel position in expanded row +- int dummy_value_c; // fix 'forbidden register spilled' +- int dummy_value_S; +- int dummy_value_D; +- +- __asm__ __volatile__ ( +- "subl $3, %%esi \n\t" +- "subl $9, %%edi \n\t" +- // (png_pass_inc[pass] + 1)*pixel_bytes +- +- ".loop3_pass4: \n\t" +- "movq (%%esi), %%mm0 \n\t" // x x 5 4 3 2 1 0 +- "movq %%mm0, %%mm1 \n\t" // x x 5 4 3 2 1 0 +- "movq %%mm0, %%mm2 \n\t" // x x 5 4 3 2 1 0 +- "psllq $24, %%mm0 \n\t" // 4 3 2 1 0 z z z +- "pand _const4, %%mm1 \n\t" // z z z z z 2 1 0 +- "psrlq $24, %%mm2 \n\t" // z z z x x 5 4 3 +- "por %%mm1, %%mm0 \n\t" // 4 3 2 1 0 2 1 0 +- "movq %%mm2, %%mm3 \n\t" // z z z x x 5 4 3 +- "psllq $8, %%mm2 \n\t" // z z x x 5 4 3 z +- "movq %%mm0, (%%edi) \n\t" +- "psrlq $16, %%mm3 \n\t" // z z z z z x x 5 +- "pand _const6, %%mm3 \n\t" // z z z z z z z 5 +- "por %%mm3, %%mm2 \n\t" // z z x x 5 4 3 5 +- "subl $6, %%esi \n\t" +- "movd %%mm2, 8(%%edi) \n\t" +- "subl $12, %%edi \n\t" +- "subl $2, %%ecx \n\t" +- "jnz .loop3_pass4 \n\t" +- "EMMS \n\t" // DONE +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "1" (sptr), // esi // input regs +- "2" (dp), // edi +- "0" (width_mmx), // ecx +- "rim" (_const4), // 0x0000000000FFFFFFLL +- "rim" (_const6) // 0x00000000000000FFLL +- +-#if 0 /* %mm0, ..., %mm3 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm1" // clobber list +- , "%mm2", "%mm3" +-#endif +- ); +- } +- +- sptr -= width_mmx*3; +- dp -= width_mmx*6; +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- +- png_memcpy(v, sptr, 3); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, 3); +- dp -= 3; +- } +- sptr -= 3; +- } +- } +- } /* end of pixel_bytes == 3 */ +- +- //-------------------------------------------------------------- +- else if (pixel_bytes == 1) +- { +- if (((pass == 0) || (pass == 1)) && width) +- { +- int width_mmx = ((width >> 2) << 2); +- width -= width_mmx; // 0-3 pixels => 0-3 bytes +- if (width_mmx) +- { +- int dummy_value_c; // fix 'forbidden register spilled' +- int dummy_value_S; +- int dummy_value_D; +- +- __asm__ __volatile__ ( +- "subl $3, %%esi \n\t" +- "subl $31, %%edi \n\t" +- +- ".loop1_pass0: \n\t" +- "movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 +- "movq %%mm0, %%mm1 \n\t" // x x x x 3 2 1 0 +- "punpcklbw %%mm0, %%mm0 \n\t" // 3 3 2 2 1 1 0 0 +- "movq %%mm0, %%mm2 \n\t" // 3 3 2 2 1 1 0 0 +- "punpcklwd %%mm0, %%mm0 \n\t" // 1 1 1 1 0 0 0 0 +- "movq %%mm0, %%mm3 \n\t" // 1 1 1 1 0 0 0 0 +- "punpckldq %%mm0, %%mm0 \n\t" // 0 0 0 0 0 0 0 0 +- "punpckhdq %%mm3, %%mm3 \n\t" // 1 1 1 1 1 1 1 1 +- "movq %%mm0, (%%edi) \n\t" +- "punpckhwd %%mm2, %%mm2 \n\t" // 3 3 3 3 2 2 2 2 +- "movq %%mm3, 8(%%edi) \n\t" +- "movq %%mm2, %%mm4 \n\t" // 3 3 3 3 2 2 2 2 +- "punpckldq %%mm2, %%mm2 \n\t" // 2 2 2 2 2 2 2 2 +- "punpckhdq %%mm4, %%mm4 \n\t" // 3 3 3 3 3 3 3 3 +- "movq %%mm2, 16(%%edi) \n\t" +- "subl $4, %%esi \n\t" +- "movq %%mm4, 24(%%edi) \n\t" +- "subl $32, %%edi \n\t" +- "subl $4, %%ecx \n\t" +- "jnz .loop1_pass0 \n\t" +- "EMMS \n\t" // DONE +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "1" (sptr), // esi // input regs +- "2" (dp), // edi +- "0" (width_mmx) // ecx +- +-#if 0 /* %mm0, ..., %mm4 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm1", "%mm2" // clobber list +- , "%mm3", "%mm4" +-#endif +- ); +- } +- +- sptr -= width_mmx; +- dp -= width_mmx*8; +- for (i = width; i; i--) +- { +- int j; +- +- /* I simplified this part in version 1.0.4e +- * here and in several other instances where +- * pixel_bytes == 1 -- GR-P +- * +- * Original code: +- * +- * png_byte v[8]; +- * png_memcpy(v, sptr, pixel_bytes); +- * for (j = 0; j < png_pass_inc[pass]; j++) +- * { +- * png_memcpy(dp, v, pixel_bytes); +- * dp -= pixel_bytes; +- * } +- * sptr -= pixel_bytes; +- * +- * Replacement code is in the next three lines: +- */ +- +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- *dp-- = *sptr; +- } +- --sptr; +- } +- } +- else if (((pass == 2) || (pass == 3)) && width) +- { +- int width_mmx = ((width >> 2) << 2); +- width -= width_mmx; // 0-3 pixels => 0-3 bytes +- if (width_mmx) +- { +- int dummy_value_c; // fix 'forbidden register spilled' +- int dummy_value_S; +- int dummy_value_D; +- +- __asm__ __volatile__ ( +- "subl $3, %%esi \n\t" +- "subl $15, %%edi \n\t" +- +- ".loop1_pass2: \n\t" +- "movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 +- "punpcklbw %%mm0, %%mm0 \n\t" // 3 3 2 2 1 1 0 0 +- "movq %%mm0, %%mm1 \n\t" // 3 3 2 2 1 1 0 0 +- "punpcklwd %%mm0, %%mm0 \n\t" // 1 1 1 1 0 0 0 0 +- "punpckhwd %%mm1, %%mm1 \n\t" // 3 3 3 3 2 2 2 2 +- "movq %%mm0, (%%edi) \n\t" +- "subl $4, %%esi \n\t" +- "movq %%mm1, 8(%%edi) \n\t" +- "subl $16, %%edi \n\t" +- "subl $4, %%ecx \n\t" +- "jnz .loop1_pass2 \n\t" +- "EMMS \n\t" // DONE +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "1" (sptr), // esi // input regs +- "2" (dp), // edi +- "0" (width_mmx) // ecx +- +-#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm1" // clobber list +-#endif +- ); +- } +- +- sptr -= width_mmx; +- dp -= width_mmx*4; +- for (i = width; i; i--) +- { +- int j; +- +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- *dp-- = *sptr; +- } +- --sptr; +- } +- } +- else if (width) /* && ((pass == 4) || (pass == 5)) */ +- { +- int width_mmx = ((width >> 3) << 3); +- width -= width_mmx; // 0-3 pixels => 0-3 bytes +- if (width_mmx) +- { +- int dummy_value_c; // fix 'forbidden register spilled' +- int dummy_value_S; +- int dummy_value_D; +- +- __asm__ __volatile__ ( +- "subl $7, %%esi \n\t" +- "subl $15, %%edi \n\t" +- +- ".loop1_pass4: \n\t" +- "movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 +- "movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 +- "punpcklbw %%mm0, %%mm0 \n\t" // 3 3 2 2 1 1 0 0 +- "punpckhbw %%mm1, %%mm1 \n\t" // 7 7 6 6 5 5 4 4 +- "movq %%mm1, 8(%%edi) \n\t" +- "subl $8, %%esi \n\t" +- "movq %%mm0, (%%edi) \n\t" +- "subl $16, %%edi \n\t" +- "subl $8, %%ecx \n\t" +- "jnz .loop1_pass4 \n\t" +- "EMMS \n\t" // DONE +- +- : "=c" (dummy_value_c), // output regs (none) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "1" (sptr), // esi // input regs +- "2" (dp), // edi +- "0" (width_mmx) // ecx +- +-#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm1" // clobber list +-#endif +- ); +- } +- +- sptr -= width_mmx; +- dp -= width_mmx*2; +- for (i = width; i; i--) +- { +- int j; +- +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- *dp-- = *sptr; +- } +- --sptr; +- } +- } +- } /* end of pixel_bytes == 1 */ +- +- //-------------------------------------------------------------- +- else if (pixel_bytes == 2) +- { +- if (((pass == 0) || (pass == 1)) && width) +- { +- int width_mmx = ((width >> 1) << 1); +- width -= width_mmx; // 0,1 pixels => 0,2 bytes +- if (width_mmx) +- { +- int dummy_value_c; // fix 'forbidden register spilled' +- int dummy_value_S; +- int dummy_value_D; +- +- __asm__ __volatile__ ( +- "subl $2, %%esi \n\t" +- "subl $30, %%edi \n\t" +- +- ".loop2_pass0: \n\t" +- "movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 +- "punpcklwd %%mm0, %%mm0 \n\t" // 3 2 3 2 1 0 1 0 +- "movq %%mm0, %%mm1 \n\t" // 3 2 3 2 1 0 1 0 +- "punpckldq %%mm0, %%mm0 \n\t" // 1 0 1 0 1 0 1 0 +- "punpckhdq %%mm1, %%mm1 \n\t" // 3 2 3 2 3 2 3 2 +- "movq %%mm0, (%%edi) \n\t" +- "movq %%mm0, 8(%%edi) \n\t" +- "movq %%mm1, 16(%%edi) \n\t" +- "subl $4, %%esi \n\t" +- "movq %%mm1, 24(%%edi) \n\t" +- "subl $32, %%edi \n\t" +- "subl $2, %%ecx \n\t" +- "jnz .loop2_pass0 \n\t" +- "EMMS \n\t" // DONE +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "1" (sptr), // esi // input regs +- "2" (dp), // edi +- "0" (width_mmx) // ecx +- +-#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm1" // clobber list +-#endif +- ); +- } +- +- sptr -= (width_mmx*2 - 2); // sign fixed +- dp -= (width_mmx*16 - 2); // sign fixed +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- sptr -= 2; +- png_memcpy(v, sptr, 2); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- dp -= 2; +- png_memcpy(dp, v, 2); +- } +- } +- } +- else if (((pass == 2) || (pass == 3)) && width) +- { +- int width_mmx = ((width >> 1) << 1) ; +- width -= width_mmx; // 0,1 pixels => 0,2 bytes +- if (width_mmx) +- { +- int dummy_value_c; // fix 'forbidden register spilled' +- int dummy_value_S; +- int dummy_value_D; +- +- __asm__ __volatile__ ( +- "subl $2, %%esi \n\t" +- "subl $14, %%edi \n\t" +- +- ".loop2_pass2: \n\t" +- "movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 +- "punpcklwd %%mm0, %%mm0 \n\t" // 3 2 3 2 1 0 1 0 +- "movq %%mm0, %%mm1 \n\t" // 3 2 3 2 1 0 1 0 +- "punpckldq %%mm0, %%mm0 \n\t" // 1 0 1 0 1 0 1 0 +- "punpckhdq %%mm1, %%mm1 \n\t" // 3 2 3 2 3 2 3 2 +- "movq %%mm0, (%%edi) \n\t" +- "subl $4, %%esi \n\t" +- "movq %%mm1, 8(%%edi) \n\t" +- "subl $16, %%edi \n\t" +- "subl $2, %%ecx \n\t" +- "jnz .loop2_pass2 \n\t" +- "EMMS \n\t" // DONE +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "1" (sptr), // esi // input regs +- "2" (dp), // edi +- "0" (width_mmx) // ecx +- +-#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm1" // clobber list +-#endif +- ); +- } +- +- sptr -= (width_mmx*2 - 2); // sign fixed +- dp -= (width_mmx*8 - 2); // sign fixed +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- sptr -= 2; +- png_memcpy(v, sptr, 2); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- dp -= 2; +- png_memcpy(dp, v, 2); +- } +- } +- } +- else if (width) // pass == 4 or 5 +- { +- int width_mmx = ((width >> 1) << 1) ; +- width -= width_mmx; // 0,1 pixels => 0,2 bytes +- if (width_mmx) +- { +- int dummy_value_c; // fix 'forbidden register spilled' +- int dummy_value_S; +- int dummy_value_D; +- +- __asm__ __volatile__ ( +- "subl $2, %%esi \n\t" +- "subl $6, %%edi \n\t" +- +- ".loop2_pass4: \n\t" +- "movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 +- "punpcklwd %%mm0, %%mm0 \n\t" // 3 2 3 2 1 0 1 0 +- "subl $4, %%esi \n\t" +- "movq %%mm0, (%%edi) \n\t" +- "subl $8, %%edi \n\t" +- "subl $2, %%ecx \n\t" +- "jnz .loop2_pass4 \n\t" +- "EMMS \n\t" // DONE +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "1" (sptr), // esi // input regs +- "2" (dp), // edi +- "0" (width_mmx) // ecx +- +-#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0" // clobber list +-#endif +- ); +- } +- +- sptr -= (width_mmx*2 - 2); // sign fixed +- dp -= (width_mmx*4 - 2); // sign fixed +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- sptr -= 2; +- png_memcpy(v, sptr, 2); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- dp -= 2; +- png_memcpy(dp, v, 2); +- } +- } +- } +- } /* end of pixel_bytes == 2 */ +- +- //-------------------------------------------------------------- +- else if (pixel_bytes == 4) +- { +- if (((pass == 0) || (pass == 1)) && width) +- { +- int width_mmx = ((width >> 1) << 1); +- width -= width_mmx; // 0,1 pixels => 0,4 bytes +- if (width_mmx) +- { +- int dummy_value_c; // fix 'forbidden register spilled' +- int dummy_value_S; +- int dummy_value_D; +- +- __asm__ __volatile__ ( +- "subl $4, %%esi \n\t" +- "subl $60, %%edi \n\t" +- +- ".loop4_pass0: \n\t" +- "movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 +- "movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 +- "punpckldq %%mm0, %%mm0 \n\t" // 3 2 1 0 3 2 1 0 +- "punpckhdq %%mm1, %%mm1 \n\t" // 7 6 5 4 7 6 5 4 +- "movq %%mm0, (%%edi) \n\t" +- "movq %%mm0, 8(%%edi) \n\t" +- "movq %%mm0, 16(%%edi) \n\t" +- "movq %%mm0, 24(%%edi) \n\t" +- "movq %%mm1, 32(%%edi) \n\t" +- "movq %%mm1, 40(%%edi) \n\t" +- "movq %%mm1, 48(%%edi) \n\t" +- "subl $8, %%esi \n\t" +- "movq %%mm1, 56(%%edi) \n\t" +- "subl $64, %%edi \n\t" +- "subl $2, %%ecx \n\t" +- "jnz .loop4_pass0 \n\t" +- "EMMS \n\t" // DONE +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "1" (sptr), // esi // input regs +- "2" (dp), // edi +- "0" (width_mmx) // ecx +- +-#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm1" // clobber list +-#endif +- ); +- } +- +- sptr -= (width_mmx*4 - 4); // sign fixed +- dp -= (width_mmx*32 - 4); // sign fixed +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- sptr -= 4; +- png_memcpy(v, sptr, 4); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- dp -= 4; +- png_memcpy(dp, v, 4); +- } +- } +- } +- else if (((pass == 2) || (pass == 3)) && width) +- { +- int width_mmx = ((width >> 1) << 1); +- width -= width_mmx; // 0,1 pixels => 0,4 bytes +- if (width_mmx) +- { +- int dummy_value_c; // fix 'forbidden register spilled' +- int dummy_value_S; +- int dummy_value_D; +- +- __asm__ __volatile__ ( +- "subl $4, %%esi \n\t" +- "subl $28, %%edi \n\t" +- +- ".loop4_pass2: \n\t" +- "movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 +- "movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 +- "punpckldq %%mm0, %%mm0 \n\t" // 3 2 1 0 3 2 1 0 +- "punpckhdq %%mm1, %%mm1 \n\t" // 7 6 5 4 7 6 5 4 +- "movq %%mm0, (%%edi) \n\t" +- "movq %%mm0, 8(%%edi) \n\t" +- "movq %%mm1, 16(%%edi) \n\t" +- "movq %%mm1, 24(%%edi) \n\t" +- "subl $8, %%esi \n\t" +- "subl $32, %%edi \n\t" +- "subl $2, %%ecx \n\t" +- "jnz .loop4_pass2 \n\t" +- "EMMS \n\t" // DONE +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "1" (sptr), // esi // input regs +- "2" (dp), // edi +- "0" (width_mmx) // ecx +- +-#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm1" // clobber list +-#endif +- ); +- } +- +- sptr -= (width_mmx*4 - 4); // sign fixed +- dp -= (width_mmx*16 - 4); // sign fixed +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- sptr -= 4; +- png_memcpy(v, sptr, 4); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- dp -= 4; +- png_memcpy(dp, v, 4); +- } +- } +- } +- else if (width) // pass == 4 or 5 +- { +- int width_mmx = ((width >> 1) << 1) ; +- width -= width_mmx; // 0,1 pixels => 0,4 bytes +- if (width_mmx) +- { +- int dummy_value_c; // fix 'forbidden register spilled' +- int dummy_value_S; +- int dummy_value_D; +- +- __asm__ __volatile__ ( +- "subl $4, %%esi \n\t" +- "subl $12, %%edi \n\t" +- +- ".loop4_pass4: \n\t" +- "movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 +- "movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 +- "punpckldq %%mm0, %%mm0 \n\t" // 3 2 1 0 3 2 1 0 +- "punpckhdq %%mm1, %%mm1 \n\t" // 7 6 5 4 7 6 5 4 +- "movq %%mm0, (%%edi) \n\t" +- "subl $8, %%esi \n\t" +- "movq %%mm1, 8(%%edi) \n\t" +- "subl $16, %%edi \n\t" +- "subl $2, %%ecx \n\t" +- "jnz .loop4_pass4 \n\t" +- "EMMS \n\t" // DONE +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "1" (sptr), // esi // input regs +- "2" (dp), // edi +- "0" (width_mmx) // ecx +- +-#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0", "%mm1" // clobber list +-#endif +- ); +- } +- +- sptr -= (width_mmx*4 - 4); // sign fixed +- dp -= (width_mmx*8 - 4); // sign fixed +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- sptr -= 4; +- png_memcpy(v, sptr, 4); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- dp -= 4; +- png_memcpy(dp, v, 4); +- } +- } +- } +- } /* end of pixel_bytes == 4 */ +- +- //-------------------------------------------------------------- +- else if (pixel_bytes == 8) +- { +-// GRR TEST: should work, but needs testing (special 64-bit version of rpng2?) +- // GRR NOTE: no need to combine passes here! +- if (((pass == 0) || (pass == 1)) && width) +- { +- int dummy_value_c; // fix 'forbidden register spilled' +- int dummy_value_S; +- int dummy_value_D; +- +- // source is 8-byte RRGGBBAA +- // dest is 64-byte RRGGBBAA RRGGBBAA RRGGBBAA RRGGBBAA ... +- __asm__ __volatile__ ( +- "subl $56, %%edi \n\t" // start of last block +- +- ".loop8_pass0: \n\t" +- "movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 +- "movq %%mm0, (%%edi) \n\t" +- "movq %%mm0, 8(%%edi) \n\t" +- "movq %%mm0, 16(%%edi) \n\t" +- "movq %%mm0, 24(%%edi) \n\t" +- "movq %%mm0, 32(%%edi) \n\t" +- "movq %%mm0, 40(%%edi) \n\t" +- "movq %%mm0, 48(%%edi) \n\t" +- "subl $8, %%esi \n\t" +- "movq %%mm0, 56(%%edi) \n\t" +- "subl $64, %%edi \n\t" +- "decl %%ecx \n\t" +- "jnz .loop8_pass0 \n\t" +- "EMMS \n\t" // DONE +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "1" (sptr), // esi // input regs +- "2" (dp), // edi +- "0" (width) // ecx +- +-#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0" // clobber list +-#endif +- ); +- } +- else if (((pass == 2) || (pass == 3)) && width) +- { +- // source is 8-byte RRGGBBAA +- // dest is 32-byte RRGGBBAA RRGGBBAA RRGGBBAA RRGGBBAA +- // (recall that expansion is _in place_: sptr and dp +- // both point at locations within same row buffer) +- { +- int dummy_value_c; // fix 'forbidden register spilled' +- int dummy_value_S; +- int dummy_value_D; +- +- __asm__ __volatile__ ( +- "subl $24, %%edi \n\t" // start of last block +- +- ".loop8_pass2: \n\t" +- "movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 +- "movq %%mm0, (%%edi) \n\t" +- "movq %%mm0, 8(%%edi) \n\t" +- "movq %%mm0, 16(%%edi) \n\t" +- "subl $8, %%esi \n\t" +- "movq %%mm0, 24(%%edi) \n\t" +- "subl $32, %%edi \n\t" +- "decl %%ecx \n\t" +- "jnz .loop8_pass2 \n\t" +- "EMMS \n\t" // DONE +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "1" (sptr), // esi // input regs +- "2" (dp), // edi +- "0" (width) // ecx +- +-#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0" // clobber list +-#endif +- ); +- } +- } +- else if (width) // pass == 4 or 5 +- { +- // source is 8-byte RRGGBBAA +- // dest is 16-byte RRGGBBAA RRGGBBAA +- { +- int dummy_value_c; // fix 'forbidden register spilled' +- int dummy_value_S; +- int dummy_value_D; +- +- __asm__ __volatile__ ( +- "subl $8, %%edi \n\t" // start of last block +- +- ".loop8_pass4: \n\t" +- "movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 +- "movq %%mm0, (%%edi) \n\t" +- "subl $8, %%esi \n\t" +- "movq %%mm0, 8(%%edi) \n\t" +- "subl $16, %%edi \n\t" +- "decl %%ecx \n\t" +- "jnz .loop8_pass4 \n\t" +- "EMMS \n\t" // DONE +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "1" (sptr), // esi // input regs +- "2" (dp), // edi +- "0" (width) // ecx +- +-#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- : "%mm0" // clobber list +-#endif +- ); +- } +- } +- +- } /* end of pixel_bytes == 8 */ +- +- //-------------------------------------------------------------- +- else if (pixel_bytes == 6) +- { +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- png_memcpy(v, sptr, 6); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, 6); +- dp -= 6; +- } +- sptr -= 6; +- } +- } /* end of pixel_bytes == 6 */ +- +- //-------------------------------------------------------------- +- else +- { +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- png_memcpy(v, sptr, pixel_bytes); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, pixel_bytes); +- dp -= pixel_bytes; +- } +- sptr-= pixel_bytes; +- } +- } +- } // end of _mmx_supported ======================================== +- +- else /* MMX not supported: use modified C code - takes advantage +- * of inlining of png_memcpy for a constant */ +- /* GRR 19991007: does it? or should pixel_bytes in each +- * block be replaced with immediate value (e.g., 1)? */ +- /* GRR 19991017: replaced with constants in each case */ +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ +- { +- if (pixel_bytes == 1) +- { +- for (i = width; i; i--) +- { +- int j; +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- *dp-- = *sptr; +- } +- --sptr; +- } +- } +- else if (pixel_bytes == 3) +- { +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- png_memcpy(v, sptr, 3); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, 3); +- dp -= 3; +- } +- sptr -= 3; +- } +- } +- else if (pixel_bytes == 2) +- { +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- png_memcpy(v, sptr, 2); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, 2); +- dp -= 2; +- } +- sptr -= 2; +- } +- } +- else if (pixel_bytes == 4) +- { +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- png_memcpy(v, sptr, 4); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +-#ifdef PNG_DEBUG +- if (dp < row || dp+3 > row+png_ptr->row_buf_size) +- { +- printf("dp out of bounds: row=%d, dp=%d, rp=%d\n", +- row, dp, row+png_ptr->row_buf_size); +- printf("row_buf=%d\n",png_ptr->row_buf_size); +- } +-#endif +- png_memcpy(dp, v, 4); +- dp -= 4; +- } +- sptr -= 4; +- } +- } +- else if (pixel_bytes == 6) +- { +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- png_memcpy(v, sptr, 6); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, 6); +- dp -= 6; +- } +- sptr -= 6; +- } +- } +- else if (pixel_bytes == 8) +- { +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- png_memcpy(v, sptr, 8); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, 8); +- dp -= 8; +- } +- sptr -= 8; +- } +- } +- else /* GRR: should never be reached */ +- { +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- png_memcpy(v, sptr, pixel_bytes); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, pixel_bytes); +- dp -= pixel_bytes; +- } +- sptr -= pixel_bytes; +- } +- } +- +- } /* end if (MMX not supported) */ +- break; +- } +- } /* end switch (row_info->pixel_depth) */ +- +- row_info->width = final_width; +- +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,final_width); +- } +- +-} /* end png_do_read_interlace() */ +- +-#endif /* PNG_HAVE_ASSEMBLER_READ_INTERLACE */ +-#endif /* PNG_READ_INTERLACING_SUPPORTED */ +- +- +- +-#if defined(PNG_HAVE_ASSEMBLER_READ_FILTER_ROW) +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +- +-// These variables are utilized in the functions below. They are declared +-// globally here to ensure alignment on 8-byte boundaries. +- +-union uAll { +- long long use; +- double align; +-} _LBCarryMask = {0x0101010101010101LL}, +- _HBClearMask = {0x7f7f7f7f7f7f7f7fLL}, +- _ActiveMask, _ActiveMask2, _ActiveMaskEnd, _ShiftBpp, _ShiftRem; +- +-#ifdef PNG_THREAD_UNSAFE_OK +-//===========================================================================// +-// // +-// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ A V G // +-// // +-//===========================================================================// +- +-// Optimized code for PNG Average filter decoder +- +-static void /* PRIVATE */ +-png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row, +- png_bytep prev_row) +-{ +- int bpp; +- int dummy_value_c; // fix 'forbidden register 2 (cx) was spilled' error +- int dummy_value_S; +- int dummy_value_D; +- +- bpp = (row_info->pixel_depth + 7) >> 3; // get # bytes per pixel +- _FullLength = row_info->rowbytes; // # of bytes to filter +- +- __asm__ __volatile__ ( +- // initialize address pointers and offset +-#ifdef __PIC__ +- "pushl %%ebx \n\t" // save index to Global Offset Table +-#endif +-//pre "movl row, %%edi \n\t" // edi: Avg(x) +- "xorl %%ebx, %%ebx \n\t" // ebx: x +- "movl %%edi, %%edx \n\t" +-//pre "movl prev_row, %%esi \n\t" // esi: Prior(x) +-//pre "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) +- "subl %%ecx, %%edx \n\t" // edx: Raw(x-bpp) +- +- "xorl %%eax,%%eax \n\t" +- +- // Compute the Raw value for the first bpp bytes +- // Raw(x) = Avg(x) + (Prior(x)/2) +- "avg_rlp: \n\t" +- "movb (%%esi,%%ebx,),%%al \n\t" // load al with Prior(x) +- "incl %%ebx \n\t" +- "shrb %%al \n\t" // divide by 2 +- "addb -1(%%edi,%%ebx,),%%al \n\t" // add Avg(x); -1 to offset inc ebx +-//pre "cmpl bpp, %%ebx \n\t" // (bpp is preloaded into ecx) +- "cmpl %%ecx, %%ebx \n\t" +- "movb %%al,-1(%%edi,%%ebx,) \n\t" // write Raw(x); -1 to offset inc ebx +- "jb avg_rlp \n\t" // mov does not affect flags +- +- // get # of bytes to alignment +- "movl %%edi, _dif \n\t" // take start of row +- "addl %%ebx, _dif \n\t" // add bpp +- "addl $0xf, _dif \n\t" // add 7+8 to incr past alignment bdry +- "andl $0xfffffff8, _dif \n\t" // mask to alignment boundary +- "subl %%edi, _dif \n\t" // subtract from start => value ebx at +- "jz avg_go \n\t" // alignment +- +- // fix alignment +- // Compute the Raw value for the bytes up to the alignment boundary +- // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) +- "xorl %%ecx, %%ecx \n\t" +- +- "avg_lp1: \n\t" +- "xorl %%eax, %%eax \n\t" +- "movb (%%esi,%%ebx,), %%cl \n\t" // load cl with Prior(x) +- "movb (%%edx,%%ebx,), %%al \n\t" // load al with Raw(x-bpp) +- "addw %%cx, %%ax \n\t" +- "incl %%ebx \n\t" +- "shrw %%ax \n\t" // divide by 2 +- "addb -1(%%edi,%%ebx,), %%al \n\t" // add Avg(x); -1 to offset inc ebx +- "cmpl _dif, %%ebx \n\t" // check if at alignment boundary +- "movb %%al, -1(%%edi,%%ebx,) \n\t" // write Raw(x); -1 to offset inc ebx +- "jb avg_lp1 \n\t" // repeat until at alignment boundary +- +- "avg_go: \n\t" +- "movl _FullLength, %%eax \n\t" +- "movl %%eax, %%ecx \n\t" +- "subl %%ebx, %%eax \n\t" // subtract alignment fix +- "andl $0x00000007, %%eax \n\t" // calc bytes over mult of 8 +- "subl %%eax, %%ecx \n\t" // drop over bytes from original length +- "movl %%ecx, _MMXLength \n\t" +-#ifdef __PIC__ +- "popl %%ebx \n\t" // restore index to Global Offset Table +-#endif +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "0" (bpp), // ecx // input regs +- "1" (prev_row), // esi +- "2" (row) // edi +- +- : "%eax", "%edx" // clobber list +-#ifndef __PIC__ +- , "%ebx" +-#endif +- // GRR: INCLUDE "memory" as clobbered? (_dif, _MMXLength) +- // (seems to work fine without...) +- ); +- +- // now do the math for the rest of the row +- switch (bpp) +- { +- case 3: +- { +- _ActiveMask.use = 0x0000000000ffffffLL; +- _ShiftBpp.use = 24; // == 3 * 8 +- _ShiftRem.use = 40; // == 64 - 24 +- +- __asm__ __volatile__ ( +- // re-init address pointers and offset +- "movq _ActiveMask, %%mm7 \n\t" +- "movl _dif, %%ecx \n\t" // ecx: x = offset to +- "movq _LBCarryMask, %%mm5 \n\t" // alignment boundary +-// preload "movl row, %%edi \n\t" // edi: Avg(x) +- "movq _HBClearMask, %%mm4 \n\t" +-// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) +- +- // prime the pump: load the first Raw(x-bpp) data set +- "movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes +- // (correct pos. in loop below) +- "avg_3lp: \n\t" +- "movq (%%edi,%%ecx,), %%mm0 \n\t" // load mm0 with Avg(x) +- "movq %%mm5, %%mm3 \n\t" +- "psrlq _ShiftRem, %%mm2 \n\t" // correct position Raw(x-bpp) +- // data +- "movq (%%esi,%%ecx,), %%mm1 \n\t" // load mm1 with Prior(x) +- "movq %%mm7, %%mm6 \n\t" +- "pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte +- "psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 +- "pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each +- // byte +- "paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for +- // each byte +- // add 1st active group (Raw(x-bpp)/2) to average with LBCarry +- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting +- // LBCarrys +- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte +- // where both +- // lsb's were == 1 (only valid for active group) +- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 +- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each +- // byte +- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) +- // for each byte +- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 1 +- // bytes to add to Avg +- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to +- // Avg for each Active +- // byte +- // add 2nd active group (Raw(x-bpp)/2) to average with _LBCarry +- "psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover +- // bytes 3-5 +- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 +- "psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly +- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting +- // LBCarrys +- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte +- // where both +- // lsb's were == 1 (only valid for active group) +- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 +- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each +- // byte +- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) +- // for each byte +- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 +- // bytes to add to Avg +- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to +- // Avg for each Active +- // byte +- +- // add 3rd active group (Raw(x-bpp)/2) to average with _LBCarry +- "psllq _ShiftBpp, %%mm6 \n\t" // shift mm6 mask to cover last +- // two +- // bytes +- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 +- "psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly +- // Data only needs to be shifted once here to +- // get the correct x-bpp offset. +- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting +- // LBCarrys +- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte +- // where both +- // lsb's were == 1 (only valid for active group) +- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 +- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each +- // byte +- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) +- // for each byte +- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 +- // bytes to add to Avg +- "addl $8, %%ecx \n\t" +- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to +- // Avg for each Active +- // byte +- // now ready to write back to memory +- "movq %%mm0, -8(%%edi,%%ecx,) \n\t" +- // move updated Raw(x) to use as Raw(x-bpp) for next loop +- "cmpl _MMXLength, %%ecx \n\t" +- "movq %%mm0, %%mm2 \n\t" // mov updated Raw(x) to mm2 +- "jb avg_3lp \n\t" +- +- : "=S" (dummy_value_S), // output regs (dummy) +- "=D" (dummy_value_D) +- +- : "0" (prev_row), // esi // input regs +- "1" (row) // edi +- +- : "%ecx" // clobber list +-#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- , "%mm0", "%mm1", "%mm2", "%mm3" +- , "%mm4", "%mm5", "%mm6", "%mm7" +-#endif +- ); +- } +- break; // end 3 bpp +- +- case 6: +- case 4: +- //case 7: // who wrote this? PNG doesn't support 5 or 7 bytes/pixel +- //case 5: // GRR BOGUS +- { +- _ActiveMask.use = 0xffffffffffffffffLL; // use shift below to clear +- // appropriate inactive bytes +- _ShiftBpp.use = bpp << 3; +- _ShiftRem.use = 64 - _ShiftBpp.use; +- +- __asm__ __volatile__ ( +- "movq _HBClearMask, %%mm4 \n\t" +- +- // re-init address pointers and offset +- "movl _dif, %%ecx \n\t" // ecx: x = offset to +- // alignment boundary +- +- // load _ActiveMask and clear all bytes except for 1st active group +- "movq _ActiveMask, %%mm7 \n\t" +-// preload "movl row, %%edi \n\t" // edi: Avg(x) +- "psrlq _ShiftRem, %%mm7 \n\t" +-// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) +- "movq %%mm7, %%mm6 \n\t" +- "movq _LBCarryMask, %%mm5 \n\t" +- "psllq _ShiftBpp, %%mm6 \n\t" // create mask for 2nd active +- // group +- +- // prime the pump: load the first Raw(x-bpp) data set +- "movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes +- // (we correct pos. in loop below) +- "avg_4lp: \n\t" +- "movq (%%edi,%%ecx,), %%mm0 \n\t" +- "psrlq _ShiftRem, %%mm2 \n\t" // shift data to pos. correctly +- "movq (%%esi,%%ecx,), %%mm1 \n\t" +- // add (Prev_row/2) to average +- "movq %%mm5, %%mm3 \n\t" +- "pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte +- "psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 +- "pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each +- // byte +- "paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for +- // each byte +- // add 1st active group (Raw(x-bpp)/2) to average with _LBCarry +- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting +- // LBCarrys +- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte +- // where both +- // lsb's were == 1 (only valid for active group) +- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 +- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each +- // byte +- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) +- // for each byte +- "pand %%mm7, %%mm2 \n\t" // leave only Active Group 1 +- // bytes to add to Avg +- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to Avg +- // for each Active +- // byte +- // add 2nd active group (Raw(x-bpp)/2) to average with _LBCarry +- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 +- "psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly +- "addl $8, %%ecx \n\t" +- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting +- // LBCarrys +- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte +- // where both +- // lsb's were == 1 (only valid for active group) +- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 +- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each +- // byte +- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) +- // for each byte +- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 +- // bytes to add to Avg +- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to +- // Avg for each Active +- // byte +- "cmpl _MMXLength, %%ecx \n\t" +- // now ready to write back to memory +- "movq %%mm0, -8(%%edi,%%ecx,) \n\t" +- // prep Raw(x-bpp) for next loop +- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 +- "jb avg_4lp \n\t" +- +- : "=S" (dummy_value_S), // output regs (dummy) +- "=D" (dummy_value_D) +- +- : "0" (prev_row), // esi // input regs +- "1" (row) // edi +- +- : "%ecx" // clobber list +-#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- , "%mm0", "%mm1", "%mm2", "%mm3" +- , "%mm4", "%mm5", "%mm6", "%mm7" +-#endif +- ); +- } +- break; // end 4,6 bpp +- +- case 2: +- { +- _ActiveMask.use = 0x000000000000ffffLL; +- _ShiftBpp.use = 16; // == 2 * 8 +- _ShiftRem.use = 48; // == 64 - 16 +- +- __asm__ __volatile__ ( +- // load _ActiveMask +- "movq _ActiveMask, %%mm7 \n\t" +- // re-init address pointers and offset +- "movl _dif, %%ecx \n\t" // ecx: x = offset to alignment +- // boundary +- "movq _LBCarryMask, %%mm5 \n\t" +-// preload "movl row, %%edi \n\t" // edi: Avg(x) +- "movq _HBClearMask, %%mm4 \n\t" +-// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) +- +- // prime the pump: load the first Raw(x-bpp) data set +- "movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes +- // (we correct pos. in loop below) +- "avg_2lp: \n\t" +- "movq (%%edi,%%ecx,), %%mm0 \n\t" +- "psrlq _ShiftRem, %%mm2 \n\t" // shift data to pos. correctly +- "movq (%%esi,%%ecx,), %%mm1 \n\t" // (GRR BUGFIX: was psllq) +- // add (Prev_row/2) to average +- "movq %%mm5, %%mm3 \n\t" +- "pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte +- "psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 +- "pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each +- // byte +- "movq %%mm7, %%mm6 \n\t" +- "paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for +- // each byte +- +- // add 1st active group (Raw(x-bpp)/2) to average with _LBCarry +- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting +- // LBCarrys +- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte +- // where both +- // lsb's were == 1 (only valid +- // for active group) +- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 +- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each +- // byte +- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) +- // for each byte +- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 1 +- // bytes to add to Avg +- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to Avg +- // for each Active byte +- +- // add 2nd active group (Raw(x-bpp)/2) to average with _LBCarry +- "psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover +- // bytes 2 & 3 +- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 +- "psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly +- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting +- // LBCarrys +- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte +- // where both +- // lsb's were == 1 (only valid +- // for active group) +- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 +- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each +- // byte +- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) +- // for each byte +- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 +- // bytes to add to Avg +- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to +- // Avg for each Active byte +- +- // add 3rd active group (Raw(x-bpp)/2) to average with _LBCarry +- "psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover +- // bytes 4 & 5 +- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 +- "psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly +- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting +- // LBCarrys +- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte +- // where both lsb's were == 1 +- // (only valid for active group) +- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 +- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each +- // byte +- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) +- // for each byte +- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 +- // bytes to add to Avg +- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to +- // Avg for each Active byte +- +- // add 4th active group (Raw(x-bpp)/2) to average with _LBCarry +- "psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover +- // bytes 6 & 7 +- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 +- "psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly +- "addl $8, %%ecx \n\t" +- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting +- // LBCarrys +- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte +- // where both +- // lsb's were == 1 (only valid +- // for active group) +- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 +- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each +- // byte +- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) +- // for each byte +- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 +- // bytes to add to Avg +- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to +- // Avg for each Active byte +- +- "cmpl _MMXLength, %%ecx \n\t" +- // now ready to write back to memory +- "movq %%mm0, -8(%%edi,%%ecx,) \n\t" +- // prep Raw(x-bpp) for next loop +- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 +- "jb avg_2lp \n\t" +- +- : "=S" (dummy_value_S), // output regs (dummy) +- "=D" (dummy_value_D) +- +- : "0" (prev_row), // esi // input regs +- "1" (row) // edi +- +- : "%ecx" // clobber list +-#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- , "%mm0", "%mm1", "%mm2", "%mm3" +- , "%mm4", "%mm5", "%mm6", "%mm7" +-#endif +- ); +- } +- break; // end 2 bpp +- +- case 1: +- { +- __asm__ __volatile__ ( +- // re-init address pointers and offset +-#ifdef __PIC__ +- "pushl %%ebx \n\t" // save Global Offset Table index +-#endif +- "movl _dif, %%ebx \n\t" // ebx: x = offset to alignment +- // boundary +-// preload "movl row, %%edi \n\t" // edi: Avg(x) +- "cmpl _FullLength, %%ebx \n\t" // test if offset at end of array +- "jnb avg_1end \n\t" +- // do Paeth decode for remaining bytes +-// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) +- "movl %%edi, %%edx \n\t" +-// preload "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) +- "subl %%ecx, %%edx \n\t" // edx: Raw(x-bpp) +- "xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx +- // in loop below +- "avg_1lp: \n\t" +- // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) +- "xorl %%eax, %%eax \n\t" +- "movb (%%esi,%%ebx,), %%cl \n\t" // load cl with Prior(x) +- "movb (%%edx,%%ebx,), %%al \n\t" // load al with Raw(x-bpp) +- "addw %%cx, %%ax \n\t" +- "incl %%ebx \n\t" +- "shrw %%ax \n\t" // divide by 2 +- "addb -1(%%edi,%%ebx,), %%al \n\t" // add Avg(x); -1 to offset +- // inc ebx +- "cmpl _FullLength, %%ebx \n\t" // check if at end of array +- "movb %%al, -1(%%edi,%%ebx,) \n\t" // write back Raw(x); +- // mov does not affect flags; -1 to offset inc ebx +- "jb avg_1lp \n\t" +- +- "avg_1end: \n\t" +-#ifdef __PIC__ +- "popl %%ebx \n\t" // Global Offset Table index +-#endif +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "0" (bpp), // ecx // input regs +- "1" (prev_row), // esi +- "2" (row) // edi +- +- : "%eax", "%edx" // clobber list +-#ifndef __PIC__ +- , "%ebx" +-#endif +- ); +- } +- return; // end 1 bpp +- +- case 8: +- { +- __asm__ __volatile__ ( +- // re-init address pointers and offset +- "movl _dif, %%ecx \n\t" // ecx: x == offset to alignment +- "movq _LBCarryMask, %%mm5 \n\t" // boundary +-// preload "movl row, %%edi \n\t" // edi: Avg(x) +- "movq _HBClearMask, %%mm4 \n\t" +-// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) +- +- // prime the pump: load the first Raw(x-bpp) data set +- "movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes +- // (NO NEED to correct pos. in loop below) +- +- "avg_8lp: \n\t" +- "movq (%%edi,%%ecx,), %%mm0 \n\t" +- "movq %%mm5, %%mm3 \n\t" +- "movq (%%esi,%%ecx,), %%mm1 \n\t" +- "addl $8, %%ecx \n\t" +- "pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte +- "psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 +- "pand %%mm2, %%mm3 \n\t" // get LBCarrys for each byte +- // where both lsb's were == 1 +- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 +- "pand %%mm4, %%mm1 \n\t" // clear invalid bit 7, each byte +- "paddb %%mm3, %%mm0 \n\t" // add LBCarrys to Avg, each byte +- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7, each byte +- "paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg, each +- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) to Avg for each +- "cmpl _MMXLength, %%ecx \n\t" +- "movq %%mm0, -8(%%edi,%%ecx,) \n\t" +- "movq %%mm0, %%mm2 \n\t" // reuse as Raw(x-bpp) +- "jb avg_8lp \n\t" +- +- : "=S" (dummy_value_S), // output regs (dummy) +- "=D" (dummy_value_D) +- +- : "0" (prev_row), // esi // input regs +- "1" (row) // edi +- +- : "%ecx" // clobber list +-#if 0 /* %mm0, ..., %mm5 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- , "%mm0", "%mm1", "%mm2" +- , "%mm3", "%mm4", "%mm5" +-#endif +- ); +- } +- break; // end 8 bpp +- +- default: // bpp greater than 8 (!= 1,2,3,4,[5],6,[7],8) +- { +- +-#ifdef PNG_DEBUG +- // GRR: PRINT ERROR HERE: SHOULD NEVER BE REACHED +- png_debug(1, +- "Internal logic error in pnggccrd (png_read_filter_row_mmx_avg())\n"); +-#endif +- +-#if 0 +- __asm__ __volatile__ ( +- "movq _LBCarryMask, %%mm5 \n\t" +- // re-init address pointers and offset +- "movl _dif, %%ebx \n\t" // ebx: x = offset to +- // alignment boundary +- "movl row, %%edi \n\t" // edi: Avg(x) +- "movq _HBClearMask, %%mm4 \n\t" +- "movl %%edi, %%edx \n\t" +- "movl prev_row, %%esi \n\t" // esi: Prior(x) +- "subl bpp, %%edx \n\t" // edx: Raw(x-bpp) +- "avg_Alp: \n\t" +- "movq (%%edi,%%ebx,), %%mm0 \n\t" +- "movq %%mm5, %%mm3 \n\t" +- "movq (%%esi,%%ebx,), %%mm1 \n\t" +- "pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte +- "movq (%%edx,%%ebx,), %%mm2 \n\t" +- "psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 +- "pand %%mm2, %%mm3 \n\t" // get LBCarrys for each byte +- // where both lsb's were == 1 +- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 +- "pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each +- // byte +- "paddb %%mm3, %%mm0 \n\t" // add LBCarrys to Avg for each +- // byte +- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each +- // byte +- "paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for +- // each byte +- "addl $8, %%ebx \n\t" +- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) to Avg for each +- // byte +- "cmpl _MMXLength, %%ebx \n\t" +- "movq %%mm0, -8(%%edi,%%ebx,) \n\t" +- "jb avg_Alp \n\t" +- +- : // FIXASM: output regs/vars go here, e.g.: "=m" (memory_var) +- +- : // FIXASM: input regs, e.g.: "c" (count), "S" (src), "D" (dest) +- +- : "%ebx", "%edx", "%edi", "%esi" // CHECKASM: clobber list +- ); +-#endif /* 0 - NEVER REACHED */ +- } +- break; +- +- } // end switch (bpp) +- +- __asm__ __volatile__ ( +- // MMX acceleration complete; now do clean-up +- // check if any remaining bytes left to decode +-#ifdef __PIC__ +- "pushl %%ebx \n\t" // save index to Global Offset Table +-#endif +- "movl _MMXLength, %%ebx \n\t" // ebx: x == offset bytes after MMX +-//pre "movl row, %%edi \n\t" // edi: Avg(x) +- "cmpl _FullLength, %%ebx \n\t" // test if offset at end of array +- "jnb avg_end \n\t" +- +- // do Avg decode for remaining bytes +-//pre "movl prev_row, %%esi \n\t" // esi: Prior(x) +- "movl %%edi, %%edx \n\t" +-//pre "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) +- "subl %%ecx, %%edx \n\t" // edx: Raw(x-bpp) +- "xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx below +- +- "avg_lp2: \n\t" +- // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) +- "xorl %%eax, %%eax \n\t" +- "movb (%%esi,%%ebx,), %%cl \n\t" // load cl with Prior(x) +- "movb (%%edx,%%ebx,), %%al \n\t" // load al with Raw(x-bpp) +- "addw %%cx, %%ax \n\t" +- "incl %%ebx \n\t" +- "shrw %%ax \n\t" // divide by 2 +- "addb -1(%%edi,%%ebx,), %%al \n\t" // add Avg(x); -1 to offset inc ebx +- "cmpl _FullLength, %%ebx \n\t" // check if at end of array +- "movb %%al, -1(%%edi,%%ebx,) \n\t" // write back Raw(x) [mov does not +- "jb avg_lp2 \n\t" // affect flags; -1 to offset inc ebx] +- +- "avg_end: \n\t" +- "EMMS \n\t" // end MMX; prep for poss. FP instrs. +-#ifdef __PIC__ +- "popl %%ebx \n\t" // restore index to Global Offset Table +-#endif +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "0" (bpp), // ecx // input regs +- "1" (prev_row), // esi +- "2" (row) // edi +- +- : "%eax", "%edx" // clobber list +-#ifndef __PIC__ +- , "%ebx" +-#endif +- ); +- +-} /* end png_read_filter_row_mmx_avg() */ +-#endif +- +- +- +-#ifdef PNG_THREAD_UNSAFE_OK +-//===========================================================================// +-// // +-// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ P A E T H // +-// // +-//===========================================================================// +- +-// Optimized code for PNG Paeth filter decoder +- +-static void /* PRIVATE */ +-png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row, +- png_bytep prev_row) +-{ +- int bpp; +- int dummy_value_c; // fix 'forbidden register 2 (cx) was spilled' error +- int dummy_value_S; +- int dummy_value_D; +- +- bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel +- _FullLength = row_info->rowbytes; // # of bytes to filter +- +- __asm__ __volatile__ ( +-#ifdef __PIC__ +- "pushl %%ebx \n\t" // save index to Global Offset Table +-#endif +- "xorl %%ebx, %%ebx \n\t" // ebx: x offset +-//pre "movl row, %%edi \n\t" +- "xorl %%edx, %%edx \n\t" // edx: x-bpp offset +-//pre "movl prev_row, %%esi \n\t" +- "xorl %%eax, %%eax \n\t" +- +- // Compute the Raw value for the first bpp bytes +- // Note: the formula works out to be always +- // Paeth(x) = Raw(x) + Prior(x) where x < bpp +- "paeth_rlp: \n\t" +- "movb (%%edi,%%ebx,), %%al \n\t" +- "addb (%%esi,%%ebx,), %%al \n\t" +- "incl %%ebx \n\t" +-//pre "cmpl bpp, %%ebx \n\t" (bpp is preloaded into ecx) +- "cmpl %%ecx, %%ebx \n\t" +- "movb %%al, -1(%%edi,%%ebx,) \n\t" +- "jb paeth_rlp \n\t" +- // get # of bytes to alignment +- "movl %%edi, _dif \n\t" // take start of row +- "addl %%ebx, _dif \n\t" // add bpp +- "xorl %%ecx, %%ecx \n\t" +- "addl $0xf, _dif \n\t" // add 7 + 8 to incr past alignment +- // boundary +- "andl $0xfffffff8, _dif \n\t" // mask to alignment boundary +- "subl %%edi, _dif \n\t" // subtract from start ==> value ebx +- // at alignment +- "jz paeth_go \n\t" +- // fix alignment +- +- "paeth_lp1: \n\t" +- "xorl %%eax, %%eax \n\t" +- // pav = p - a = (a + b - c) - a = b - c +- "movb (%%esi,%%ebx,), %%al \n\t" // load Prior(x) into al +- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl +- "subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) +- "movl %%eax, _patemp \n\t" // Save pav for later use +- "xorl %%eax, %%eax \n\t" +- // pbv = p - b = (a + b - c) - b = a - c +- "movb (%%edi,%%edx,), %%al \n\t" // load Raw(x-bpp) into al +- "subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) +- "movl %%eax, %%ecx \n\t" +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- "addl _patemp, %%eax \n\t" // pcv = pav + pbv +- // pc = abs(pcv) +- "testl $0x80000000, %%eax \n\t" +- "jz paeth_pca \n\t" +- "negl %%eax \n\t" // reverse sign of neg values +- +- "paeth_pca: \n\t" +- "movl %%eax, _pctemp \n\t" // save pc for later use +- // pb = abs(pbv) +- "testl $0x80000000, %%ecx \n\t" +- "jz paeth_pba \n\t" +- "negl %%ecx \n\t" // reverse sign of neg values +- +- "paeth_pba: \n\t" +- "movl %%ecx, _pbtemp \n\t" // save pb for later use +- // pa = abs(pav) +- "movl _patemp, %%eax \n\t" +- "testl $0x80000000, %%eax \n\t" +- "jz paeth_paa \n\t" +- "negl %%eax \n\t" // reverse sign of neg values +- +- "paeth_paa: \n\t" +- "movl %%eax, _patemp \n\t" // save pa for later use +- // test if pa <= pb +- "cmpl %%ecx, %%eax \n\t" +- "jna paeth_abb \n\t" +- // pa > pb; now test if pb <= pc +- "cmpl _pctemp, %%ecx \n\t" +- "jna paeth_bbc \n\t" +- // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) +- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl +- "jmp paeth_paeth \n\t" +- +- "paeth_bbc: \n\t" +- // pb <= pc; Raw(x) = Paeth(x) + Prior(x) +- "movb (%%esi,%%ebx,), %%cl \n\t" // load Prior(x) into cl +- "jmp paeth_paeth \n\t" +- +- "paeth_abb: \n\t" +- // pa <= pb; now test if pa <= pc +- "cmpl _pctemp, %%eax \n\t" +- "jna paeth_abc \n\t" +- // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) +- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl +- "jmp paeth_paeth \n\t" +- +- "paeth_abc: \n\t" +- // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) +- "movb (%%edi,%%edx,), %%cl \n\t" // load Raw(x-bpp) into cl +- +- "paeth_paeth: \n\t" +- "incl %%ebx \n\t" +- "incl %%edx \n\t" +- // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 +- "addb %%cl, -1(%%edi,%%ebx,) \n\t" +- "cmpl _dif, %%ebx \n\t" +- "jb paeth_lp1 \n\t" +- +- "paeth_go: \n\t" +- "movl _FullLength, %%ecx \n\t" +- "movl %%ecx, %%eax \n\t" +- "subl %%ebx, %%eax \n\t" // subtract alignment fix +- "andl $0x00000007, %%eax \n\t" // calc bytes over mult of 8 +- "subl %%eax, %%ecx \n\t" // drop over bytes from original length +- "movl %%ecx, _MMXLength \n\t" +-#ifdef __PIC__ +- "popl %%ebx \n\t" // restore index to Global Offset Table +-#endif +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "0" (bpp), // ecx // input regs +- "1" (prev_row), // esi +- "2" (row) // edi +- +- : "%eax", "%edx" // clobber list +-#ifndef __PIC__ +- , "%ebx" +-#endif +- ); +- +- // now do the math for the rest of the row +- switch (bpp) +- { +- case 3: +- { +- _ActiveMask.use = 0x0000000000ffffffLL; +- _ActiveMaskEnd.use = 0xffff000000000000LL; +- _ShiftBpp.use = 24; // == bpp(3) * 8 +- _ShiftRem.use = 40; // == 64 - 24 +- +- __asm__ __volatile__ ( +- "movl _dif, %%ecx \n\t" +-// preload "movl row, %%edi \n\t" +-// preload "movl prev_row, %%esi \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- // prime the pump: load the first Raw(x-bpp) data set +- "movq -8(%%edi,%%ecx,), %%mm1 \n\t" +- "paeth_3lp: \n\t" +- "psrlq _ShiftRem, %%mm1 \n\t" // shift last 3 bytes to 1st +- // 3 bytes +- "movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) +- "punpcklbw %%mm0, %%mm1 \n\t" // unpack High bytes of a +- "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // prep c=Prior(x-bpp) bytes +- "punpcklbw %%mm0, %%mm2 \n\t" // unpack High bytes of b +- "psrlq _ShiftRem, %%mm3 \n\t" // shift last 3 bytes to 1st +- // 3 bytes +- // pav = p - a = (a + b - c) - a = b - c +- "movq %%mm2, %%mm4 \n\t" +- "punpcklbw %%mm0, %%mm3 \n\t" // unpack High bytes of c +- // pbv = p - b = (a + b - c) - b = a - c +- "movq %%mm1, %%mm5 \n\t" +- "psubw %%mm3, %%mm4 \n\t" +- "pxor %%mm7, %%mm7 \n\t" +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- "movq %%mm4, %%mm6 \n\t" +- "psubw %%mm3, %%mm5 \n\t" +- +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 +- "paddw %%mm5, %%mm6 \n\t" +- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 +- "psubw %%mm0, %%mm4 \n\t" +- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 +- "psubw %%mm0, %%mm4 \n\t" +- "psubw %%mm7, %%mm5 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 +- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "psubw %%mm7, %%mm5 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- // test pa <= pb +- "movq %%mm4, %%mm7 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? +- "movq %%mm7, %%mm0 \n\t" +- // use mm7 mask to merge pa & pb +- "pand %%mm7, %%mm5 \n\t" +- // use mm0 mask copy to merge a & b +- "pand %%mm0, %%mm2 \n\t" +- "pandn %%mm4, %%mm7 \n\t" +- "pandn %%mm1, %%mm0 \n\t" +- "paddw %%mm5, %%mm7 \n\t" +- "paddw %%mm2, %%mm0 \n\t" +- // test ((pa <= pb)? pa:pb) <= pc +- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? +- "pxor %%mm1, %%mm1 \n\t" +- "pand %%mm7, %%mm3 \n\t" +- "pandn %%mm0, %%mm7 \n\t" +- "paddw %%mm3, %%mm7 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- "packuswb %%mm1, %%mm7 \n\t" +- "movq (%%esi,%%ecx,), %%mm3 \n\t" // load c=Prior(x-bpp) +- "pand _ActiveMask, %%mm7 \n\t" +- "movq %%mm3, %%mm2 \n\t" // load b=Prior(x) step 1 +- "paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) +- "punpcklbw %%mm0, %%mm3 \n\t" // unpack High bytes of c +- "movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value +- "movq %%mm7, %%mm1 \n\t" // now mm1 will be used as +- // Raw(x-bpp) +- // now do Paeth for 2nd set of bytes (3-5) +- "psrlq _ShiftBpp, %%mm2 \n\t" // load b=Prior(x) step 2 +- "punpcklbw %%mm0, %%mm1 \n\t" // unpack High bytes of a +- "pxor %%mm7, %%mm7 \n\t" +- "punpcklbw %%mm0, %%mm2 \n\t" // unpack High bytes of b +- // pbv = p - b = (a + b - c) - b = a - c +- "movq %%mm1, %%mm5 \n\t" +- // pav = p - a = (a + b - c) - a = b - c +- "movq %%mm2, %%mm4 \n\t" +- "psubw %%mm3, %%mm5 \n\t" +- "psubw %%mm3, %%mm4 \n\t" +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = +- // pav + pbv = pbv + pav +- "movq %%mm5, %%mm6 \n\t" +- "paddw %%mm4, %%mm6 \n\t" +- +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- "pcmpgtw %%mm5, %%mm0 \n\t" // create mask pbv bytes < 0 +- "pcmpgtw %%mm4, %%mm7 \n\t" // create mask pav bytes < 0 +- "pand %%mm5, %%mm0 \n\t" // only pbv bytes < 0 in mm0 +- "pand %%mm4, %%mm7 \n\t" // only pav bytes < 0 in mm7 +- "psubw %%mm0, %%mm5 \n\t" +- "psubw %%mm7, %%mm4 \n\t" +- "psubw %%mm0, %%mm5 \n\t" +- "psubw %%mm7, %%mm4 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 +- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "psubw %%mm0, %%mm6 \n\t" +- // test pa <= pb +- "movq %%mm4, %%mm7 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? +- "movq %%mm7, %%mm0 \n\t" +- // use mm7 mask to merge pa & pb +- "pand %%mm7, %%mm5 \n\t" +- // use mm0 mask copy to merge a & b +- "pand %%mm0, %%mm2 \n\t" +- "pandn %%mm4, %%mm7 \n\t" +- "pandn %%mm1, %%mm0 \n\t" +- "paddw %%mm5, %%mm7 \n\t" +- "paddw %%mm2, %%mm0 \n\t" +- // test ((pa <= pb)? pa:pb) <= pc +- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? +- "movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) +- "pand %%mm7, %%mm3 \n\t" +- "pandn %%mm0, %%mm7 \n\t" +- "pxor %%mm1, %%mm1 \n\t" +- "paddw %%mm3, %%mm7 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- "packuswb %%mm1, %%mm7 \n\t" +- "movq %%mm2, %%mm3 \n\t" // load c=Prior(x-bpp) step 1 +- "pand _ActiveMask, %%mm7 \n\t" +- "punpckhbw %%mm0, %%mm2 \n\t" // unpack High bytes of b +- "psllq _ShiftBpp, %%mm7 \n\t" // shift bytes to 2nd group of +- // 3 bytes +- // pav = p - a = (a + b - c) - a = b - c +- "movq %%mm2, %%mm4 \n\t" +- "paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) +- "psllq _ShiftBpp, %%mm3 \n\t" // load c=Prior(x-bpp) step 2 +- "movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value +- "movq %%mm7, %%mm1 \n\t" +- "punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c +- "psllq _ShiftBpp, %%mm1 \n\t" // shift bytes +- // now mm1 will be used as Raw(x-bpp) +- // now do Paeth for 3rd, and final, set of bytes (6-7) +- "pxor %%mm7, %%mm7 \n\t" +- "punpckhbw %%mm0, %%mm1 \n\t" // unpack High bytes of a +- "psubw %%mm3, %%mm4 \n\t" +- // pbv = p - b = (a + b - c) - b = a - c +- "movq %%mm1, %%mm5 \n\t" +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- "movq %%mm4, %%mm6 \n\t" +- "psubw %%mm3, %%mm5 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- "paddw %%mm5, %%mm6 \n\t" +- +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 +- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 +- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 +- "psubw %%mm0, %%mm4 \n\t" +- "psubw %%mm7, %%mm5 \n\t" +- "psubw %%mm0, %%mm4 \n\t" +- "psubw %%mm7, %%mm5 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 +- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "psubw %%mm0, %%mm6 \n\t" +- // test pa <= pb +- "movq %%mm4, %%mm7 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? +- "movq %%mm7, %%mm0 \n\t" +- // use mm0 mask copy to merge a & b +- "pand %%mm0, %%mm2 \n\t" +- // use mm7 mask to merge pa & pb +- "pand %%mm7, %%mm5 \n\t" +- "pandn %%mm1, %%mm0 \n\t" +- "pandn %%mm4, %%mm7 \n\t" +- "paddw %%mm2, %%mm0 \n\t" +- "paddw %%mm5, %%mm7 \n\t" +- // test ((pa <= pb)? pa:pb) <= pc +- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? +- "pand %%mm7, %%mm3 \n\t" +- "pandn %%mm0, %%mm7 \n\t" +- "paddw %%mm3, %%mm7 \n\t" +- "pxor %%mm1, %%mm1 \n\t" +- "packuswb %%mm7, %%mm1 \n\t" +- // step ecx to next set of 8 bytes and repeat loop til done +- "addl $8, %%ecx \n\t" +- "pand _ActiveMaskEnd, %%mm1 \n\t" +- "paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add Paeth predictor with +- // Raw(x) +- +- "cmpl _MMXLength, %%ecx \n\t" +- "pxor %%mm0, %%mm0 \n\t" // pxor does not affect flags +- "movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value +- // mm1 will be used as Raw(x-bpp) next loop +- // mm3 ready to be used as Prior(x-bpp) next loop +- "jb paeth_3lp \n\t" +- +- : "=S" (dummy_value_S), // output regs (dummy) +- "=D" (dummy_value_D) +- +- : "0" (prev_row), // esi // input regs +- "1" (row) // edi +- +- : "%ecx" // clobber list +-#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- , "%mm0", "%mm1", "%mm2", "%mm3" +- , "%mm4", "%mm5", "%mm6", "%mm7" +-#endif +- ); +- } +- break; // end 3 bpp +- +- case 6: +- //case 7: // GRR BOGUS +- //case 5: // GRR BOGUS +- { +- _ActiveMask.use = 0x00000000ffffffffLL; +- _ActiveMask2.use = 0xffffffff00000000LL; +- _ShiftBpp.use = bpp << 3; // == bpp * 8 +- _ShiftRem.use = 64 - _ShiftBpp.use; +- +- __asm__ __volatile__ ( +- "movl _dif, %%ecx \n\t" +-// preload "movl row, %%edi \n\t" +-// preload "movl prev_row, %%esi \n\t" +- // prime the pump: load the first Raw(x-bpp) data set +- "movq -8(%%edi,%%ecx,), %%mm1 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- +- "paeth_6lp: \n\t" +- // must shift to position Raw(x-bpp) data +- "psrlq _ShiftRem, %%mm1 \n\t" +- // do first set of 4 bytes +- "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes +- "punpcklbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a +- "movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) +- "punpcklbw %%mm0, %%mm2 \n\t" // unpack Low bytes of b +- // must shift to position Prior(x-bpp) data +- "psrlq _ShiftRem, %%mm3 \n\t" +- // pav = p - a = (a + b - c) - a = b - c +- "movq %%mm2, %%mm4 \n\t" +- "punpcklbw %%mm0, %%mm3 \n\t" // unpack Low bytes of c +- // pbv = p - b = (a + b - c) - b = a - c +- "movq %%mm1, %%mm5 \n\t" +- "psubw %%mm3, %%mm4 \n\t" +- "pxor %%mm7, %%mm7 \n\t" +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- "movq %%mm4, %%mm6 \n\t" +- "psubw %%mm3, %%mm5 \n\t" +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 +- "paddw %%mm5, %%mm6 \n\t" +- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 +- "psubw %%mm0, %%mm4 \n\t" +- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 +- "psubw %%mm0, %%mm4 \n\t" +- "psubw %%mm7, %%mm5 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 +- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "psubw %%mm7, %%mm5 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- // test pa <= pb +- "movq %%mm4, %%mm7 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? +- "movq %%mm7, %%mm0 \n\t" +- // use mm7 mask to merge pa & pb +- "pand %%mm7, %%mm5 \n\t" +- // use mm0 mask copy to merge a & b +- "pand %%mm0, %%mm2 \n\t" +- "pandn %%mm4, %%mm7 \n\t" +- "pandn %%mm1, %%mm0 \n\t" +- "paddw %%mm5, %%mm7 \n\t" +- "paddw %%mm2, %%mm0 \n\t" +- // test ((pa <= pb)? pa:pb) <= pc +- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? +- "pxor %%mm1, %%mm1 \n\t" +- "pand %%mm7, %%mm3 \n\t" +- "pandn %%mm0, %%mm7 \n\t" +- "paddw %%mm3, %%mm7 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- "packuswb %%mm1, %%mm7 \n\t" +- "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // load c=Prior(x-bpp) +- "pand _ActiveMask, %%mm7 \n\t" +- "psrlq _ShiftRem, %%mm3 \n\t" +- "movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) step 1 +- "paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor and Raw(x) +- "movq %%mm2, %%mm6 \n\t" +- "movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value +- "movq -8(%%edi,%%ecx,), %%mm1 \n\t" +- "psllq _ShiftBpp, %%mm6 \n\t" +- "movq %%mm7, %%mm5 \n\t" +- "psrlq _ShiftRem, %%mm1 \n\t" +- "por %%mm6, %%mm3 \n\t" +- "psllq _ShiftBpp, %%mm5 \n\t" +- "punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c +- "por %%mm5, %%mm1 \n\t" +- // do second set of 4 bytes +- "punpckhbw %%mm0, %%mm2 \n\t" // unpack High bytes of b +- "punpckhbw %%mm0, %%mm1 \n\t" // unpack High bytes of a +- // pav = p - a = (a + b - c) - a = b - c +- "movq %%mm2, %%mm4 \n\t" +- // pbv = p - b = (a + b - c) - b = a - c +- "movq %%mm1, %%mm5 \n\t" +- "psubw %%mm3, %%mm4 \n\t" +- "pxor %%mm7, %%mm7 \n\t" +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- "movq %%mm4, %%mm6 \n\t" +- "psubw %%mm3, %%mm5 \n\t" +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 +- "paddw %%mm5, %%mm6 \n\t" +- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 +- "psubw %%mm0, %%mm4 \n\t" +- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 +- "psubw %%mm0, %%mm4 \n\t" +- "psubw %%mm7, %%mm5 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 +- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "psubw %%mm7, %%mm5 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- // test pa <= pb +- "movq %%mm4, %%mm7 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? +- "movq %%mm7, %%mm0 \n\t" +- // use mm7 mask to merge pa & pb +- "pand %%mm7, %%mm5 \n\t" +- // use mm0 mask copy to merge a & b +- "pand %%mm0, %%mm2 \n\t" +- "pandn %%mm4, %%mm7 \n\t" +- "pandn %%mm1, %%mm0 \n\t" +- "paddw %%mm5, %%mm7 \n\t" +- "paddw %%mm2, %%mm0 \n\t" +- // test ((pa <= pb)? pa:pb) <= pc +- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? +- "pxor %%mm1, %%mm1 \n\t" +- "pand %%mm7, %%mm3 \n\t" +- "pandn %%mm0, %%mm7 \n\t" +- "pxor %%mm1, %%mm1 \n\t" +- "paddw %%mm3, %%mm7 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- // step ecx to next set of 8 bytes and repeat loop til done +- "addl $8, %%ecx \n\t" +- "packuswb %%mm7, %%mm1 \n\t" +- "paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add Paeth predictor with Raw(x) +- "cmpl _MMXLength, %%ecx \n\t" +- "movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value +- // mm1 will be used as Raw(x-bpp) next loop +- "jb paeth_6lp \n\t" +- +- : "=S" (dummy_value_S), // output regs (dummy) +- "=D" (dummy_value_D) +- +- : "0" (prev_row), // esi // input regs +- "1" (row) // edi +- +- : "%ecx" // clobber list +-#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- , "%mm0", "%mm1", "%mm2", "%mm3" +- , "%mm4", "%mm5", "%mm6", "%mm7" +-#endif +- ); +- } +- break; // end 6 bpp +- +- case 4: +- { +- _ActiveMask.use = 0x00000000ffffffffLL; +- +- __asm__ __volatile__ ( +- "movl _dif, %%ecx \n\t" +-// preload "movl row, %%edi \n\t" +-// preload "movl prev_row, %%esi \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- // prime the pump: load the first Raw(x-bpp) data set +- "movq -8(%%edi,%%ecx,), %%mm1 \n\t" // only time should need to read +- // a=Raw(x-bpp) bytes +- "paeth_4lp: \n\t" +- // do first set of 4 bytes +- "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes +- "punpckhbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a +- "movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) +- "punpcklbw %%mm0, %%mm2 \n\t" // unpack High bytes of b +- // pav = p - a = (a + b - c) - a = b - c +- "movq %%mm2, %%mm4 \n\t" +- "punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c +- // pbv = p - b = (a + b - c) - b = a - c +- "movq %%mm1, %%mm5 \n\t" +- "psubw %%mm3, %%mm4 \n\t" +- "pxor %%mm7, %%mm7 \n\t" +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- "movq %%mm4, %%mm6 \n\t" +- "psubw %%mm3, %%mm5 \n\t" +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 +- "paddw %%mm5, %%mm6 \n\t" +- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 +- "psubw %%mm0, %%mm4 \n\t" +- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 +- "psubw %%mm0, %%mm4 \n\t" +- "psubw %%mm7, %%mm5 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 +- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "psubw %%mm7, %%mm5 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- // test pa <= pb +- "movq %%mm4, %%mm7 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? +- "movq %%mm7, %%mm0 \n\t" +- // use mm7 mask to merge pa & pb +- "pand %%mm7, %%mm5 \n\t" +- // use mm0 mask copy to merge a & b +- "pand %%mm0, %%mm2 \n\t" +- "pandn %%mm4, %%mm7 \n\t" +- "pandn %%mm1, %%mm0 \n\t" +- "paddw %%mm5, %%mm7 \n\t" +- "paddw %%mm2, %%mm0 \n\t" +- // test ((pa <= pb)? pa:pb) <= pc +- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? +- "pxor %%mm1, %%mm1 \n\t" +- "pand %%mm7, %%mm3 \n\t" +- "pandn %%mm0, %%mm7 \n\t" +- "paddw %%mm3, %%mm7 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- "packuswb %%mm1, %%mm7 \n\t" +- "movq (%%esi,%%ecx,), %%mm3 \n\t" // load c=Prior(x-bpp) +- "pand _ActiveMask, %%mm7 \n\t" +- "movq %%mm3, %%mm2 \n\t" // load b=Prior(x) step 1 +- "paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) +- "punpcklbw %%mm0, %%mm3 \n\t" // unpack High bytes of c +- "movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value +- "movq %%mm7, %%mm1 \n\t" // now mm1 will be used as Raw(x-bpp) +- // do second set of 4 bytes +- "punpckhbw %%mm0, %%mm2 \n\t" // unpack Low bytes of b +- "punpcklbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a +- // pav = p - a = (a + b - c) - a = b - c +- "movq %%mm2, %%mm4 \n\t" +- // pbv = p - b = (a + b - c) - b = a - c +- "movq %%mm1, %%mm5 \n\t" +- "psubw %%mm3, %%mm4 \n\t" +- "pxor %%mm7, %%mm7 \n\t" +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- "movq %%mm4, %%mm6 \n\t" +- "psubw %%mm3, %%mm5 \n\t" +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 +- "paddw %%mm5, %%mm6 \n\t" +- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 +- "psubw %%mm0, %%mm4 \n\t" +- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 +- "psubw %%mm0, %%mm4 \n\t" +- "psubw %%mm7, %%mm5 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 +- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "psubw %%mm7, %%mm5 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- // test pa <= pb +- "movq %%mm4, %%mm7 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? +- "movq %%mm7, %%mm0 \n\t" +- // use mm7 mask to merge pa & pb +- "pand %%mm7, %%mm5 \n\t" +- // use mm0 mask copy to merge a & b +- "pand %%mm0, %%mm2 \n\t" +- "pandn %%mm4, %%mm7 \n\t" +- "pandn %%mm1, %%mm0 \n\t" +- "paddw %%mm5, %%mm7 \n\t" +- "paddw %%mm2, %%mm0 \n\t" +- // test ((pa <= pb)? pa:pb) <= pc +- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? +- "pxor %%mm1, %%mm1 \n\t" +- "pand %%mm7, %%mm3 \n\t" +- "pandn %%mm0, %%mm7 \n\t" +- "pxor %%mm1, %%mm1 \n\t" +- "paddw %%mm3, %%mm7 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- // step ecx to next set of 8 bytes and repeat loop til done +- "addl $8, %%ecx \n\t" +- "packuswb %%mm7, %%mm1 \n\t" +- "paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add predictor with Raw(x) +- "cmpl _MMXLength, %%ecx \n\t" +- "movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value +- // mm1 will be used as Raw(x-bpp) next loop +- "jb paeth_4lp \n\t" +- +- : "=S" (dummy_value_S), // output regs (dummy) +- "=D" (dummy_value_D) +- +- : "0" (prev_row), // esi // input regs +- "1" (row) // edi +- +- : "%ecx" // clobber list +-#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- , "%mm0", "%mm1", "%mm2", "%mm3" +- , "%mm4", "%mm5", "%mm6", "%mm7" +-#endif +- ); +- } +- break; // end 4 bpp +- +- case 8: // bpp == 8 +- { +- _ActiveMask.use = 0x00000000ffffffffLL; +- +- __asm__ __volatile__ ( +- "movl _dif, %%ecx \n\t" +-// preload "movl row, %%edi \n\t" +-// preload "movl prev_row, %%esi \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- // prime the pump: load the first Raw(x-bpp) data set +- "movq -8(%%edi,%%ecx,), %%mm1 \n\t" // only time should need to read +- // a=Raw(x-bpp) bytes +- "paeth_8lp: \n\t" +- // do first set of 4 bytes +- "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes +- "punpcklbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a +- "movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) +- "punpcklbw %%mm0, %%mm2 \n\t" // unpack Low bytes of b +- // pav = p - a = (a + b - c) - a = b - c +- "movq %%mm2, %%mm4 \n\t" +- "punpcklbw %%mm0, %%mm3 \n\t" // unpack Low bytes of c +- // pbv = p - b = (a + b - c) - b = a - c +- "movq %%mm1, %%mm5 \n\t" +- "psubw %%mm3, %%mm4 \n\t" +- "pxor %%mm7, %%mm7 \n\t" +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- "movq %%mm4, %%mm6 \n\t" +- "psubw %%mm3, %%mm5 \n\t" +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 +- "paddw %%mm5, %%mm6 \n\t" +- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 +- "psubw %%mm0, %%mm4 \n\t" +- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 +- "psubw %%mm0, %%mm4 \n\t" +- "psubw %%mm7, %%mm5 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 +- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "psubw %%mm7, %%mm5 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- // test pa <= pb +- "movq %%mm4, %%mm7 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? +- "movq %%mm7, %%mm0 \n\t" +- // use mm7 mask to merge pa & pb +- "pand %%mm7, %%mm5 \n\t" +- // use mm0 mask copy to merge a & b +- "pand %%mm0, %%mm2 \n\t" +- "pandn %%mm4, %%mm7 \n\t" +- "pandn %%mm1, %%mm0 \n\t" +- "paddw %%mm5, %%mm7 \n\t" +- "paddw %%mm2, %%mm0 \n\t" +- // test ((pa <= pb)? pa:pb) <= pc +- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? +- "pxor %%mm1, %%mm1 \n\t" +- "pand %%mm7, %%mm3 \n\t" +- "pandn %%mm0, %%mm7 \n\t" +- "paddw %%mm3, %%mm7 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- "packuswb %%mm1, %%mm7 \n\t" +- "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes +- "pand _ActiveMask, %%mm7 \n\t" +- "movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) +- "paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) +- "punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c +- "movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value +- "movq -8(%%edi,%%ecx,), %%mm1 \n\t" // read a=Raw(x-bpp) bytes +- +- // do second set of 4 bytes +- "punpckhbw %%mm0, %%mm2 \n\t" // unpack High bytes of b +- "punpckhbw %%mm0, %%mm1 \n\t" // unpack High bytes of a +- // pav = p - a = (a + b - c) - a = b - c +- "movq %%mm2, %%mm4 \n\t" +- // pbv = p - b = (a + b - c) - b = a - c +- "movq %%mm1, %%mm5 \n\t" +- "psubw %%mm3, %%mm4 \n\t" +- "pxor %%mm7, %%mm7 \n\t" +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- "movq %%mm4, %%mm6 \n\t" +- "psubw %%mm3, %%mm5 \n\t" +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 +- "paddw %%mm5, %%mm6 \n\t" +- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 +- "psubw %%mm0, %%mm4 \n\t" +- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 +- "psubw %%mm0, %%mm4 \n\t" +- "psubw %%mm7, %%mm5 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 +- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 +- "psubw %%mm7, %%mm5 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- // test pa <= pb +- "movq %%mm4, %%mm7 \n\t" +- "psubw %%mm0, %%mm6 \n\t" +- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? +- "movq %%mm7, %%mm0 \n\t" +- // use mm7 mask to merge pa & pb +- "pand %%mm7, %%mm5 \n\t" +- // use mm0 mask copy to merge a & b +- "pand %%mm0, %%mm2 \n\t" +- "pandn %%mm4, %%mm7 \n\t" +- "pandn %%mm1, %%mm0 \n\t" +- "paddw %%mm5, %%mm7 \n\t" +- "paddw %%mm2, %%mm0 \n\t" +- // test ((pa <= pb)? pa:pb) <= pc +- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? +- "pxor %%mm1, %%mm1 \n\t" +- "pand %%mm7, %%mm3 \n\t" +- "pandn %%mm0, %%mm7 \n\t" +- "pxor %%mm1, %%mm1 \n\t" +- "paddw %%mm3, %%mm7 \n\t" +- "pxor %%mm0, %%mm0 \n\t" +- // step ecx to next set of 8 bytes and repeat loop til done +- "addl $8, %%ecx \n\t" +- "packuswb %%mm7, %%mm1 \n\t" +- "paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add Paeth predictor with Raw(x) +- "cmpl _MMXLength, %%ecx \n\t" +- "movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value +- // mm1 will be used as Raw(x-bpp) next loop +- "jb paeth_8lp \n\t" +- +- : "=S" (dummy_value_S), // output regs (dummy) +- "=D" (dummy_value_D) +- +- : "0" (prev_row), // esi // input regs +- "1" (row) // edi +- +- : "%ecx" // clobber list +-#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ +- , "%mm0", "%mm1", "%mm2", "%mm3" +- , "%mm4", "%mm5", "%mm6", "%mm7" +-#endif +- ); +- } +- break; // end 8 bpp +- +- case 1: // bpp = 1 +- case 2: // bpp = 2 +- default: // bpp > 8 +- { +- __asm__ __volatile__ ( +-#ifdef __PIC__ +- "pushl %%ebx \n\t" // save Global Offset Table index +-#endif +- "movl _dif, %%ebx \n\t" +- "cmpl _FullLength, %%ebx \n\t" +- "jnb paeth_dend \n\t" +- +-// preload "movl row, %%edi \n\t" +-// preload "movl prev_row, %%esi \n\t" +- // do Paeth decode for remaining bytes +- "movl %%ebx, %%edx \n\t" +-// preload "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) +- "subl %%ecx, %%edx \n\t" // edx = ebx - bpp +- "xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx +- +- "paeth_dlp: \n\t" +- "xorl %%eax, %%eax \n\t" +- // pav = p - a = (a + b - c) - a = b - c +- "movb (%%esi,%%ebx,), %%al \n\t" // load Prior(x) into al +- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl +- "subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) +- "movl %%eax, _patemp \n\t" // Save pav for later use +- "xorl %%eax, %%eax \n\t" +- // pbv = p - b = (a + b - c) - b = a - c +- "movb (%%edi,%%edx,), %%al \n\t" // load Raw(x-bpp) into al +- "subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) +- "movl %%eax, %%ecx \n\t" +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- "addl _patemp, %%eax \n\t" // pcv = pav + pbv +- // pc = abs(pcv) +- "testl $0x80000000, %%eax \n\t" +- "jz paeth_dpca \n\t" +- "negl %%eax \n\t" // reverse sign of neg values +- +- "paeth_dpca: \n\t" +- "movl %%eax, _pctemp \n\t" // save pc for later use +- // pb = abs(pbv) +- "testl $0x80000000, %%ecx \n\t" +- "jz paeth_dpba \n\t" +- "negl %%ecx \n\t" // reverse sign of neg values +- +- "paeth_dpba: \n\t" +- "movl %%ecx, _pbtemp \n\t" // save pb for later use +- // pa = abs(pav) +- "movl _patemp, %%eax \n\t" +- "testl $0x80000000, %%eax \n\t" +- "jz paeth_dpaa \n\t" +- "negl %%eax \n\t" // reverse sign of neg values +- +- "paeth_dpaa: \n\t" +- "movl %%eax, _patemp \n\t" // save pa for later use +- // test if pa <= pb +- "cmpl %%ecx, %%eax \n\t" +- "jna paeth_dabb \n\t" +- // pa > pb; now test if pb <= pc +- "cmpl _pctemp, %%ecx \n\t" +- "jna paeth_dbbc \n\t" +- // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) +- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl +- "jmp paeth_dpaeth \n\t" +- +- "paeth_dbbc: \n\t" +- // pb <= pc; Raw(x) = Paeth(x) + Prior(x) +- "movb (%%esi,%%ebx,), %%cl \n\t" // load Prior(x) into cl +- "jmp paeth_dpaeth \n\t" +- +- "paeth_dabb: \n\t" +- // pa <= pb; now test if pa <= pc +- "cmpl _pctemp, %%eax \n\t" +- "jna paeth_dabc \n\t" +- // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) +- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl +- "jmp paeth_dpaeth \n\t" +- +- "paeth_dabc: \n\t" +- // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) +- "movb (%%edi,%%edx,), %%cl \n\t" // load Raw(x-bpp) into cl +- +- "paeth_dpaeth: \n\t" +- "incl %%ebx \n\t" +- "incl %%edx \n\t" +- // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 +- "addb %%cl, -1(%%edi,%%ebx,) \n\t" +- "cmpl _FullLength, %%ebx \n\t" +- "jb paeth_dlp \n\t" +- +- "paeth_dend: \n\t" +-#ifdef __PIC__ +- "popl %%ebx \n\t" // index to Global Offset Table +-#endif +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "0" (bpp), // ecx // input regs +- "1" (prev_row), // esi +- "2" (row) // edi +- +- : "%eax", "%edx" // clobber list +-#ifndef __PIC__ +- , "%ebx" +-#endif +- ); +- } +- return; // No need to go further with this one +- +- } // end switch (bpp) +- +- __asm__ __volatile__ ( +- // MMX acceleration complete; now do clean-up +- // check if any remaining bytes left to decode +-#ifdef __PIC__ +- "pushl %%ebx \n\t" // save index to Global Offset Table +-#endif +- "movl _MMXLength, %%ebx \n\t" +- "cmpl _FullLength, %%ebx \n\t" +- "jnb paeth_end \n\t" +-//pre "movl row, %%edi \n\t" +-//pre "movl prev_row, %%esi \n\t" +- // do Paeth decode for remaining bytes +- "movl %%ebx, %%edx \n\t" +-//pre "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) +- "subl %%ecx, %%edx \n\t" // edx = ebx - bpp +- "xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx below +- +- "paeth_lp2: \n\t" +- "xorl %%eax, %%eax \n\t" +- // pav = p - a = (a + b - c) - a = b - c +- "movb (%%esi,%%ebx,), %%al \n\t" // load Prior(x) into al +- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl +- "subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) +- "movl %%eax, _patemp \n\t" // Save pav for later use +- "xorl %%eax, %%eax \n\t" +- // pbv = p - b = (a + b - c) - b = a - c +- "movb (%%edi,%%edx,), %%al \n\t" // load Raw(x-bpp) into al +- "subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) +- "movl %%eax, %%ecx \n\t" +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- "addl _patemp, %%eax \n\t" // pcv = pav + pbv +- // pc = abs(pcv) +- "testl $0x80000000, %%eax \n\t" +- "jz paeth_pca2 \n\t" +- "negl %%eax \n\t" // reverse sign of neg values +- +- "paeth_pca2: \n\t" +- "movl %%eax, _pctemp \n\t" // save pc for later use +- // pb = abs(pbv) +- "testl $0x80000000, %%ecx \n\t" +- "jz paeth_pba2 \n\t" +- "negl %%ecx \n\t" // reverse sign of neg values +- +- "paeth_pba2: \n\t" +- "movl %%ecx, _pbtemp \n\t" // save pb for later use +- // pa = abs(pav) +- "movl _patemp, %%eax \n\t" +- "testl $0x80000000, %%eax \n\t" +- "jz paeth_paa2 \n\t" +- "negl %%eax \n\t" // reverse sign of neg values +- +- "paeth_paa2: \n\t" +- "movl %%eax, _patemp \n\t" // save pa for later use +- // test if pa <= pb +- "cmpl %%ecx, %%eax \n\t" +- "jna paeth_abb2 \n\t" +- // pa > pb; now test if pb <= pc +- "cmpl _pctemp, %%ecx \n\t" +- "jna paeth_bbc2 \n\t" +- // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) +- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl +- "jmp paeth_paeth2 \n\t" +- +- "paeth_bbc2: \n\t" +- // pb <= pc; Raw(x) = Paeth(x) + Prior(x) +- "movb (%%esi,%%ebx,), %%cl \n\t" // load Prior(x) into cl +- "jmp paeth_paeth2 \n\t" +- +- "paeth_abb2: \n\t" +- // pa <= pb; now test if pa <= pc +- "cmpl _pctemp, %%eax \n\t" +- "jna paeth_abc2 \n\t" +- // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) +- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl +- "jmp paeth_paeth2 \n\t" +- +- "paeth_abc2: \n\t" +- // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) +- "movb (%%edi,%%edx,), %%cl \n\t" // load Raw(x-bpp) into cl +- +- "paeth_paeth2: \n\t" +- "incl %%ebx \n\t" +- "incl %%edx \n\t" +- // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 +- "addb %%cl, -1(%%edi,%%ebx,) \n\t" +- "cmpl _FullLength, %%ebx \n\t" +- "jb paeth_lp2 \n\t" +- +- "paeth_end: \n\t" +- "EMMS \n\t" // end MMX; prep for poss. FP instrs. +-#ifdef __PIC__ +- "popl %%ebx \n\t" // restore index to Global Offset Table +-#endif +- +- : "=c" (dummy_value_c), // output regs (dummy) +- "=S" (dummy_value_S), +- "=D" (dummy_value_D) +- +- : "0" (bpp), // ecx // input regs +- "1" (prev_row), // esi +- "2" (row) // edi +- +- : "%eax", "%edx" // clobber list (no input regs!) +-#ifndef __PIC__ +- , "%ebx" +-#endif +- ); +- +-} /* end png_read_filter_row_mmx_paeth() */ +-#endif +- +- +- +- +-#ifdef PNG_THREAD_UNSAFE_OK +-//===========================================================================// +-// // +-// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ S U B // +-// // +-//===========================================================================// +- +-// Optimized code for PNG Sub filter decoder +- +-static void /* PRIVATE */ +-png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row) +-{ +- int bpp; +- int dummy_value_a; +- int dummy_value_D; +- +- bpp = (row_info->pixel_depth + 7) >> 3; // calc number of bytes per pixel +- _FullLength = row_info->rowbytes - bpp; // number of bytes to filter +- +- __asm__ __volatile__ ( +-//pre "movl row, %%edi \n\t" +- "movl %%edi, %%esi \n\t" // lp = row +-//pre "movl bpp, %%eax \n\t" +- "addl %%eax, %%edi \n\t" // rp = row + bpp +-//irr "xorl %%eax, %%eax \n\t" +- // get # of bytes to alignment +- "movl %%edi, _dif \n\t" // take start of row +- "addl $0xf, _dif \n\t" // add 7 + 8 to incr past +- // alignment boundary +- "xorl %%ecx, %%ecx \n\t" +- "andl $0xfffffff8, _dif \n\t" // mask to alignment boundary +- "subl %%edi, _dif \n\t" // subtract from start ==> value +- "jz sub_go \n\t" // ecx at alignment +- +- "sub_lp1: \n\t" // fix alignment +- "movb (%%esi,%%ecx,), %%al \n\t" +- "addb %%al, (%%edi,%%ecx,) \n\t" +- "incl %%ecx \n\t" +- "cmpl _dif, %%ecx \n\t" +- "jb sub_lp1 \n\t" +- +- "sub_go: \n\t" +- "movl _FullLength, %%eax \n\t" +- "movl %%eax, %%edx \n\t" +- "subl %%ecx, %%edx \n\t" // subtract alignment fix +- "andl $0x00000007, %%edx \n\t" // calc bytes over mult of 8 +- "subl %%edx, %%eax \n\t" // drop over bytes from length +- "movl %%eax, _MMXLength \n\t" +- +- : "=a" (dummy_value_a), // 0 // output regs (dummy) +- "=D" (dummy_value_D) // 1 +- +- : "0" (bpp), // eax // input regs +- "1" (row) // edi +- +- : "%esi", "%ecx", "%edx" // clobber list +- +-#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ +- , "%mm0", "%mm1", "%mm2", "%mm3" +- , "%mm4", "%mm5", "%mm6", "%mm7" +-#endif +- ); +- +- // now do the math for the rest of the row +- switch (bpp) +- { +- case 3: +- { +- _ActiveMask.use = 0x0000ffffff000000LL; +- _ShiftBpp.use = 24; // == 3 * 8 +- _ShiftRem.use = 40; // == 64 - 24 +- +- __asm__ __volatile__ ( +-// preload "movl row, %%edi \n\t" +- "movq _ActiveMask, %%mm7 \n\t" // load _ActiveMask for 2nd +- // active byte group +- "movl %%edi, %%esi \n\t" // lp = row +-// preload "movl bpp, %%eax \n\t" +- "addl %%eax, %%edi \n\t" // rp = row + bpp +- "movq %%mm7, %%mm6 \n\t" +- "movl _dif, %%edx \n\t" +- "psllq _ShiftBpp, %%mm6 \n\t" // move mask in mm6 to cover +- // 3rd active byte group +- // prime the pump: load the first Raw(x-bpp) data set +- "movq -8(%%edi,%%edx,), %%mm1 \n\t" +- +- "sub_3lp: \n\t" // shift data for adding first +- "psrlq _ShiftRem, %%mm1 \n\t" // bpp bytes (no need for mask; +- // shift clears inactive bytes) +- // add 1st active group +- "movq (%%edi,%%edx,), %%mm0 \n\t" +- "paddb %%mm1, %%mm0 \n\t" +- +- // add 2nd active group +- "movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 +- "psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly +- "pand %%mm7, %%mm1 \n\t" // mask to use 2nd active group +- "paddb %%mm1, %%mm0 \n\t" +- +- // add 3rd active group +- "movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 +- "psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly +- "pand %%mm6, %%mm1 \n\t" // mask to use 3rd active group +- "addl $8, %%edx \n\t" +- "paddb %%mm1, %%mm0 \n\t" +- +- "cmpl _MMXLength, %%edx \n\t" +- "movq %%mm0, -8(%%edi,%%edx,) \n\t" // write updated Raws to array +- "movq %%mm0, %%mm1 \n\t" // prep 1st add at top of loop +- "jb sub_3lp \n\t" +- +- : "=a" (dummy_value_a), // 0 // output regs (dummy) +- "=D" (dummy_value_D) // 1 +- +- : "0" (bpp), // eax // input regs +- "1" (row) // edi +- +- : "%edx", "%esi" // clobber list +-#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ +- , "%mm0", "%mm1", "%mm6", "%mm7" +-#endif +- ); +- } +- break; +- +- case 1: +- { +- __asm__ __volatile__ ( +- "movl _dif, %%edx \n\t" +-// preload "movl row, %%edi \n\t" +- "cmpl _FullLength, %%edx \n\t" +- "jnb sub_1end \n\t" +- "movl %%edi, %%esi \n\t" // lp = row +- "xorl %%eax, %%eax \n\t" +-// preload "movl bpp, %%eax \n\t" +- "addl %%eax, %%edi \n\t" // rp = row + bpp +- +- "sub_1lp: \n\t" +- "movb (%%esi,%%edx,), %%al \n\t" +- "addb %%al, (%%edi,%%edx,) \n\t" +- "incl %%edx \n\t" +- "cmpl _FullLength, %%edx \n\t" +- "jb sub_1lp \n\t" +- +- "sub_1end: \n\t" +- +- : "=a" (dummy_value_a), // 0 // output regs (dummy) +- "=D" (dummy_value_D) // 1 +- +- : "0" (bpp), // eax // input regs +- "1" (row) // edi +- +- : "%edx", "%esi" // clobber list +- ); +- } +- return; +- +- case 6: +- case 4: +- //case 7: // GRR BOGUS +- //case 5: // GRR BOGUS +- { +- _ShiftBpp.use = bpp << 3; +- _ShiftRem.use = 64 - _ShiftBpp.use; +- +- __asm__ __volatile__ ( +-// preload "movl row, %%edi \n\t" +- "movl _dif, %%edx \n\t" +- "movl %%edi, %%esi \n\t" // lp = row +-// preload "movl bpp, %%eax \n\t" +- "addl %%eax, %%edi \n\t" // rp = row + bpp +- +- // prime the pump: load the first Raw(x-bpp) data set +- "movq -8(%%edi,%%edx,), %%mm1 \n\t" +- +- "sub_4lp: \n\t" // shift data for adding first +- "psrlq _ShiftRem, %%mm1 \n\t" // bpp bytes (no need for mask; +- // shift clears inactive bytes) +- "movq (%%edi,%%edx,), %%mm0 \n\t" +- "paddb %%mm1, %%mm0 \n\t" +- +- // add 2nd active group +- "movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 +- "psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly +- "addl $8, %%edx \n\t" +- "paddb %%mm1, %%mm0 \n\t" +- +- "cmpl _MMXLength, %%edx \n\t" +- "movq %%mm0, -8(%%edi,%%edx,) \n\t" +- "movq %%mm0, %%mm1 \n\t" // prep 1st add at top of loop +- "jb sub_4lp \n\t" +- +- : "=a" (dummy_value_a), // 0 // output regs (dummy) +- "=D" (dummy_value_D) // 1 +- +- : "0" (bpp), // eax // input regs +- "1" (row) // edi +- +- : "%edx", "%esi" // clobber list +-#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ +- , "%mm0", "%mm1" +-#endif +- ); +- } +- break; +- +- case 2: +- { +- _ActiveMask.use = 0x00000000ffff0000LL; +- _ShiftBpp.use = 16; // == 2 * 8 +- _ShiftRem.use = 48; // == 64 - 16 +- +- __asm__ __volatile__ ( +- "movq _ActiveMask, %%mm7 \n\t" // load _ActiveMask for 2nd +- // active byte group +- "movl _dif, %%edx \n\t" +- "movq %%mm7, %%mm6 \n\t" +-// preload "movl row, %%edi \n\t" +- "psllq _ShiftBpp, %%mm6 \n\t" // move mask in mm6 to cover +- // 3rd active byte group +- "movl %%edi, %%esi \n\t" // lp = row +- "movq %%mm6, %%mm5 \n\t" +-// preload "movl bpp, %%eax \n\t" +- "addl %%eax, %%edi \n\t" // rp = row + bpp +- "psllq _ShiftBpp, %%mm5 \n\t" // move mask in mm5 to cover +- // 4th active byte group +- // prime the pump: load the first Raw(x-bpp) data set +- "movq -8(%%edi,%%edx,), %%mm1 \n\t" +- +- "sub_2lp: \n\t" // shift data for adding first +- "psrlq _ShiftRem, %%mm1 \n\t" // bpp bytes (no need for mask; +- // shift clears inactive bytes) +- // add 1st active group +- "movq (%%edi,%%edx,), %%mm0 \n\t" +- "paddb %%mm1, %%mm0 \n\t" +- +- // add 2nd active group +- "movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 +- "psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly +- "pand %%mm7, %%mm1 \n\t" // mask to use 2nd active group +- "paddb %%mm1, %%mm0 \n\t" +- +- // add 3rd active group +- "movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 +- "psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly +- "pand %%mm6, %%mm1 \n\t" // mask to use 3rd active group +- "paddb %%mm1, %%mm0 \n\t" +- +- // add 4th active group +- "movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 +- "psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly +- "pand %%mm5, %%mm1 \n\t" // mask to use 4th active group +- "addl $8, %%edx \n\t" +- "paddb %%mm1, %%mm0 \n\t" +- "cmpl _MMXLength, %%edx \n\t" +- "movq %%mm0, -8(%%edi,%%edx,) \n\t" // write updated Raws to array +- "movq %%mm0, %%mm1 \n\t" // prep 1st add at top of loop +- "jb sub_2lp \n\t" +- +- : "=a" (dummy_value_a), // 0 // output regs (dummy) +- "=D" (dummy_value_D) // 1 +- +- : "0" (bpp), // eax // input regs +- "1" (row) // edi +- +- : "%edx", "%esi" // clobber list +-#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ +- , "%mm0", "%mm1", "%mm5", "%mm6", "%mm7" +-#endif +- ); +- } +- break; +- +- case 8: +- { +- __asm__ __volatile__ ( +-// preload "movl row, %%edi \n\t" +- "movl _dif, %%edx \n\t" +- "movl %%edi, %%esi \n\t" // lp = row +-// preload "movl bpp, %%eax \n\t" +- "addl %%eax, %%edi \n\t" // rp = row + bpp +- "movl _MMXLength, %%ecx \n\t" +- +- // prime the pump: load the first Raw(x-bpp) data set +- "movq -8(%%edi,%%edx,), %%mm7 \n\t" +- "andl $0x0000003f, %%ecx \n\t" // calc bytes over mult of 64 +- +- "sub_8lp: \n\t" +- "movq (%%edi,%%edx,), %%mm0 \n\t" // load Sub(x) for 1st 8 bytes +- "paddb %%mm7, %%mm0 \n\t" +- "movq 8(%%edi,%%edx,), %%mm1 \n\t" // load Sub(x) for 2nd 8 bytes +- "movq %%mm0, (%%edi,%%edx,) \n\t" // write Raw(x) for 1st 8 bytes +- +- // Now mm0 will be used as Raw(x-bpp) for the 2nd group of 8 bytes. +- // This will be repeated for each group of 8 bytes with the 8th +- // group being used as the Raw(x-bpp) for the 1st group of the +- // next loop. +- +- "paddb %%mm0, %%mm1 \n\t" +- "movq 16(%%edi,%%edx,), %%mm2 \n\t" // load Sub(x) for 3rd 8 bytes +- "movq %%mm1, 8(%%edi,%%edx,) \n\t" // write Raw(x) for 2nd 8 bytes +- "paddb %%mm1, %%mm2 \n\t" +- "movq 24(%%edi,%%edx,), %%mm3 \n\t" // load Sub(x) for 4th 8 bytes +- "movq %%mm2, 16(%%edi,%%edx,) \n\t" // write Raw(x) for 3rd 8 bytes +- "paddb %%mm2, %%mm3 \n\t" +- "movq 32(%%edi,%%edx,), %%mm4 \n\t" // load Sub(x) for 5th 8 bytes +- "movq %%mm3, 24(%%edi,%%edx,) \n\t" // write Raw(x) for 4th 8 bytes +- "paddb %%mm3, %%mm4 \n\t" +- "movq 40(%%edi,%%edx,), %%mm5 \n\t" // load Sub(x) for 6th 8 bytes +- "movq %%mm4, 32(%%edi,%%edx,) \n\t" // write Raw(x) for 5th 8 bytes +- "paddb %%mm4, %%mm5 \n\t" +- "movq 48(%%edi,%%edx,), %%mm6 \n\t" // load Sub(x) for 7th 8 bytes +- "movq %%mm5, 40(%%edi,%%edx,) \n\t" // write Raw(x) for 6th 8 bytes +- "paddb %%mm5, %%mm6 \n\t" +- "movq 56(%%edi,%%edx,), %%mm7 \n\t" // load Sub(x) for 8th 8 bytes +- "movq %%mm6, 48(%%edi,%%edx,) \n\t" // write Raw(x) for 7th 8 bytes +- "addl $64, %%edx \n\t" +- "paddb %%mm6, %%mm7 \n\t" +- "cmpl %%ecx, %%edx \n\t" +- "movq %%mm7, -8(%%edi,%%edx,) \n\t" // write Raw(x) for 8th 8 bytes +- "jb sub_8lp \n\t" +- +- "cmpl _MMXLength, %%edx \n\t" +- "jnb sub_8lt8 \n\t" +- +- "sub_8lpA: \n\t" +- "movq (%%edi,%%edx,), %%mm0 \n\t" +- "addl $8, %%edx \n\t" +- "paddb %%mm7, %%mm0 \n\t" +- "cmpl _MMXLength, %%edx \n\t" +- "movq %%mm0, -8(%%edi,%%edx,) \n\t" // -8 to offset early addl edx +- "movq %%mm0, %%mm7 \n\t" // move calculated Raw(x) data +- // to mm1 to be new Raw(x-bpp) +- // for next loop +- "jb sub_8lpA \n\t" +- +- "sub_8lt8: \n\t" +- +- : "=a" (dummy_value_a), // 0 // output regs (dummy) +- "=D" (dummy_value_D) // 1 +- +- : "0" (bpp), // eax // input regs +- "1" (row) // edi +- +- : "%ecx", "%edx", "%esi" // clobber list +-#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ +- , "%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7" +-#endif +- ); +- } +- break; +- +- default: // bpp greater than 8 bytes GRR BOGUS +- { +- __asm__ __volatile__ ( +- "movl _dif, %%edx \n\t" +-// preload "movl row, %%edi \n\t" +- "movl %%edi, %%esi \n\t" // lp = row +-// preload "movl bpp, %%eax \n\t" +- "addl %%eax, %%edi \n\t" // rp = row + bpp +- +- "sub_Alp: \n\t" +- "movq (%%edi,%%edx,), %%mm0 \n\t" +- "movq (%%esi,%%edx,), %%mm1 \n\t" +- "addl $8, %%edx \n\t" +- "paddb %%mm1, %%mm0 \n\t" +- "cmpl _MMXLength, %%edx \n\t" +- "movq %%mm0, -8(%%edi,%%edx,) \n\t" // mov does not affect flags; +- // -8 to offset addl edx +- "jb sub_Alp \n\t" +- +- : "=a" (dummy_value_a), // 0 // output regs (dummy) +- "=D" (dummy_value_D) // 1 +- +- : "0" (bpp), // eax // input regs +- "1" (row) // edi +- +- : "%edx", "%esi" // clobber list +-#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ +- , "%mm0", "%mm1" +-#endif +- ); +- } +- break; +- +- } // end switch (bpp) +- +- __asm__ __volatile__ ( +- "movl _MMXLength, %%edx \n\t" +-//pre "movl row, %%edi \n\t" +- "cmpl _FullLength, %%edx \n\t" +- "jnb sub_end \n\t" +- +- "movl %%edi, %%esi \n\t" // lp = row +-//pre "movl bpp, %%eax \n\t" +- "addl %%eax, %%edi \n\t" // rp = row + bpp +- "xorl %%eax, %%eax \n\t" +- +- "sub_lp2: \n\t" +- "movb (%%esi,%%edx,), %%al \n\t" +- "addb %%al, (%%edi,%%edx,) \n\t" +- "incl %%edx \n\t" +- "cmpl _FullLength, %%edx \n\t" +- "jb sub_lp2 \n\t" +- +- "sub_end: \n\t" +- "EMMS \n\t" // end MMX instructions +- +- : "=a" (dummy_value_a), // 0 // output regs (dummy) +- "=D" (dummy_value_D) // 1 +- +- : "0" (bpp), // eax // input regs +- "1" (row) // edi +- +- : "%edx", "%esi" // clobber list +- ); +- +-} // end of png_read_filter_row_mmx_sub() +-#endif +- +- +- +- +-//===========================================================================// +-// // +-// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ U P // +-// // +-//===========================================================================// +- +-// Optimized code for PNG Up filter decoder +- +-static void /* PRIVATE */ +-png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row, +- png_bytep prev_row) +-{ +- png_uint_32 len; +- int dummy_value_d; // fix 'forbidden register 3 (dx) was spilled' error +- int dummy_value_S; +- int dummy_value_D; +- +- len = row_info->rowbytes; // number of bytes to filter +- +- __asm__ __volatile__ ( +-//pre "movl row, %%edi \n\t" +- // get # of bytes to alignment +-#ifdef __PIC__ +- "pushl %%ebx \n\t" +-#endif +- "movl %%edi, %%ecx \n\t" +- "xorl %%ebx, %%ebx \n\t" +- "addl $0x7, %%ecx \n\t" +- "xorl %%eax, %%eax \n\t" +- "andl $0xfffffff8, %%ecx \n\t" +-//pre "movl prev_row, %%esi \n\t" +- "subl %%edi, %%ecx \n\t" +- "jz up_go \n\t" +- +- "up_lp1: \n\t" // fix alignment +- "movb (%%edi,%%ebx,), %%al \n\t" +- "addb (%%esi,%%ebx,), %%al \n\t" +- "incl %%ebx \n\t" +- "cmpl %%ecx, %%ebx \n\t" +- "movb %%al, -1(%%edi,%%ebx,) \n\t" // mov does not affect flags; -1 to +- "jb up_lp1 \n\t" // offset incl ebx +- +- "up_go: \n\t" +-//pre "movl len, %%edx \n\t" +- "movl %%edx, %%ecx \n\t" +- "subl %%ebx, %%edx \n\t" // subtract alignment fix +- "andl $0x0000003f, %%edx \n\t" // calc bytes over mult of 64 +- "subl %%edx, %%ecx \n\t" // drop over bytes from length +- +- // unrolled loop - use all MMX registers and interleave to reduce +- // number of branch instructions (loops) and reduce partial stalls +- "up_loop: \n\t" +- "movq (%%esi,%%ebx,), %%mm1 \n\t" +- "movq (%%edi,%%ebx,), %%mm0 \n\t" +- "movq 8(%%esi,%%ebx,), %%mm3 \n\t" +- "paddb %%mm1, %%mm0 \n\t" +- "movq 8(%%edi,%%ebx,), %%mm2 \n\t" +- "movq %%mm0, (%%edi,%%ebx,) \n\t" +- "paddb %%mm3, %%mm2 \n\t" +- "movq 16(%%esi,%%ebx,), %%mm5 \n\t" +- "movq %%mm2, 8(%%edi,%%ebx,) \n\t" +- "movq 16(%%edi,%%ebx,), %%mm4 \n\t" +- "movq 24(%%esi,%%ebx,), %%mm7 \n\t" +- "paddb %%mm5, %%mm4 \n\t" +- "movq 24(%%edi,%%ebx,), %%mm6 \n\t" +- "movq %%mm4, 16(%%edi,%%ebx,) \n\t" +- "paddb %%mm7, %%mm6 \n\t" +- "movq 32(%%esi,%%ebx,), %%mm1 \n\t" +- "movq %%mm6, 24(%%edi,%%ebx,) \n\t" +- "movq 32(%%edi,%%ebx,), %%mm0 \n\t" +- "movq 40(%%esi,%%ebx,), %%mm3 \n\t" +- "paddb %%mm1, %%mm0 \n\t" +- "movq 40(%%edi,%%ebx,), %%mm2 \n\t" +- "movq %%mm0, 32(%%edi,%%ebx,) \n\t" +- "paddb %%mm3, %%mm2 \n\t" +- "movq 48(%%esi,%%ebx,), %%mm5 \n\t" +- "movq %%mm2, 40(%%edi,%%ebx,) \n\t" +- "movq 48(%%edi,%%ebx,), %%mm4 \n\t" +- "movq 56(%%esi,%%ebx,), %%mm7 \n\t" +- "paddb %%mm5, %%mm4 \n\t" +- "movq 56(%%edi,%%ebx,), %%mm6 \n\t" +- "movq %%mm4, 48(%%edi,%%ebx,) \n\t" +- "addl $64, %%ebx \n\t" +- "paddb %%mm7, %%mm6 \n\t" +- "cmpl %%ecx, %%ebx \n\t" +- "movq %%mm6, -8(%%edi,%%ebx,) \n\t" // (+56)movq does not affect flags; +- "jb up_loop \n\t" // -8 to offset addl ebx +- +- "cmpl $0, %%edx \n\t" // test for bytes over mult of 64 +- "jz up_end \n\t" +- +- "cmpl $8, %%edx \n\t" // test for less than 8 bytes +- "jb up_lt8 \n\t" // [added by lcreeve@netins.net] +- +- "addl %%edx, %%ecx \n\t" +- "andl $0x00000007, %%edx \n\t" // calc bytes over mult of 8 +- "subl %%edx, %%ecx \n\t" // drop over bytes from length +- "jz up_lt8 \n\t" +- +- "up_lpA: \n\t" // use MMX regs to update 8 bytes sim. +- "movq (%%esi,%%ebx,), %%mm1 \n\t" +- "movq (%%edi,%%ebx,), %%mm0 \n\t" +- "addl $8, %%ebx \n\t" +- "paddb %%mm1, %%mm0 \n\t" +- "cmpl %%ecx, %%ebx \n\t" +- "movq %%mm0, -8(%%edi,%%ebx,) \n\t" // movq does not affect flags; -8 to +- "jb up_lpA \n\t" // offset add ebx +- "cmpl $0, %%edx \n\t" // test for bytes over mult of 8 +- "jz up_end \n\t" +- +- "up_lt8: \n\t" +- "xorl %%eax, %%eax \n\t" +- "addl %%edx, %%ecx \n\t" // move over byte count into counter +- +- "up_lp2: \n\t" // use x86 regs for remaining bytes +- "movb (%%edi,%%ebx,), %%al \n\t" +- "addb (%%esi,%%ebx,), %%al \n\t" +- "incl %%ebx \n\t" +- "cmpl %%ecx, %%ebx \n\t" +- "movb %%al, -1(%%edi,%%ebx,) \n\t" // mov does not affect flags; -1 to +- "jb up_lp2 \n\t" // offset inc ebx +- +- "up_end: \n\t" +- "EMMS \n\t" // conversion of filtered row complete +-#ifdef __PIC__ +- "popl %%ebx \n\t" +-#endif +- +- : "=d" (dummy_value_d), // 0 // output regs (dummy) +- "=S" (dummy_value_S), // 1 +- "=D" (dummy_value_D) // 2 +- +- : "0" (len), // edx // input regs +- "1" (prev_row), // esi +- "2" (row) // edi +- +- : "%eax", "%ecx" // clobber list (no input regs!) +-#ifndef __PIC__ +- , "%ebx" +-#endif +- +-#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ +- , "%mm0", "%mm1", "%mm2", "%mm3" +- , "%mm4", "%mm5", "%mm6", "%mm7" +-#endif +- ); +- +-} // end of png_read_filter_row_mmx_up() +- +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ +- +- +- +- +-/*===========================================================================*/ +-/* */ +-/* P N G _ R E A D _ F I L T E R _ R O W */ +-/* */ +-/*===========================================================================*/ +- +- +-/* Optimized png_read_filter_row routines */ +- +-void /* PRIVATE */ +-png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep +- row, png_bytep prev_row, int filter) +-{ +-#ifdef PNG_DEBUG +- char filnm[10]; +-#endif +- +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +-/* GRR: these are superseded by png_ptr->asm_flags: */ +-#define UseMMX_sub 1 // GRR: converted 20000730 +-#define UseMMX_up 1 // GRR: converted 20000729 +-#define UseMMX_avg 1 // GRR: converted 20000828 (+ 16-bit bugfix 20000916) +-#define UseMMX_paeth 1 // GRR: converted 20000828 +- +- if (_mmx_supported == 2) { +- /* this should have happened in png_init_mmx_flags() already */ +-#if !defined(PNG_1_0_X) +- png_warning(png_ptr, "asm_flags may not have been initialized"); +-#endif +- png_mmx_support(); +- } +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ +- +-#ifdef PNG_DEBUG +- png_debug(1, "in png_read_filter_row (pnggccrd.c)\n"); +- switch (filter) +- { +- case 0: sprintf(filnm, "none"); +- break; +- case 1: sprintf(filnm, "sub-%s", +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) +-#if !defined(PNG_1_0_X) +- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "MMX" : +-#endif +-#endif +-"x86"); +- break; +- case 2: sprintf(filnm, "up-%s", +-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED +-#if !defined(PNG_1_0_X) +- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "MMX" : +-#endif +-#endif +- "x86"); +- break; +- case 3: sprintf(filnm, "avg-%s", +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) +-#if !defined(PNG_1_0_X) +- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "MMX" : +-#endif +-#endif +- "x86"); +- break; +- case 4: sprintf(filnm, "Paeth-%s", +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) +-#if !defined(PNG_1_0_X) +- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "MMX": +-#endif +-#endif +-"x86"); +- break; +- default: sprintf(filnm, "unknw"); +- break; +- } +- png_debug2(0, "row_number=%5ld, %5s, ", png_ptr->row_number, filnm); +- png_debug1(0, "row=0x%08lx, ", (unsigned long)row); +- png_debug2(0, "pixdepth=%2d, bytes=%d, ", (int)row_info->pixel_depth, +- (int)((row_info->pixel_depth + 7) >> 3)); +- png_debug1(0,"rowbytes=%8ld\n", row_info->rowbytes); +-#endif /* PNG_DEBUG */ +- +- switch (filter) +- { +- case PNG_FILTER_VALUE_NONE: +- break; +- +- case PNG_FILTER_VALUE_SUB: +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB) && +- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && +- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) +-#else +- if (_mmx_supported) +-#endif +- { +- png_read_filter_row_mmx_sub(row_info, row); +- } +- else +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ +- { +- png_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; +- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; +- png_bytep rp = row + bpp; +- png_bytep lp = row; +- +- for (i = bpp; i < istop; i++) +- { +- *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff); +- rp++; +- } +- } /* end !UseMMX_sub */ +- break; +- +- case PNG_FILTER_VALUE_UP: +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP) && +- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && +- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) +-#else +- if (_mmx_supported) +-#endif +- { +- png_read_filter_row_mmx_up(row_info, row, prev_row); +- } +- else +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ +- { +- png_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; +- png_bytep rp = row; +- png_bytep pp = prev_row; +- +- for (i = 0; i < istop; ++i) +- { +- *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); +- rp++; +- } +- } /* end !UseMMX_up */ +- break; +- +- case PNG_FILTER_VALUE_AVG: +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG) && +- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && +- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) +-#else +- if (_mmx_supported) +-#endif +- { +- png_read_filter_row_mmx_avg(row_info, row, prev_row); +- } +- else +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ +- { +- png_uint_32 i; +- png_bytep rp = row; +- png_bytep pp = prev_row; +- png_bytep lp = row; +- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; +- png_uint_32 istop = row_info->rowbytes - bpp; +- +- for (i = 0; i < bpp; i++) +- { +- *rp = (png_byte)(((int)(*rp) + +- ((int)(*pp++) >> 1)) & 0xff); +- rp++; +- } +- +- for (i = 0; i < istop; i++) +- { +- *rp = (png_byte)(((int)(*rp) + +- ((int)(*pp++ + *lp++) >> 1)) & 0xff); +- rp++; +- } +- } /* end !UseMMX_avg */ +- break; +- +- case PNG_FILTER_VALUE_PAETH: +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH) && +- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && +- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) +-#else +- if (_mmx_supported) +-#endif +- { +- png_read_filter_row_mmx_paeth(row_info, row, prev_row); +- } +- else +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ +- { +- png_uint_32 i; +- png_bytep rp = row; +- png_bytep pp = prev_row; +- png_bytep lp = row; +- png_bytep cp = prev_row; +- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; +- png_uint_32 istop = row_info->rowbytes - bpp; +- +- for (i = 0; i < bpp; i++) +- { +- *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); +- rp++; +- } +- +- for (i = 0; i < istop; i++) /* use leftover rp,pp */ +- { +- int a, b, c, pa, pb, pc, p; +- +- a = *lp++; +- b = *pp++; +- c = *cp++; +- +- p = b - c; +- pc = a - c; +- +-#ifdef PNG_USE_ABS +- pa = abs(p); +- pb = abs(pc); +- pc = abs(p + pc); +-#else +- pa = p < 0 ? -p : p; +- pb = pc < 0 ? -pc : pc; +- pc = (p + pc) < 0 ? -(p + pc) : p + pc; +-#endif +- +- /* +- if (pa <= pb && pa <= pc) +- p = a; +- else if (pb <= pc) +- p = b; +- else +- p = c; +- */ +- +- p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c; +- +- *rp = (png_byte)(((int)(*rp) + p) & 0xff); +- rp++; +- } +- } /* end !UseMMX_paeth */ +- break; +- +- default: +- png_warning(png_ptr, "Ignoring bad row-filter type"); +- *row=0; +- break; +- } +-} +- +-#endif /* PNG_HAVE_ASSEMBLER_READ_FILTER_ROW */ +- +- +-/*===========================================================================*/ +-/* */ +-/* P N G _ M M X _ S U P P O R T */ +-/* */ +-/*===========================================================================*/ +- +-/* GRR NOTES: (1) the following code assumes 386 or better (pushfl/popfl) +- * (2) all instructions compile with gcc 2.7.2.3 and later +- * (3) the function is moved down here to prevent gcc from +- * inlining it in multiple places and then barfing be- +- * cause the ".NOT_SUPPORTED" label is multiply defined +- * [is there a way to signal that a *single* function should +- * not be inlined? is there a way to modify the label for +- * each inlined instance, e.g., by appending _1, _2, etc.? +- * maybe if don't use leading "." in label name? (nope...sigh)] +- */ +- +-int PNGAPI +-png_mmx_support(void) +-{ +-#if defined(PNG_MMX_CODE_SUPPORTED) +- __asm__ __volatile__ ( +- "pushl %%ebx \n\t" // ebx gets clobbered by CPUID instruction +- "pushl %%ecx \n\t" // so does ecx... +- "pushl %%edx \n\t" // ...and edx (but ecx & edx safe on Linux) +-// ".byte 0x66 \n\t" // convert 16-bit pushf to 32-bit pushfd +-// "pushf \n\t" // 16-bit pushf +- "pushfl \n\t" // save Eflag to stack +- "popl %%eax \n\t" // get Eflag from stack into eax +- "movl %%eax, %%ecx \n\t" // make another copy of Eflag in ecx +- "xorl $0x200000, %%eax \n\t" // toggle ID bit in Eflag (i.e., bit 21) +- "pushl %%eax \n\t" // save modified Eflag back to stack +-// ".byte 0x66 \n\t" // convert 16-bit popf to 32-bit popfd +-// "popf \n\t" // 16-bit popf +- "popfl \n\t" // restore modified value to Eflag reg +- "pushfl \n\t" // save Eflag to stack +- "popl %%eax \n\t" // get Eflag from stack +- "pushl %%ecx \n\t" // save original Eflag to stack +- "popfl \n\t" // restore original Eflag +- "xorl %%ecx, %%eax \n\t" // compare new Eflag with original Eflag +- "jz 0f \n\t" // if same, CPUID instr. is not supported +- +- "xorl %%eax, %%eax \n\t" // set eax to zero +-// ".byte 0x0f, 0xa2 \n\t" // CPUID instruction (two-byte opcode) +- "cpuid \n\t" // get the CPU identification info +- "cmpl $1, %%eax \n\t" // make sure eax return non-zero value +- "jl 0f \n\t" // if eax is zero, MMX is not supported +- +- "xorl %%eax, %%eax \n\t" // set eax to zero and... +- "incl %%eax \n\t" // ...increment eax to 1. This pair is +- // faster than the instruction "mov eax, 1" +- "cpuid \n\t" // get the CPU identification info again +- "andl $0x800000, %%edx \n\t" // mask out all bits but MMX bit (23) +- "cmpl $0, %%edx \n\t" // 0 = MMX not supported +- "jz 0f \n\t" // non-zero = yes, MMX IS supported +- +- "movl $1, %%eax \n\t" // set return value to 1 +- "jmp 1f \n\t" // DONE: have MMX support +- +- "0: \n\t" // .NOT_SUPPORTED: target label for jump instructions +- "movl $0, %%eax \n\t" // set return value to 0 +- "1: \n\t" // .RETURN: target label for jump instructions +- "movl %%eax, _mmx_supported \n\t" // save in global static variable, too +- "popl %%edx \n\t" // restore edx +- "popl %%ecx \n\t" // restore ecx +- "popl %%ebx \n\t" // restore ebx +- +-// "ret \n\t" // DONE: no MMX support +- // (fall through to standard C "ret") +- +- : // output list (none) +- +- : // any variables used on input (none) +- +- : "%eax" // clobber list +-// , "%ebx", "%ecx", "%edx" // GRR: we handle these manually +-// , "memory" // if write to a variable gcc thought was in a reg +-// , "cc" // "condition codes" (flag bits) +- ); +-#else +- _mmx_supported = 0; +-#endif /* PNG_MMX_CODE_SUPPORTED */ +- +- return _mmx_supported; +-} +- +- +-#endif /* PNG_USE_PNGGCCRD */ +diff --git a/thirdparty/libpng/pngget.c b/thirdparty/libpng/pngget.c +deleted file mode 100644 +index 1d1cc21..0000000 +--- a/thirdparty/libpng/pngget.c ++++ /dev/null +@@ -1,934 +0,0 @@ +- +-/* pngget.c - retrieval of values from info struct +- * +- * libpng 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- */ +- +-#define PNG_INTERNAL +-#include "png.h" +- +-png_uint_32 PNGAPI +-png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +- return(info_ptr->valid & flag); +- else +- return(0); +-} +- +-png_uint_32 PNGAPI +-png_get_rowbytes(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +- return(info_ptr->rowbytes); +- else +- return(0); +-} +- +-#if defined(PNG_INFO_IMAGE_SUPPORTED) +-png_bytepp PNGAPI +-png_get_rows(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +- return(info_ptr->row_pointers); +- else +- return(0); +-} +-#endif +- +-#ifdef PNG_EASY_ACCESS_SUPPORTED +-/* easy access to info, added in libpng-0.99 */ +-png_uint_32 PNGAPI +-png_get_image_width(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +- { +- return info_ptr->width; +- } +- return (0); +-} +- +-png_uint_32 PNGAPI +-png_get_image_height(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +- { +- return info_ptr->height; +- } +- return (0); +-} +- +-png_byte PNGAPI +-png_get_bit_depth(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +- { +- return info_ptr->bit_depth; +- } +- return (0); +-} +- +-png_byte PNGAPI +-png_get_color_type(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +- { +- return info_ptr->color_type; +- } +- return (0); +-} +- +-png_byte PNGAPI +-png_get_filter_type(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +- { +- return info_ptr->filter_type; +- } +- return (0); +-} +- +-png_byte PNGAPI +-png_get_interlace_type(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +- { +- return info_ptr->interlace_type; +- } +- return (0); +-} +- +-png_byte PNGAPI +-png_get_compression_type(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +- { +- return info_ptr->compression_type; +- } +- return (0); +-} +- +-png_uint_32 PNGAPI +-png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +-#if defined(PNG_pHYs_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_pHYs) +- { +- png_debug1(1, "in %s retrieval function\n", "png_get_x_pixels_per_meter"); +- if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER) +- return (0); +- else return (info_ptr->x_pixels_per_unit); +- } +-#else +- return (0); +-#endif +- return (0); +-} +- +-png_uint_32 PNGAPI +-png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +-#if defined(PNG_pHYs_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_pHYs) +- { +- png_debug1(1, "in %s retrieval function\n", "png_get_y_pixels_per_meter"); +- if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER) +- return (0); +- else return (info_ptr->y_pixels_per_unit); +- } +-#else +- return (0); +-#endif +- return (0); +-} +- +-png_uint_32 PNGAPI +-png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +-#if defined(PNG_pHYs_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_pHYs) +- { +- png_debug1(1, "in %s retrieval function\n", "png_get_pixels_per_meter"); +- if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER || +- info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit) +- return (0); +- else return (info_ptr->x_pixels_per_unit); +- } +-#else +- return (0); +-#endif +- return (0); +-} +- +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-float PNGAPI +-png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr) +- { +- if (png_ptr != NULL && info_ptr != NULL) +-#if defined(PNG_pHYs_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_pHYs) +- { +- png_debug1(1, "in %s retrieval function\n", "png_get_aspect_ratio"); +- if (info_ptr->x_pixels_per_unit == 0) +- return ((float)0.0); +- else +- return ((float)((float)info_ptr->y_pixels_per_unit +- /(float)info_ptr->x_pixels_per_unit)); +- } +-#else +- return (0.0); +-#endif +- return ((float)0.0); +-} +-#endif +- +-png_int_32 PNGAPI +-png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +-#if defined(PNG_oFFs_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_oFFs) +- { +- png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns"); +- if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER) +- return (0); +- else return (info_ptr->x_offset); +- } +-#else +- return (0); +-#endif +- return (0); +-} +- +-png_int_32 PNGAPI +-png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +-#if defined(PNG_oFFs_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_oFFs) +- { +- png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns"); +- if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER) +- return (0); +- else return (info_ptr->y_offset); +- } +-#else +- return (0); +-#endif +- return (0); +-} +- +-png_int_32 PNGAPI +-png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +-#if defined(PNG_oFFs_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_oFFs) +- { +- png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns"); +- if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL) +- return (0); +- else return (info_ptr->x_offset); +- } +-#else +- return (0); +-#endif +- return (0); +-} +- +-png_int_32 PNGAPI +-png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +-#if defined(PNG_oFFs_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_oFFs) +- { +- png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns"); +- if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL) +- return (0); +- else return (info_ptr->y_offset); +- } +-#else +- return (0); +-#endif +- return (0); +-} +- +-#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED) +-png_uint_32 PNGAPI +-png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) +-{ +- return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr) +- *.0254 +.5)); +-} +- +-png_uint_32 PNGAPI +-png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) +-{ +- return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr) +- *.0254 +.5)); +-} +- +-png_uint_32 PNGAPI +-png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) +-{ +- return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr) +- *.0254 +.5)); +-} +- +-float PNGAPI +-png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr) +-{ +- return ((float)png_get_x_offset_microns(png_ptr, info_ptr) +- *.00003937); +-} +- +-float PNGAPI +-png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr) +-{ +- return ((float)png_get_y_offset_microns(png_ptr, info_ptr) +- *.00003937); +-} +- +-#if defined(PNG_pHYs_SUPPORTED) +-png_uint_32 PNGAPI +-png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr, +- png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) +-{ +- png_uint_32 retval = 0; +- +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) +- { +- png_debug1(1, "in %s retrieval function\n", "pHYs"); +- if (res_x != NULL) +- { +- *res_x = info_ptr->x_pixels_per_unit; +- retval |= PNG_INFO_pHYs; +- } +- if (res_y != NULL) +- { +- *res_y = info_ptr->y_pixels_per_unit; +- retval |= PNG_INFO_pHYs; +- } +- if (unit_type != NULL) +- { +- *unit_type = (int)info_ptr->phys_unit_type; +- retval |= PNG_INFO_pHYs; +- if(*unit_type == 1) +- { +- if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50); +- if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50); +- } +- } +- } +- return (retval); +-} +-#endif /* PNG_pHYs_SUPPORTED */ +-#endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */ +- +-/* png_get_channels really belongs in here, too, but it's been around longer */ +- +-#endif /* PNG_EASY_ACCESS_SUPPORTED */ +- +-png_byte PNGAPI +-png_get_channels(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +- return(info_ptr->channels); +- else +- return (0); +-} +- +-png_bytep PNGAPI +-png_get_signature(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr != NULL && info_ptr != NULL) +- return(info_ptr->signature); +- else +- return (NULL); +-} +- +-#if defined(PNG_bKGD_SUPPORTED) +-png_uint_32 PNGAPI +-png_get_bKGD(png_structp png_ptr, png_infop info_ptr, +- png_color_16p *background) +-{ +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD) +- && background != NULL) +- { +- png_debug1(1, "in %s retrieval function\n", "bKGD"); +- *background = &(info_ptr->background); +- return (PNG_INFO_bKGD); +- } +- return (0); +-} +-#endif +- +-#if defined(PNG_cHRM_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-png_uint_32 PNGAPI +-png_get_cHRM(png_structp png_ptr, png_infop info_ptr, +- double *white_x, double *white_y, double *red_x, double *red_y, +- double *green_x, double *green_y, double *blue_x, double *blue_y) +-{ +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) +- { +- png_debug1(1, "in %s retrieval function\n", "cHRM"); +- if (white_x != NULL) +- *white_x = (double)info_ptr->x_white; +- if (white_y != NULL) +- *white_y = (double)info_ptr->y_white; +- if (red_x != NULL) +- *red_x = (double)info_ptr->x_red; +- if (red_y != NULL) +- *red_y = (double)info_ptr->y_red; +- if (green_x != NULL) +- *green_x = (double)info_ptr->x_green; +- if (green_y != NULL) +- *green_y = (double)info_ptr->y_green; +- if (blue_x != NULL) +- *blue_x = (double)info_ptr->x_blue; +- if (blue_y != NULL) +- *blue_y = (double)info_ptr->y_blue; +- return (PNG_INFO_cHRM); +- } +- return (0); +-} +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +-png_uint_32 PNGAPI +-png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr, +- png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x, +- png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y, +- png_fixed_point *blue_x, png_fixed_point *blue_y) +-{ +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) +- { +- png_debug1(1, "in %s retrieval function\n", "cHRM"); +- if (white_x != NULL) +- *white_x = info_ptr->int_x_white; +- if (white_y != NULL) +- *white_y = info_ptr->int_y_white; +- if (red_x != NULL) +- *red_x = info_ptr->int_x_red; +- if (red_y != NULL) +- *red_y = info_ptr->int_y_red; +- if (green_x != NULL) +- *green_x = info_ptr->int_x_green; +- if (green_y != NULL) +- *green_y = info_ptr->int_y_green; +- if (blue_x != NULL) +- *blue_x = info_ptr->int_x_blue; +- if (blue_y != NULL) +- *blue_y = info_ptr->int_y_blue; +- return (PNG_INFO_cHRM); +- } +- return (0); +-} +-#endif +-#endif +- +-#if defined(PNG_gAMA_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-png_uint_32 PNGAPI +-png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma) +-{ +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) +- && file_gamma != NULL) +- { +- png_debug1(1, "in %s retrieval function\n", "gAMA"); +- *file_gamma = (double)info_ptr->gamma; +- return (PNG_INFO_gAMA); +- } +- return (0); +-} +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +-png_uint_32 PNGAPI +-png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, +- png_fixed_point *int_file_gamma) +-{ +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) +- && int_file_gamma != NULL) +- { +- png_debug1(1, "in %s retrieval function\n", "gAMA"); +- *int_file_gamma = info_ptr->int_gamma; +- return (PNG_INFO_gAMA); +- } +- return (0); +-} +-#endif +-#endif +- +-#if defined(PNG_sRGB_SUPPORTED) +-png_uint_32 PNGAPI +-png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent) +-{ +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB) +- && file_srgb_intent != NULL) +- { +- png_debug1(1, "in %s retrieval function\n", "sRGB"); +- *file_srgb_intent = (int)info_ptr->srgb_intent; +- return (PNG_INFO_sRGB); +- } +- return (0); +-} +-#endif +- +-#if defined(PNG_iCCP_SUPPORTED) +-png_uint_32 PNGAPI +-png_get_iCCP(png_structp png_ptr, png_infop info_ptr, +- png_charpp name, int *compression_type, +- png_charpp profile, png_uint_32 *proflen) +-{ +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP) +- && name != NULL && profile != NULL && proflen != NULL) +- { +- png_debug1(1, "in %s retrieval function\n", "iCCP"); +- *name = info_ptr->iccp_name; +- *profile = info_ptr->iccp_profile; +- /* compression_type is a dummy so the API won't have to change +- if we introduce multiple compression types later. */ +- *proflen = (int)info_ptr->iccp_proflen; +- *compression_type = (int)info_ptr->iccp_compression; +- return (PNG_INFO_iCCP); +- } +- return (0); +-} +-#endif +- +-#if defined(PNG_sPLT_SUPPORTED) +-png_uint_32 PNGAPI +-png_get_sPLT(png_structp png_ptr, png_infop info_ptr, +- png_sPLT_tpp spalettes) +-{ +- if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL) +- *spalettes = info_ptr->splt_palettes; +- return ((png_uint_32)info_ptr->splt_palettes_num); +-} +-#endif +- +-#if defined(PNG_hIST_SUPPORTED) +-png_uint_32 PNGAPI +-png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist) +-{ +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST) +- && hist != NULL) +- { +- png_debug1(1, "in %s retrieval function\n", "hIST"); +- *hist = info_ptr->hist; +- return (PNG_INFO_hIST); +- } +- return (0); +-} +-#endif +- +-png_uint_32 PNGAPI +-png_get_IHDR(png_structp png_ptr, png_infop info_ptr, +- png_uint_32 *width, png_uint_32 *height, int *bit_depth, +- int *color_type, int *interlace_type, int *compression_type, +- int *filter_type) +- +-{ +- if (png_ptr != NULL && info_ptr != NULL && width != NULL && height != NULL && +- bit_depth != NULL && color_type != NULL) +- { +- png_debug1(1, "in %s retrieval function\n", "IHDR"); +- *width = info_ptr->width; +- *height = info_ptr->height; +- *bit_depth = info_ptr->bit_depth; +- if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16) +- png_error(png_ptr, "Invalid bit depth"); +- *color_type = info_ptr->color_type; +- if (info_ptr->color_type > 6) +- png_error(png_ptr, "Invalid color type"); +- if (compression_type != NULL) +- *compression_type = info_ptr->compression_type; +- if (filter_type != NULL) +- *filter_type = info_ptr->filter_type; +- if (interlace_type != NULL) +- *interlace_type = info_ptr->interlace_type; +- +- /* check for potential overflow of rowbytes */ +- if (width == 0 || *width > PNG_UINT_31_MAX) +- png_error(png_ptr, "Invalid image width"); +- if (height == 0 || *height > PNG_UINT_31_MAX) +- png_error(png_ptr, "Invalid image height"); +- if (info_ptr->width > (PNG_UINT_32_MAX +- >> 3) /* 8-byte RGBA pixels */ +- - 64 /* bigrowbuf hack */ +- - 1 /* filter byte */ +- - 7*8 /* rounding of width to multiple of 8 pixels */ +- - 8) /* extra max_pixel_depth pad */ +- { +- png_warning(png_ptr, +- "Width too large for libpng to process image data."); +- } +- return (1); +- } +- return (0); +-} +- +-#if defined(PNG_oFFs_SUPPORTED) +-png_uint_32 PNGAPI +-png_get_oFFs(png_structp png_ptr, png_infop info_ptr, +- png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type) +-{ +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs) +- && offset_x != NULL && offset_y != NULL && unit_type != NULL) +- { +- png_debug1(1, "in %s retrieval function\n", "oFFs"); +- *offset_x = info_ptr->x_offset; +- *offset_y = info_ptr->y_offset; +- *unit_type = (int)info_ptr->offset_unit_type; +- return (PNG_INFO_oFFs); +- } +- return (0); +-} +-#endif +- +-#if defined(PNG_pCAL_SUPPORTED) +-png_uint_32 PNGAPI +-png_get_pCAL(png_structp png_ptr, png_infop info_ptr, +- png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams, +- png_charp *units, png_charpp *params) +-{ +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL) +- && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL && +- nparams != NULL && units != NULL && params != NULL) +- { +- png_debug1(1, "in %s retrieval function\n", "pCAL"); +- *purpose = info_ptr->pcal_purpose; +- *X0 = info_ptr->pcal_X0; +- *X1 = info_ptr->pcal_X1; +- *type = (int)info_ptr->pcal_type; +- *nparams = (int)info_ptr->pcal_nparams; +- *units = info_ptr->pcal_units; +- *params = info_ptr->pcal_params; +- return (PNG_INFO_pCAL); +- } +- return (0); +-} +-#endif +- +-#if defined(PNG_sCAL_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-png_uint_32 PNGAPI +-png_get_sCAL(png_structp png_ptr, png_infop info_ptr, +- int *unit, double *width, double *height) +-{ +- if (png_ptr != NULL && info_ptr != NULL && +- (info_ptr->valid & PNG_INFO_sCAL)) +- { +- *unit = info_ptr->scal_unit; +- *width = info_ptr->scal_pixel_width; +- *height = info_ptr->scal_pixel_height; +- return (PNG_INFO_sCAL); +- } +- return(0); +-} +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +-png_uint_32 PNGAPI +-png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr, +- int *unit, png_charpp width, png_charpp height) +-{ +- if (png_ptr != NULL && info_ptr != NULL && +- (info_ptr->valid & PNG_INFO_sCAL)) +- { +- *unit = info_ptr->scal_unit; +- *width = info_ptr->scal_s_width; +- *height = info_ptr->scal_s_height; +- return (PNG_INFO_sCAL); +- } +- return(0); +-} +-#endif +-#endif +-#endif +- +-#if defined(PNG_pHYs_SUPPORTED) +-png_uint_32 PNGAPI +-png_get_pHYs(png_structp png_ptr, png_infop info_ptr, +- png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) +-{ +- png_uint_32 retval = 0; +- +- if (png_ptr != NULL && info_ptr != NULL && +- (info_ptr->valid & PNG_INFO_pHYs)) +- { +- png_debug1(1, "in %s retrieval function\n", "pHYs"); +- if (res_x != NULL) +- { +- *res_x = info_ptr->x_pixels_per_unit; +- retval |= PNG_INFO_pHYs; +- } +- if (res_y != NULL) +- { +- *res_y = info_ptr->y_pixels_per_unit; +- retval |= PNG_INFO_pHYs; +- } +- if (unit_type != NULL) +- { +- *unit_type = (int)info_ptr->phys_unit_type; +- retval |= PNG_INFO_pHYs; +- } +- } +- return (retval); +-} +-#endif +- +-png_uint_32 PNGAPI +-png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette, +- int *num_palette) +-{ +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE) +- && palette != NULL) +- { +- png_debug1(1, "in %s retrieval function\n", "PLTE"); +- *palette = info_ptr->palette; +- *num_palette = info_ptr->num_palette; +- png_debug1(3, "num_palette = %d\n", *num_palette); +- return (PNG_INFO_PLTE); +- } +- return (0); +-} +- +-#if defined(PNG_sBIT_SUPPORTED) +-png_uint_32 PNGAPI +-png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit) +-{ +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT) +- && sig_bit != NULL) +- { +- png_debug1(1, "in %s retrieval function\n", "sBIT"); +- *sig_bit = &(info_ptr->sig_bit); +- return (PNG_INFO_sBIT); +- } +- return (0); +-} +-#endif +- +-#if defined(PNG_TEXT_SUPPORTED) +-png_uint_32 PNGAPI +-png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr, +- int *num_text) +-{ +- if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0) +- { +- png_debug1(1, "in %s retrieval function\n", +- (png_ptr->chunk_name[0] == '\0' ? "text" +- : (png_const_charp)png_ptr->chunk_name)); +- if (text_ptr != NULL) +- *text_ptr = info_ptr->text; +- if (num_text != NULL) +- *num_text = info_ptr->num_text; +- return ((png_uint_32)info_ptr->num_text); +- } +- if (num_text != NULL) +- *num_text = 0; +- return(0); +-} +-#endif +- +-#if defined(PNG_tIME_SUPPORTED) +-png_uint_32 PNGAPI +-png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time) +-{ +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME) +- && mod_time != NULL) +- { +- png_debug1(1, "in %s retrieval function\n", "tIME"); +- *mod_time = &(info_ptr->mod_time); +- return (PNG_INFO_tIME); +- } +- return (0); +-} +-#endif +- +-#if defined(PNG_tRNS_SUPPORTED) +-png_uint_32 PNGAPI +-png_get_tRNS(png_structp png_ptr, png_infop info_ptr, +- png_bytep *trans, int *num_trans, png_color_16p *trans_values) +-{ +- png_uint_32 retval = 0; +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) +- { +- png_debug1(1, "in %s retrieval function\n", "tRNS"); +- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- { +- if (trans != NULL) +- { +- *trans = info_ptr->trans; +- retval |= PNG_INFO_tRNS; +- } +- if (trans_values != NULL) +- *trans_values = &(info_ptr->trans_values); +- } +- else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */ +- { +- if (trans_values != NULL) +- { +- *trans_values = &(info_ptr->trans_values); +- retval |= PNG_INFO_tRNS; +- } +- if(trans != NULL) +- *trans = NULL; +- } +- if(num_trans != NULL) +- { +- *num_trans = info_ptr->num_trans; +- retval |= PNG_INFO_tRNS; +- } +- } +- return (retval); +-} +-#endif +- +-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +-png_uint_32 PNGAPI +-png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr, +- png_unknown_chunkpp unknowns) +-{ +- if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL) +- *unknowns = info_ptr->unknown_chunks; +- return ((png_uint_32)info_ptr->unknown_chunks_num); +-} +-#endif +- +-#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +-png_byte PNGAPI +-png_get_rgb_to_gray_status (png_structp png_ptr) +-{ +- return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0); +-} +-#endif +- +-#if defined(PNG_USER_CHUNKS_SUPPORTED) +-png_voidp PNGAPI +-png_get_user_chunk_ptr(png_structp png_ptr) +-{ +- return (png_ptr? png_ptr->user_chunk_ptr : NULL); +-} +-#endif +- +-#ifdef PNG_WRITE_SUPPORTED +-png_uint_32 PNGAPI +-png_get_compression_buffer_size(png_structp png_ptr) +-{ +- return (png_uint_32)(png_ptr? png_ptr->zbuf_size : 0L); +-} +-#endif +- +-#ifndef PNG_1_0_X +-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED +-/* this function was added to libpng 1.2.0 and should exist by default */ +-png_uint_32 PNGAPI +-png_get_asm_flags (png_structp png_ptr) +-{ +- return (png_uint_32)(png_ptr? png_ptr->asm_flags : 0L); +-} +- +-/* this function was added to libpng 1.2.0 and should exist by default */ +-png_uint_32 PNGAPI +-png_get_asm_flagmask (int flag_select) +-{ +- png_uint_32 settable_asm_flags = 0; +- +- if (flag_select & PNG_SELECT_READ) +- settable_asm_flags |= +- PNG_ASM_FLAG_MMX_READ_COMBINE_ROW | +- PNG_ASM_FLAG_MMX_READ_INTERLACE | +- PNG_ASM_FLAG_MMX_READ_FILTER_SUB | +- PNG_ASM_FLAG_MMX_READ_FILTER_UP | +- PNG_ASM_FLAG_MMX_READ_FILTER_AVG | +- PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ; +- /* no non-MMX flags yet */ +- +-#if 0 +- /* GRR: no write-flags yet, either, but someday... */ +- if (flag_select & PNG_SELECT_WRITE) +- settable_asm_flags |= +- PNG_ASM_FLAG_MMX_WRITE_ [whatever] ; +-#endif /* 0 */ +- +- return settable_asm_flags; /* _theoretically_ settable capabilities only */ +-} +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ +- +- +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +- /* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */ +-/* this function was added to libpng 1.2.0 */ +-png_uint_32 PNGAPI +-png_get_mmx_flagmask (int flag_select, int *compilerID) +-{ +- png_uint_32 settable_mmx_flags = 0; +- +- if (flag_select & PNG_SELECT_READ) +- settable_mmx_flags |= +- PNG_ASM_FLAG_MMX_READ_COMBINE_ROW | +- PNG_ASM_FLAG_MMX_READ_INTERLACE | +- PNG_ASM_FLAG_MMX_READ_FILTER_SUB | +- PNG_ASM_FLAG_MMX_READ_FILTER_UP | +- PNG_ASM_FLAG_MMX_READ_FILTER_AVG | +- PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ; +-#if 0 +- /* GRR: no MMX write support yet, but someday... */ +- if (flag_select & PNG_SELECT_WRITE) +- settable_mmx_flags |= +- PNG_ASM_FLAG_MMX_WRITE_ [whatever] ; +-#endif /* 0 */ +- +- if (compilerID != NULL) { +-#ifdef PNG_USE_PNGVCRD +- *compilerID = 1; /* MSVC */ +-#else +-#ifdef PNG_USE_PNGGCCRD +- *compilerID = 2; /* gcc/gas */ +-#else +- *compilerID = -1; /* unknown (i.e., no asm/MMX code compiled) */ +-#endif +-#endif +- } +- +- return settable_mmx_flags; /* _theoretically_ settable capabilities only */ +-} +- +-/* this function was added to libpng 1.2.0 */ +-png_byte PNGAPI +-png_get_mmx_bitdepth_threshold (png_structp png_ptr) +-{ +- return (png_byte)(png_ptr? png_ptr->mmx_bitdepth_threshold : 0); +-} +- +-/* this function was added to libpng 1.2.0 */ +-png_uint_32 PNGAPI +-png_get_mmx_rowbytes_threshold (png_structp png_ptr) +-{ +- return (png_uint_32)(png_ptr? png_ptr->mmx_rowbytes_threshold : 0L); +-} +-#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */ +- +-#ifdef PNG_SET_USER_LIMITS_SUPPORTED +-/* these functions were added to libpng 1.2.6 */ +-png_uint_32 PNGAPI +-png_get_user_width_max (png_structp png_ptr) +-{ +- return (png_ptr? png_ptr->user_width_max : 0); +-} +-png_uint_32 PNGAPI +-png_get_user_height_max (png_structp png_ptr) +-{ +- return (png_ptr? png_ptr->user_height_max : 0); +-} +-#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */ +- +-#endif /* ?PNG_1_0_X */ +diff --git a/thirdparty/libpng/pngmem.c b/thirdparty/libpng/pngmem.c +deleted file mode 100644 +index 2682394..0000000 +--- a/thirdparty/libpng/pngmem.c ++++ /dev/null +@@ -1,595 +0,0 @@ +- +-/* pngmem.c - stub functions for memory allocation +- * +- * libpng version 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- * +- * This file provides a location for all memory allocation. Users who +- * need special memory handling are expected to supply replacement +- * functions for png_malloc() and png_free(), and to use +- * png_create_read_struct_2() and png_create_write_struct_2() to +- * identify the replacement functions. +- */ +- +-#define PNG_INTERNAL +-#include "png.h" +- +-/* Borland DOS special memory handler */ +-#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) +-/* if you change this, be sure to change the one in png.h also */ +- +-/* Allocate memory for a png_struct. The malloc and memset can be replaced +- by a single call to calloc() if this is thought to improve performance. */ +-png_voidp /* PRIVATE */ +-png_create_struct(int type) +-{ +-#ifdef PNG_USER_MEM_SUPPORTED +- return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL)); +-} +- +-/* Alternate version of png_create_struct, for use with user-defined malloc. */ +-png_voidp /* PRIVATE */ +-png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr) +-{ +-#endif /* PNG_USER_MEM_SUPPORTED */ +- png_size_t size; +- png_voidp struct_ptr; +- +- if (type == PNG_STRUCT_INFO) +- size = png_sizeof(png_info); +- else if (type == PNG_STRUCT_PNG) +- size = png_sizeof(png_struct); +- else +- return (png_get_copyright(NULL)); +- +-#ifdef PNG_USER_MEM_SUPPORTED +- if(malloc_fn != NULL) +- { +- png_struct dummy_struct; +- png_structp png_ptr = &dummy_struct; +- png_ptr->mem_ptr=mem_ptr; +- struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size); +- } +- else +-#endif /* PNG_USER_MEM_SUPPORTED */ +- struct_ptr = (png_voidp)farmalloc(size); +- if (struct_ptr != NULL) +- png_memset(struct_ptr, 0, size); +- return (struct_ptr); +-} +- +-/* Free memory allocated by a png_create_struct() call */ +-void /* PRIVATE */ +-png_destroy_struct(png_voidp struct_ptr) +-{ +-#ifdef PNG_USER_MEM_SUPPORTED +- png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL); +-} +- +-/* Free memory allocated by a png_create_struct() call */ +-void /* PRIVATE */ +-png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, +- png_voidp mem_ptr) +-{ +-#endif +- if (struct_ptr != NULL) +- { +-#ifdef PNG_USER_MEM_SUPPORTED +- if(free_fn != NULL) +- { +- png_struct dummy_struct; +- png_structp png_ptr = &dummy_struct; +- png_ptr->mem_ptr=mem_ptr; +- (*(free_fn))(png_ptr, struct_ptr); +- return; +- } +-#endif /* PNG_USER_MEM_SUPPORTED */ +- farfree (struct_ptr); +- } +-} +- +-/* Allocate memory. For reasonable files, size should never exceed +- * 64K. However, zlib may allocate more then 64K if you don't tell +- * it not to. See zconf.h and png.h for more information. zlib does +- * need to allocate exactly 64K, so whatever you call here must +- * have the ability to do that. +- * +- * Borland seems to have a problem in DOS mode for exactly 64K. +- * It gives you a segment with an offset of 8 (perhaps to store its +- * memory stuff). zlib doesn't like this at all, so we have to +- * detect and deal with it. This code should not be needed in +- * Windows or OS/2 modes, and only in 16 bit mode. This code has +- * been updated by Alexander Lehmann for version 0.89 to waste less +- * memory. +- * +- * Note that we can't use png_size_t for the "size" declaration, +- * since on some systems a png_size_t is a 16-bit quantity, and as a +- * result, we would be truncating potentially larger memory requests +- * (which should cause a fatal error) and introducing major problems. +- */ +- +-png_voidp PNGAPI +-png_malloc(png_structp png_ptr, png_uint_32 size) +-{ +- png_voidp ret; +- +- if (png_ptr == NULL || size == 0) +- return (NULL); +- +-#ifdef PNG_USER_MEM_SUPPORTED +- if(png_ptr->malloc_fn != NULL) +- ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size)); +- else +- ret = (png_malloc_default(png_ptr, size)); +- if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) +- png_error(png_ptr, "Out of memory!"); +- return (ret); +-} +- +-png_voidp PNGAPI +-png_malloc_default(png_structp png_ptr, png_uint_32 size) +-{ +- png_voidp ret; +-#endif /* PNG_USER_MEM_SUPPORTED */ +- +-#ifdef PNG_MAX_MALLOC_64K +- if (size > (png_uint_32)65536L) +- { +- png_warning(png_ptr, "Cannot Allocate > 64K"); +- ret = NULL; +- } +- else +-#endif +- +- if (size != (size_t)size) +- ret = NULL; +- else if (size == (png_uint_32)65536L) +- { +- if (png_ptr->offset_table == NULL) +- { +- /* try to see if we need to do any of this fancy stuff */ +- ret = farmalloc(size); +- if (ret == NULL || ((png_size_t)ret & 0xffff)) +- { +- int num_blocks; +- png_uint_32 total_size; +- png_bytep table; +- int i; +- png_byte huge * hptr; +- +- if (ret != NULL) +- { +- farfree(ret); +- ret = NULL; +- } +- +- if(png_ptr->zlib_window_bits > 14) +- num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14)); +- else +- num_blocks = 1; +- if (png_ptr->zlib_mem_level >= 7) +- num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7)); +- else +- num_blocks++; +- +- total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16; +- +- table = farmalloc(total_size); +- +- if (table == NULL) +- { +-#ifndef PNG_USER_MEM_SUPPORTED +- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) +- png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */ +- else +- png_warning(png_ptr, "Out Of Memory."); +-#endif +- return (NULL); +- } +- +- if ((png_size_t)table & 0xfff0) +- { +-#ifndef PNG_USER_MEM_SUPPORTED +- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) +- png_error(png_ptr, +- "Farmalloc didn't return normalized pointer"); +- else +- png_warning(png_ptr, +- "Farmalloc didn't return normalized pointer"); +-#endif +- return (NULL); +- } +- +- png_ptr->offset_table = table; +- png_ptr->offset_table_ptr = farmalloc(num_blocks * +- png_sizeof (png_bytep)); +- +- if (png_ptr->offset_table_ptr == NULL) +- { +-#ifndef PNG_USER_MEM_SUPPORTED +- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) +- png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */ +- else +- png_warning(png_ptr, "Out Of memory."); +-#endif +- return (NULL); +- } +- +- hptr = (png_byte huge *)table; +- if ((png_size_t)hptr & 0xf) +- { +- hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L); +- hptr = hptr + 16L; /* "hptr += 16L" fails on Turbo C++ 3.0 */ +- } +- for (i = 0; i < num_blocks; i++) +- { +- png_ptr->offset_table_ptr[i] = (png_bytep)hptr; +- hptr = hptr + (png_uint_32)65536L; /* "+=" fails on TC++3.0 */ +- } +- +- png_ptr->offset_table_number = num_blocks; +- png_ptr->offset_table_count = 0; +- png_ptr->offset_table_count_free = 0; +- } +- } +- +- if (png_ptr->offset_table_count >= png_ptr->offset_table_number) +- { +-#ifndef PNG_USER_MEM_SUPPORTED +- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) +- png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */ +- else +- png_warning(png_ptr, "Out of Memory."); +-#endif +- return (NULL); +- } +- +- ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++]; +- } +- else +- ret = farmalloc(size); +- +-#ifndef PNG_USER_MEM_SUPPORTED +- if (ret == NULL) +- { +- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) +- png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */ +- else +- png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */ +- } +-#endif +- +- return (ret); +-} +- +-/* free a pointer allocated by png_malloc(). In the default +- configuration, png_ptr is not used, but is passed in case it +- is needed. If ptr is NULL, return without taking any action. */ +-void PNGAPI +-png_free(png_structp png_ptr, png_voidp ptr) +-{ +- if (png_ptr == NULL || ptr == NULL) +- return; +- +-#ifdef PNG_USER_MEM_SUPPORTED +- if (png_ptr->free_fn != NULL) +- { +- (*(png_ptr->free_fn))(png_ptr, ptr); +- return; +- } +- else png_free_default(png_ptr, ptr); +-} +- +-void PNGAPI +-png_free_default(png_structp png_ptr, png_voidp ptr) +-{ +-#endif /* PNG_USER_MEM_SUPPORTED */ +- +- if (png_ptr->offset_table != NULL) +- { +- int i; +- +- for (i = 0; i < png_ptr->offset_table_count; i++) +- { +- if (ptr == png_ptr->offset_table_ptr[i]) +- { +- ptr = NULL; +- png_ptr->offset_table_count_free++; +- break; +- } +- } +- if (png_ptr->offset_table_count_free == png_ptr->offset_table_count) +- { +- farfree(png_ptr->offset_table); +- farfree(png_ptr->offset_table_ptr); +- png_ptr->offset_table = NULL; +- png_ptr->offset_table_ptr = NULL; +- } +- } +- +- if (ptr != NULL) +- { +- farfree(ptr); +- } +-} +- +-#else /* Not the Borland DOS special memory handler */ +- +-/* Allocate memory for a png_struct or a png_info. The malloc and +- memset can be replaced by a single call to calloc() if this is thought +- to improve performance noticably. */ +-png_voidp /* PRIVATE */ +-png_create_struct(int type) +-{ +-#ifdef PNG_USER_MEM_SUPPORTED +- return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL)); +-} +- +-/* Allocate memory for a png_struct or a png_info. The malloc and +- memset can be replaced by a single call to calloc() if this is thought +- to improve performance noticably. */ +-png_voidp /* PRIVATE */ +-png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr) +-{ +-#endif /* PNG_USER_MEM_SUPPORTED */ +- png_size_t size; +- png_voidp struct_ptr; +- +- if (type == PNG_STRUCT_INFO) +- size = png_sizeof(png_info); +- else if (type == PNG_STRUCT_PNG) +- size = png_sizeof(png_struct); +- else +- return (NULL); +- +-#ifdef PNG_USER_MEM_SUPPORTED +- if(malloc_fn != NULL) +- { +- png_struct dummy_struct; +- png_structp png_ptr = &dummy_struct; +- png_ptr->mem_ptr=mem_ptr; +- struct_ptr = (*(malloc_fn))(png_ptr, size); +- if (struct_ptr != NULL) +- png_memset(struct_ptr, 0, size); +- return (struct_ptr); +- } +-#endif /* PNG_USER_MEM_SUPPORTED */ +- +-#if defined(__TURBOC__) && !defined(__FLAT__) +- struct_ptr = (png_voidp)farmalloc(size); +-#else +-# if defined(_MSC_VER) && defined(MAXSEG_64K) +- struct_ptr = (png_voidp)halloc(size,1); +-# else +- struct_ptr = (png_voidp)malloc(size); +-# endif +-#endif +- if (struct_ptr != NULL) +- png_memset(struct_ptr, 0, size); +- +- return (struct_ptr); +-} +- +- +-/* Free memory allocated by a png_create_struct() call */ +-void /* PRIVATE */ +-png_destroy_struct(png_voidp struct_ptr) +-{ +-#ifdef PNG_USER_MEM_SUPPORTED +- png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL); +-} +- +-/* Free memory allocated by a png_create_struct() call */ +-void /* PRIVATE */ +-png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, +- png_voidp mem_ptr) +-{ +-#endif /* PNG_USER_MEM_SUPPORTED */ +- if (struct_ptr != NULL) +- { +-#ifdef PNG_USER_MEM_SUPPORTED +- if(free_fn != NULL) +- { +- png_struct dummy_struct; +- png_structp png_ptr = &dummy_struct; +- png_ptr->mem_ptr=mem_ptr; +- (*(free_fn))(png_ptr, struct_ptr); +- return; +- } +-#endif /* PNG_USER_MEM_SUPPORTED */ +-#if defined(__TURBOC__) && !defined(__FLAT__) +- farfree(struct_ptr); +-#else +-# if defined(_MSC_VER) && defined(MAXSEG_64K) +- hfree(struct_ptr); +-# else +- free(struct_ptr); +-# endif +-#endif +- } +-} +- +-/* Allocate memory. For reasonable files, size should never exceed +- 64K. However, zlib may allocate more then 64K if you don't tell +- it not to. See zconf.h and png.h for more information. zlib does +- need to allocate exactly 64K, so whatever you call here must +- have the ability to do that. */ +- +-png_voidp PNGAPI +-png_malloc(png_structp png_ptr, png_uint_32 size) +-{ +- png_voidp ret; +- +-#ifdef PNG_USER_MEM_SUPPORTED +- if (png_ptr == NULL || size == 0) +- return (NULL); +- +- if(png_ptr->malloc_fn != NULL) +- ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size)); +- else +- ret = (png_malloc_default(png_ptr, size)); +- if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) +- png_error(png_ptr, "Out of Memory!"); +- return (ret); +-} +- +-png_voidp PNGAPI +-png_malloc_default(png_structp png_ptr, png_uint_32 size) +-{ +- png_voidp ret; +-#endif /* PNG_USER_MEM_SUPPORTED */ +- +- if (png_ptr == NULL || size == 0) +- return (NULL); +- +-#ifdef PNG_MAX_MALLOC_64K +- if (size > (png_uint_32)65536L) +- { +-#ifndef PNG_USER_MEM_SUPPORTED +- if(png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) +- png_error(png_ptr, "Cannot Allocate > 64K"); +- else +-#endif +- return NULL; +- } +-#endif +- +- /* Check for overflow */ +-#if defined(__TURBOC__) && !defined(__FLAT__) +- if (size != (unsigned long)size) +- ret = NULL; +- else +- ret = farmalloc(size); +-#else +-# if defined(_MSC_VER) && defined(MAXSEG_64K) +- if (size != (unsigned long)size) +- ret = NULL; +- else +- ret = halloc(size, 1); +-# else +- if (size != (size_t)size) +- ret = NULL; +- else +- ret = malloc((size_t)size); +-# endif +-#endif +- +-#ifndef PNG_USER_MEM_SUPPORTED +- if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) +- png_error(png_ptr, "Out of Memory"); +-#endif +- +- return (ret); +-} +- +-/* Free a pointer allocated by png_malloc(). If ptr is NULL, return +- without taking any action. */ +-void PNGAPI +-png_free(png_structp png_ptr, png_voidp ptr) +-{ +- if (png_ptr == NULL || ptr == NULL) +- return; +- +-#ifdef PNG_USER_MEM_SUPPORTED +- if (png_ptr->free_fn != NULL) +- { +- (*(png_ptr->free_fn))(png_ptr, ptr); +- return; +- } +- else png_free_default(png_ptr, ptr); +-} +-void PNGAPI +-png_free_default(png_structp png_ptr, png_voidp ptr) +-{ +- if (png_ptr == NULL || ptr == NULL) +- return; +- +-#endif /* PNG_USER_MEM_SUPPORTED */ +- +-#if defined(__TURBOC__) && !defined(__FLAT__) +- farfree(ptr); +-#else +-# if defined(_MSC_VER) && defined(MAXSEG_64K) +- hfree(ptr); +-# else +- free(ptr); +-# endif +-#endif +-} +- +-#endif /* Not Borland DOS special memory handler */ +- +-#if defined(PNG_1_0_X) +-# define png_malloc_warn png_malloc +-#else +-/* This function was added at libpng version 1.2.3. The png_malloc_warn() +- * function will set up png_malloc() to issue a png_warning and return NULL +- * instead of issuing a png_error, if it fails to allocate the requested +- * memory. +- */ +-png_voidp PNGAPI +-png_malloc_warn(png_structp png_ptr, png_uint_32 size) +-{ +- png_voidp ptr; +- png_uint_32 save_flags=png_ptr->flags; +- +- png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; +- ptr = (png_voidp)png_malloc((png_structp)png_ptr, size); +- png_ptr->flags=save_flags; +- return(ptr); +-} +-#endif +- +-png_voidp PNGAPI +-png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2, +- png_uint_32 length) +-{ +- png_size_t size; +- +- size = (png_size_t)length; +- if ((png_uint_32)size != length) +- png_error(png_ptr,"Overflow in png_memcpy_check."); +- +- return(png_memcpy (s1, s2, size)); +-} +- +-png_voidp PNGAPI +-png_memset_check (png_structp png_ptr, png_voidp s1, int value, +- png_uint_32 length) +-{ +- png_size_t size; +- +- size = (png_size_t)length; +- if ((png_uint_32)size != length) +- png_error(png_ptr,"Overflow in png_memset_check."); +- +- return (png_memset (s1, value, size)); +- +-} +- +-#ifdef PNG_USER_MEM_SUPPORTED +-/* This function is called when the application wants to use another method +- * of allocating and freeing memory. +- */ +-void PNGAPI +-png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr +- malloc_fn, png_free_ptr free_fn) +-{ +- png_ptr->mem_ptr = mem_ptr; +- png_ptr->malloc_fn = malloc_fn; +- png_ptr->free_fn = free_fn; +-} +- +-/* This function returns a pointer to the mem_ptr associated with the user +- * functions. The application should free any memory associated with this +- * pointer before png_write_destroy and png_read_destroy are called. +- */ +-png_voidp PNGAPI +-png_get_mem_ptr(png_structp png_ptr) +-{ +- return ((png_voidp)png_ptr->mem_ptr); +-} +-#endif /* PNG_USER_MEM_SUPPORTED */ +diff --git a/thirdparty/libpng/pngpread.c b/thirdparty/libpng/pngpread.c +deleted file mode 100644 +index bbf2e14..0000000 +--- a/thirdparty/libpng/pngpread.c ++++ /dev/null +@@ -1,1573 +0,0 @@ +- +-/* pngpread.c - read a png file in push mode +- * +- * libpng version 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- */ +- +-#define PNG_INTERNAL +-#include "png.h" +- +-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +- +-/* push model modes */ +-#define PNG_READ_SIG_MODE 0 +-#define PNG_READ_CHUNK_MODE 1 +-#define PNG_READ_IDAT_MODE 2 +-#define PNG_SKIP_MODE 3 +-#define PNG_READ_tEXt_MODE 4 +-#define PNG_READ_zTXt_MODE 5 +-#define PNG_READ_DONE_MODE 6 +-#define PNG_READ_iTXt_MODE 7 +-#define PNG_ERROR_MODE 8 +- +-void PNGAPI +-png_process_data(png_structp png_ptr, png_infop info_ptr, +- png_bytep buffer, png_size_t buffer_size) +-{ +- png_push_restore_buffer(png_ptr, buffer, buffer_size); +- +- while (png_ptr->buffer_size) +- { +- png_process_some_data(png_ptr, info_ptr); +- } +-} +- +-/* What we do with the incoming data depends on what we were previously +- * doing before we ran out of data... +- */ +-void /* PRIVATE */ +-png_process_some_data(png_structp png_ptr, png_infop info_ptr) +-{ +- switch (png_ptr->process_mode) +- { +- case PNG_READ_SIG_MODE: +- { +- png_push_read_sig(png_ptr, info_ptr); +- break; +- } +- case PNG_READ_CHUNK_MODE: +- { +- png_push_read_chunk(png_ptr, info_ptr); +- break; +- } +- case PNG_READ_IDAT_MODE: +- { +- png_push_read_IDAT(png_ptr); +- break; +- } +-#if defined(PNG_READ_tEXt_SUPPORTED) +- case PNG_READ_tEXt_MODE: +- { +- png_push_read_tEXt(png_ptr, info_ptr); +- break; +- } +-#endif +-#if defined(PNG_READ_zTXt_SUPPORTED) +- case PNG_READ_zTXt_MODE: +- { +- png_push_read_zTXt(png_ptr, info_ptr); +- break; +- } +-#endif +-#if defined(PNG_READ_iTXt_SUPPORTED) +- case PNG_READ_iTXt_MODE: +- { +- png_push_read_iTXt(png_ptr, info_ptr); +- break; +- } +-#endif +- case PNG_SKIP_MODE: +- { +- png_push_crc_finish(png_ptr); +- break; +- } +- default: +- { +- png_ptr->buffer_size = 0; +- break; +- } +- } +-} +- +-/* Read any remaining signature bytes from the stream and compare them with +- * the correct PNG signature. It is possible that this routine is called +- * with bytes already read from the signature, either because they have been +- * checked by the calling application, or because of multiple calls to this +- * routine. +- */ +-void /* PRIVATE */ +-png_push_read_sig(png_structp png_ptr, png_infop info_ptr) +-{ +- png_size_t num_checked = png_ptr->sig_bytes, +- num_to_check = 8 - num_checked; +- +- if (png_ptr->buffer_size < num_to_check) +- { +- num_to_check = png_ptr->buffer_size; +- } +- +- png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]), +- num_to_check); +- png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes+num_to_check); +- +- if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) +- { +- if (num_checked < 4 && +- png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4)) +- png_error(png_ptr, "Not a PNG file"); +- else +- png_error(png_ptr, "PNG file corrupted by ASCII conversion"); +- } +- else +- { +- if (png_ptr->sig_bytes >= 8) +- { +- png_ptr->process_mode = PNG_READ_CHUNK_MODE; +- } +- } +-} +- +-void /* PRIVATE */ +-png_push_read_chunk(png_structp png_ptr, png_infop info_ptr) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_IHDR; +- PNG_IDAT; +- PNG_IEND; +- PNG_PLTE; +-#if defined(PNG_READ_bKGD_SUPPORTED) +- PNG_bKGD; +-#endif +-#if defined(PNG_READ_cHRM_SUPPORTED) +- PNG_cHRM; +-#endif +-#if defined(PNG_READ_gAMA_SUPPORTED) +- PNG_gAMA; +-#endif +-#if defined(PNG_READ_hIST_SUPPORTED) +- PNG_hIST; +-#endif +-#if defined(PNG_READ_iCCP_SUPPORTED) +- PNG_iCCP; +-#endif +-#if defined(PNG_READ_iTXt_SUPPORTED) +- PNG_iTXt; +-#endif +-#if defined(PNG_READ_oFFs_SUPPORTED) +- PNG_oFFs; +-#endif +-#if defined(PNG_READ_pCAL_SUPPORTED) +- PNG_pCAL; +-#endif +-#if defined(PNG_READ_pHYs_SUPPORTED) +- PNG_pHYs; +-#endif +-#if defined(PNG_READ_sBIT_SUPPORTED) +- PNG_sBIT; +-#endif +-#if defined(PNG_READ_sCAL_SUPPORTED) +- PNG_sCAL; +-#endif +-#if defined(PNG_READ_sRGB_SUPPORTED) +- PNG_sRGB; +-#endif +-#if defined(PNG_READ_sPLT_SUPPORTED) +- PNG_sPLT; +-#endif +-#if defined(PNG_READ_tEXt_SUPPORTED) +- PNG_tEXt; +-#endif +-#if defined(PNG_READ_tIME_SUPPORTED) +- PNG_tIME; +-#endif +-#if defined(PNG_READ_tRNS_SUPPORTED) +- PNG_tRNS; +-#endif +-#if defined(PNG_READ_zTXt_SUPPORTED) +- PNG_zTXt; +-#endif +-#endif /* PNG_USE_LOCAL_ARRAYS */ +- /* First we make sure we have enough data for the 4 byte chunk name +- * and the 4 byte chunk length before proceeding with decoding the +- * chunk data. To fully decode each of these chunks, we also make +- * sure we have enough data in the buffer for the 4 byte CRC at the +- * end of every chunk (except IDAT, which is handled separately). +- */ +- if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER)) +- { +- png_byte chunk_length[4]; +- +- if (png_ptr->buffer_size < 8) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- +- png_push_fill_buffer(png_ptr, chunk_length, 4); +- png_ptr->push_length = png_get_uint_31(png_ptr,chunk_length); +- png_reset_crc(png_ptr); +- png_crc_read(png_ptr, png_ptr->chunk_name, 4); +- png_ptr->mode |= PNG_HAVE_CHUNK_HEADER; +- } +- +- if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length); +- } +- else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length); +- +- png_ptr->process_mode = PNG_READ_DONE_MODE; +- png_push_have_end(png_ptr, info_ptr); +- } +-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +- else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) +- png_ptr->mode |= PNG_HAVE_IDAT; +- png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length); +- if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) +- png_ptr->mode |= PNG_HAVE_PLTE; +- else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) +- { +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before IDAT"); +- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && +- !(png_ptr->mode & PNG_HAVE_PLTE)) +- png_error(png_ptr, "Missing PLTE before IDAT"); +- } +- } +-#endif +- else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length); +- } +- else if (!png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4)) +- { +- /* If we reach an IDAT chunk, this means we have read all of the +- * header chunks, and we can start reading the image (or if this +- * is called after the image has been read - we have an error). +- */ +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before IDAT"); +- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && +- !(png_ptr->mode & PNG_HAVE_PLTE)) +- png_error(png_ptr, "Missing PLTE before IDAT"); +- +- if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- if (png_ptr->push_length == 0) +- return; +- +- if (png_ptr->mode & PNG_AFTER_IDAT) +- png_error(png_ptr, "Too many IDAT's found"); +- } +- +- png_ptr->idat_size = png_ptr->push_length; +- png_ptr->mode |= PNG_HAVE_IDAT; +- png_ptr->process_mode = PNG_READ_IDAT_MODE; +- png_push_have_info(png_ptr, info_ptr); +- png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; +- png_ptr->zstream.next_out = png_ptr->row_buf; +- return; +- } +-#if defined(PNG_READ_gAMA_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_sBIT_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_cHRM_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_sRGB_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_iCCP_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_sPLT_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_tRNS_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_bKGD_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_hIST_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_pHYs_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_oFFs_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_pCAL_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_sCAL_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_tIME_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_tEXt_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_zTXt_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +-#if defined(PNG_READ_iTXt_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length); +- } +-#endif +- else +- { +- if (png_ptr->push_length + 4 > png_ptr->buffer_size) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length); +- } +- +- png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; +-} +- +-void /* PRIVATE */ +-png_push_crc_skip(png_structp png_ptr, png_uint_32 skip) +-{ +- png_ptr->process_mode = PNG_SKIP_MODE; +- png_ptr->skip_length = skip; +-} +- +-void /* PRIVATE */ +-png_push_crc_finish(png_structp png_ptr) +-{ +- if (png_ptr->skip_length && png_ptr->save_buffer_size) +- { +- png_size_t save_size; +- +- if (png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size) +- save_size = (png_size_t)png_ptr->skip_length; +- else +- save_size = png_ptr->save_buffer_size; +- +- png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); +- +- png_ptr->skip_length -= save_size; +- png_ptr->buffer_size -= save_size; +- png_ptr->save_buffer_size -= save_size; +- png_ptr->save_buffer_ptr += save_size; +- } +- if (png_ptr->skip_length && png_ptr->current_buffer_size) +- { +- png_size_t save_size; +- +- if (png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size) +- save_size = (png_size_t)png_ptr->skip_length; +- else +- save_size = png_ptr->current_buffer_size; +- +- png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size); +- +- png_ptr->skip_length -= save_size; +- png_ptr->buffer_size -= save_size; +- png_ptr->current_buffer_size -= save_size; +- png_ptr->current_buffer_ptr += save_size; +- } +- if (!png_ptr->skip_length) +- { +- if (png_ptr->buffer_size < 4) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- +- png_crc_finish(png_ptr, 0); +- png_ptr->process_mode = PNG_READ_CHUNK_MODE; +- } +-} +- +-void PNGAPI +-png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length) +-{ +- png_bytep ptr; +- +- ptr = buffer; +- if (png_ptr->save_buffer_size) +- { +- png_size_t save_size; +- +- if (length < png_ptr->save_buffer_size) +- save_size = length; +- else +- save_size = png_ptr->save_buffer_size; +- +- png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size); +- length -= save_size; +- ptr += save_size; +- png_ptr->buffer_size -= save_size; +- png_ptr->save_buffer_size -= save_size; +- png_ptr->save_buffer_ptr += save_size; +- } +- if (length && png_ptr->current_buffer_size) +- { +- png_size_t save_size; +- +- if (length < png_ptr->current_buffer_size) +- save_size = length; +- else +- save_size = png_ptr->current_buffer_size; +- +- png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size); +- png_ptr->buffer_size -= save_size; +- png_ptr->current_buffer_size -= save_size; +- png_ptr->current_buffer_ptr += save_size; +- } +-} +- +-void /* PRIVATE */ +-png_push_save_buffer(png_structp png_ptr) +-{ +- if (png_ptr->save_buffer_size) +- { +- if (png_ptr->save_buffer_ptr != png_ptr->save_buffer) +- { +- png_size_t i,istop; +- png_bytep sp; +- png_bytep dp; +- +- istop = png_ptr->save_buffer_size; +- for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer; +- i < istop; i++, sp++, dp++) +- { +- *dp = *sp; +- } +- } +- } +- if (png_ptr->save_buffer_size + png_ptr->current_buffer_size > +- png_ptr->save_buffer_max) +- { +- png_size_t new_max; +- png_bytep old_buffer; +- +- if (png_ptr->save_buffer_size > PNG_SIZE_MAX - +- (png_ptr->current_buffer_size + 256)) +- { +- png_error(png_ptr, "Potential overflow of save_buffer"); +- } +- new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256; +- old_buffer = png_ptr->save_buffer; +- png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)new_max); +- png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size); +- png_free(png_ptr, old_buffer); +- png_ptr->save_buffer_max = new_max; +- } +- if (png_ptr->current_buffer_size) +- { +- png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size, +- png_ptr->current_buffer_ptr, png_ptr->current_buffer_size); +- png_ptr->save_buffer_size += png_ptr->current_buffer_size; +- png_ptr->current_buffer_size = 0; +- } +- png_ptr->save_buffer_ptr = png_ptr->save_buffer; +- png_ptr->buffer_size = 0; +-} +- +-void /* PRIVATE */ +-png_push_restore_buffer(png_structp png_ptr, png_bytep buffer, +- png_size_t buffer_length) +-{ +- png_ptr->current_buffer = buffer; +- png_ptr->current_buffer_size = buffer_length; +- png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size; +- png_ptr->current_buffer_ptr = png_ptr->current_buffer; +-} +- +-void /* PRIVATE */ +-png_push_read_IDAT(png_structp png_ptr) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_IDAT; +-#endif +- if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER)) +- { +- png_byte chunk_length[4]; +- +- if (png_ptr->buffer_size < 8) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- +- png_push_fill_buffer(png_ptr, chunk_length, 4); +- png_ptr->push_length = png_get_uint_31(png_ptr,chunk_length); +- png_reset_crc(png_ptr); +- png_crc_read(png_ptr, png_ptr->chunk_name, 4); +- png_ptr->mode |= PNG_HAVE_CHUNK_HEADER; +- +- if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4)) +- { +- png_ptr->process_mode = PNG_READ_CHUNK_MODE; +- if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) +- png_error(png_ptr, "Not enough compressed data"); +- return; +- } +- +- png_ptr->idat_size = png_ptr->push_length; +- } +- if (png_ptr->idat_size && png_ptr->save_buffer_size) +- { +- png_size_t save_size; +- +- if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size) +- { +- save_size = (png_size_t)png_ptr->idat_size; +- /* check for overflow */ +- if((png_uint_32)save_size != png_ptr->idat_size) +- png_error(png_ptr, "save_size overflowed in pngpread"); +- } +- else +- save_size = png_ptr->save_buffer_size; +- +- png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); +- if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) +- png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size); +- png_ptr->idat_size -= save_size; +- png_ptr->buffer_size -= save_size; +- png_ptr->save_buffer_size -= save_size; +- png_ptr->save_buffer_ptr += save_size; +- } +- if (png_ptr->idat_size && png_ptr->current_buffer_size) +- { +- png_size_t save_size; +- +- if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size) +- { +- save_size = (png_size_t)png_ptr->idat_size; +- /* check for overflow */ +- if((png_uint_32)save_size != png_ptr->idat_size) +- png_error(png_ptr, "save_size overflowed in pngpread"); +- } +- else +- save_size = png_ptr->current_buffer_size; +- +- png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size); +- if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) +- png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size); +- +- png_ptr->idat_size -= save_size; +- png_ptr->buffer_size -= save_size; +- png_ptr->current_buffer_size -= save_size; +- png_ptr->current_buffer_ptr += save_size; +- } +- if (!png_ptr->idat_size) +- { +- if (png_ptr->buffer_size < 4) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- +- png_crc_finish(png_ptr, 0); +- png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; +- png_ptr->mode |= PNG_AFTER_IDAT; +- } +-} +- +-void /* PRIVATE */ +-png_process_IDAT_data(png_structp png_ptr, png_bytep buffer, +- png_size_t buffer_length) +-{ +- int ret; +- +- if ((png_ptr->flags & PNG_FLAG_ZLIB_FINISHED) && buffer_length) +- png_error(png_ptr, "Extra compression data"); +- +- png_ptr->zstream.next_in = buffer; +- png_ptr->zstream.avail_in = (uInt)buffer_length; +- for(;;) +- { +- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); +- if (ret != Z_OK) +- { +- if (ret == Z_STREAM_END) +- { +- if (png_ptr->zstream.avail_in) +- png_error(png_ptr, "Extra compressed data"); +- if (!(png_ptr->zstream.avail_out)) +- { +- png_push_process_row(png_ptr); +- } +- +- png_ptr->mode |= PNG_AFTER_IDAT; +- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; +- break; +- } +- else if (ret == Z_BUF_ERROR) +- break; +- else +- png_error(png_ptr, "Decompression Error"); +- } +- if (!(png_ptr->zstream.avail_out)) +- { +- if (( +-#if defined(PNG_READ_INTERLACING_SUPPORTED) +- png_ptr->interlaced && png_ptr->pass > 6) || +- (!png_ptr->interlaced && +-#endif +- png_ptr->row_number == png_ptr->num_rows)) +- { +- if (png_ptr->zstream.avail_in) +- png_warning(png_ptr, "Too much data in IDAT chunks"); +- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; +- break; +- } +- png_push_process_row(png_ptr); +- png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; +- png_ptr->zstream.next_out = png_ptr->row_buf; +- } +- else +- break; +- } +-} +- +-void /* PRIVATE */ +-png_push_process_row(png_structp png_ptr) +-{ +- png_ptr->row_info.color_type = png_ptr->color_type; +- png_ptr->row_info.width = png_ptr->iwidth; +- png_ptr->row_info.channels = png_ptr->channels; +- png_ptr->row_info.bit_depth = png_ptr->bit_depth; +- png_ptr->row_info.pixel_depth = png_ptr->pixel_depth; +- +- png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, +- png_ptr->row_info.width); +- +- png_read_filter_row(png_ptr, &(png_ptr->row_info), +- png_ptr->row_buf + 1, png_ptr->prev_row + 1, +- (int)(png_ptr->row_buf[0])); +- +- png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf, +- png_ptr->rowbytes + 1); +- +- if (png_ptr->transformations) +- png_do_read_transformations(png_ptr); +- +-#if defined(PNG_READ_INTERLACING_SUPPORTED) +- /* blow up interlaced rows to full size */ +- if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) +- { +- if (png_ptr->pass < 6) +-/* old interface (pre-1.0.9): +- png_do_read_interlace(&(png_ptr->row_info), +- png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); +- */ +- png_do_read_interlace(png_ptr); +- +- switch (png_ptr->pass) +- { +- case 0: +- { +- int i; +- for (i = 0; i < 8 && png_ptr->pass == 0; i++) +- { +- png_push_have_row(png_ptr, png_ptr->row_buf + 1); +- png_read_push_finish_row(png_ptr); /* updates png_ptr->pass */ +- } +- if (png_ptr->pass == 2) /* pass 1 might be empty */ +- { +- for (i = 0; i < 4 && png_ptr->pass == 2; i++) +- { +- png_push_have_row(png_ptr, png_bytep_NULL); +- png_read_push_finish_row(png_ptr); +- } +- } +- if (png_ptr->pass == 4 && png_ptr->height <= 4) +- { +- for (i = 0; i < 2 && png_ptr->pass == 4; i++) +- { +- png_push_have_row(png_ptr, png_bytep_NULL); +- png_read_push_finish_row(png_ptr); +- } +- } +- if (png_ptr->pass == 6 && png_ptr->height <= 4) +- { +- png_push_have_row(png_ptr, png_bytep_NULL); +- png_read_push_finish_row(png_ptr); +- } +- break; +- } +- case 1: +- { +- int i; +- for (i = 0; i < 8 && png_ptr->pass == 1; i++) +- { +- png_push_have_row(png_ptr, png_ptr->row_buf + 1); +- png_read_push_finish_row(png_ptr); +- } +- if (png_ptr->pass == 2) /* skip top 4 generated rows */ +- { +- for (i = 0; i < 4 && png_ptr->pass == 2; i++) +- { +- png_push_have_row(png_ptr, png_bytep_NULL); +- png_read_push_finish_row(png_ptr); +- } +- } +- break; +- } +- case 2: +- { +- int i; +- for (i = 0; i < 4 && png_ptr->pass == 2; i++) +- { +- png_push_have_row(png_ptr, png_ptr->row_buf + 1); +- png_read_push_finish_row(png_ptr); +- } +- for (i = 0; i < 4 && png_ptr->pass == 2; i++) +- { +- png_push_have_row(png_ptr, png_bytep_NULL); +- png_read_push_finish_row(png_ptr); +- } +- if (png_ptr->pass == 4) /* pass 3 might be empty */ +- { +- for (i = 0; i < 2 && png_ptr->pass == 4; i++) +- { +- png_push_have_row(png_ptr, png_bytep_NULL); +- png_read_push_finish_row(png_ptr); +- } +- } +- break; +- } +- case 3: +- { +- int i; +- for (i = 0; i < 4 && png_ptr->pass == 3; i++) +- { +- png_push_have_row(png_ptr, png_ptr->row_buf + 1); +- png_read_push_finish_row(png_ptr); +- } +- if (png_ptr->pass == 4) /* skip top two generated rows */ +- { +- for (i = 0; i < 2 && png_ptr->pass == 4; i++) +- { +- png_push_have_row(png_ptr, png_bytep_NULL); +- png_read_push_finish_row(png_ptr); +- } +- } +- break; +- } +- case 4: +- { +- int i; +- for (i = 0; i < 2 && png_ptr->pass == 4; i++) +- { +- png_push_have_row(png_ptr, png_ptr->row_buf + 1); +- png_read_push_finish_row(png_ptr); +- } +- for (i = 0; i < 2 && png_ptr->pass == 4; i++) +- { +- png_push_have_row(png_ptr, png_bytep_NULL); +- png_read_push_finish_row(png_ptr); +- } +- if (png_ptr->pass == 6) /* pass 5 might be empty */ +- { +- png_push_have_row(png_ptr, png_bytep_NULL); +- png_read_push_finish_row(png_ptr); +- } +- break; +- } +- case 5: +- { +- int i; +- for (i = 0; i < 2 && png_ptr->pass == 5; i++) +- { +- png_push_have_row(png_ptr, png_ptr->row_buf + 1); +- png_read_push_finish_row(png_ptr); +- } +- if (png_ptr->pass == 6) /* skip top generated row */ +- { +- png_push_have_row(png_ptr, png_bytep_NULL); +- png_read_push_finish_row(png_ptr); +- } +- break; +- } +- case 6: +- { +- png_push_have_row(png_ptr, png_ptr->row_buf + 1); +- png_read_push_finish_row(png_ptr); +- if (png_ptr->pass != 6) +- break; +- png_push_have_row(png_ptr, png_bytep_NULL); +- png_read_push_finish_row(png_ptr); +- } +- } +- } +- else +-#endif +- { +- png_push_have_row(png_ptr, png_ptr->row_buf + 1); +- png_read_push_finish_row(png_ptr); +- } +-} +- +-void /* PRIVATE */ +-png_read_push_finish_row(png_structp png_ptr) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ +- +- /* start of interlace block */ +- const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; +- +- /* offset to next interlace block */ +- const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; +- +- /* start of interlace block in the y direction */ +- const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; +- +- /* offset to next interlace block in the y direction */ +- const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; +- +- /* Width of interlace block. This is not currently used - if you need +- * it, uncomment it here and in png.h +- const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; +- */ +- +- /* Height of interlace block. This is not currently used - if you need +- * it, uncomment it here and in png.h +- const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; +- */ +-#endif +- +- png_ptr->row_number++; +- if (png_ptr->row_number < png_ptr->num_rows) +- return; +- +- if (png_ptr->interlaced) +- { +- png_ptr->row_number = 0; +- png_memset_check(png_ptr, png_ptr->prev_row, 0, +- png_ptr->rowbytes + 1); +- do +- { +- png_ptr->pass++; +- if ((png_ptr->pass == 1 && png_ptr->width < 5) || +- (png_ptr->pass == 3 && png_ptr->width < 3) || +- (png_ptr->pass == 5 && png_ptr->width < 2)) +- png_ptr->pass++; +- +- if (png_ptr->pass > 7) +- png_ptr->pass--; +- if (png_ptr->pass >= 7) +- break; +- +- png_ptr->iwidth = (png_ptr->width + +- png_pass_inc[png_ptr->pass] - 1 - +- png_pass_start[png_ptr->pass]) / +- png_pass_inc[png_ptr->pass]; +- +- png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, +- png_ptr->iwidth) + 1; +- +- if (png_ptr->transformations & PNG_INTERLACE) +- break; +- +- png_ptr->num_rows = (png_ptr->height + +- png_pass_yinc[png_ptr->pass] - 1 - +- png_pass_ystart[png_ptr->pass]) / +- png_pass_yinc[png_ptr->pass]; +- +- } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0); +- } +-} +- +-#if defined(PNG_READ_tEXt_SUPPORTED) +-void /* PRIVATE */ +-png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 +- length) +-{ +- if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) +- { +- png_error(png_ptr, "Out of place tEXt"); +- /* to quiet some compiler warnings */ +- if(info_ptr == NULL) return; +- } +- +-#ifdef PNG_MAX_MALLOC_64K +- png_ptr->skip_length = 0; /* This may not be necessary */ +- +- if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */ +- { +- png_warning(png_ptr, "tEXt chunk too large to fit in memory"); +- png_ptr->skip_length = length - (png_uint_32)65535L; +- length = (png_uint_32)65535L; +- } +-#endif +- +- png_ptr->current_text = (png_charp)png_malloc(png_ptr, +- (png_uint_32)(length+1)); +- png_ptr->current_text[length] = '\0'; +- png_ptr->current_text_ptr = png_ptr->current_text; +- png_ptr->current_text_size = (png_size_t)length; +- png_ptr->current_text_left = (png_size_t)length; +- png_ptr->process_mode = PNG_READ_tEXt_MODE; +-} +- +-void /* PRIVATE */ +-png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr->buffer_size && png_ptr->current_text_left) +- { +- png_size_t text_size; +- +- if (png_ptr->buffer_size < png_ptr->current_text_left) +- text_size = png_ptr->buffer_size; +- else +- text_size = png_ptr->current_text_left; +- png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); +- png_ptr->current_text_left -= text_size; +- png_ptr->current_text_ptr += text_size; +- } +- if (!(png_ptr->current_text_left)) +- { +- png_textp text_ptr; +- png_charp text; +- png_charp key; +- int ret; +- +- if (png_ptr->buffer_size < 4) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- +- png_push_crc_finish(png_ptr); +- +-#if defined(PNG_MAX_MALLOC_64K) +- if (png_ptr->skip_length) +- return; +-#endif +- +- key = png_ptr->current_text; +- +- for (text = key; *text; text++) +- /* empty loop */ ; +- +- if (text != key + png_ptr->current_text_size) +- text++; +- +- text_ptr = (png_textp)png_malloc(png_ptr, +- (png_uint_32)png_sizeof(png_text)); +- text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; +- text_ptr->key = key; +-#ifdef PNG_iTXt_SUPPORTED +- text_ptr->lang = NULL; +- text_ptr->lang_key = NULL; +-#endif +- text_ptr->text = text; +- +- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); +- +- png_free(png_ptr, key); +- png_free(png_ptr, text_ptr); +- png_ptr->current_text = NULL; +- +- if (ret) +- png_warning(png_ptr, "Insufficient memory to store text chunk."); +- } +-} +-#endif +- +-#if defined(PNG_READ_zTXt_SUPPORTED) +-void /* PRIVATE */ +-png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 +- length) +-{ +- if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) +- { +- png_error(png_ptr, "Out of place zTXt"); +- /* to quiet some compiler warnings */ +- if(info_ptr == NULL) return; +- } +- +-#ifdef PNG_MAX_MALLOC_64K +- /* We can't handle zTXt chunks > 64K, since we don't have enough space +- * to be able to store the uncompressed data. Actually, the threshold +- * is probably around 32K, but it isn't as definite as 64K is. +- */ +- if (length > (png_uint_32)65535L) +- { +- png_warning(png_ptr, "zTXt chunk too large to fit in memory"); +- png_push_crc_skip(png_ptr, length); +- return; +- } +-#endif +- +- png_ptr->current_text = (png_charp)png_malloc(png_ptr, +- (png_uint_32)(length+1)); +- png_ptr->current_text[length] = '\0'; +- png_ptr->current_text_ptr = png_ptr->current_text; +- png_ptr->current_text_size = (png_size_t)length; +- png_ptr->current_text_left = (png_size_t)length; +- png_ptr->process_mode = PNG_READ_zTXt_MODE; +-} +- +-void /* PRIVATE */ +-png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr->buffer_size && png_ptr->current_text_left) +- { +- png_size_t text_size; +- +- if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left) +- text_size = png_ptr->buffer_size; +- else +- text_size = png_ptr->current_text_left; +- png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); +- png_ptr->current_text_left -= text_size; +- png_ptr->current_text_ptr += text_size; +- } +- if (!(png_ptr->current_text_left)) +- { +- png_textp text_ptr; +- png_charp text; +- png_charp key; +- int ret; +- png_size_t text_size, key_size; +- +- if (png_ptr->buffer_size < 4) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- +- png_push_crc_finish(png_ptr); +- +- key = png_ptr->current_text; +- +- for (text = key; *text; text++) +- /* empty loop */ ; +- +- /* zTXt can't have zero text */ +- if (text == key + png_ptr->current_text_size) +- { +- png_ptr->current_text = NULL; +- png_free(png_ptr, key); +- return; +- } +- +- text++; +- +- if (*text != PNG_TEXT_COMPRESSION_zTXt) /* check compression byte */ +- { +- png_ptr->current_text = NULL; +- png_free(png_ptr, key); +- return; +- } +- +- text++; +- +- png_ptr->zstream.next_in = (png_bytep )text; +- png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size - +- (text - key)); +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- +- key_size = text - key; +- text_size = 0; +- text = NULL; +- ret = Z_STREAM_END; +- +- while (png_ptr->zstream.avail_in) +- { +- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); +- if (ret != Z_OK && ret != Z_STREAM_END) +- { +- inflateReset(&png_ptr->zstream); +- png_ptr->zstream.avail_in = 0; +- png_ptr->current_text = NULL; +- png_free(png_ptr, key); +- png_free(png_ptr, text); +- return; +- } +- if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END) +- { +- if (text == NULL) +- { +- text = (png_charp)png_malloc(png_ptr, +- (png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out +- + key_size + 1)); +- png_memcpy(text + key_size, png_ptr->zbuf, +- png_ptr->zbuf_size - png_ptr->zstream.avail_out); +- png_memcpy(text, key, key_size); +- text_size = key_size + png_ptr->zbuf_size - +- png_ptr->zstream.avail_out; +- *(text + text_size) = '\0'; +- } +- else +- { +- png_charp tmp; +- +- tmp = text; +- text = (png_charp)png_malloc(png_ptr, text_size + +- (png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out +- + 1)); +- png_memcpy(text, tmp, text_size); +- png_free(png_ptr, tmp); +- png_memcpy(text + text_size, png_ptr->zbuf, +- png_ptr->zbuf_size - png_ptr->zstream.avail_out); +- text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out; +- *(text + text_size) = '\0'; +- } +- if (ret != Z_STREAM_END) +- { +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- } +- } +- else +- { +- break; +- } +- +- if (ret == Z_STREAM_END) +- break; +- } +- +- inflateReset(&png_ptr->zstream); +- png_ptr->zstream.avail_in = 0; +- +- if (ret != Z_STREAM_END) +- { +- png_ptr->current_text = NULL; +- png_free(png_ptr, key); +- png_free(png_ptr, text); +- return; +- } +- +- png_ptr->current_text = NULL; +- png_free(png_ptr, key); +- key = text; +- text += key_size; +- +- text_ptr = (png_textp)png_malloc(png_ptr, +- (png_uint_32)png_sizeof(png_text)); +- text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt; +- text_ptr->key = key; +-#ifdef PNG_iTXt_SUPPORTED +- text_ptr->lang = NULL; +- text_ptr->lang_key = NULL; +-#endif +- text_ptr->text = text; +- +- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); +- +- png_free(png_ptr, key); +- png_free(png_ptr, text_ptr); +- +- if (ret) +- png_warning(png_ptr, "Insufficient memory to store text chunk."); +- } +-} +-#endif +- +-#if defined(PNG_READ_iTXt_SUPPORTED) +-void /* PRIVATE */ +-png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 +- length) +-{ +- if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) +- { +- png_error(png_ptr, "Out of place iTXt"); +- /* to quiet some compiler warnings */ +- if(info_ptr == NULL) return; +- } +- +-#ifdef PNG_MAX_MALLOC_64K +- png_ptr->skip_length = 0; /* This may not be necessary */ +- +- if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */ +- { +- png_warning(png_ptr, "iTXt chunk too large to fit in memory"); +- png_ptr->skip_length = length - (png_uint_32)65535L; +- length = (png_uint_32)65535L; +- } +-#endif +- +- png_ptr->current_text = (png_charp)png_malloc(png_ptr, +- (png_uint_32)(length+1)); +- png_ptr->current_text[length] = '\0'; +- png_ptr->current_text_ptr = png_ptr->current_text; +- png_ptr->current_text_size = (png_size_t)length; +- png_ptr->current_text_left = (png_size_t)length; +- png_ptr->process_mode = PNG_READ_iTXt_MODE; +-} +- +-void /* PRIVATE */ +-png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr) +-{ +- +- if (png_ptr->buffer_size && png_ptr->current_text_left) +- { +- png_size_t text_size; +- +- if (png_ptr->buffer_size < png_ptr->current_text_left) +- text_size = png_ptr->buffer_size; +- else +- text_size = png_ptr->current_text_left; +- png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); +- png_ptr->current_text_left -= text_size; +- png_ptr->current_text_ptr += text_size; +- } +- if (!(png_ptr->current_text_left)) +- { +- png_textp text_ptr; +- png_charp key; +- int comp_flag; +- png_charp lang; +- png_charp lang_key; +- png_charp text; +- int ret; +- +- if (png_ptr->buffer_size < 4) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- +- png_push_crc_finish(png_ptr); +- +-#if defined(PNG_MAX_MALLOC_64K) +- if (png_ptr->skip_length) +- return; +-#endif +- +- key = png_ptr->current_text; +- +- for (lang = key; *lang; lang++) +- /* empty loop */ ; +- +- if (lang != key + png_ptr->current_text_size) +- lang++; +- +- comp_flag = *lang++; +- lang++; /* skip comp_type, always zero */ +- +- for (lang_key = lang; *lang_key; lang_key++) +- /* empty loop */ ; +- lang_key++; /* skip NUL separator */ +- +- for (text = lang_key; *text; text++) +- /* empty loop */ ; +- +- if (text != key + png_ptr->current_text_size) +- text++; +- +- text_ptr = (png_textp)png_malloc(png_ptr, +- (png_uint_32)png_sizeof(png_text)); +- text_ptr->compression = comp_flag + 2; +- text_ptr->key = key; +- text_ptr->lang = lang; +- text_ptr->lang_key = lang_key; +- text_ptr->text = text; +- text_ptr->text_length = 0; +- text_ptr->itxt_length = png_strlen(text); +- +- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); +- +- png_ptr->current_text = NULL; +- +- png_free(png_ptr, text_ptr); +- if (ret) +- png_warning(png_ptr, "Insufficient memory to store iTXt chunk."); +- } +-} +-#endif +- +-/* This function is called when we haven't found a handler for this +- * chunk. If there isn't a problem with the chunk itself (ie a bad chunk +- * name or a critical chunk), the chunk is (currently) silently ignored. +- */ +-void /* PRIVATE */ +-png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 +- length) +-{ +- png_uint_32 skip=0; +- png_check_chunk_name(png_ptr, png_ptr->chunk_name); +- +- if (!(png_ptr->chunk_name[0] & 0x20)) +- { +-#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) +- if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != +- PNG_HANDLE_CHUNK_ALWAYS +-#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) +- && png_ptr->read_user_chunk_fn == NULL +-#endif +- ) +-#endif +- png_chunk_error(png_ptr, "unknown critical chunk"); +- +- /* to quiet compiler warnings about unused info_ptr */ +- if (info_ptr == NULL) +- return; +- } +- +-#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) +- if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) +- { +- png_unknown_chunk chunk; +- +-#ifdef PNG_MAX_MALLOC_64K +- if (length > (png_uint_32)65535L) +- { +- png_warning(png_ptr, "unknown chunk too large to fit in memory"); +- skip = length - (png_uint_32)65535L; +- length = (png_uint_32)65535L; +- } +-#endif +- +- png_strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name); +- chunk.data = (png_bytep)png_malloc(png_ptr, length); +- png_crc_read(png_ptr, chunk.data, length); +- chunk.size = length; +-#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) +- if(png_ptr->read_user_chunk_fn != NULL) +- { +- /* callback to user unknown chunk handler */ +- if ((*(png_ptr->read_user_chunk_fn)) (png_ptr, &chunk) <= 0) +- { +- if (!(png_ptr->chunk_name[0] & 0x20)) +- if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != +- PNG_HANDLE_CHUNK_ALWAYS) +- png_chunk_error(png_ptr, "unknown critical chunk"); +- } +- png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); +- } +- else +-#endif +- png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); +- png_free(png_ptr, chunk.data); +- } +- else +-#endif +- skip=length; +- png_push_crc_skip(png_ptr, skip); +-} +- +-void /* PRIVATE */ +-png_push_have_info(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr->info_fn != NULL) +- (*(png_ptr->info_fn))(png_ptr, info_ptr); +-} +- +-void /* PRIVATE */ +-png_push_have_end(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr->end_fn != NULL) +- (*(png_ptr->end_fn))(png_ptr, info_ptr); +-} +- +-void /* PRIVATE */ +-png_push_have_row(png_structp png_ptr, png_bytep row) +-{ +- if (png_ptr->row_fn != NULL) +- (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number, +- (int)png_ptr->pass); +-} +- +-void PNGAPI +-png_progressive_combine_row (png_structp png_ptr, +- png_bytep old_row, png_bytep new_row) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- const int FARDATA png_pass_dsp_mask[7] = +- {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; +-#endif +- if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */ +- png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]); +-} +- +-void PNGAPI +-png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr, +- png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, +- png_progressive_end_ptr end_fn) +-{ +- png_ptr->info_fn = info_fn; +- png_ptr->row_fn = row_fn; +- png_ptr->end_fn = end_fn; +- +- png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer); +-} +- +-png_voidp PNGAPI +-png_get_progressive_ptr(png_structp png_ptr) +-{ +- return png_ptr->io_ptr; +-} +-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ +diff --git a/thirdparty/libpng/pngread.c b/thirdparty/libpng/pngread.c +deleted file mode 100644 +index 2224022..0000000 +--- a/thirdparty/libpng/pngread.c ++++ /dev/null +@@ -1,1453 +0,0 @@ +- +-/* pngread.c - read a PNG file +- * +- * libpng 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- * +- * This file contains routines that an application calls directly to +- * read a PNG file or stream. +- */ +- +-#define PNG_INTERNAL +-#include "png.h" +- +-/* Create a PNG structure for reading, and allocate any memory needed. */ +-png_structp PNGAPI +-png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn) +-{ +- +-#ifdef PNG_USER_MEM_SUPPORTED +- return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn, +- warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL)); +-} +- +-/* Alternate create PNG structure for reading, and allocate any memory needed. */ +-png_structp PNGAPI +-png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, +- png_malloc_ptr malloc_fn, png_free_ptr free_fn) +-{ +-#endif /* PNG_USER_MEM_SUPPORTED */ +- +- png_structp png_ptr; +- +-#ifdef PNG_SETJMP_SUPPORTED +-#ifdef USE_FAR_KEYWORD +- jmp_buf jmpbuf; +-#endif +-#endif +- +- int i; +- +- png_debug(1, "in png_create_read_struct\n"); +-#ifdef PNG_USER_MEM_SUPPORTED +- png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, +- (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr); +-#else +- png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); +-#endif +- if (png_ptr == NULL) +- return (NULL); +- +-#if !defined(PNG_1_0_X) +-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED +- png_init_mmx_flags(png_ptr); /* 1.2.0 addition */ +-#endif +-#endif /* PNG_1_0_X */ +- +- /* added at libpng-1.2.6 */ +-#ifdef PNG_SET_USER_LIMITS_SUPPORTED +- png_ptr->user_width_max=PNG_USER_WIDTH_MAX; +- png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; +-#endif +- +-#ifdef PNG_SETJMP_SUPPORTED +-#ifdef USE_FAR_KEYWORD +- if (setjmp(jmpbuf)) +-#else +- if (setjmp(png_ptr->jmpbuf)) +-#endif +- { +- png_free(png_ptr, png_ptr->zbuf); +- png_ptr->zbuf=NULL; +-#ifdef PNG_USER_MEM_SUPPORTED +- png_destroy_struct_2((png_voidp)png_ptr, +- (png_free_ptr)free_fn, (png_voidp)mem_ptr); +-#else +- png_destroy_struct((png_voidp)png_ptr); +-#endif +- return (NULL); +- } +-#ifdef USE_FAR_KEYWORD +- png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf)); +-#endif +-#endif +- +-#ifdef PNG_USER_MEM_SUPPORTED +- png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); +-#endif +- +- png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); +- +- i=0; +- do +- { +- if(user_png_ver[i] != png_libpng_ver[i]) +- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; +- } while (png_libpng_ver[i++]); +- +- if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) +- { +- /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so +- * we must recompile any applications that use any older library version. +- * For versions after libpng 1.0, we will be compatible, so we need +- * only check the first digit. +- */ +- if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || +- (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || +- (user_png_ver[0] == '0' && user_png_ver[2] < '9')) +- { +-#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) +- char msg[80]; +- if (user_png_ver) +- { +- sprintf(msg, "Application was compiled with png.h from libpng-%.20s", +- user_png_ver); +- png_warning(png_ptr, msg); +- } +- sprintf(msg, "Application is running with png.c from libpng-%.20s", +- png_libpng_ver); +- png_warning(png_ptr, msg); +-#endif +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +- png_ptr->flags=0; +-#endif +- png_error(png_ptr, +- "Incompatible libpng version in application and library"); +- } +- } +- +- /* initialize zbuf - compression buffer */ +- png_ptr->zbuf_size = PNG_ZBUF_SIZE; +- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)png_ptr->zbuf_size); +- png_ptr->zstream.zalloc = png_zalloc; +- png_ptr->zstream.zfree = png_zfree; +- png_ptr->zstream.opaque = (voidpf)png_ptr; +- +- switch (inflateInit(&png_ptr->zstream)) +- { +- case Z_OK: /* Do nothing */ break; +- case Z_MEM_ERROR: +- case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break; +- case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); break; +- default: png_error(png_ptr, "Unknown zlib error"); +- } +- +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- +- png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL); +- +-#ifdef PNG_SETJMP_SUPPORTED +-/* Applications that neglect to set up their own setjmp() and then encounter +- a png_error() will longjmp here. Since the jmpbuf is then meaningless we +- abort instead of returning. */ +-#ifdef USE_FAR_KEYWORD +- if (setjmp(jmpbuf)) +- PNG_ABORT(); +- png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf)); +-#else +- if (setjmp(png_ptr->jmpbuf)) +- PNG_ABORT(); +-#endif +-#endif +- return (png_ptr); +-} +- +-/* Initialize PNG structure for reading, and allocate any memory needed. +- This interface is deprecated in favour of the png_create_read_struct(), +- and it will eventually disappear. */ +-#undef png_read_init +-void PNGAPI +-png_read_init(png_structp png_ptr) +-{ +- /* We only come here via pre-1.0.7-compiled applications */ +- png_read_init_2(png_ptr, "1.0.6 or earlier", 0, 0); +-} +- +-void PNGAPI +-png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver, +- png_size_t png_struct_size, png_size_t png_info_size) +-{ +- /* We only come here via pre-1.0.12-compiled applications */ +-#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) +- if(png_sizeof(png_struct) > png_struct_size || +- png_sizeof(png_info) > png_info_size) +- { +- char msg[80]; +- png_ptr->warning_fn=NULL; +- if (user_png_ver) +- { +- sprintf(msg, "Application was compiled with png.h from libpng-%.20s", +- user_png_ver); +- png_warning(png_ptr, msg); +- } +- sprintf(msg, "Application is running with png.c from libpng-%.20s", +- png_libpng_ver); +- png_warning(png_ptr, msg); +- } +-#endif +- if(png_sizeof(png_struct) > png_struct_size) +- { +- png_ptr->error_fn=NULL; +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +- png_ptr->flags=0; +-#endif +- png_error(png_ptr, +- "The png struct allocated by the application for reading is too small."); +- } +- if(png_sizeof(png_info) > png_info_size) +- { +- png_ptr->error_fn=NULL; +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +- png_ptr->flags=0; +-#endif +- png_error(png_ptr, +- "The info struct allocated by application for reading is too small."); +- } +- png_read_init_3(&png_ptr, user_png_ver, png_struct_size); +-} +- +-void PNGAPI +-png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver, +- png_size_t png_struct_size) +-{ +-#ifdef PNG_SETJMP_SUPPORTED +- jmp_buf tmp_jmp; /* to save current jump buffer */ +-#endif +- +- int i=0; +- +- png_structp png_ptr=*ptr_ptr; +- +- do +- { +- if(user_png_ver[i] != png_libpng_ver[i]) +- { +-#ifdef PNG_LEGACY_SUPPORTED +- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; +-#else +- png_ptr->warning_fn=NULL; +- png_warning(png_ptr, +- "Application uses deprecated png_read_init() and should be recompiled."); +- break; +-#endif +- } +- } while (png_libpng_ver[i++]); +- +- png_debug(1, "in png_read_init_3\n"); +- +-#ifdef PNG_SETJMP_SUPPORTED +- /* save jump buffer and error functions */ +- png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf)); +-#endif +- +- if(png_sizeof(png_struct) > png_struct_size) +- { +- png_destroy_struct(png_ptr); +- *ptr_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); +- png_ptr = *ptr_ptr; +- } +- +- /* reset all variables to 0 */ +- png_memset(png_ptr, 0, png_sizeof (png_struct)); +- +-#ifdef PNG_SETJMP_SUPPORTED +- /* restore jump buffer */ +- png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf)); +-#endif +- +- /* added at libpng-1.2.6 */ +-#ifdef PNG_SET_USER_LIMITS_SUPPORTED +- png_ptr->user_width_max=PNG_USER_WIDTH_MAX; +- png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; +-#endif +- +- /* initialize zbuf - compression buffer */ +- png_ptr->zbuf_size = PNG_ZBUF_SIZE; +- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)png_ptr->zbuf_size); +- png_ptr->zstream.zalloc = png_zalloc; +- png_ptr->zstream.zfree = png_zfree; +- png_ptr->zstream.opaque = (voidpf)png_ptr; +- +- switch (inflateInit(&png_ptr->zstream)) +- { +- case Z_OK: /* Do nothing */ break; +- case Z_MEM_ERROR: +- case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory"); break; +- case Z_VERSION_ERROR: png_error(png_ptr, "zlib version"); break; +- default: png_error(png_ptr, "Unknown zlib error"); +- } +- +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- +- png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL); +-} +- +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +-/* Read the information before the actual image data. This has been +- * changed in v0.90 to allow reading a file that already has the magic +- * bytes read from the stream. You can tell libpng how many bytes have +- * been read from the beginning of the stream (up to the maximum of 8) +- * via png_set_sig_bytes(), and we will only check the remaining bytes +- * here. The application can then have access to the signature bytes we +- * read if it is determined that this isn't a valid PNG file. +- */ +-void PNGAPI +-png_read_info(png_structp png_ptr, png_infop info_ptr) +-{ +- png_debug(1, "in png_read_info\n"); +- /* If we haven't checked all of the PNG signature bytes, do so now. */ +- if (png_ptr->sig_bytes < 8) +- { +- png_size_t num_checked = png_ptr->sig_bytes, +- num_to_check = 8 - num_checked; +- +- png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check); +- png_ptr->sig_bytes = 8; +- +- if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) +- { +- if (num_checked < 4 && +- png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4)) +- png_error(png_ptr, "Not a PNG file"); +- else +- png_error(png_ptr, "PNG file corrupted by ASCII conversion"); +- } +- if (num_checked < 3) +- png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; +- } +- +- for(;;) +- { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_IHDR; +- PNG_IDAT; +- PNG_IEND; +- PNG_PLTE; +-#if defined(PNG_READ_bKGD_SUPPORTED) +- PNG_bKGD; +-#endif +-#if defined(PNG_READ_cHRM_SUPPORTED) +- PNG_cHRM; +-#endif +-#if defined(PNG_READ_gAMA_SUPPORTED) +- PNG_gAMA; +-#endif +-#if defined(PNG_READ_hIST_SUPPORTED) +- PNG_hIST; +-#endif +-#if defined(PNG_READ_iCCP_SUPPORTED) +- PNG_iCCP; +-#endif +-#if defined(PNG_READ_iTXt_SUPPORTED) +- PNG_iTXt; +-#endif +-#if defined(PNG_READ_oFFs_SUPPORTED) +- PNG_oFFs; +-#endif +-#if defined(PNG_READ_pCAL_SUPPORTED) +- PNG_pCAL; +-#endif +-#if defined(PNG_READ_pHYs_SUPPORTED) +- PNG_pHYs; +-#endif +-#if defined(PNG_READ_sBIT_SUPPORTED) +- PNG_sBIT; +-#endif +-#if defined(PNG_READ_sCAL_SUPPORTED) +- PNG_sCAL; +-#endif +-#if defined(PNG_READ_sPLT_SUPPORTED) +- PNG_sPLT; +-#endif +-#if defined(PNG_READ_sRGB_SUPPORTED) +- PNG_sRGB; +-#endif +-#if defined(PNG_READ_tEXt_SUPPORTED) +- PNG_tEXt; +-#endif +-#if defined(PNG_READ_tIME_SUPPORTED) +- PNG_tIME; +-#endif +-#if defined(PNG_READ_tRNS_SUPPORTED) +- PNG_tRNS; +-#endif +-#if defined(PNG_READ_zTXt_SUPPORTED) +- PNG_zTXt; +-#endif +-#endif /* PNG_GLOBAL_ARRAYS */ +- png_byte chunk_length[4]; +- png_uint_32 length; +- +- png_read_data(png_ptr, chunk_length, 4); +- length = png_get_uint_31(png_ptr,chunk_length); +- +- png_reset_crc(png_ptr); +- png_crc_read(png_ptr, png_ptr->chunk_name, 4); +- +- png_debug2(0, "Reading %s chunk, length=%lu.\n", png_ptr->chunk_name, +- length); +- +- /* This should be a binary subdivision search or a hash for +- * matching the chunk name rather than a linear search. +- */ +- if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) +- png_handle_IHDR(png_ptr, info_ptr, length); +- else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) +- png_handle_IEND(png_ptr, info_ptr, length); +-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +- else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name)) +- { +- if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) +- png_ptr->mode |= PNG_HAVE_IDAT; +- png_handle_unknown(png_ptr, info_ptr, length); +- if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) +- png_ptr->mode |= PNG_HAVE_PLTE; +- else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) +- { +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before IDAT"); +- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && +- !(png_ptr->mode & PNG_HAVE_PLTE)) +- png_error(png_ptr, "Missing PLTE before IDAT"); +- break; +- } +- } +-#endif +- else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) +- png_handle_PLTE(png_ptr, info_ptr, length); +- else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) +- { +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before IDAT"); +- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && +- !(png_ptr->mode & PNG_HAVE_PLTE)) +- png_error(png_ptr, "Missing PLTE before IDAT"); +- +- png_ptr->idat_size = length; +- png_ptr->mode |= PNG_HAVE_IDAT; +- break; +- } +-#if defined(PNG_READ_bKGD_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4)) +- png_handle_bKGD(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_cHRM_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4)) +- png_handle_cHRM(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_gAMA_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4)) +- png_handle_gAMA(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_hIST_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4)) +- png_handle_hIST(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_oFFs_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4)) +- png_handle_oFFs(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_pCAL_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4)) +- png_handle_pCAL(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_sCAL_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4)) +- png_handle_sCAL(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_pHYs_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4)) +- png_handle_pHYs(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_sBIT_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) +- png_handle_sBIT(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_sRGB_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4)) +- png_handle_sRGB(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_iCCP_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4)) +- png_handle_iCCP(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_sPLT_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4)) +- png_handle_sPLT(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_tEXt_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) +- png_handle_tEXt(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_tIME_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4)) +- png_handle_tIME(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_tRNS_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4)) +- png_handle_tRNS(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_zTXt_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4)) +- png_handle_zTXt(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_iTXt_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) +- png_handle_iTXt(png_ptr, info_ptr, length); +-#endif +- else +- png_handle_unknown(png_ptr, info_ptr, length); +- } +-} +-#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ +- +-/* optional call to update the users info_ptr structure */ +-void PNGAPI +-png_read_update_info(png_structp png_ptr, png_infop info_ptr) +-{ +- png_debug(1, "in png_read_update_info\n"); +- if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) +- png_read_start_row(png_ptr); +- else +- png_warning(png_ptr, +- "Ignoring extra png_read_update_info() call; row buffer not reallocated"); +- png_read_transform_info(png_ptr, info_ptr); +-} +- +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +-/* Initialize palette, background, etc, after transformations +- * are set, but before any reading takes place. This allows +- * the user to obtain a gamma-corrected palette, for example. +- * If the user doesn't call this, we will do it ourselves. +- */ +-void PNGAPI +-png_start_read_image(png_structp png_ptr) +-{ +- png_debug(1, "in png_start_read_image\n"); +- if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) +- png_read_start_row(png_ptr); +-} +-#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ +- +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +-void PNGAPI +-png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_IDAT; +- const int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; +- const int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; +-#endif +- int ret; +- png_debug2(1, "in png_read_row (row %lu, pass %d)\n", +- png_ptr->row_number, png_ptr->pass); +- if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) +- png_read_start_row(png_ptr); +- if (png_ptr->row_number == 0 && png_ptr->pass == 0) +- { +- /* check for transforms that have been set but were defined out */ +-#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED) +- if (png_ptr->transformations & PNG_INVERT_MONO) +- png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined."); +-#endif +-#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED) +- if (png_ptr->transformations & PNG_FILLER) +- png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined."); +-#endif +-#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && !defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_PACKSWAP) +- png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined."); +-#endif +-#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED) +- if (png_ptr->transformations & PNG_PACK) +- png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined."); +-#endif +-#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) +- if (png_ptr->transformations & PNG_SHIFT) +- png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined."); +-#endif +-#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED) +- if (png_ptr->transformations & PNG_BGR) +- png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined."); +-#endif +-#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_SWAP_BYTES) +- png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined."); +-#endif +- } +- +-#if defined(PNG_READ_INTERLACING_SUPPORTED) +- /* if interlaced and we do not need a new row, combine row and return */ +- if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) +- { +- switch (png_ptr->pass) +- { +- case 0: +- if (png_ptr->row_number & 0x07) +- { +- if (dsp_row != NULL) +- png_combine_row(png_ptr, dsp_row, +- png_pass_dsp_mask[png_ptr->pass]); +- png_read_finish_row(png_ptr); +- return; +- } +- break; +- case 1: +- if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) +- { +- if (dsp_row != NULL) +- png_combine_row(png_ptr, dsp_row, +- png_pass_dsp_mask[png_ptr->pass]); +- png_read_finish_row(png_ptr); +- return; +- } +- break; +- case 2: +- if ((png_ptr->row_number & 0x07) != 4) +- { +- if (dsp_row != NULL && (png_ptr->row_number & 4)) +- png_combine_row(png_ptr, dsp_row, +- png_pass_dsp_mask[png_ptr->pass]); +- png_read_finish_row(png_ptr); +- return; +- } +- break; +- case 3: +- if ((png_ptr->row_number & 3) || png_ptr->width < 3) +- { +- if (dsp_row != NULL) +- png_combine_row(png_ptr, dsp_row, +- png_pass_dsp_mask[png_ptr->pass]); +- png_read_finish_row(png_ptr); +- return; +- } +- break; +- case 4: +- if ((png_ptr->row_number & 3) != 2) +- { +- if (dsp_row != NULL && (png_ptr->row_number & 2)) +- png_combine_row(png_ptr, dsp_row, +- png_pass_dsp_mask[png_ptr->pass]); +- png_read_finish_row(png_ptr); +- return; +- } +- break; +- case 5: +- if ((png_ptr->row_number & 1) || png_ptr->width < 2) +- { +- if (dsp_row != NULL) +- png_combine_row(png_ptr, dsp_row, +- png_pass_dsp_mask[png_ptr->pass]); +- png_read_finish_row(png_ptr); +- return; +- } +- break; +- case 6: +- if (!(png_ptr->row_number & 1)) +- { +- png_read_finish_row(png_ptr); +- return; +- } +- break; +- } +- } +-#endif +- +- if (!(png_ptr->mode & PNG_HAVE_IDAT)) +- png_error(png_ptr, "Invalid attempt to read row data"); +- +- png_ptr->zstream.next_out = png_ptr->row_buf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; +- do +- { +- if (!(png_ptr->zstream.avail_in)) +- { +- while (!png_ptr->idat_size) +- { +- png_byte chunk_length[4]; +- +- png_crc_finish(png_ptr, 0); +- +- png_read_data(png_ptr, chunk_length, 4); +- png_ptr->idat_size = png_get_uint_31(png_ptr,chunk_length); +- +- png_reset_crc(png_ptr); +- png_crc_read(png_ptr, png_ptr->chunk_name, 4); +- if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) +- png_error(png_ptr, "Not enough image data"); +- } +- png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; +- png_ptr->zstream.next_in = png_ptr->zbuf; +- if (png_ptr->zbuf_size > png_ptr->idat_size) +- png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; +- png_crc_read(png_ptr, png_ptr->zbuf, +- (png_size_t)png_ptr->zstream.avail_in); +- png_ptr->idat_size -= png_ptr->zstream.avail_in; +- } +- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); +- if (ret == Z_STREAM_END) +- { +- if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in || +- png_ptr->idat_size) +- png_error(png_ptr, "Extra compressed data"); +- png_ptr->mode |= PNG_AFTER_IDAT; +- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; +- break; +- } +- if (ret != Z_OK) +- png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : +- "Decompression error"); +- +- } while (png_ptr->zstream.avail_out); +- +- png_ptr->row_info.color_type = png_ptr->color_type; +- png_ptr->row_info.width = png_ptr->iwidth; +- png_ptr->row_info.channels = png_ptr->channels; +- png_ptr->row_info.bit_depth = png_ptr->bit_depth; +- png_ptr->row_info.pixel_depth = png_ptr->pixel_depth; +- png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, +- png_ptr->row_info.width); +- +- if(png_ptr->row_buf[0]) +- png_read_filter_row(png_ptr, &(png_ptr->row_info), +- png_ptr->row_buf + 1, png_ptr->prev_row + 1, +- (int)(png_ptr->row_buf[0])); +- +- png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf, +- png_ptr->rowbytes + 1); +- +-#if defined(PNG_MNG_FEATURES_SUPPORTED) +- if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && +- (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) +- { +- /* Intrapixel differencing */ +- png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1); +- } +-#endif +- +- if (png_ptr->transformations) +- png_do_read_transformations(png_ptr); +- +-#if defined(PNG_READ_INTERLACING_SUPPORTED) +- /* blow up interlaced rows to full size */ +- if (png_ptr->interlaced && +- (png_ptr->transformations & PNG_INTERLACE)) +- { +- if (png_ptr->pass < 6) +-/* old interface (pre-1.0.9): +- png_do_read_interlace(&(png_ptr->row_info), +- png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); +- */ +- png_do_read_interlace(png_ptr); +- +- if (dsp_row != NULL) +- png_combine_row(png_ptr, dsp_row, +- png_pass_dsp_mask[png_ptr->pass]); +- if (row != NULL) +- png_combine_row(png_ptr, row, +- png_pass_mask[png_ptr->pass]); +- } +- else +-#endif +- { +- if (row != NULL) +- png_combine_row(png_ptr, row, 0xff); +- if (dsp_row != NULL) +- png_combine_row(png_ptr, dsp_row, 0xff); +- } +- png_read_finish_row(png_ptr); +- +- if (png_ptr->read_row_fn != NULL) +- (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); +-} +-#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ +- +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +-/* Read one or more rows of image data. If the image is interlaced, +- * and png_set_interlace_handling() has been called, the rows need to +- * contain the contents of the rows from the previous pass. If the +- * image has alpha or transparency, and png_handle_alpha()[*] has been +- * called, the rows contents must be initialized to the contents of the +- * screen. +- * +- * "row" holds the actual image, and pixels are placed in it +- * as they arrive. If the image is displayed after each pass, it will +- * appear to "sparkle" in. "display_row" can be used to display a +- * "chunky" progressive image, with finer detail added as it becomes +- * available. If you do not want this "chunky" display, you may pass +- * NULL for display_row. If you do not want the sparkle display, and +- * you have not called png_handle_alpha(), you may pass NULL for rows. +- * If you have called png_handle_alpha(), and the image has either an +- * alpha channel or a transparency chunk, you must provide a buffer for +- * rows. In this case, you do not have to provide a display_row buffer +- * also, but you may. If the image is not interlaced, or if you have +- * not called png_set_interlace_handling(), the display_row buffer will +- * be ignored, so pass NULL to it. +- * +- * [*] png_handle_alpha() does not exist yet, as of libpng version 1.2.7 +- */ +- +-void PNGAPI +-png_read_rows(png_structp png_ptr, png_bytepp row, +- png_bytepp display_row, png_uint_32 num_rows) +-{ +- png_uint_32 i; +- png_bytepp rp; +- png_bytepp dp; +- +- png_debug(1, "in png_read_rows\n"); +- rp = row; +- dp = display_row; +- if (rp != NULL && dp != NULL) +- for (i = 0; i < num_rows; i++) +- { +- png_bytep rptr = *rp++; +- png_bytep dptr = *dp++; +- +- png_read_row(png_ptr, rptr, dptr); +- } +- else if(rp != NULL) +- for (i = 0; i < num_rows; i++) +- { +- png_bytep rptr = *rp; +- png_read_row(png_ptr, rptr, png_bytep_NULL); +- rp++; +- } +- else if(dp != NULL) +- for (i = 0; i < num_rows; i++) +- { +- png_bytep dptr = *dp; +- png_read_row(png_ptr, png_bytep_NULL, dptr); +- dp++; +- } +-} +-#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ +- +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +-/* Read the entire image. If the image has an alpha channel or a tRNS +- * chunk, and you have called png_handle_alpha()[*], you will need to +- * initialize the image to the current image that PNG will be overlaying. +- * We set the num_rows again here, in case it was incorrectly set in +- * png_read_start_row() by a call to png_read_update_info() or +- * png_start_read_image() if png_set_interlace_handling() wasn't called +- * prior to either of these functions like it should have been. You can +- * only call this function once. If you desire to have an image for +- * each pass of a interlaced image, use png_read_rows() instead. +- * +- * [*] png_handle_alpha() does not exist yet, as of libpng version 1.2.7 +- */ +-void PNGAPI +-png_read_image(png_structp png_ptr, png_bytepp image) +-{ +- png_uint_32 i,image_height; +- int pass, j; +- png_bytepp rp; +- +- png_debug(1, "in png_read_image\n"); +- +-#ifdef PNG_READ_INTERLACING_SUPPORTED +- pass = png_set_interlace_handling(png_ptr); +-#else +- if (png_ptr->interlaced) +- png_error(png_ptr, +- "Cannot read interlaced image -- interlace handler disabled."); +- pass = 1; +-#endif +- +- +- image_height=png_ptr->height; +- png_ptr->num_rows = image_height; /* Make sure this is set correctly */ +- +- for (j = 0; j < pass; j++) +- { +- rp = image; +- for (i = 0; i < image_height; i++) +- { +- png_read_row(png_ptr, *rp, png_bytep_NULL); +- rp++; +- } +- } +-} +-#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ +- +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +-/* Read the end of the PNG file. Will not read past the end of the +- * file, will verify the end is accurate, and will read any comments +- * or time information at the end of the file, if info is not NULL. +- */ +-void PNGAPI +-png_read_end(png_structp png_ptr, png_infop info_ptr) +-{ +- png_byte chunk_length[4]; +- png_uint_32 length; +- +- png_debug(1, "in png_read_end\n"); +- png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */ +- +- do +- { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_IHDR; +- PNG_IDAT; +- PNG_IEND; +- PNG_PLTE; +-#if defined(PNG_READ_bKGD_SUPPORTED) +- PNG_bKGD; +-#endif +-#if defined(PNG_READ_cHRM_SUPPORTED) +- PNG_cHRM; +-#endif +-#if defined(PNG_READ_gAMA_SUPPORTED) +- PNG_gAMA; +-#endif +-#if defined(PNG_READ_hIST_SUPPORTED) +- PNG_hIST; +-#endif +-#if defined(PNG_READ_iCCP_SUPPORTED) +- PNG_iCCP; +-#endif +-#if defined(PNG_READ_iTXt_SUPPORTED) +- PNG_iTXt; +-#endif +-#if defined(PNG_READ_oFFs_SUPPORTED) +- PNG_oFFs; +-#endif +-#if defined(PNG_READ_pCAL_SUPPORTED) +- PNG_pCAL; +-#endif +-#if defined(PNG_READ_pHYs_SUPPORTED) +- PNG_pHYs; +-#endif +-#if defined(PNG_READ_sBIT_SUPPORTED) +- PNG_sBIT; +-#endif +-#if defined(PNG_READ_sCAL_SUPPORTED) +- PNG_sCAL; +-#endif +-#if defined(PNG_READ_sPLT_SUPPORTED) +- PNG_sPLT; +-#endif +-#if defined(PNG_READ_sRGB_SUPPORTED) +- PNG_sRGB; +-#endif +-#if defined(PNG_READ_tEXt_SUPPORTED) +- PNG_tEXt; +-#endif +-#if defined(PNG_READ_tIME_SUPPORTED) +- PNG_tIME; +-#endif +-#if defined(PNG_READ_tRNS_SUPPORTED) +- PNG_tRNS; +-#endif +-#if defined(PNG_READ_zTXt_SUPPORTED) +- PNG_zTXt; +-#endif +-#endif /* PNG_GLOBAL_ARRAYS */ +- +- png_read_data(png_ptr, chunk_length, 4); +- length = png_get_uint_31(png_ptr,chunk_length); +- +- png_reset_crc(png_ptr); +- png_crc_read(png_ptr, png_ptr->chunk_name, 4); +- +- png_debug1(0, "Reading %s chunk.\n", png_ptr->chunk_name); +- +- if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) +- png_handle_IHDR(png_ptr, info_ptr, length); +- else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) +- png_handle_IEND(png_ptr, info_ptr, length); +-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +- else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name)) +- { +- if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) +- { +- if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT) +- png_error(png_ptr, "Too many IDAT's found"); +- } +- else +- png_ptr->mode |= PNG_AFTER_IDAT; +- png_handle_unknown(png_ptr, info_ptr, length); +- if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) +- png_ptr->mode |= PNG_HAVE_PLTE; +- } +-#endif +- else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) +- { +- /* Zero length IDATs are legal after the last IDAT has been +- * read, but not after other chunks have been read. +- */ +- if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT) +- png_error(png_ptr, "Too many IDAT's found"); +- png_crc_finish(png_ptr, length); +- } +- else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) +- png_handle_PLTE(png_ptr, info_ptr, length); +-#if defined(PNG_READ_bKGD_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4)) +- png_handle_bKGD(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_cHRM_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4)) +- png_handle_cHRM(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_gAMA_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4)) +- png_handle_gAMA(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_hIST_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4)) +- png_handle_hIST(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_oFFs_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4)) +- png_handle_oFFs(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_pCAL_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4)) +- png_handle_pCAL(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_sCAL_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4)) +- png_handle_sCAL(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_pHYs_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4)) +- png_handle_pHYs(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_sBIT_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) +- png_handle_sBIT(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_sRGB_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4)) +- png_handle_sRGB(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_iCCP_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4)) +- png_handle_iCCP(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_sPLT_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4)) +- png_handle_sPLT(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_tEXt_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) +- png_handle_tEXt(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_tIME_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4)) +- png_handle_tIME(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_tRNS_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4)) +- png_handle_tRNS(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_zTXt_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4)) +- png_handle_zTXt(png_ptr, info_ptr, length); +-#endif +-#if defined(PNG_READ_iTXt_SUPPORTED) +- else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) +- png_handle_iTXt(png_ptr, info_ptr, length); +-#endif +- else +- png_handle_unknown(png_ptr, info_ptr, length); +- } while (!(png_ptr->mode & PNG_HAVE_IEND)); +-} +-#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ +- +-/* free all memory used by the read */ +-void PNGAPI +-png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, +- png_infopp end_info_ptr_ptr) +-{ +- png_structp png_ptr = NULL; +- png_infop info_ptr = NULL, end_info_ptr = NULL; +-#ifdef PNG_USER_MEM_SUPPORTED +- png_free_ptr free_fn; +- png_voidp mem_ptr; +-#endif +- +- png_debug(1, "in png_destroy_read_struct\n"); +- if (png_ptr_ptr != NULL) +- png_ptr = *png_ptr_ptr; +- +- if (info_ptr_ptr != NULL) +- info_ptr = *info_ptr_ptr; +- +- if (end_info_ptr_ptr != NULL) +- end_info_ptr = *end_info_ptr_ptr; +- +-#ifdef PNG_USER_MEM_SUPPORTED +- free_fn = png_ptr->free_fn; +- mem_ptr = png_ptr->mem_ptr; +-#endif +- +- png_read_destroy(png_ptr, info_ptr, end_info_ptr); +- +- if (info_ptr != NULL) +- { +-#if defined(PNG_TEXT_SUPPORTED) +- png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1); +-#endif +- +-#ifdef PNG_USER_MEM_SUPPORTED +- png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn, +- (png_voidp)mem_ptr); +-#else +- png_destroy_struct((png_voidp)info_ptr); +-#endif +- *info_ptr_ptr = NULL; +- } +- +- if (end_info_ptr != NULL) +- { +-#if defined(PNG_READ_TEXT_SUPPORTED) +- png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1); +-#endif +-#ifdef PNG_USER_MEM_SUPPORTED +- png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn, +- (png_voidp)mem_ptr); +-#else +- png_destroy_struct((png_voidp)end_info_ptr); +-#endif +- *end_info_ptr_ptr = NULL; +- } +- +- if (png_ptr != NULL) +- { +-#ifdef PNG_USER_MEM_SUPPORTED +- png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, +- (png_voidp)mem_ptr); +-#else +- png_destroy_struct((png_voidp)png_ptr); +-#endif +- *png_ptr_ptr = NULL; +- } +-} +- +-/* free all memory used by the read (old method) */ +-void /* PRIVATE */ +-png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr) +-{ +-#ifdef PNG_SETJMP_SUPPORTED +- jmp_buf tmp_jmp; +-#endif +- png_error_ptr error_fn; +- png_error_ptr warning_fn; +- png_voidp error_ptr; +-#ifdef PNG_USER_MEM_SUPPORTED +- png_free_ptr free_fn; +-#endif +- +- png_debug(1, "in png_read_destroy\n"); +- if (info_ptr != NULL) +- png_info_destroy(png_ptr, info_ptr); +- +- if (end_info_ptr != NULL) +- png_info_destroy(png_ptr, end_info_ptr); +- +- png_free(png_ptr, png_ptr->zbuf); +- png_free(png_ptr, png_ptr->big_row_buf); +- png_free(png_ptr, png_ptr->prev_row); +-#if defined(PNG_READ_DITHER_SUPPORTED) +- png_free(png_ptr, png_ptr->palette_lookup); +- png_free(png_ptr, png_ptr->dither_index); +-#endif +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- png_free(png_ptr, png_ptr->gamma_table); +-#endif +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) +- png_free(png_ptr, png_ptr->gamma_from_1); +- png_free(png_ptr, png_ptr->gamma_to_1); +-#endif +-#ifdef PNG_FREE_ME_SUPPORTED +- if (png_ptr->free_me & PNG_FREE_PLTE) +- png_zfree(png_ptr, png_ptr->palette); +- png_ptr->free_me &= ~PNG_FREE_PLTE; +-#else +- if (png_ptr->flags & PNG_FLAG_FREE_PLTE) +- png_zfree(png_ptr, png_ptr->palette); +- png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; +-#endif +-#if defined(PNG_tRNS_SUPPORTED) || \ +- defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +-#ifdef PNG_FREE_ME_SUPPORTED +- if (png_ptr->free_me & PNG_FREE_TRNS) +- png_free(png_ptr, png_ptr->trans); +- png_ptr->free_me &= ~PNG_FREE_TRNS; +-#else +- if (png_ptr->flags & PNG_FLAG_FREE_TRNS) +- png_free(png_ptr, png_ptr->trans); +- png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; +-#endif +-#endif +-#if defined(PNG_READ_hIST_SUPPORTED) +-#ifdef PNG_FREE_ME_SUPPORTED +- if (png_ptr->free_me & PNG_FREE_HIST) +- png_free(png_ptr, png_ptr->hist); +- png_ptr->free_me &= ~PNG_FREE_HIST; +-#else +- if (png_ptr->flags & PNG_FLAG_FREE_HIST) +- png_free(png_ptr, png_ptr->hist); +- png_ptr->flags &= ~PNG_FLAG_FREE_HIST; +-#endif +-#endif +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- if (png_ptr->gamma_16_table != NULL) +- { +- int i; +- int istop = (1 << (8 - png_ptr->gamma_shift)); +- for (i = 0; i < istop; i++) +- { +- png_free(png_ptr, png_ptr->gamma_16_table[i]); +- } +- png_free(png_ptr, png_ptr->gamma_16_table); +- } +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) +- if (png_ptr->gamma_16_from_1 != NULL) +- { +- int i; +- int istop = (1 << (8 - png_ptr->gamma_shift)); +- for (i = 0; i < istop; i++) +- { +- png_free(png_ptr, png_ptr->gamma_16_from_1[i]); +- } +- png_free(png_ptr, png_ptr->gamma_16_from_1); +- } +- if (png_ptr->gamma_16_to_1 != NULL) +- { +- int i; +- int istop = (1 << (8 - png_ptr->gamma_shift)); +- for (i = 0; i < istop; i++) +- { +- png_free(png_ptr, png_ptr->gamma_16_to_1[i]); +- } +- png_free(png_ptr, png_ptr->gamma_16_to_1); +- } +-#endif +-#endif +-#if defined(PNG_TIME_RFC1123_SUPPORTED) +- png_free(png_ptr, png_ptr->time_buffer); +-#endif +- +- inflateEnd(&png_ptr->zstream); +-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +- png_free(png_ptr, png_ptr->save_buffer); +-#endif +- +-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +-#ifdef PNG_TEXT_SUPPORTED +- png_free(png_ptr, png_ptr->current_text); +-#endif /* PNG_TEXT_SUPPORTED */ +-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ +- +- /* Save the important info out of the png_struct, in case it is +- * being used again. +- */ +-#ifdef PNG_SETJMP_SUPPORTED +- png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf)); +-#endif +- +- error_fn = png_ptr->error_fn; +- warning_fn = png_ptr->warning_fn; +- error_ptr = png_ptr->error_ptr; +-#ifdef PNG_USER_MEM_SUPPORTED +- free_fn = png_ptr->free_fn; +-#endif +- +- png_memset(png_ptr, 0, png_sizeof (png_struct)); +- +- png_ptr->error_fn = error_fn; +- png_ptr->warning_fn = warning_fn; +- png_ptr->error_ptr = error_ptr; +-#ifdef PNG_USER_MEM_SUPPORTED +- png_ptr->free_fn = free_fn; +-#endif +- +-#ifdef PNG_SETJMP_SUPPORTED +- png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf)); +-#endif +- +-} +- +-void PNGAPI +-png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn) +-{ +- png_ptr->read_row_fn = read_row_fn; +-} +- +- +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +-#if defined(PNG_INFO_IMAGE_SUPPORTED) +-void PNGAPI +-png_read_png(png_structp png_ptr, png_infop info_ptr, +- int transforms, +- voidp params) +-{ +- int row; +- +-#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) +- /* invert the alpha channel from opacity to transparency +- */ +- if (transforms & PNG_TRANSFORM_INVERT_ALPHA) +- png_set_invert_alpha(png_ptr); +-#endif +- +- /* png_read_info() gives us all of the information from the +- * PNG file before the first IDAT (image data chunk). +- */ +- png_read_info(png_ptr, info_ptr); +- if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep)) +- png_error(png_ptr,"Image is too high to process with png_read_png()"); +- +- /* -------------- image transformations start here ------------------- */ +- +-#if defined(PNG_READ_16_TO_8_SUPPORTED) +- /* tell libpng to strip 16 bit/color files down to 8 bits per color +- */ +- if (transforms & PNG_TRANSFORM_STRIP_16) +- png_set_strip_16(png_ptr); +-#endif +- +-#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +- /* Strip alpha bytes from the input data without combining with +- * the background (not recommended). +- */ +- if (transforms & PNG_TRANSFORM_STRIP_ALPHA) +- png_set_strip_alpha(png_ptr); +-#endif +- +-#if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED) +- /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single +- * byte into separate bytes (useful for paletted and grayscale images). +- */ +- if (transforms & PNG_TRANSFORM_PACKING) +- png_set_packing(png_ptr); +-#endif +- +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- /* Change the order of packed pixels to least significant bit first +- * (not useful if you are using png_set_packing). +- */ +- if (transforms & PNG_TRANSFORM_PACKSWAP) +- png_set_packswap(png_ptr); +-#endif +- +-#if defined(PNG_READ_EXPAND_SUPPORTED) +- /* Expand paletted colors into true RGB triplets +- * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel +- * Expand paletted or RGB images with transparency to full alpha +- * channels so the data will be available as RGBA quartets. +- */ +- if (transforms & PNG_TRANSFORM_EXPAND) +- if ((png_ptr->bit_depth < 8) || +- (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) || +- (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))) +- png_set_expand(png_ptr); +-#endif +- +- /* We don't handle background color or gamma transformation or dithering. +- */ +- +-#if defined(PNG_READ_INVERT_SUPPORTED) +- /* invert monochrome files to have 0 as white and 1 as black +- */ +- if (transforms & PNG_TRANSFORM_INVERT_MONO) +- png_set_invert_mono(png_ptr); +-#endif +- +-#if defined(PNG_READ_SHIFT_SUPPORTED) +- /* If you want to shift the pixel values from the range [0,255] or +- * [0,65535] to the original [0,7] or [0,31], or whatever range the +- * colors were originally in: +- */ +- if ((transforms & PNG_TRANSFORM_SHIFT) +- && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT)) +- { +- png_color_8p sig_bit; +- +- png_get_sBIT(png_ptr, info_ptr, &sig_bit); +- png_set_shift(png_ptr, sig_bit); +- } +-#endif +- +-#if defined(PNG_READ_BGR_SUPPORTED) +- /* flip the RGB pixels to BGR (or RGBA to BGRA) +- */ +- if (transforms & PNG_TRANSFORM_BGR) +- png_set_bgr(png_ptr); +-#endif +- +-#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) +- /* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) +- */ +- if (transforms & PNG_TRANSFORM_SWAP_ALPHA) +- png_set_swap_alpha(png_ptr); +-#endif +- +-#if defined(PNG_READ_SWAP_SUPPORTED) +- /* swap bytes of 16 bit files to least significant byte first +- */ +- if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) +- png_set_swap(png_ptr); +-#endif +- +- /* We don't handle adding filler bytes */ +- +- /* Optional call to gamma correct and add the background to the palette +- * and update info structure. REQUIRED if you are expecting libpng to +- * update the palette for you (i.e., you selected such a transform above). +- */ +- png_read_update_info(png_ptr, info_ptr); +- +- /* -------------- image transformations end here ------------------- */ +- +-#ifdef PNG_FREE_ME_SUPPORTED +- png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); +-#endif +- if(info_ptr->row_pointers == NULL) +- { +- info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr, +- info_ptr->height * png_sizeof(png_bytep)); +-#ifdef PNG_FREE_ME_SUPPORTED +- info_ptr->free_me |= PNG_FREE_ROWS; +-#endif +- for (row = 0; row < (int)info_ptr->height; row++) +- { +- info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr, +- png_get_rowbytes(png_ptr, info_ptr)); +- } +- } +- +- png_read_image(png_ptr, info_ptr->row_pointers); +- info_ptr->valid |= PNG_INFO_IDAT; +- +- /* read rest of file, and get additional chunks in info_ptr - REQUIRED */ +- png_read_end(png_ptr, info_ptr); +- +- if(transforms == 0 || params == NULL) +- /* quiet compiler warnings */ return; +- +-} +-#endif +-#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ +diff --git a/thirdparty/libpng/pngrio.c b/thirdparty/libpng/pngrio.c +deleted file mode 100644 +index 806f791..0000000 +--- a/thirdparty/libpng/pngrio.c ++++ /dev/null +@@ -1,161 +0,0 @@ +- +-/* pngrio.c - functions for data input +- * +- * libpng 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- * +- * This file provides a location for all input. Users who need +- * special handling are expected to write a function that has the same +- * arguments as this and performs a similar function, but that possibly +- * has a different input method. Note that you shouldn't change this +- * function, but rather write a replacement function and then make +- * libpng use it at run time with png_set_read_fn(...). +- */ +- +-#define PNG_INTERNAL +-#include "png.h" +- +-/* Read the data from whatever input you are using. The default routine +- reads from a file pointer. Note that this routine sometimes gets called +- with very small lengths, so you should implement some kind of simple +- buffering if you are using unbuffered reads. This should never be asked +- to read more then 64K on a 16 bit machine. */ +-void /* PRIVATE */ +-png_read_data(png_structp png_ptr, png_bytep data, png_size_t length) +-{ +- png_debug1(4,"reading %d bytes\n", (int)length); +- if (png_ptr->read_data_fn != NULL) +- (*(png_ptr->read_data_fn))(png_ptr, data, length); +- else +- png_error(png_ptr, "Call to NULL read function"); +-} +- +-#if !defined(PNG_NO_STDIO) +-/* This is the function that does the actual reading of data. If you are +- not reading from a standard C stream, you should create a replacement +- read_data function and use it at run time with png_set_read_fn(), rather +- than changing the library. */ +-#ifndef USE_FAR_KEYWORD +-void PNGAPI +-png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) +-{ +- png_size_t check; +- +- /* fread() returns 0 on error, so it is OK to store this in a png_size_t +- * instead of an int, which is what fread() actually returns. +- */ +-#if defined(_WIN32_WCE) +- if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) +- check = 0; +-#else +- check = (png_size_t)fread(data, (png_size_t)1, length, +- (png_FILE_p)png_ptr->io_ptr); +-#endif +- +- if (check != length) +- png_error(png_ptr, "Read Error"); +-} +-#else +-/* this is the model-independent version. Since the standard I/O library +- can't handle far buffers in the medium and small models, we have to copy +- the data. +-*/ +- +-#define NEAR_BUF_SIZE 1024 +-#define MIN(a,b) (a <= b ? a : b) +- +-static void /* PRIVATE */ +-png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) +-{ +- int check; +- png_byte *n_data; +- png_FILE_p io_ptr; +- +- /* Check if data really is near. If so, use usual code. */ +- n_data = (png_byte *)CVT_PTR_NOCHECK(data); +- io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); +- if ((png_bytep)n_data == data) +- { +-#if defined(_WIN32_WCE) +- if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) +- check = 0; +-#else +- check = fread(n_data, 1, length, io_ptr); +-#endif +- } +- else +- { +- png_byte buf[NEAR_BUF_SIZE]; +- png_size_t read, remaining, err; +- check = 0; +- remaining = length; +- do +- { +- read = MIN(NEAR_BUF_SIZE, remaining); +-#if defined(_WIN32_WCE) +- if ( !ReadFile((HANDLE)(io_ptr), buf, read, &err, NULL) ) +- err = 0; +-#else +- err = fread(buf, (png_size_t)1, read, io_ptr); +-#endif +- png_memcpy(data, buf, read); /* copy far buffer to near buffer */ +- if(err != read) +- break; +- else +- check += err; +- data += read; +- remaining -= read; +- } +- while (remaining != 0); +- } +- if ((png_uint_32)check != (png_uint_32)length) +- png_error(png_ptr, "read Error"); +-} +-#endif +-#endif +- +-/* This function allows the application to supply a new input function +- for libpng if standard C streams aren't being used. +- +- This function takes as its arguments: +- png_ptr - pointer to a png input data structure +- io_ptr - pointer to user supplied structure containing info about +- the input functions. May be NULL. +- read_data_fn - pointer to a new input function that takes as its +- arguments a pointer to a png_struct, a pointer to +- a location where input data can be stored, and a 32-bit +- unsigned int that is the number of bytes to be read. +- To exit and output any fatal error messages the new write +- function should call png_error(png_ptr, "Error msg"). */ +-void PNGAPI +-png_set_read_fn(png_structp png_ptr, png_voidp io_ptr, +- png_rw_ptr read_data_fn) +-{ +- png_ptr->io_ptr = io_ptr; +- +-#if !defined(PNG_NO_STDIO) +- if (read_data_fn != NULL) +- png_ptr->read_data_fn = read_data_fn; +- else +- png_ptr->read_data_fn = png_default_read_data; +-#else +- png_ptr->read_data_fn = read_data_fn; +-#endif +- +- /* It is an error to write to a read device */ +- if (png_ptr->write_data_fn != NULL) +- { +- png_ptr->write_data_fn = NULL; +- png_warning(png_ptr, +- "It's an error to set both read_data_fn and write_data_fn in the "); +- png_warning(png_ptr, +- "same structure. Resetting write_data_fn to NULL."); +- } +- +-#if defined(PNG_WRITE_FLUSH_SUPPORTED) +- png_ptr->output_flush_fn = NULL; +-#endif +-} +diff --git a/thirdparty/libpng/pngrtran.c b/thirdparty/libpng/pngrtran.c +deleted file mode 100644 +index b914d0e..0000000 +--- a/thirdparty/libpng/pngrtran.c ++++ /dev/null +@@ -1,4177 +0,0 @@ +- +-/* pngrtran.c - transforms the data in a row for PNG readers +- * +- * libpng version 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- * +- * This file contains functions optionally called by an application +- * in order to tell libpng how to handle data when reading a PNG. +- * Transformations that are used in both reading and writing are +- * in pngtrans.c. +- */ +- +-#define PNG_INTERNAL +-#include "png.h" +- +-/* Set the action on getting a CRC error for an ancillary or critical chunk. */ +-void PNGAPI +-png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action) +-{ +- png_debug(1, "in png_set_crc_action\n"); +- /* Tell libpng how we react to CRC errors in critical chunks */ +- switch (crit_action) +- { +- case PNG_CRC_NO_CHANGE: /* leave setting as is */ +- break; +- case PNG_CRC_WARN_USE: /* warn/use data */ +- png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; +- png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE; +- break; +- case PNG_CRC_QUIET_USE: /* quiet/use data */ +- png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; +- png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE | +- PNG_FLAG_CRC_CRITICAL_IGNORE; +- break; +- case PNG_CRC_WARN_DISCARD: /* not a valid action for critical data */ +- png_warning(png_ptr, "Can't discard critical data on CRC error."); +- case PNG_CRC_ERROR_QUIT: /* error/quit */ +- case PNG_CRC_DEFAULT: +- default: +- png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; +- break; +- } +- +- switch (ancil_action) +- { +- case PNG_CRC_NO_CHANGE: /* leave setting as is */ +- break; +- case PNG_CRC_WARN_USE: /* warn/use data */ +- png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; +- png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE; +- break; +- case PNG_CRC_QUIET_USE: /* quiet/use data */ +- png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; +- png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE | +- PNG_FLAG_CRC_ANCILLARY_NOWARN; +- break; +- case PNG_CRC_ERROR_QUIT: /* error/quit */ +- png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; +- png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN; +- break; +- case PNG_CRC_WARN_DISCARD: /* warn/discard data */ +- case PNG_CRC_DEFAULT: +- default: +- png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; +- break; +- } +-} +- +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ +- defined(PNG_FLOATING_POINT_SUPPORTED) +-/* handle alpha and tRNS via a background color */ +-void PNGAPI +-png_set_background(png_structp png_ptr, +- png_color_16p background_color, int background_gamma_code, +- int need_expand, double background_gamma) +-{ +- png_debug(1, "in png_set_background\n"); +- if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN) +- { +- png_warning(png_ptr, "Application must supply a known background gamma"); +- return; +- } +- +- png_ptr->transformations |= PNG_BACKGROUND; +- png_memcpy(&(png_ptr->background), background_color, +- png_sizeof(png_color_16)); +- png_ptr->background_gamma = (float)background_gamma; +- png_ptr->background_gamma_type = (png_byte)(background_gamma_code); +- png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0); +- +- /* Note: if need_expand is set and color_type is either RGB or RGB_ALPHA +- * (in which case need_expand is superfluous anyway), the background color +- * might actually be gray yet not be flagged as such. This is not a problem +- * for the current code, which uses PNG_BACKGROUND_IS_GRAY only to +- * decide when to do the png_do_gray_to_rgb() transformation. +- */ +- if ((need_expand && !(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) || +- (!need_expand && background_color->red == background_color->green && +- background_color->red == background_color->blue)) +- png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; +-} +-#endif +- +-#if defined(PNG_READ_16_TO_8_SUPPORTED) +-/* strip 16 bit depth files to 8 bit depth */ +-void PNGAPI +-png_set_strip_16(png_structp png_ptr) +-{ +- png_debug(1, "in png_set_strip_16\n"); +- png_ptr->transformations |= PNG_16_TO_8; +-} +-#endif +- +-#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +-void PNGAPI +-png_set_strip_alpha(png_structp png_ptr) +-{ +- png_debug(1, "in png_set_strip_alpha\n"); +- png_ptr->transformations |= PNG_STRIP_ALPHA; +-} +-#endif +- +-#if defined(PNG_READ_DITHER_SUPPORTED) +-/* Dither file to 8 bit. Supply a palette, the current number +- * of elements in the palette, the maximum number of elements +- * allowed, and a histogram if possible. If the current number +- * of colors is greater then the maximum number, the palette will be +- * modified to fit in the maximum number. "full_dither" indicates +- * whether we need a dithering cube set up for RGB images, or if we +- * simply are reducing the number of colors in a paletted image. +- */ +- +-typedef struct png_dsort_struct +-{ +- struct png_dsort_struct FAR * next; +- png_byte left; +- png_byte right; +-} png_dsort; +-typedef png_dsort FAR * png_dsortp; +-typedef png_dsort FAR * FAR * png_dsortpp; +- +-void PNGAPI +-png_set_dither(png_structp png_ptr, png_colorp palette, +- int num_palette, int maximum_colors, png_uint_16p histogram, +- int full_dither) +-{ +- png_debug(1, "in png_set_dither\n"); +- png_ptr->transformations |= PNG_DITHER; +- +- if (!full_dither) +- { +- int i; +- +- png_ptr->dither_index = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)(num_palette * png_sizeof (png_byte))); +- for (i = 0; i < num_palette; i++) +- png_ptr->dither_index[i] = (png_byte)i; +- } +- +- if (num_palette > maximum_colors) +- { +- if (histogram != NULL) +- { +- /* This is easy enough, just throw out the least used colors. +- Perhaps not the best solution, but good enough. */ +- +- int i; +- +- /* initialize an array to sort colors */ +- png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)(num_palette * png_sizeof (png_byte))); +- +- /* initialize the dither_sort array */ +- for (i = 0; i < num_palette; i++) +- png_ptr->dither_sort[i] = (png_byte)i; +- +- /* Find the least used palette entries by starting a +- bubble sort, and running it until we have sorted +- out enough colors. Note that we don't care about +- sorting all the colors, just finding which are +- least used. */ +- +- for (i = num_palette - 1; i >= maximum_colors; i--) +- { +- int done; /* to stop early if the list is pre-sorted */ +- int j; +- +- done = 1; +- for (j = 0; j < i; j++) +- { +- if (histogram[png_ptr->dither_sort[j]] +- < histogram[png_ptr->dither_sort[j + 1]]) +- { +- png_byte t; +- +- t = png_ptr->dither_sort[j]; +- png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1]; +- png_ptr->dither_sort[j + 1] = t; +- done = 0; +- } +- } +- if (done) +- break; +- } +- +- /* swap the palette around, and set up a table, if necessary */ +- if (full_dither) +- { +- int j = num_palette; +- +- /* put all the useful colors within the max, but don't +- move the others */ +- for (i = 0; i < maximum_colors; i++) +- { +- if ((int)png_ptr->dither_sort[i] >= maximum_colors) +- { +- do +- j--; +- while ((int)png_ptr->dither_sort[j] >= maximum_colors); +- palette[i] = palette[j]; +- } +- } +- } +- else +- { +- int j = num_palette; +- +- /* move all the used colors inside the max limit, and +- develop a translation table */ +- for (i = 0; i < maximum_colors; i++) +- { +- /* only move the colors we need to */ +- if ((int)png_ptr->dither_sort[i] >= maximum_colors) +- { +- png_color tmp_color; +- +- do +- j--; +- while ((int)png_ptr->dither_sort[j] >= maximum_colors); +- +- tmp_color = palette[j]; +- palette[j] = palette[i]; +- palette[i] = tmp_color; +- /* indicate where the color went */ +- png_ptr->dither_index[j] = (png_byte)i; +- png_ptr->dither_index[i] = (png_byte)j; +- } +- } +- +- /* find closest color for those colors we are not using */ +- for (i = 0; i < num_palette; i++) +- { +- if ((int)png_ptr->dither_index[i] >= maximum_colors) +- { +- int min_d, k, min_k, d_index; +- +- /* find the closest color to one we threw out */ +- d_index = png_ptr->dither_index[i]; +- min_d = PNG_COLOR_DIST(palette[d_index], palette[0]); +- for (k = 1, min_k = 0; k < maximum_colors; k++) +- { +- int d; +- +- d = PNG_COLOR_DIST(palette[d_index], palette[k]); +- +- if (d < min_d) +- { +- min_d = d; +- min_k = k; +- } +- } +- /* point to closest color */ +- png_ptr->dither_index[i] = (png_byte)min_k; +- } +- } +- } +- png_free(png_ptr, png_ptr->dither_sort); +- png_ptr->dither_sort=NULL; +- } +- else +- { +- /* This is much harder to do simply (and quickly). Perhaps +- we need to go through a median cut routine, but those +- don't always behave themselves with only a few colors +- as input. So we will just find the closest two colors, +- and throw out one of them (chosen somewhat randomly). +- [We don't understand this at all, so if someone wants to +- work on improving it, be our guest - AED, GRP] +- */ +- int i; +- int max_d; +- int num_new_palette; +- png_dsortp t; +- png_dsortpp hash; +- +- t=NULL; +- +- /* initialize palette index arrays */ +- png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)(num_palette * png_sizeof (png_byte))); +- png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)(num_palette * png_sizeof (png_byte))); +- +- /* initialize the sort array */ +- for (i = 0; i < num_palette; i++) +- { +- png_ptr->index_to_palette[i] = (png_byte)i; +- png_ptr->palette_to_index[i] = (png_byte)i; +- } +- +- hash = (png_dsortpp)png_malloc(png_ptr, (png_uint_32)(769 * +- png_sizeof (png_dsortp))); +- for (i = 0; i < 769; i++) +- hash[i] = NULL; +-/* png_memset(hash, 0, 769 * png_sizeof (png_dsortp)); */ +- +- num_new_palette = num_palette; +- +- /* initial wild guess at how far apart the farthest pixel +- pair we will be eliminating will be. Larger +- numbers mean more areas will be allocated, Smaller +- numbers run the risk of not saving enough data, and +- having to do this all over again. +- +- I have not done extensive checking on this number. +- */ +- max_d = 96; +- +- while (num_new_palette > maximum_colors) +- { +- for (i = 0; i < num_new_palette - 1; i++) +- { +- int j; +- +- for (j = i + 1; j < num_new_palette; j++) +- { +- int d; +- +- d = PNG_COLOR_DIST(palette[i], palette[j]); +- +- if (d <= max_d) +- { +- +- t = (png_dsortp)png_malloc_warn(png_ptr, +- (png_uint_32)(png_sizeof(png_dsort))); +- if (t == NULL) +- break; +- t->next = hash[d]; +- t->left = (png_byte)i; +- t->right = (png_byte)j; +- hash[d] = t; +- } +- } +- if (t == NULL) +- break; +- } +- +- if (t != NULL) +- for (i = 0; i <= max_d; i++) +- { +- if (hash[i] != NULL) +- { +- png_dsortp p; +- +- for (p = hash[i]; p; p = p->next) +- { +- if ((int)png_ptr->index_to_palette[p->left] +- < num_new_palette && +- (int)png_ptr->index_to_palette[p->right] +- < num_new_palette) +- { +- int j, next_j; +- +- if (num_new_palette & 0x01) +- { +- j = p->left; +- next_j = p->right; +- } +- else +- { +- j = p->right; +- next_j = p->left; +- } +- +- num_new_palette--; +- palette[png_ptr->index_to_palette[j]] +- = palette[num_new_palette]; +- if (!full_dither) +- { +- int k; +- +- for (k = 0; k < num_palette; k++) +- { +- if (png_ptr->dither_index[k] == +- png_ptr->index_to_palette[j]) +- png_ptr->dither_index[k] = +- png_ptr->index_to_palette[next_j]; +- if ((int)png_ptr->dither_index[k] == +- num_new_palette) +- png_ptr->dither_index[k] = +- png_ptr->index_to_palette[j]; +- } +- } +- +- png_ptr->index_to_palette[png_ptr->palette_to_index +- [num_new_palette]] = png_ptr->index_to_palette[j]; +- png_ptr->palette_to_index[png_ptr->index_to_palette[j]] +- = png_ptr->palette_to_index[num_new_palette]; +- +- png_ptr->index_to_palette[j] = (png_byte)num_new_palette; +- png_ptr->palette_to_index[num_new_palette] = (png_byte)j; +- } +- if (num_new_palette <= maximum_colors) +- break; +- } +- if (num_new_palette <= maximum_colors) +- break; +- } +- } +- +- for (i = 0; i < 769; i++) +- { +- if (hash[i] != NULL) +- { +- png_dsortp p = hash[i]; +- while (p) +- { +- t = p->next; +- png_free(png_ptr, p); +- p = t; +- } +- } +- hash[i] = 0; +- } +- max_d += 96; +- } +- png_free(png_ptr, hash); +- png_free(png_ptr, png_ptr->palette_to_index); +- png_free(png_ptr, png_ptr->index_to_palette); +- png_ptr->palette_to_index=NULL; +- png_ptr->index_to_palette=NULL; +- } +- num_palette = maximum_colors; +- } +- if (png_ptr->palette == NULL) +- { +- png_ptr->palette = palette; +- } +- png_ptr->num_palette = (png_uint_16)num_palette; +- +- if (full_dither) +- { +- int i; +- png_bytep distance; +- int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS + +- PNG_DITHER_BLUE_BITS; +- int num_red = (1 << PNG_DITHER_RED_BITS); +- int num_green = (1 << PNG_DITHER_GREEN_BITS); +- int num_blue = (1 << PNG_DITHER_BLUE_BITS); +- png_size_t num_entries = ((png_size_t)1 << total_bits); +- +- png_ptr->palette_lookup = (png_bytep )png_malloc(png_ptr, +- (png_uint_32)(num_entries * png_sizeof (png_byte))); +- +- png_memset(png_ptr->palette_lookup, 0, num_entries * +- png_sizeof (png_byte)); +- +- distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries * +- png_sizeof(png_byte))); +- +- png_memset(distance, 0xff, num_entries * png_sizeof(png_byte)); +- +- for (i = 0; i < num_palette; i++) +- { +- int ir, ig, ib; +- int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS)); +- int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS)); +- int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS)); +- +- for (ir = 0; ir < num_red; ir++) +- { +- /* int dr = abs(ir - r); */ +- int dr = ((ir > r) ? ir - r : r - ir); +- int index_r = (ir << (PNG_DITHER_BLUE_BITS + PNG_DITHER_GREEN_BITS)); +- +- for (ig = 0; ig < num_green; ig++) +- { +- /* int dg = abs(ig - g); */ +- int dg = ((ig > g) ? ig - g : g - ig); +- int dt = dr + dg; +- int dm = ((dr > dg) ? dr : dg); +- int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS); +- +- for (ib = 0; ib < num_blue; ib++) +- { +- int d_index = index_g | ib; +- /* int db = abs(ib - b); */ +- int db = ((ib > b) ? ib - b : b - ib); +- int dmax = ((dm > db) ? dm : db); +- int d = dmax + dt + db; +- +- if (d < (int)distance[d_index]) +- { +- distance[d_index] = (png_byte)d; +- png_ptr->palette_lookup[d_index] = (png_byte)i; +- } +- } +- } +- } +- } +- +- png_free(png_ptr, distance); +- } +-} +-#endif +- +-#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) +-/* Transform the image from the file_gamma to the screen_gamma. We +- * only do transformations on images where the file_gamma and screen_gamma +- * are not close reciprocals, otherwise it slows things down slightly, and +- * also needlessly introduces small errors. +- * +- * We will turn off gamma transformation later if no semitransparent entries +- * are present in the tRNS array for palette images. We can't do it here +- * because we don't necessarily have the tRNS chunk yet. +- */ +-void PNGAPI +-png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma) +-{ +- png_debug(1, "in png_set_gamma\n"); +- if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) || +- (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) || +- (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)) +- png_ptr->transformations |= PNG_GAMMA; +- png_ptr->gamma = (float)file_gamma; +- png_ptr->screen_gamma = (float)scrn_gamma; +-} +-#endif +- +-#if defined(PNG_READ_EXPAND_SUPPORTED) +-/* Expand paletted images to RGB, expand grayscale images of +- * less than 8-bit depth to 8-bit depth, and expand tRNS chunks +- * to alpha channels. +- */ +-void PNGAPI +-png_set_expand(png_structp png_ptr) +-{ +- png_debug(1, "in png_set_expand\n"); +- png_ptr->transformations |= PNG_EXPAND; +-} +- +-/* GRR 19990627: the following three functions currently are identical +- * to png_set_expand(). However, it is entirely reasonable that someone +- * might wish to expand an indexed image to RGB but *not* expand a single, +- * fully transparent palette entry to a full alpha channel--perhaps instead +- * convert tRNS to the grayscale/RGB format (16-bit RGB value), or replace +- * the transparent color with a particular RGB value, or drop tRNS entirely. +- * IOW, a future version of the library may make the transformations flag +- * a bit more fine-grained, with separate bits for each of these three +- * functions. +- * +- * More to the point, these functions make it obvious what libpng will be +- * doing, whereas "expand" can (and does) mean any number of things. +- */ +- +-/* Expand paletted images to RGB. */ +-void PNGAPI +-png_set_palette_to_rgb(png_structp png_ptr) +-{ +- png_debug(1, "in png_set_expand\n"); +- png_ptr->transformations |= PNG_EXPAND; +-} +- +-/* Expand grayscale images of less than 8-bit depth to 8 bits. */ +-void PNGAPI +-png_set_gray_1_2_4_to_8(png_structp png_ptr) +-{ +- png_debug(1, "in png_set_expand\n"); +- png_ptr->transformations |= PNG_EXPAND; +-} +- +-/* Expand tRNS chunks to alpha channels. */ +-void PNGAPI +-png_set_tRNS_to_alpha(png_structp png_ptr) +-{ +- png_debug(1, "in png_set_expand\n"); +- png_ptr->transformations |= PNG_EXPAND; +-} +-#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */ +- +-#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +-void PNGAPI +-png_set_gray_to_rgb(png_structp png_ptr) +-{ +- png_debug(1, "in png_set_gray_to_rgb\n"); +- png_ptr->transformations |= PNG_GRAY_TO_RGB; +-} +-#endif +- +-#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +-#if defined(PNG_FLOATING_POINT_SUPPORTED) +-/* Convert a RGB image to a grayscale of the same width. This allows us, +- * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image. +- */ +- +-void PNGAPI +-png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red, +- double green) +-{ +- int red_fixed = (int)((float)red*100000.0 + 0.5); +- int green_fixed = (int)((float)green*100000.0 + 0.5); +- png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed); +-} +-#endif +- +-void PNGAPI +-png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action, +- png_fixed_point red, png_fixed_point green) +-{ +- png_debug(1, "in png_set_rgb_to_gray\n"); +- switch(error_action) +- { +- case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY; +- break; +- case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN; +- break; +- case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR; +- } +- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +-#if defined(PNG_READ_EXPAND_SUPPORTED) +- png_ptr->transformations |= PNG_EXPAND; +-#else +- { +- png_warning(png_ptr, "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED."); +- png_ptr->transformations &= ~PNG_RGB_TO_GRAY; +- } +-#endif +- { +- png_uint_16 red_int, green_int; +- if(red < 0 || green < 0) +- { +- red_int = 6968; /* .212671 * 32768 + .5 */ +- green_int = 23434; /* .715160 * 32768 + .5 */ +- } +- else if(red + green < 100000L) +- { +- red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L); +- green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L); +- } +- else +- { +- png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients"); +- red_int = 6968; +- green_int = 23434; +- } +- png_ptr->rgb_to_gray_red_coeff = red_int; +- png_ptr->rgb_to_gray_green_coeff = green_int; +- png_ptr->rgb_to_gray_blue_coeff = (png_uint_16)(32768-red_int-green_int); +- } +-} +-#endif +- +-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_LEGACY_SUPPORTED) +-void PNGAPI +-png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr +- read_user_transform_fn) +-{ +- png_debug(1, "in png_set_read_user_transform_fn\n"); +-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) +- png_ptr->transformations |= PNG_USER_TRANSFORM; +- png_ptr->read_user_transform_fn = read_user_transform_fn; +-#endif +-#ifdef PNG_LEGACY_SUPPORTED +- if(read_user_transform_fn) +- png_warning(png_ptr, +- "This version of libpng does not support user transforms"); +-#endif +-} +-#endif +- +-/* Initialize everything needed for the read. This includes modifying +- * the palette. +- */ +-void /* PRIVATE */ +-png_init_read_transformations(png_structp png_ptr) +-{ +- png_debug(1, "in png_init_read_transformations\n"); +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- if(png_ptr != NULL) +-#endif +- { +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) || defined(PNG_READ_SHIFT_SUPPORTED) \ +- || defined(PNG_READ_GAMMA_SUPPORTED) +- int color_type = png_ptr->color_type; +-#endif +- +-#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED) +- if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) && +- (png_ptr->transformations & PNG_EXPAND)) +- { +- if (!(color_type & PNG_COLOR_MASK_COLOR)) /* i.e., GRAY or GRAY_ALPHA */ +- { +- /* expand background chunk. */ +- switch (png_ptr->bit_depth) +- { +- case 1: +- png_ptr->background.gray *= (png_uint_16)0xff; +- png_ptr->background.red = png_ptr->background.green +- = png_ptr->background.blue = png_ptr->background.gray; +- break; +- case 2: +- png_ptr->background.gray *= (png_uint_16)0x55; +- png_ptr->background.red = png_ptr->background.green +- = png_ptr->background.blue = png_ptr->background.gray; +- break; +- case 4: +- png_ptr->background.gray *= (png_uint_16)0x11; +- png_ptr->background.red = png_ptr->background.green +- = png_ptr->background.blue = png_ptr->background.gray; +- break; +- case 8: +- case 16: +- png_ptr->background.red = png_ptr->background.green +- = png_ptr->background.blue = png_ptr->background.gray; +- break; +- } +- } +- else if (color_type == PNG_COLOR_TYPE_PALETTE) +- { +- png_ptr->background.red = +- png_ptr->palette[png_ptr->background.index].red; +- png_ptr->background.green = +- png_ptr->palette[png_ptr->background.index].green; +- png_ptr->background.blue = +- png_ptr->palette[png_ptr->background.index].blue; +- +-#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) +- if (png_ptr->transformations & PNG_INVERT_ALPHA) +- { +-#if defined(PNG_READ_EXPAND_SUPPORTED) +- if (!(png_ptr->transformations & PNG_EXPAND)) +-#endif +- { +- /* invert the alpha channel (in tRNS) unless the pixels are +- going to be expanded, in which case leave it for later */ +- int i,istop; +- istop=(int)png_ptr->num_trans; +- for (i=0; itrans[i] = (png_byte)(255 - png_ptr->trans[i]); +- } +- } +-#endif +- +- } +- } +-#endif +- +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED) +- png_ptr->background_1 = png_ptr->background; +-#endif +-#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) +- +- if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0) +- && (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0) +- < PNG_GAMMA_THRESHOLD)) +- { +- int i,k; +- k=0; +- for (i=0; inum_trans; i++) +- { +- if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff) +- k=1; /* partial transparency is present */ +- } +- if (k == 0) +- png_ptr->transformations &= (~PNG_GAMMA); +- } +- +- if (png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY)) +- { +- png_build_gamma_table(png_ptr); +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) +- if (png_ptr->transformations & PNG_BACKGROUND) +- { +- if (color_type == PNG_COLOR_TYPE_PALETTE) +- { +- /* could skip if no transparency and +- */ +- png_color back, back_1; +- png_colorp palette = png_ptr->palette; +- int num_palette = png_ptr->num_palette; +- int i; +- if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE) +- { +- back.red = png_ptr->gamma_table[png_ptr->background.red]; +- back.green = png_ptr->gamma_table[png_ptr->background.green]; +- back.blue = png_ptr->gamma_table[png_ptr->background.blue]; +- +- back_1.red = png_ptr->gamma_to_1[png_ptr->background.red]; +- back_1.green = png_ptr->gamma_to_1[png_ptr->background.green]; +- back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue]; +- } +- else +- { +- double g, gs; +- +- switch (png_ptr->background_gamma_type) +- { +- case PNG_BACKGROUND_GAMMA_SCREEN: +- g = (png_ptr->screen_gamma); +- gs = 1.0; +- break; +- case PNG_BACKGROUND_GAMMA_FILE: +- g = 1.0 / (png_ptr->gamma); +- gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); +- break; +- case PNG_BACKGROUND_GAMMA_UNIQUE: +- g = 1.0 / (png_ptr->background_gamma); +- gs = 1.0 / (png_ptr->background_gamma * +- png_ptr->screen_gamma); +- break; +- default: +- g = 1.0; /* back_1 */ +- gs = 1.0; /* back */ +- } +- +- if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD) +- { +- back.red = (png_byte)png_ptr->background.red; +- back.green = (png_byte)png_ptr->background.green; +- back.blue = (png_byte)png_ptr->background.blue; +- } +- else +- { +- back.red = (png_byte)(pow( +- (double)png_ptr->background.red/255, gs) * 255.0 + .5); +- back.green = (png_byte)(pow( +- (double)png_ptr->background.green/255, gs) * 255.0 + .5); +- back.blue = (png_byte)(pow( +- (double)png_ptr->background.blue/255, gs) * 255.0 + .5); +- } +- +- back_1.red = (png_byte)(pow( +- (double)png_ptr->background.red/255, g) * 255.0 + .5); +- back_1.green = (png_byte)(pow( +- (double)png_ptr->background.green/255, g) * 255.0 + .5); +- back_1.blue = (png_byte)(pow( +- (double)png_ptr->background.blue/255, g) * 255.0 + .5); +- } +- for (i = 0; i < num_palette; i++) +- { +- if (i < (int)png_ptr->num_trans && png_ptr->trans[i] != 0xff) +- { +- if (png_ptr->trans[i] == 0) +- { +- palette[i] = back; +- } +- else /* if (png_ptr->trans[i] != 0xff) */ +- { +- png_byte v, w; +- +- v = png_ptr->gamma_to_1[palette[i].red]; +- png_composite(w, v, png_ptr->trans[i], back_1.red); +- palette[i].red = png_ptr->gamma_from_1[w]; +- +- v = png_ptr->gamma_to_1[palette[i].green]; +- png_composite(w, v, png_ptr->trans[i], back_1.green); +- palette[i].green = png_ptr->gamma_from_1[w]; +- +- v = png_ptr->gamma_to_1[palette[i].blue]; +- png_composite(w, v, png_ptr->trans[i], back_1.blue); +- palette[i].blue = png_ptr->gamma_from_1[w]; +- } +- } +- else +- { +- palette[i].red = png_ptr->gamma_table[palette[i].red]; +- palette[i].green = png_ptr->gamma_table[palette[i].green]; +- palette[i].blue = png_ptr->gamma_table[palette[i].blue]; +- } +- } +- } +- /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */ +- else +- /* color_type != PNG_COLOR_TYPE_PALETTE */ +- { +- double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1); +- double g = 1.0; +- double gs = 1.0; +- +- switch (png_ptr->background_gamma_type) +- { +- case PNG_BACKGROUND_GAMMA_SCREEN: +- g = (png_ptr->screen_gamma); +- gs = 1.0; +- break; +- case PNG_BACKGROUND_GAMMA_FILE: +- g = 1.0 / (png_ptr->gamma); +- gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); +- break; +- case PNG_BACKGROUND_GAMMA_UNIQUE: +- g = 1.0 / (png_ptr->background_gamma); +- gs = 1.0 / (png_ptr->background_gamma * +- png_ptr->screen_gamma); +- break; +- } +- +- png_ptr->background_1.gray = (png_uint_16)(pow( +- (double)png_ptr->background.gray / m, g) * m + .5); +- png_ptr->background.gray = (png_uint_16)(pow( +- (double)png_ptr->background.gray / m, gs) * m + .5); +- +- if ((png_ptr->background.red != png_ptr->background.green) || +- (png_ptr->background.red != png_ptr->background.blue) || +- (png_ptr->background.red != png_ptr->background.gray)) +- { +- /* RGB or RGBA with color background */ +- png_ptr->background_1.red = (png_uint_16)(pow( +- (double)png_ptr->background.red / m, g) * m + .5); +- png_ptr->background_1.green = (png_uint_16)(pow( +- (double)png_ptr->background.green / m, g) * m + .5); +- png_ptr->background_1.blue = (png_uint_16)(pow( +- (double)png_ptr->background.blue / m, g) * m + .5); +- png_ptr->background.red = (png_uint_16)(pow( +- (double)png_ptr->background.red / m, gs) * m + .5); +- png_ptr->background.green = (png_uint_16)(pow( +- (double)png_ptr->background.green / m, gs) * m + .5); +- png_ptr->background.blue = (png_uint_16)(pow( +- (double)png_ptr->background.blue / m, gs) * m + .5); +- } +- else +- { +- /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */ +- png_ptr->background_1.red = png_ptr->background_1.green +- = png_ptr->background_1.blue = png_ptr->background_1.gray; +- png_ptr->background.red = png_ptr->background.green +- = png_ptr->background.blue = png_ptr->background.gray; +- } +- } +- } +- else +- /* transformation does not include PNG_BACKGROUND */ +-#endif /* PNG_READ_BACKGROUND_SUPPORTED */ +- if (color_type == PNG_COLOR_TYPE_PALETTE) +- { +- png_colorp palette = png_ptr->palette; +- int num_palette = png_ptr->num_palette; +- int i; +- +- for (i = 0; i < num_palette; i++) +- { +- palette[i].red = png_ptr->gamma_table[palette[i].red]; +- palette[i].green = png_ptr->gamma_table[palette[i].green]; +- palette[i].blue = png_ptr->gamma_table[palette[i].blue]; +- } +- } +- } +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) +- else +-#endif +-#endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */ +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) +- /* No GAMMA transformation */ +- if ((png_ptr->transformations & PNG_BACKGROUND) && +- (color_type == PNG_COLOR_TYPE_PALETTE)) +- { +- int i; +- int istop = (int)png_ptr->num_trans; +- png_color back; +- png_colorp palette = png_ptr->palette; +- +- back.red = (png_byte)png_ptr->background.red; +- back.green = (png_byte)png_ptr->background.green; +- back.blue = (png_byte)png_ptr->background.blue; +- +- for (i = 0; i < istop; i++) +- { +- if (png_ptr->trans[i] == 0) +- { +- palette[i] = back; +- } +- else if (png_ptr->trans[i] != 0xff) +- { +- /* The png_composite() macro is defined in png.h */ +- png_composite(palette[i].red, palette[i].red, +- png_ptr->trans[i], back.red); +- png_composite(palette[i].green, palette[i].green, +- png_ptr->trans[i], back.green); +- png_composite(palette[i].blue, palette[i].blue, +- png_ptr->trans[i], back.blue); +- } +- } +- } +-#endif /* PNG_READ_BACKGROUND_SUPPORTED */ +- +-#if defined(PNG_READ_SHIFT_SUPPORTED) +- if ((png_ptr->transformations & PNG_SHIFT) && +- (color_type == PNG_COLOR_TYPE_PALETTE)) +- { +- png_uint_16 i; +- png_uint_16 istop = png_ptr->num_palette; +- int sr = 8 - png_ptr->sig_bit.red; +- int sg = 8 - png_ptr->sig_bit.green; +- int sb = 8 - png_ptr->sig_bit.blue; +- +- if (sr < 0 || sr > 8) +- sr = 0; +- if (sg < 0 || sg > 8) +- sg = 0; +- if (sb < 0 || sb > 8) +- sb = 0; +- for (i = 0; i < istop; i++) +- { +- png_ptr->palette[i].red >>= sr; +- png_ptr->palette[i].green >>= sg; +- png_ptr->palette[i].blue >>= sb; +- } +- } +-#endif /* PNG_READ_SHIFT_SUPPORTED */ +- } +-#if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \ +- && !defined(PNG_READ_BACKGROUND_SUPPORTED) +- if(png_ptr) +- return; +-#endif +-} +- +-/* Modify the info structure to reflect the transformations. The +- * info should be updated so a PNG file could be written with it, +- * assuming the transformations result in valid PNG data. +- */ +-void /* PRIVATE */ +-png_read_transform_info(png_structp png_ptr, png_infop info_ptr) +-{ +- png_debug(1, "in png_read_transform_info\n"); +-#if defined(PNG_READ_EXPAND_SUPPORTED) +- if (png_ptr->transformations & PNG_EXPAND) +- { +- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- { +- if (png_ptr->num_trans) +- info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA; +- else +- info_ptr->color_type = PNG_COLOR_TYPE_RGB; +- info_ptr->bit_depth = 8; +- info_ptr->num_trans = 0; +- } +- else +- { +- if (png_ptr->num_trans) +- info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; +- if (info_ptr->bit_depth < 8) +- info_ptr->bit_depth = 8; +- info_ptr->num_trans = 0; +- } +- } +-#endif +- +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) +- if (png_ptr->transformations & PNG_BACKGROUND) +- { +- info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA; +- info_ptr->num_trans = 0; +- info_ptr->background = png_ptr->background; +- } +-#endif +- +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- if (png_ptr->transformations & PNG_GAMMA) +- { +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- info_ptr->gamma = png_ptr->gamma; +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +- info_ptr->int_gamma = png_ptr->int_gamma; +-#endif +- } +-#endif +- +-#if defined(PNG_READ_16_TO_8_SUPPORTED) +- if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16)) +- info_ptr->bit_depth = 8; +-#endif +- +-#if defined(PNG_READ_DITHER_SUPPORTED) +- if (png_ptr->transformations & PNG_DITHER) +- { +- if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) || +- (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) && +- png_ptr->palette_lookup && info_ptr->bit_depth == 8) +- { +- info_ptr->color_type = PNG_COLOR_TYPE_PALETTE; +- } +- } +-#endif +- +-#if defined(PNG_READ_PACK_SUPPORTED) +- if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8)) +- info_ptr->bit_depth = 8; +-#endif +- +-#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +- if (png_ptr->transformations & PNG_GRAY_TO_RGB) +- info_ptr->color_type |= PNG_COLOR_MASK_COLOR; +-#endif +- +-#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +- if (png_ptr->transformations & PNG_RGB_TO_GRAY) +- info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR; +-#endif +- +- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- info_ptr->channels = 1; +- else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) +- info_ptr->channels = 3; +- else +- info_ptr->channels = 1; +- +-#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +- if (png_ptr->transformations & PNG_STRIP_ALPHA) +- info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA; +-#endif +- +- if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) +- info_ptr->channels++; +- +-#if defined(PNG_READ_FILLER_SUPPORTED) +- /* STRIP_ALPHA and FILLER allowed: MASK_ALPHA bit stripped above */ +- if ((png_ptr->transformations & PNG_FILLER) && +- ((info_ptr->color_type == PNG_COLOR_TYPE_RGB) || +- (info_ptr->color_type == PNG_COLOR_TYPE_GRAY))) +- { +- info_ptr->channels++; +- /* if adding a true alpha channel not just filler */ +-#if !defined(PNG_1_0_X) +- if (png_ptr->transformations & PNG_ADD_ALPHA) +- info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; +-#endif +- } +-#endif +- +-#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \ +-defined(PNG_READ_USER_TRANSFORM_SUPPORTED) +- if(png_ptr->transformations & PNG_USER_TRANSFORM) +- { +- if(info_ptr->bit_depth < png_ptr->user_transform_depth) +- info_ptr->bit_depth = png_ptr->user_transform_depth; +- if(info_ptr->channels < png_ptr->user_transform_channels) +- info_ptr->channels = png_ptr->user_transform_channels; +- } +-#endif +- +- info_ptr->pixel_depth = (png_byte)(info_ptr->channels * +- info_ptr->bit_depth); +- +- info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth,info_ptr->width); +- +-#if !defined(PNG_READ_EXPAND_SUPPORTED) +- if(png_ptr) +- return; +-#endif +-} +- +-/* Transform the row. The order of transformations is significant, +- * and is very touchy. If you add a transformation, take care to +- * decide how it fits in with the other transformations here. +- */ +-void /* PRIVATE */ +-png_do_read_transformations(png_structp png_ptr) +-{ +- png_debug(1, "in png_do_read_transformations\n"); +-#if !defined(PNG_USELESS_TESTS_SUPPORTED) +- if (png_ptr->row_buf == NULL) +- { +-#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) +- char msg[50]; +- +- sprintf(msg, "NULL row buffer for row %ld, pass %d", png_ptr->row_number, +- png_ptr->pass); +- png_error(png_ptr, msg); +-#else +- png_error(png_ptr, "NULL row buffer"); +-#endif +- } +-#endif +- +-#if defined(PNG_READ_EXPAND_SUPPORTED) +- if (png_ptr->transformations & PNG_EXPAND) +- { +- if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE) +- { +- png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1, +- png_ptr->palette, png_ptr->trans, png_ptr->num_trans); +- } +- else +- { +- if (png_ptr->num_trans) +- png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1, +- &(png_ptr->trans_values)); +- else +- png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1, +- NULL); +- } +- } +-#endif +- +-#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +- if (png_ptr->transformations & PNG_STRIP_ALPHA) +- png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, +- PNG_FLAG_FILLER_AFTER); +-#endif +- +-#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +- if (png_ptr->transformations & PNG_RGB_TO_GRAY) +- { +- int rgb_error = +- png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), png_ptr->row_buf + 1); +- if(rgb_error) +- { +- png_ptr->rgb_to_gray_status=1; +- if(png_ptr->transformations == PNG_RGB_TO_GRAY_WARN) +- png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel"); +- if(png_ptr->transformations == PNG_RGB_TO_GRAY_ERR) +- png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel"); +- } +- } +-#endif +- +-/* +-From Andreas Dilger e-mail to png-implement, 26 March 1998: +- +- In most cases, the "simple transparency" should be done prior to doing +- gray-to-RGB, or you will have to test 3x as many bytes to check if a +- pixel is transparent. You would also need to make sure that the +- transparency information is upgraded to RGB. +- +- To summarize, the current flow is: +- - Gray + simple transparency -> compare 1 or 2 gray bytes and composite +- with background "in place" if transparent, +- convert to RGB if necessary +- - Gray + alpha -> composite with gray background and remove alpha bytes, +- convert to RGB if necessary +- +- To support RGB backgrounds for gray images we need: +- - Gray + simple transparency -> convert to RGB + simple transparency, compare +- 3 or 6 bytes and composite with background +- "in place" if transparent (3x compare/pixel +- compared to doing composite with gray bkgrnd) +- - Gray + alpha -> convert to RGB + alpha, composite with background and +- remove alpha bytes (3x float operations/pixel +- compared with composite on gray background) +- +- Greg's change will do this. The reason it wasn't done before is for +- performance, as this increases the per-pixel operations. If we would check +- in advance if the background was gray or RGB, and position the gray-to-RGB +- transform appropriately, then it would save a lot of work/time. +- */ +- +-#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +- /* if gray -> RGB, do so now only if background is non-gray; else do later +- * for performance reasons */ +- if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && +- !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) +- png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) +- if ((png_ptr->transformations & PNG_BACKGROUND) && +- ((png_ptr->num_trans != 0 ) || +- (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) +- png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1, +- &(png_ptr->trans_values), &(png_ptr->background) +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- , &(png_ptr->background_1), +- png_ptr->gamma_table, png_ptr->gamma_from_1, +- png_ptr->gamma_to_1, png_ptr->gamma_16_table, +- png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1, +- png_ptr->gamma_shift +-#endif +-); +-#endif +- +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- if ((png_ptr->transformations & PNG_GAMMA) && +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) +- !((png_ptr->transformations & PNG_BACKGROUND) && +- ((png_ptr->num_trans != 0) || +- (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) && +-#endif +- (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)) +- png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1, +- png_ptr->gamma_table, png_ptr->gamma_16_table, +- png_ptr->gamma_shift); +-#endif +- +-#if defined(PNG_READ_16_TO_8_SUPPORTED) +- if (png_ptr->transformations & PNG_16_TO_8) +- png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#if defined(PNG_READ_DITHER_SUPPORTED) +- if (png_ptr->transformations & PNG_DITHER) +- { +- png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1, +- png_ptr->palette_lookup, png_ptr->dither_index); +- if(png_ptr->row_info.rowbytes == (png_uint_32)0) +- png_error(png_ptr, "png_do_dither returned rowbytes=0"); +- } +-#endif +- +-#if defined(PNG_READ_INVERT_SUPPORTED) +- if (png_ptr->transformations & PNG_INVERT_MONO) +- png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#if defined(PNG_READ_SHIFT_SUPPORTED) +- if (png_ptr->transformations & PNG_SHIFT) +- png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1, +- &(png_ptr->shift)); +-#endif +- +-#if defined(PNG_READ_PACK_SUPPORTED) +- if (png_ptr->transformations & PNG_PACK) +- png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#if defined(PNG_READ_BGR_SUPPORTED) +- if (png_ptr->transformations & PNG_BGR) +- png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_PACKSWAP) +- png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +- /* if gray -> RGB, do so now only if we did not do so above */ +- if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && +- (png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) +- png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#if defined(PNG_READ_FILLER_SUPPORTED) +- if (png_ptr->transformations & PNG_FILLER) +- png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, +- (png_uint_32)png_ptr->filler, png_ptr->flags); +-#endif +- +-#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) +- if (png_ptr->transformations & PNG_INVERT_ALPHA) +- png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) +- if (png_ptr->transformations & PNG_SWAP_ALPHA) +- png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#if defined(PNG_READ_SWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_SWAP_BYTES) +- png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) +- if (png_ptr->transformations & PNG_USER_TRANSFORM) +- { +- if(png_ptr->read_user_transform_fn != NULL) +- (*(png_ptr->read_user_transform_fn)) /* user read transform function */ +- (png_ptr, /* png_ptr */ +- &(png_ptr->row_info), /* row_info: */ +- /* png_uint_32 width; width of row */ +- /* png_uint_32 rowbytes; number of bytes in row */ +- /* png_byte color_type; color type of pixels */ +- /* png_byte bit_depth; bit depth of samples */ +- /* png_byte channels; number of channels (1-4) */ +- /* png_byte pixel_depth; bits per pixel (depth*channels) */ +- png_ptr->row_buf + 1); /* start of pixel data for row */ +-#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) +- if(png_ptr->user_transform_depth) +- png_ptr->row_info.bit_depth = png_ptr->user_transform_depth; +- if(png_ptr->user_transform_channels) +- png_ptr->row_info.channels = png_ptr->user_transform_channels; +-#endif +- png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth * +- png_ptr->row_info.channels); +- png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, +- png_ptr->row_info.width); +- } +-#endif +- +-} +- +-#if defined(PNG_READ_PACK_SUPPORTED) +-/* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel, +- * without changing the actual values. Thus, if you had a row with +- * a bit depth of 1, you would end up with bytes that only contained +- * the numbers 0 or 1. If you would rather they contain 0 and 255, use +- * png_do_shift() after this. +- */ +-void /* PRIVATE */ +-png_do_unpack(png_row_infop row_info, png_bytep row) +-{ +- png_debug(1, "in png_do_unpack\n"); +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- if (row != NULL && row_info != NULL && row_info->bit_depth < 8) +-#else +- if (row_info->bit_depth < 8) +-#endif +- { +- png_uint_32 i; +- png_uint_32 row_width=row_info->width; +- +- switch (row_info->bit_depth) +- { +- case 1: +- { +- png_bytep sp = row + (png_size_t)((row_width - 1) >> 3); +- png_bytep dp = row + (png_size_t)row_width - 1; +- png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07); +- for (i = 0; i < row_width; i++) +- { +- *dp = (png_byte)((*sp >> shift) & 0x01); +- if (shift == 7) +- { +- shift = 0; +- sp--; +- } +- else +- shift++; +- +- dp--; +- } +- break; +- } +- case 2: +- { +- +- png_bytep sp = row + (png_size_t)((row_width - 1) >> 2); +- png_bytep dp = row + (png_size_t)row_width - 1; +- png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); +- for (i = 0; i < row_width; i++) +- { +- *dp = (png_byte)((*sp >> shift) & 0x03); +- if (shift == 6) +- { +- shift = 0; +- sp--; +- } +- else +- shift += 2; +- +- dp--; +- } +- break; +- } +- case 4: +- { +- png_bytep sp = row + (png_size_t)((row_width - 1) >> 1); +- png_bytep dp = row + (png_size_t)row_width - 1; +- png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); +- for (i = 0; i < row_width; i++) +- { +- *dp = (png_byte)((*sp >> shift) & 0x0f); +- if (shift == 4) +- { +- shift = 0; +- sp--; +- } +- else +- shift = 4; +- +- dp--; +- } +- break; +- } +- } +- row_info->bit_depth = 8; +- row_info->pixel_depth = (png_byte)(8 * row_info->channels); +- row_info->rowbytes = row_width * row_info->channels; +- } +-} +-#endif +- +-#if defined(PNG_READ_SHIFT_SUPPORTED) +-/* Reverse the effects of png_do_shift. This routine merely shifts the +- * pixels back to their significant bits values. Thus, if you have +- * a row of bit depth 8, but only 5 are significant, this will shift +- * the values back to 0 through 31. +- */ +-void /* PRIVATE */ +-png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits) +-{ +- png_debug(1, "in png_do_unshift\n"); +- if ( +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- row != NULL && row_info != NULL && sig_bits != NULL && +-#endif +- row_info->color_type != PNG_COLOR_TYPE_PALETTE) +- { +- int shift[4]; +- int channels = 0; +- int c; +- png_uint_16 value = 0; +- png_uint_32 row_width = row_info->width; +- +- if (row_info->color_type & PNG_COLOR_MASK_COLOR) +- { +- shift[channels++] = row_info->bit_depth - sig_bits->red; +- shift[channels++] = row_info->bit_depth - sig_bits->green; +- shift[channels++] = row_info->bit_depth - sig_bits->blue; +- } +- else +- { +- shift[channels++] = row_info->bit_depth - sig_bits->gray; +- } +- if (row_info->color_type & PNG_COLOR_MASK_ALPHA) +- { +- shift[channels++] = row_info->bit_depth - sig_bits->alpha; +- } +- +- for (c = 0; c < channels; c++) +- { +- if (shift[c] <= 0) +- shift[c] = 0; +- else +- value = 1; +- } +- +- if (!value) +- return; +- +- switch (row_info->bit_depth) +- { +- case 2: +- { +- png_bytep bp; +- png_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; +- +- for (bp = row, i = 0; i < istop; i++) +- { +- *bp >>= 1; +- *bp++ &= 0x55; +- } +- break; +- } +- case 4: +- { +- png_bytep bp = row; +- png_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; +- png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) | +- (png_byte)((int)0xf >> shift[0])); +- +- for (i = 0; i < istop; i++) +- { +- *bp >>= shift[0]; +- *bp++ &= mask; +- } +- break; +- } +- case 8: +- { +- png_bytep bp = row; +- png_uint_32 i; +- png_uint_32 istop = row_width * channels; +- +- for (i = 0; i < istop; i++) +- { +- *bp++ >>= shift[i%channels]; +- } +- break; +- } +- case 16: +- { +- png_bytep bp = row; +- png_uint_32 i; +- png_uint_32 istop = channels * row_width; +- +- for (i = 0; i < istop; i++) +- { +- value = (png_uint_16)((*bp << 8) + *(bp + 1)); +- value >>= shift[i%channels]; +- *bp++ = (png_byte)(value >> 8); +- *bp++ = (png_byte)(value & 0xff); +- } +- break; +- } +- } +- } +-} +-#endif +- +-#if defined(PNG_READ_16_TO_8_SUPPORTED) +-/* chop rows of bit depth 16 down to 8 */ +-void /* PRIVATE */ +-png_do_chop(png_row_infop row_info, png_bytep row) +-{ +- png_debug(1, "in png_do_chop\n"); +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- if (row != NULL && row_info != NULL && row_info->bit_depth == 16) +-#else +- if (row_info->bit_depth == 16) +-#endif +- { +- png_bytep sp = row; +- png_bytep dp = row; +- png_uint_32 i; +- png_uint_32 istop = row_info->width * row_info->channels; +- +- for (i = 0; i> 8)) >> 8; +- * +- * Approximate calculation with shift/add instead of multiply/divide: +- * *dp = ((((png_uint_32)(*sp) << 8) | +- * (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8; +- * +- * What we actually do to avoid extra shifting and conversion: +- */ +- +- *dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0); +-#else +- /* Simply discard the low order byte */ +- *dp = *sp; +-#endif +- } +- row_info->bit_depth = 8; +- row_info->pixel_depth = (png_byte)(8 * row_info->channels); +- row_info->rowbytes = row_info->width * row_info->channels; +- } +-} +-#endif +- +-#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) +-void /* PRIVATE */ +-png_do_read_swap_alpha(png_row_infop row_info, png_bytep row) +-{ +- png_debug(1, "in png_do_read_swap_alpha\n"); +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- if (row != NULL && row_info != NULL) +-#endif +- { +- png_uint_32 row_width = row_info->width; +- if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- { +- /* This converts from RGBA to ARGB */ +- if (row_info->bit_depth == 8) +- { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_byte save; +- png_uint_32 i; +- +- for (i = 0; i < row_width; i++) +- { +- save = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = save; +- } +- } +- /* This converts from RRGGBBAA to AARRGGBB */ +- else +- { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_byte save[2]; +- png_uint_32 i; +- +- for (i = 0; i < row_width; i++) +- { +- save[0] = *(--sp); +- save[1] = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = save[0]; +- *(--dp) = save[1]; +- } +- } +- } +- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) +- { +- /* This converts from GA to AG */ +- if (row_info->bit_depth == 8) +- { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_byte save; +- png_uint_32 i; +- +- for (i = 0; i < row_width; i++) +- { +- save = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = save; +- } +- } +- /* This converts from GGAA to AAGG */ +- else +- { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_byte save[2]; +- png_uint_32 i; +- +- for (i = 0; i < row_width; i++) +- { +- save[0] = *(--sp); +- save[1] = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = save[0]; +- *(--dp) = save[1]; +- } +- } +- } +- } +-} +-#endif +- +-#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) +-void /* PRIVATE */ +-png_do_read_invert_alpha(png_row_infop row_info, png_bytep row) +-{ +- png_debug(1, "in png_do_read_invert_alpha\n"); +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- if (row != NULL && row_info != NULL) +-#endif +- { +- png_uint_32 row_width = row_info->width; +- if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- { +- /* This inverts the alpha channel in RGBA */ +- if (row_info->bit_depth == 8) +- { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_uint_32 i; +- +- for (i = 0; i < row_width; i++) +- { +- *(--dp) = (png_byte)(255 - *(--sp)); +- +-/* This does nothing: +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- We can replace it with: +-*/ +- sp-=3; +- dp=sp; +- } +- } +- /* This inverts the alpha channel in RRGGBBAA */ +- else +- { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_uint_32 i; +- +- for (i = 0; i < row_width; i++) +- { +- *(--dp) = (png_byte)(255 - *(--sp)); +- *(--dp) = (png_byte)(255 - *(--sp)); +- +-/* This does nothing: +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- We can replace it with: +-*/ +- sp-=6; +- dp=sp; +- } +- } +- } +- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) +- { +- /* This inverts the alpha channel in GA */ +- if (row_info->bit_depth == 8) +- { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_uint_32 i; +- +- for (i = 0; i < row_width; i++) +- { +- *(--dp) = (png_byte)(255 - *(--sp)); +- *(--dp) = *(--sp); +- } +- } +- /* This inverts the alpha channel in GGAA */ +- else +- { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_uint_32 i; +- +- for (i = 0; i < row_width; i++) +- { +- *(--dp) = (png_byte)(255 - *(--sp)); +- *(--dp) = (png_byte)(255 - *(--sp)); +-/* +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +-*/ +- sp-=2; +- dp=sp; +- } +- } +- } +- } +-} +-#endif +- +-#if defined(PNG_READ_FILLER_SUPPORTED) +-/* Add filler channel if we have RGB color */ +-void /* PRIVATE */ +-png_do_read_filler(png_row_infop row_info, png_bytep row, +- png_uint_32 filler, png_uint_32 flags) +-{ +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- +- png_byte hi_filler = (png_byte)((filler>>8) & 0xff); +- png_byte lo_filler = (png_byte)(filler & 0xff); +- +- png_debug(1, "in png_do_read_filler\n"); +- if ( +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- row != NULL && row_info != NULL && +-#endif +- row_info->color_type == PNG_COLOR_TYPE_GRAY) +- { +- if(row_info->bit_depth == 8) +- { +- /* This changes the data from G to GX */ +- if (flags & PNG_FLAG_FILLER_AFTER) +- { +- png_bytep sp = row + (png_size_t)row_width; +- png_bytep dp = sp + (png_size_t)row_width; +- for (i = 1; i < row_width; i++) +- { +- *(--dp) = lo_filler; +- *(--dp) = *(--sp); +- } +- *(--dp) = lo_filler; +- row_info->channels = 2; +- row_info->pixel_depth = 16; +- row_info->rowbytes = row_width * 2; +- } +- /* This changes the data from G to XG */ +- else +- { +- png_bytep sp = row + (png_size_t)row_width; +- png_bytep dp = sp + (png_size_t)row_width; +- for (i = 0; i < row_width; i++) +- { +- *(--dp) = *(--sp); +- *(--dp) = lo_filler; +- } +- row_info->channels = 2; +- row_info->pixel_depth = 16; +- row_info->rowbytes = row_width * 2; +- } +- } +- else if(row_info->bit_depth == 16) +- { +- /* This changes the data from GG to GGXX */ +- if (flags & PNG_FLAG_FILLER_AFTER) +- { +- png_bytep sp = row + (png_size_t)row_width * 2; +- png_bytep dp = sp + (png_size_t)row_width * 2; +- for (i = 1; i < row_width; i++) +- { +- *(--dp) = hi_filler; +- *(--dp) = lo_filler; +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- } +- *(--dp) = hi_filler; +- *(--dp) = lo_filler; +- row_info->channels = 2; +- row_info->pixel_depth = 32; +- row_info->rowbytes = row_width * 4; +- } +- /* This changes the data from GG to XXGG */ +- else +- { +- png_bytep sp = row + (png_size_t)row_width * 2; +- png_bytep dp = sp + (png_size_t)row_width * 2; +- for (i = 0; i < row_width; i++) +- { +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = hi_filler; +- *(--dp) = lo_filler; +- } +- row_info->channels = 2; +- row_info->pixel_depth = 32; +- row_info->rowbytes = row_width * 4; +- } +- } +- } /* COLOR_TYPE == GRAY */ +- else if (row_info->color_type == PNG_COLOR_TYPE_RGB) +- { +- if(row_info->bit_depth == 8) +- { +- /* This changes the data from RGB to RGBX */ +- if (flags & PNG_FLAG_FILLER_AFTER) +- { +- png_bytep sp = row + (png_size_t)row_width * 3; +- png_bytep dp = sp + (png_size_t)row_width; +- for (i = 1; i < row_width; i++) +- { +- *(--dp) = lo_filler; +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- } +- *(--dp) = lo_filler; +- row_info->channels = 4; +- row_info->pixel_depth = 32; +- row_info->rowbytes = row_width * 4; +- } +- /* This changes the data from RGB to XRGB */ +- else +- { +- png_bytep sp = row + (png_size_t)row_width * 3; +- png_bytep dp = sp + (png_size_t)row_width; +- for (i = 0; i < row_width; i++) +- { +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = lo_filler; +- } +- row_info->channels = 4; +- row_info->pixel_depth = 32; +- row_info->rowbytes = row_width * 4; +- } +- } +- else if(row_info->bit_depth == 16) +- { +- /* This changes the data from RRGGBB to RRGGBBXX */ +- if (flags & PNG_FLAG_FILLER_AFTER) +- { +- png_bytep sp = row + (png_size_t)row_width * 6; +- png_bytep dp = sp + (png_size_t)row_width * 2; +- for (i = 1; i < row_width; i++) +- { +- *(--dp) = hi_filler; +- *(--dp) = lo_filler; +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- } +- *(--dp) = hi_filler; +- *(--dp) = lo_filler; +- row_info->channels = 4; +- row_info->pixel_depth = 64; +- row_info->rowbytes = row_width * 8; +- } +- /* This changes the data from RRGGBB to XXRRGGBB */ +- else +- { +- png_bytep sp = row + (png_size_t)row_width * 6; +- png_bytep dp = sp + (png_size_t)row_width * 2; +- for (i = 0; i < row_width; i++) +- { +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = hi_filler; +- *(--dp) = lo_filler; +- } +- row_info->channels = 4; +- row_info->pixel_depth = 64; +- row_info->rowbytes = row_width * 8; +- } +- } +- } /* COLOR_TYPE == RGB */ +-} +-#endif +- +-#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +-/* expand grayscale files to RGB, with or without alpha */ +-void /* PRIVATE */ +-png_do_gray_to_rgb(png_row_infop row_info, png_bytep row) +-{ +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- +- png_debug(1, "in png_do_gray_to_rgb\n"); +- if (row_info->bit_depth >= 8 && +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- row != NULL && row_info != NULL && +-#endif +- !(row_info->color_type & PNG_COLOR_MASK_COLOR)) +- { +- if (row_info->color_type == PNG_COLOR_TYPE_GRAY) +- { +- if (row_info->bit_depth == 8) +- { +- png_bytep sp = row + (png_size_t)row_width - 1; +- png_bytep dp = sp + (png_size_t)row_width * 2; +- for (i = 0; i < row_width; i++) +- { +- *(dp--) = *sp; +- *(dp--) = *sp; +- *(dp--) = *(sp--); +- } +- } +- else +- { +- png_bytep sp = row + (png_size_t)row_width * 2 - 1; +- png_bytep dp = sp + (png_size_t)row_width * 4; +- for (i = 0; i < row_width; i++) +- { +- *(dp--) = *sp; +- *(dp--) = *(sp - 1); +- *(dp--) = *sp; +- *(dp--) = *(sp - 1); +- *(dp--) = *(sp--); +- *(dp--) = *(sp--); +- } +- } +- } +- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) +- { +- if (row_info->bit_depth == 8) +- { +- png_bytep sp = row + (png_size_t)row_width * 2 - 1; +- png_bytep dp = sp + (png_size_t)row_width * 2; +- for (i = 0; i < row_width; i++) +- { +- *(dp--) = *(sp--); +- *(dp--) = *sp; +- *(dp--) = *sp; +- *(dp--) = *(sp--); +- } +- } +- else +- { +- png_bytep sp = row + (png_size_t)row_width * 4 - 1; +- png_bytep dp = sp + (png_size_t)row_width * 4; +- for (i = 0; i < row_width; i++) +- { +- *(dp--) = *(sp--); +- *(dp--) = *(sp--); +- *(dp--) = *sp; +- *(dp--) = *(sp - 1); +- *(dp--) = *sp; +- *(dp--) = *(sp - 1); +- *(dp--) = *(sp--); +- *(dp--) = *(sp--); +- } +- } +- } +- row_info->channels += (png_byte)2; +- row_info->color_type |= PNG_COLOR_MASK_COLOR; +- row_info->pixel_depth = (png_byte)(row_info->channels * +- row_info->bit_depth); +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width); +- } +-} +-#endif +- +-#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +-/* reduce RGB files to grayscale, with or without alpha +- * using the equation given in Poynton's ColorFAQ at +- * +- * Copyright (c) 1998-01-04 Charles Poynton poynton@inforamp.net +- * +- * Y = 0.212671 * R + 0.715160 * G + 0.072169 * B +- * +- * We approximate this with +- * +- * Y = 0.21268 * R + 0.7151 * G + 0.07217 * B +- * +- * which can be expressed with integers as +- * +- * Y = (6969 * R + 23434 * G + 2365 * B)/32768 +- * +- * The calculation is to be done in a linear colorspace. +- * +- * Other integer coefficents can be used via png_set_rgb_to_gray(). +- */ +-int /* PRIVATE */ +-png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row) +- +-{ +- png_uint_32 i; +- +- png_uint_32 row_width = row_info->width; +- int rgb_error = 0; +- +- png_debug(1, "in png_do_rgb_to_gray\n"); +- if ( +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- row != NULL && row_info != NULL && +-#endif +- (row_info->color_type & PNG_COLOR_MASK_COLOR)) +- { +- png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff; +- png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff; +- png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff; +- +- if (row_info->color_type == PNG_COLOR_TYPE_RGB) +- { +- if (row_info->bit_depth == 8) +- { +-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +- if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL) +- { +- png_bytep sp = row; +- png_bytep dp = row; +- +- for (i = 0; i < row_width; i++) +- { +- png_byte red = png_ptr->gamma_to_1[*(sp++)]; +- png_byte green = png_ptr->gamma_to_1[*(sp++)]; +- png_byte blue = png_ptr->gamma_to_1[*(sp++)]; +- if(red != green || red != blue) +- { +- rgb_error |= 1; +- *(dp++) = png_ptr->gamma_from_1[ +- (rc*red+gc*green+bc*blue)>>15]; +- } +- else +- *(dp++) = *(sp-1); +- } +- } +- else +-#endif +- { +- png_bytep sp = row; +- png_bytep dp = row; +- for (i = 0; i < row_width; i++) +- { +- png_byte red = *(sp++); +- png_byte green = *(sp++); +- png_byte blue = *(sp++); +- if(red != green || red != blue) +- { +- rgb_error |= 1; +- *(dp++) = (png_byte)((rc*red+gc*green+bc*blue)>>15); +- } +- else +- *(dp++) = *(sp-1); +- } +- } +- } +- +- else /* RGB bit_depth == 16 */ +- { +-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +- if (png_ptr->gamma_16_to_1 != NULL && +- png_ptr->gamma_16_from_1 != NULL) +- { +- png_bytep sp = row; +- png_bytep dp = row; +- for (i = 0; i < row_width; i++) +- { +- png_uint_16 red, green, blue, w; +- +- red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; +- green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; +- blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; +- +- if(red == green && red == blue) +- w = red; +- else +- { +- png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >> +- png_ptr->gamma_shift][red>>8]; +- png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >> +- png_ptr->gamma_shift][green>>8]; +- png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >> +- png_ptr->gamma_shift][blue>>8]; +- png_uint_16 gray16 = (png_uint_16)((rc*red_1 + gc*green_1 +- + bc*blue_1)>>15); +- w = png_ptr->gamma_16_from_1[(gray16&0xff) >> +- png_ptr->gamma_shift][gray16 >> 8]; +- rgb_error |= 1; +- } +- +- *(dp++) = (png_byte)((w>>8) & 0xff); +- *(dp++) = (png_byte)(w & 0xff); +- } +- } +- else +-#endif +- { +- png_bytep sp = row; +- png_bytep dp = row; +- for (i = 0; i < row_width; i++) +- { +- png_uint_16 red, green, blue, gray16; +- +- red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; +- green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; +- blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; +- +- if(red != green || red != blue) +- rgb_error |= 1; +- gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15); +- *(dp++) = (png_byte)((gray16>>8) & 0xff); +- *(dp++) = (png_byte)(gray16 & 0xff); +- } +- } +- } +- } +- if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- { +- if (row_info->bit_depth == 8) +- { +-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +- if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL) +- { +- png_bytep sp = row; +- png_bytep dp = row; +- for (i = 0; i < row_width; i++) +- { +- png_byte red = png_ptr->gamma_to_1[*(sp++)]; +- png_byte green = png_ptr->gamma_to_1[*(sp++)]; +- png_byte blue = png_ptr->gamma_to_1[*(sp++)]; +- if(red != green || red != blue) +- rgb_error |= 1; +- *(dp++) = png_ptr->gamma_from_1 +- [(rc*red + gc*green + bc*blue)>>15]; +- *(dp++) = *(sp++); /* alpha */ +- } +- } +- else +-#endif +- { +- png_bytep sp = row; +- png_bytep dp = row; +- for (i = 0; i < row_width; i++) +- { +- png_byte red = *(sp++); +- png_byte green = *(sp++); +- png_byte blue = *(sp++); +- if(red != green || red != blue) +- rgb_error |= 1; +- *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15); +- *(dp++) = *(sp++); /* alpha */ +- } +- } +- } +- else /* RGBA bit_depth == 16 */ +- { +-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +- if (png_ptr->gamma_16_to_1 != NULL && +- png_ptr->gamma_16_from_1 != NULL) +- { +- png_bytep sp = row; +- png_bytep dp = row; +- for (i = 0; i < row_width; i++) +- { +- png_uint_16 red, green, blue, w; +- +- red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; +- green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; +- blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; +- +- if(red == green && red == blue) +- w = red; +- else +- { +- png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >> +- png_ptr->gamma_shift][red>>8]; +- png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >> +- png_ptr->gamma_shift][green>>8]; +- png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >> +- png_ptr->gamma_shift][blue>>8]; +- png_uint_16 gray16 = (png_uint_16)((rc * red_1 +- + gc * green_1 + bc * blue_1)>>15); +- w = png_ptr->gamma_16_from_1[(gray16&0xff) >> +- png_ptr->gamma_shift][gray16 >> 8]; +- rgb_error |= 1; +- } +- +- *(dp++) = (png_byte)((w>>8) & 0xff); +- *(dp++) = (png_byte)(w & 0xff); +- *(dp++) = *(sp++); /* alpha */ +- *(dp++) = *(sp++); +- } +- } +- else +-#endif +- { +- png_bytep sp = row; +- png_bytep dp = row; +- for (i = 0; i < row_width; i++) +- { +- png_uint_16 red, green, blue, gray16; +- red = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2; +- green = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2; +- blue = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2; +- if(red != green || red != blue) +- rgb_error |= 1; +- gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15); +- *(dp++) = (png_byte)((gray16>>8) & 0xff); +- *(dp++) = (png_byte)(gray16 & 0xff); +- *(dp++) = *(sp++); /* alpha */ +- *(dp++) = *(sp++); +- } +- } +- } +- } +- row_info->channels -= (png_byte)2; +- row_info->color_type &= ~PNG_COLOR_MASK_COLOR; +- row_info->pixel_depth = (png_byte)(row_info->channels * +- row_info->bit_depth); +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width); +- } +- return rgb_error; +-} +-#endif +- +-/* Build a grayscale palette. Palette is assumed to be 1 << bit_depth +- * large of png_color. This lets grayscale images be treated as +- * paletted. Most useful for gamma correction and simplification +- * of code. +- */ +-void PNGAPI +-png_build_grayscale_palette(int bit_depth, png_colorp palette) +-{ +- int num_palette; +- int color_inc; +- int i; +- int v; +- +- png_debug(1, "in png_do_build_grayscale_palette\n"); +- if (palette == NULL) +- return; +- +- switch (bit_depth) +- { +- case 1: +- num_palette = 2; +- color_inc = 0xff; +- break; +- case 2: +- num_palette = 4; +- color_inc = 0x55; +- break; +- case 4: +- num_palette = 16; +- color_inc = 0x11; +- break; +- case 8: +- num_palette = 256; +- color_inc = 1; +- break; +- default: +- num_palette = 0; +- color_inc = 0; +- break; +- } +- +- for (i = 0, v = 0; i < num_palette; i++, v += color_inc) +- { +- palette[i].red = (png_byte)v; +- palette[i].green = (png_byte)v; +- palette[i].blue = (png_byte)v; +- } +-} +- +-/* This function is currently unused. Do we really need it? */ +-#if defined(PNG_READ_DITHER_SUPPORTED) && defined(PNG_CORRECT_PALETTE_SUPPORTED) +-void /* PRIVATE */ +-png_correct_palette(png_structp png_ptr, png_colorp palette, +- int num_palette) +-{ +- png_debug(1, "in png_correct_palette\n"); +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ +- defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) +- if (png_ptr->transformations & (PNG_GAMMA | PNG_BACKGROUND)) +- { +- png_color back, back_1; +- +- if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE) +- { +- back.red = png_ptr->gamma_table[png_ptr->background.red]; +- back.green = png_ptr->gamma_table[png_ptr->background.green]; +- back.blue = png_ptr->gamma_table[png_ptr->background.blue]; +- +- back_1.red = png_ptr->gamma_to_1[png_ptr->background.red]; +- back_1.green = png_ptr->gamma_to_1[png_ptr->background.green]; +- back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue]; +- } +- else +- { +- double g; +- +- g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma); +- +- if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_SCREEN || +- fabs(g - 1.0) < PNG_GAMMA_THRESHOLD) +- { +- back.red = png_ptr->background.red; +- back.green = png_ptr->background.green; +- back.blue = png_ptr->background.blue; +- } +- else +- { +- back.red = +- (png_byte)(pow((double)png_ptr->background.red/255, g) * +- 255.0 + 0.5); +- back.green = +- (png_byte)(pow((double)png_ptr->background.green/255, g) * +- 255.0 + 0.5); +- back.blue = +- (png_byte)(pow((double)png_ptr->background.blue/255, g) * +- 255.0 + 0.5); +- } +- +- g = 1.0 / png_ptr->background_gamma; +- +- back_1.red = +- (png_byte)(pow((double)png_ptr->background.red/255, g) * +- 255.0 + 0.5); +- back_1.green = +- (png_byte)(pow((double)png_ptr->background.green/255, g) * +- 255.0 + 0.5); +- back_1.blue = +- (png_byte)(pow((double)png_ptr->background.blue/255, g) * +- 255.0 + 0.5); +- } +- +- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- { +- png_uint_32 i; +- +- for (i = 0; i < (png_uint_32)num_palette; i++) +- { +- if (i < png_ptr->num_trans && png_ptr->trans[i] == 0) +- { +- palette[i] = back; +- } +- else if (i < png_ptr->num_trans && png_ptr->trans[i] != 0xff) +- { +- png_byte v, w; +- +- v = png_ptr->gamma_to_1[png_ptr->palette[i].red]; +- png_composite(w, v, png_ptr->trans[i], back_1.red); +- palette[i].red = png_ptr->gamma_from_1[w]; +- +- v = png_ptr->gamma_to_1[png_ptr->palette[i].green]; +- png_composite(w, v, png_ptr->trans[i], back_1.green); +- palette[i].green = png_ptr->gamma_from_1[w]; +- +- v = png_ptr->gamma_to_1[png_ptr->palette[i].blue]; +- png_composite(w, v, png_ptr->trans[i], back_1.blue); +- palette[i].blue = png_ptr->gamma_from_1[w]; +- } +- else +- { +- palette[i].red = png_ptr->gamma_table[palette[i].red]; +- palette[i].green = png_ptr->gamma_table[palette[i].green]; +- palette[i].blue = png_ptr->gamma_table[palette[i].blue]; +- } +- } +- } +- else +- { +- int i; +- +- for (i = 0; i < num_palette; i++) +- { +- if (palette[i].red == (png_byte)png_ptr->trans_values.gray) +- { +- palette[i] = back; +- } +- else +- { +- palette[i].red = png_ptr->gamma_table[palette[i].red]; +- palette[i].green = png_ptr->gamma_table[palette[i].green]; +- palette[i].blue = png_ptr->gamma_table[palette[i].blue]; +- } +- } +- } +- } +- else +-#endif +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- if (png_ptr->transformations & PNG_GAMMA) +- { +- int i; +- +- for (i = 0; i < num_palette; i++) +- { +- palette[i].red = png_ptr->gamma_table[palette[i].red]; +- palette[i].green = png_ptr->gamma_table[palette[i].green]; +- palette[i].blue = png_ptr->gamma_table[palette[i].blue]; +- } +- } +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) +- else +-#endif +-#endif +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) +- if (png_ptr->transformations & PNG_BACKGROUND) +- { +- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- { +- png_color back; +- +- back.red = (png_byte)png_ptr->background.red; +- back.green = (png_byte)png_ptr->background.green; +- back.blue = (png_byte)png_ptr->background.blue; +- +- for (i = 0; i < (int)png_ptr->num_trans; i++) +- { +- if (png_ptr->trans[i] == 0) +- { +- palette[i].red = back.red; +- palette[i].green = back.green; +- palette[i].blue = back.blue; +- } +- else if (png_ptr->trans[i] != 0xff) +- { +- png_composite(palette[i].red, png_ptr->palette[i].red, +- png_ptr->trans[i], back.red); +- png_composite(palette[i].green, png_ptr->palette[i].green, +- png_ptr->trans[i], back.green); +- png_composite(palette[i].blue, png_ptr->palette[i].blue, +- png_ptr->trans[i], back.blue); +- } +- } +- } +- else /* assume grayscale palette (what else could it be?) */ +- { +- int i; +- +- for (i = 0; i < num_palette; i++) +- { +- if (i == (png_byte)png_ptr->trans_values.gray) +- { +- palette[i].red = (png_byte)png_ptr->background.red; +- palette[i].green = (png_byte)png_ptr->background.green; +- palette[i].blue = (png_byte)png_ptr->background.blue; +- } +- } +- } +- } +-#endif +-} +-#endif +- +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) +-/* Replace any alpha or transparency with the supplied background color. +- * "background" is already in the screen gamma, while "background_1" is +- * at a gamma of 1.0. Paletted files have already been taken care of. +- */ +-void /* PRIVATE */ +-png_do_background(png_row_infop row_info, png_bytep row, +- png_color_16p trans_values, png_color_16p background +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- , png_color_16p background_1, +- png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, +- png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, +- png_uint_16pp gamma_16_to_1, int gamma_shift +-#endif +- ) +-{ +- png_bytep sp, dp; +- png_uint_32 i; +- png_uint_32 row_width=row_info->width; +- int shift; +- +- png_debug(1, "in png_do_background\n"); +- if (background != NULL && +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- row != NULL && row_info != NULL && +-#endif +- (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) || +- (row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_values))) +- { +- switch (row_info->color_type) +- { +- case PNG_COLOR_TYPE_GRAY: +- { +- switch (row_info->bit_depth) +- { +- case 1: +- { +- sp = row; +- shift = 7; +- for (i = 0; i < row_width; i++) +- { +- if ((png_uint_16)((*sp >> shift) & 0x01) +- == trans_values->gray) +- { +- *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); +- *sp |= (png_byte)(background->gray << shift); +- } +- if (!shift) +- { +- shift = 7; +- sp++; +- } +- else +- shift--; +- } +- break; +- } +- case 2: +- { +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- if (gamma_table != NULL) +- { +- sp = row; +- shift = 6; +- for (i = 0; i < row_width; i++) +- { +- if ((png_uint_16)((*sp >> shift) & 0x03) +- == trans_values->gray) +- { +- *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); +- *sp |= (png_byte)(background->gray << shift); +- } +- else +- { +- png_byte p = (png_byte)((*sp >> shift) & 0x03); +- png_byte g = (png_byte)((gamma_table [p | (p << 2) | +- (p << 4) | (p << 6)] >> 6) & 0x03); +- *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); +- *sp |= (png_byte)(g << shift); +- } +- if (!shift) +- { +- shift = 6; +- sp++; +- } +- else +- shift -= 2; +- } +- } +- else +-#endif +- { +- sp = row; +- shift = 6; +- for (i = 0; i < row_width; i++) +- { +- if ((png_uint_16)((*sp >> shift) & 0x03) +- == trans_values->gray) +- { +- *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); +- *sp |= (png_byte)(background->gray << shift); +- } +- if (!shift) +- { +- shift = 6; +- sp++; +- } +- else +- shift -= 2; +- } +- } +- break; +- } +- case 4: +- { +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- if (gamma_table != NULL) +- { +- sp = row; +- shift = 4; +- for (i = 0; i < row_width; i++) +- { +- if ((png_uint_16)((*sp >> shift) & 0x0f) +- == trans_values->gray) +- { +- *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); +- *sp |= (png_byte)(background->gray << shift); +- } +- else +- { +- png_byte p = (png_byte)((*sp >> shift) & 0x0f); +- png_byte g = (png_byte)((gamma_table[p | +- (p << 4)] >> 4) & 0x0f); +- *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); +- *sp |= (png_byte)(g << shift); +- } +- if (!shift) +- { +- shift = 4; +- sp++; +- } +- else +- shift -= 4; +- } +- } +- else +-#endif +- { +- sp = row; +- shift = 4; +- for (i = 0; i < row_width; i++) +- { +- if ((png_uint_16)((*sp >> shift) & 0x0f) +- == trans_values->gray) +- { +- *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); +- *sp |= (png_byte)(background->gray << shift); +- } +- if (!shift) +- { +- shift = 4; +- sp++; +- } +- else +- shift -= 4; +- } +- } +- break; +- } +- case 8: +- { +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- if (gamma_table != NULL) +- { +- sp = row; +- for (i = 0; i < row_width; i++, sp++) +- { +- if (*sp == trans_values->gray) +- { +- *sp = (png_byte)background->gray; +- } +- else +- { +- *sp = gamma_table[*sp]; +- } +- } +- } +- else +-#endif +- { +- sp = row; +- for (i = 0; i < row_width; i++, sp++) +- { +- if (*sp == trans_values->gray) +- { +- *sp = (png_byte)background->gray; +- } +- } +- } +- break; +- } +- case 16: +- { +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- if (gamma_16 != NULL) +- { +- sp = row; +- for (i = 0; i < row_width; i++, sp += 2) +- { +- png_uint_16 v; +- +- v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); +- if (v == trans_values->gray) +- { +- /* background is already in screen gamma */ +- *sp = (png_byte)((background->gray >> 8) & 0xff); +- *(sp + 1) = (png_byte)(background->gray & 0xff); +- } +- else +- { +- v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; +- *sp = (png_byte)((v >> 8) & 0xff); +- *(sp + 1) = (png_byte)(v & 0xff); +- } +- } +- } +- else +-#endif +- { +- sp = row; +- for (i = 0; i < row_width; i++, sp += 2) +- { +- png_uint_16 v; +- +- v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); +- if (v == trans_values->gray) +- { +- *sp = (png_byte)((background->gray >> 8) & 0xff); +- *(sp + 1) = (png_byte)(background->gray & 0xff); +- } +- } +- } +- break; +- } +- } +- break; +- } +- case PNG_COLOR_TYPE_RGB: +- { +- if (row_info->bit_depth == 8) +- { +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- if (gamma_table != NULL) +- { +- sp = row; +- for (i = 0; i < row_width; i++, sp += 3) +- { +- if (*sp == trans_values->red && +- *(sp + 1) == trans_values->green && +- *(sp + 2) == trans_values->blue) +- { +- *sp = (png_byte)background->red; +- *(sp + 1) = (png_byte)background->green; +- *(sp + 2) = (png_byte)background->blue; +- } +- else +- { +- *sp = gamma_table[*sp]; +- *(sp + 1) = gamma_table[*(sp + 1)]; +- *(sp + 2) = gamma_table[*(sp + 2)]; +- } +- } +- } +- else +-#endif +- { +- sp = row; +- for (i = 0; i < row_width; i++, sp += 3) +- { +- if (*sp == trans_values->red && +- *(sp + 1) == trans_values->green && +- *(sp + 2) == trans_values->blue) +- { +- *sp = (png_byte)background->red; +- *(sp + 1) = (png_byte)background->green; +- *(sp + 2) = (png_byte)background->blue; +- } +- } +- } +- } +- else /* if (row_info->bit_depth == 16) */ +- { +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- if (gamma_16 != NULL) +- { +- sp = row; +- for (i = 0; i < row_width; i++, sp += 6) +- { +- png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); +- png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); +- png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5)); +- if (r == trans_values->red && g == trans_values->green && +- b == trans_values->blue) +- { +- /* background is already in screen gamma */ +- *sp = (png_byte)((background->red >> 8) & 0xff); +- *(sp + 1) = (png_byte)(background->red & 0xff); +- *(sp + 2) = (png_byte)((background->green >> 8) & 0xff); +- *(sp + 3) = (png_byte)(background->green & 0xff); +- *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff); +- *(sp + 5) = (png_byte)(background->blue & 0xff); +- } +- else +- { +- png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; +- *sp = (png_byte)((v >> 8) & 0xff); +- *(sp + 1) = (png_byte)(v & 0xff); +- v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; +- *(sp + 2) = (png_byte)((v >> 8) & 0xff); +- *(sp + 3) = (png_byte)(v & 0xff); +- v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; +- *(sp + 4) = (png_byte)((v >> 8) & 0xff); +- *(sp + 5) = (png_byte)(v & 0xff); +- } +- } +- } +- else +-#endif +- { +- sp = row; +- for (i = 0; i < row_width; i++, sp += 6) +- { +- png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp+1)); +- png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); +- png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5)); +- +- if (r == trans_values->red && g == trans_values->green && +- b == trans_values->blue) +- { +- *sp = (png_byte)((background->red >> 8) & 0xff); +- *(sp + 1) = (png_byte)(background->red & 0xff); +- *(sp + 2) = (png_byte)((background->green >> 8) & 0xff); +- *(sp + 3) = (png_byte)(background->green & 0xff); +- *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff); +- *(sp + 5) = (png_byte)(background->blue & 0xff); +- } +- } +- } +- } +- break; +- } +- case PNG_COLOR_TYPE_GRAY_ALPHA: +- { +- if (row_info->bit_depth == 8) +- { +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- if (gamma_to_1 != NULL && gamma_from_1 != NULL && +- gamma_table != NULL) +- { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 2, dp++) +- { +- png_uint_16 a = *(sp + 1); +- +- if (a == 0xff) +- { +- *dp = gamma_table[*sp]; +- } +- else if (a == 0) +- { +- /* background is already in screen gamma */ +- *dp = (png_byte)background->gray; +- } +- else +- { +- png_byte v, w; +- +- v = gamma_to_1[*sp]; +- png_composite(w, v, a, background_1->gray); +- *dp = gamma_from_1[w]; +- } +- } +- } +- else +-#endif +- { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 2, dp++) +- { +- png_byte a = *(sp + 1); +- +- if (a == 0xff) +- { +- *dp = *sp; +- } +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- else if (a == 0) +- { +- *dp = (png_byte)background->gray; +- } +- else +- { +- png_composite(*dp, *sp, a, background_1->gray); +- } +-#else +- *dp = (png_byte)background->gray; +-#endif +- } +- } +- } +- else /* if (png_ptr->bit_depth == 16) */ +- { +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- if (gamma_16 != NULL && gamma_16_from_1 != NULL && +- gamma_16_to_1 != NULL) +- { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 4, dp += 2) +- { +- png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); +- +- if (a == (png_uint_16)0xffff) +- { +- png_uint_16 v; +- +- v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; +- *dp = (png_byte)((v >> 8) & 0xff); +- *(dp + 1) = (png_byte)(v & 0xff); +- } +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- else if (a == 0) +-#else +- else +-#endif +- { +- /* background is already in screen gamma */ +- *dp = (png_byte)((background->gray >> 8) & 0xff); +- *(dp + 1) = (png_byte)(background->gray & 0xff); +- } +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- else +- { +- png_uint_16 g, v, w; +- +- g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; +- png_composite_16(v, g, a, background_1->gray); +- w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8]; +- *dp = (png_byte)((w >> 8) & 0xff); +- *(dp + 1) = (png_byte)(w & 0xff); +- } +-#endif +- } +- } +- else +-#endif +- { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 4, dp += 2) +- { +- png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); +- if (a == (png_uint_16)0xffff) +- { +- png_memcpy(dp, sp, 2); +- } +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- else if (a == 0) +-#else +- else +-#endif +- { +- *dp = (png_byte)((background->gray >> 8) & 0xff); +- *(dp + 1) = (png_byte)(background->gray & 0xff); +- } +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- else +- { +- png_uint_16 g, v; +- +- g = (png_uint_16)(((*sp) << 8) + *(sp + 1)); +- png_composite_16(v, g, a, background_1->gray); +- *dp = (png_byte)((v >> 8) & 0xff); +- *(dp + 1) = (png_byte)(v & 0xff); +- } +-#endif +- } +- } +- } +- break; +- } +- case PNG_COLOR_TYPE_RGB_ALPHA: +- { +- if (row_info->bit_depth == 8) +- { +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- if (gamma_to_1 != NULL && gamma_from_1 != NULL && +- gamma_table != NULL) +- { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 4, dp += 3) +- { +- png_byte a = *(sp + 3); +- +- if (a == 0xff) +- { +- *dp = gamma_table[*sp]; +- *(dp + 1) = gamma_table[*(sp + 1)]; +- *(dp + 2) = gamma_table[*(sp + 2)]; +- } +- else if (a == 0) +- { +- /* background is already in screen gamma */ +- *dp = (png_byte)background->red; +- *(dp + 1) = (png_byte)background->green; +- *(dp + 2) = (png_byte)background->blue; +- } +- else +- { +- png_byte v, w; +- +- v = gamma_to_1[*sp]; +- png_composite(w, v, a, background_1->red); +- *dp = gamma_from_1[w]; +- v = gamma_to_1[*(sp + 1)]; +- png_composite(w, v, a, background_1->green); +- *(dp + 1) = gamma_from_1[w]; +- v = gamma_to_1[*(sp + 2)]; +- png_composite(w, v, a, background_1->blue); +- *(dp + 2) = gamma_from_1[w]; +- } +- } +- } +- else +-#endif +- { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 4, dp += 3) +- { +- png_byte a = *(sp + 3); +- +- if (a == 0xff) +- { +- *dp = *sp; +- *(dp + 1) = *(sp + 1); +- *(dp + 2) = *(sp + 2); +- } +- else if (a == 0) +- { +- *dp = (png_byte)background->red; +- *(dp + 1) = (png_byte)background->green; +- *(dp + 2) = (png_byte)background->blue; +- } +- else +- { +- png_composite(*dp, *sp, a, background->red); +- png_composite(*(dp + 1), *(sp + 1), a, +- background->green); +- png_composite(*(dp + 2), *(sp + 2), a, +- background->blue); +- } +- } +- } +- } +- else /* if (row_info->bit_depth == 16) */ +- { +-#if defined(PNG_READ_GAMMA_SUPPORTED) +- if (gamma_16 != NULL && gamma_16_from_1 != NULL && +- gamma_16_to_1 != NULL) +- { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 8, dp += 6) +- { +- png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) +- << 8) + (png_uint_16)(*(sp + 7))); +- if (a == (png_uint_16)0xffff) +- { +- png_uint_16 v; +- +- v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; +- *dp = (png_byte)((v >> 8) & 0xff); +- *(dp + 1) = (png_byte)(v & 0xff); +- v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; +- *(dp + 2) = (png_byte)((v >> 8) & 0xff); +- *(dp + 3) = (png_byte)(v & 0xff); +- v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; +- *(dp + 4) = (png_byte)((v >> 8) & 0xff); +- *(dp + 5) = (png_byte)(v & 0xff); +- } +- else if (a == 0) +- { +- /* background is already in screen gamma */ +- *dp = (png_byte)((background->red >> 8) & 0xff); +- *(dp + 1) = (png_byte)(background->red & 0xff); +- *(dp + 2) = (png_byte)((background->green >> 8) & 0xff); +- *(dp + 3) = (png_byte)(background->green & 0xff); +- *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff); +- *(dp + 5) = (png_byte)(background->blue & 0xff); +- } +- else +- { +- png_uint_16 v, w, x; +- +- v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; +- png_composite_16(w, v, a, background_1->red); +- x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8]; +- *dp = (png_byte)((x >> 8) & 0xff); +- *(dp + 1) = (png_byte)(x & 0xff); +- v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)]; +- png_composite_16(w, v, a, background_1->green); +- x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8]; +- *(dp + 2) = (png_byte)((x >> 8) & 0xff); +- *(dp + 3) = (png_byte)(x & 0xff); +- v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)]; +- png_composite_16(w, v, a, background_1->blue); +- x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8]; +- *(dp + 4) = (png_byte)((x >> 8) & 0xff); +- *(dp + 5) = (png_byte)(x & 0xff); +- } +- } +- } +- else +-#endif +- { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 8, dp += 6) +- { +- png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) +- << 8) + (png_uint_16)(*(sp + 7))); +- if (a == (png_uint_16)0xffff) +- { +- png_memcpy(dp, sp, 6); +- } +- else if (a == 0) +- { +- *dp = (png_byte)((background->red >> 8) & 0xff); +- *(dp + 1) = (png_byte)(background->red & 0xff); +- *(dp + 2) = (png_byte)((background->green >> 8) & 0xff); +- *(dp + 3) = (png_byte)(background->green & 0xff); +- *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff); +- *(dp + 5) = (png_byte)(background->blue & 0xff); +- } +- else +- { +- png_uint_16 v; +- +- png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); +- png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) +- + *(sp + 3)); +- png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) +- + *(sp + 5)); +- +- png_composite_16(v, r, a, background->red); +- *dp = (png_byte)((v >> 8) & 0xff); +- *(dp + 1) = (png_byte)(v & 0xff); +- png_composite_16(v, g, a, background->green); +- *(dp + 2) = (png_byte)((v >> 8) & 0xff); +- *(dp + 3) = (png_byte)(v & 0xff); +- png_composite_16(v, b, a, background->blue); +- *(dp + 4) = (png_byte)((v >> 8) & 0xff); +- *(dp + 5) = (png_byte)(v & 0xff); +- } +- } +- } +- } +- break; +- } +- } +- +- if (row_info->color_type & PNG_COLOR_MASK_ALPHA) +- { +- row_info->color_type &= ~PNG_COLOR_MASK_ALPHA; +- row_info->channels--; +- row_info->pixel_depth = (png_byte)(row_info->channels * +- row_info->bit_depth); +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width); +- } +- } +-} +-#endif +- +-#if defined(PNG_READ_GAMMA_SUPPORTED) +-/* Gamma correct the image, avoiding the alpha channel. Make sure +- * you do this after you deal with the transparency issue on grayscale +- * or RGB images. If your bit depth is 8, use gamma_table, if it +- * is 16, use gamma_16_table and gamma_shift. Build these with +- * build_gamma_table(). +- */ +-void /* PRIVATE */ +-png_do_gamma(png_row_infop row_info, png_bytep row, +- png_bytep gamma_table, png_uint_16pp gamma_16_table, +- int gamma_shift) +-{ +- png_bytep sp; +- png_uint_32 i; +- png_uint_32 row_width=row_info->width; +- +- png_debug(1, "in png_do_gamma\n"); +- if ( +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- row != NULL && row_info != NULL && +-#endif +- ((row_info->bit_depth <= 8 && gamma_table != NULL) || +- (row_info->bit_depth == 16 && gamma_16_table != NULL))) +- { +- switch (row_info->color_type) +- { +- case PNG_COLOR_TYPE_RGB: +- { +- if (row_info->bit_depth == 8) +- { +- sp = row; +- for (i = 0; i < row_width; i++) +- { +- *sp = gamma_table[*sp]; +- sp++; +- *sp = gamma_table[*sp]; +- sp++; +- *sp = gamma_table[*sp]; +- sp++; +- } +- } +- else /* if (row_info->bit_depth == 16) */ +- { +- sp = row; +- for (i = 0; i < row_width; i++) +- { +- png_uint_16 v; +- +- v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; +- *sp = (png_byte)((v >> 8) & 0xff); +- *(sp + 1) = (png_byte)(v & 0xff); +- sp += 2; +- v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; +- *sp = (png_byte)((v >> 8) & 0xff); +- *(sp + 1) = (png_byte)(v & 0xff); +- sp += 2; +- v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; +- *sp = (png_byte)((v >> 8) & 0xff); +- *(sp + 1) = (png_byte)(v & 0xff); +- sp += 2; +- } +- } +- break; +- } +- case PNG_COLOR_TYPE_RGB_ALPHA: +- { +- if (row_info->bit_depth == 8) +- { +- sp = row; +- for (i = 0; i < row_width; i++) +- { +- *sp = gamma_table[*sp]; +- sp++; +- *sp = gamma_table[*sp]; +- sp++; +- *sp = gamma_table[*sp]; +- sp++; +- sp++; +- } +- } +- else /* if (row_info->bit_depth == 16) */ +- { +- sp = row; +- for (i = 0; i < row_width; i++) +- { +- png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; +- *sp = (png_byte)((v >> 8) & 0xff); +- *(sp + 1) = (png_byte)(v & 0xff); +- sp += 2; +- v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; +- *sp = (png_byte)((v >> 8) & 0xff); +- *(sp + 1) = (png_byte)(v & 0xff); +- sp += 2; +- v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; +- *sp = (png_byte)((v >> 8) & 0xff); +- *(sp + 1) = (png_byte)(v & 0xff); +- sp += 4; +- } +- } +- break; +- } +- case PNG_COLOR_TYPE_GRAY_ALPHA: +- { +- if (row_info->bit_depth == 8) +- { +- sp = row; +- for (i = 0; i < row_width; i++) +- { +- *sp = gamma_table[*sp]; +- sp += 2; +- } +- } +- else /* if (row_info->bit_depth == 16) */ +- { +- sp = row; +- for (i = 0; i < row_width; i++) +- { +- png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; +- *sp = (png_byte)((v >> 8) & 0xff); +- *(sp + 1) = (png_byte)(v & 0xff); +- sp += 4; +- } +- } +- break; +- } +- case PNG_COLOR_TYPE_GRAY: +- { +- if (row_info->bit_depth == 2) +- { +- sp = row; +- for (i = 0; i < row_width; i += 4) +- { +- int a = *sp & 0xc0; +- int b = *sp & 0x30; +- int c = *sp & 0x0c; +- int d = *sp & 0x03; +- +- *sp = (png_byte)( +- ((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)]) ) & 0xc0)| +- ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)| +- ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)| +- ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) )); +- sp++; +- } +- } +- if (row_info->bit_depth == 4) +- { +- sp = row; +- for (i = 0; i < row_width; i += 2) +- { +- int msb = *sp & 0xf0; +- int lsb = *sp & 0x0f; +- +- *sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0) +- | (((int)gamma_table[(lsb << 4) | lsb]) >> 4)); +- sp++; +- } +- } +- else if (row_info->bit_depth == 8) +- { +- sp = row; +- for (i = 0; i < row_width; i++) +- { +- *sp = gamma_table[*sp]; +- sp++; +- } +- } +- else if (row_info->bit_depth == 16) +- { +- sp = row; +- for (i = 0; i < row_width; i++) +- { +- png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; +- *sp = (png_byte)((v >> 8) & 0xff); +- *(sp + 1) = (png_byte)(v & 0xff); +- sp += 2; +- } +- } +- break; +- } +- } +- } +-} +-#endif +- +-#if defined(PNG_READ_EXPAND_SUPPORTED) +-/* Expands a palette row to an RGB or RGBA row depending +- * upon whether you supply trans and num_trans. +- */ +-void /* PRIVATE */ +-png_do_expand_palette(png_row_infop row_info, png_bytep row, +- png_colorp palette, png_bytep trans, int num_trans) +-{ +- int shift, value; +- png_bytep sp, dp; +- png_uint_32 i; +- png_uint_32 row_width=row_info->width; +- +- png_debug(1, "in png_do_expand_palette\n"); +- if ( +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- row != NULL && row_info != NULL && +-#endif +- row_info->color_type == PNG_COLOR_TYPE_PALETTE) +- { +- if (row_info->bit_depth < 8) +- { +- switch (row_info->bit_depth) +- { +- case 1: +- { +- sp = row + (png_size_t)((row_width - 1) >> 3); +- dp = row + (png_size_t)row_width - 1; +- shift = 7 - (int)((row_width + 7) & 0x07); +- for (i = 0; i < row_width; i++) +- { +- if ((*sp >> shift) & 0x01) +- *dp = 1; +- else +- *dp = 0; +- if (shift == 7) +- { +- shift = 0; +- sp--; +- } +- else +- shift++; +- +- dp--; +- } +- break; +- } +- case 2: +- { +- sp = row + (png_size_t)((row_width - 1) >> 2); +- dp = row + (png_size_t)row_width - 1; +- shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); +- for (i = 0; i < row_width; i++) +- { +- value = (*sp >> shift) & 0x03; +- *dp = (png_byte)value; +- if (shift == 6) +- { +- shift = 0; +- sp--; +- } +- else +- shift += 2; +- +- dp--; +- } +- break; +- } +- case 4: +- { +- sp = row + (png_size_t)((row_width - 1) >> 1); +- dp = row + (png_size_t)row_width - 1; +- shift = (int)((row_width & 0x01) << 2); +- for (i = 0; i < row_width; i++) +- { +- value = (*sp >> shift) & 0x0f; +- *dp = (png_byte)value; +- if (shift == 4) +- { +- shift = 0; +- sp--; +- } +- else +- shift += 4; +- +- dp--; +- } +- break; +- } +- } +- row_info->bit_depth = 8; +- row_info->pixel_depth = 8; +- row_info->rowbytes = row_width; +- } +- switch (row_info->bit_depth) +- { +- case 8: +- { +- if (trans != NULL) +- { +- sp = row + (png_size_t)row_width - 1; +- dp = row + (png_size_t)(row_width << 2) - 1; +- +- for (i = 0; i < row_width; i++) +- { +- if ((int)(*sp) >= num_trans) +- *dp-- = 0xff; +- else +- *dp-- = trans[*sp]; +- *dp-- = palette[*sp].blue; +- *dp-- = palette[*sp].green; +- *dp-- = palette[*sp].red; +- sp--; +- } +- row_info->bit_depth = 8; +- row_info->pixel_depth = 32; +- row_info->rowbytes = row_width * 4; +- row_info->color_type = 6; +- row_info->channels = 4; +- } +- else +- { +- sp = row + (png_size_t)row_width - 1; +- dp = row + (png_size_t)(row_width * 3) - 1; +- +- for (i = 0; i < row_width; i++) +- { +- *dp-- = palette[*sp].blue; +- *dp-- = palette[*sp].green; +- *dp-- = palette[*sp].red; +- sp--; +- } +- row_info->bit_depth = 8; +- row_info->pixel_depth = 24; +- row_info->rowbytes = row_width * 3; +- row_info->color_type = 2; +- row_info->channels = 3; +- } +- break; +- } +- } +- } +-} +- +-/* If the bit depth < 8, it is expanded to 8. Also, if the +- * transparency value is supplied, an alpha channel is built. +- */ +-void /* PRIVATE */ +-png_do_expand(png_row_infop row_info, png_bytep row, +- png_color_16p trans_value) +-{ +- int shift, value; +- png_bytep sp, dp; +- png_uint_32 i; +- png_uint_32 row_width=row_info->width; +- +- png_debug(1, "in png_do_expand\n"); +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- if (row != NULL && row_info != NULL) +-#endif +- { +- if (row_info->color_type == PNG_COLOR_TYPE_GRAY) +- { +- png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0); +- +- if (row_info->bit_depth < 8) +- { +- switch (row_info->bit_depth) +- { +- case 1: +- { +- gray = (png_uint_16)(gray*0xff); +- sp = row + (png_size_t)((row_width - 1) >> 3); +- dp = row + (png_size_t)row_width - 1; +- shift = 7 - (int)((row_width + 7) & 0x07); +- for (i = 0; i < row_width; i++) +- { +- if ((*sp >> shift) & 0x01) +- *dp = 0xff; +- else +- *dp = 0; +- if (shift == 7) +- { +- shift = 0; +- sp--; +- } +- else +- shift++; +- +- dp--; +- } +- break; +- } +- case 2: +- { +- gray = (png_uint_16)(gray*0x55); +- sp = row + (png_size_t)((row_width - 1) >> 2); +- dp = row + (png_size_t)row_width - 1; +- shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); +- for (i = 0; i < row_width; i++) +- { +- value = (*sp >> shift) & 0x03; +- *dp = (png_byte)(value | (value << 2) | (value << 4) | +- (value << 6)); +- if (shift == 6) +- { +- shift = 0; +- sp--; +- } +- else +- shift += 2; +- +- dp--; +- } +- break; +- } +- case 4: +- { +- gray = (png_uint_16)(gray*0x11); +- sp = row + (png_size_t)((row_width - 1) >> 1); +- dp = row + (png_size_t)row_width - 1; +- shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); +- for (i = 0; i < row_width; i++) +- { +- value = (*sp >> shift) & 0x0f; +- *dp = (png_byte)(value | (value << 4)); +- if (shift == 4) +- { +- shift = 0; +- sp--; +- } +- else +- shift = 4; +- +- dp--; +- } +- break; +- } +- } +- row_info->bit_depth = 8; +- row_info->pixel_depth = 8; +- row_info->rowbytes = row_width; +- } +- +- if (trans_value != NULL) +- { +- if (row_info->bit_depth == 8) +- { +- sp = row + (png_size_t)row_width - 1; +- dp = row + (png_size_t)(row_width << 1) - 1; +- for (i = 0; i < row_width; i++) +- { +- if (*sp == gray) +- *dp-- = 0; +- else +- *dp-- = 0xff; +- *dp-- = *sp--; +- } +- } +- else if (row_info->bit_depth == 16) +- { +- sp = row + row_info->rowbytes - 1; +- dp = row + (row_info->rowbytes << 1) - 1; +- for (i = 0; i < row_width; i++) +- { +- if (((png_uint_16)*(sp) | +- ((png_uint_16)*(sp - 1) << 8)) == gray) +- { +- *dp-- = 0; +- *dp-- = 0; +- } +- else +- { +- *dp-- = 0xff; +- *dp-- = 0xff; +- } +- *dp-- = *sp--; +- *dp-- = *sp--; +- } +- } +- row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA; +- row_info->channels = 2; +- row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1); +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, +- row_width); +- } +- } +- else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value) +- { +- if (row_info->bit_depth == 8) +- { +- sp = row + (png_size_t)row_info->rowbytes - 1; +- dp = row + (png_size_t)(row_width << 2) - 1; +- for (i = 0; i < row_width; i++) +- { +- if (*(sp - 2) == trans_value->red && +- *(sp - 1) == trans_value->green && +- *(sp - 0) == trans_value->blue) +- *dp-- = 0; +- else +- *dp-- = 0xff; +- *dp-- = *sp--; +- *dp-- = *sp--; +- *dp-- = *sp--; +- } +- } +- else if (row_info->bit_depth == 16) +- { +- sp = row + row_info->rowbytes - 1; +- dp = row + (png_size_t)(row_width << 3) - 1; +- for (i = 0; i < row_width; i++) +- { +- if ((((png_uint_16)*(sp - 4) | +- ((png_uint_16)*(sp - 5) << 8)) == trans_value->red) && +- (((png_uint_16)*(sp - 2) | +- ((png_uint_16)*(sp - 3) << 8)) == trans_value->green) && +- (((png_uint_16)*(sp - 0) | +- ((png_uint_16)*(sp - 1) << 8)) == trans_value->blue)) +- { +- *dp-- = 0; +- *dp-- = 0; +- } +- else +- { +- *dp-- = 0xff; +- *dp-- = 0xff; +- } +- *dp-- = *sp--; +- *dp-- = *sp--; +- *dp-- = *sp--; +- *dp-- = *sp--; +- *dp-- = *sp--; +- *dp-- = *sp--; +- } +- } +- row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA; +- row_info->channels = 4; +- row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2); +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width); +- } +- } +-} +-#endif +- +-#if defined(PNG_READ_DITHER_SUPPORTED) +-void /* PRIVATE */ +-png_do_dither(png_row_infop row_info, png_bytep row, +- png_bytep palette_lookup, png_bytep dither_lookup) +-{ +- png_bytep sp, dp; +- png_uint_32 i; +- png_uint_32 row_width=row_info->width; +- +- png_debug(1, "in png_do_dither\n"); +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- if (row != NULL && row_info != NULL) +-#endif +- { +- if (row_info->color_type == PNG_COLOR_TYPE_RGB && +- palette_lookup && row_info->bit_depth == 8) +- { +- int r, g, b, p; +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++) +- { +- r = *sp++; +- g = *sp++; +- b = *sp++; +- +- /* this looks real messy, but the compiler will reduce +- it down to a reasonable formula. For example, with +- 5 bits per color, we get: +- p = (((r >> 3) & 0x1f) << 10) | +- (((g >> 3) & 0x1f) << 5) | +- ((b >> 3) & 0x1f); +- */ +- p = (((r >> (8 - PNG_DITHER_RED_BITS)) & +- ((1 << PNG_DITHER_RED_BITS) - 1)) << +- (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) | +- (((g >> (8 - PNG_DITHER_GREEN_BITS)) & +- ((1 << PNG_DITHER_GREEN_BITS) - 1)) << +- (PNG_DITHER_BLUE_BITS)) | +- ((b >> (8 - PNG_DITHER_BLUE_BITS)) & +- ((1 << PNG_DITHER_BLUE_BITS) - 1)); +- +- *dp++ = palette_lookup[p]; +- } +- row_info->color_type = PNG_COLOR_TYPE_PALETTE; +- row_info->channels = 1; +- row_info->pixel_depth = row_info->bit_depth; +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width); +- } +- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA && +- palette_lookup != NULL && row_info->bit_depth == 8) +- { +- int r, g, b, p; +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++) +- { +- r = *sp++; +- g = *sp++; +- b = *sp++; +- sp++; +- +- p = (((r >> (8 - PNG_DITHER_RED_BITS)) & +- ((1 << PNG_DITHER_RED_BITS) - 1)) << +- (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) | +- (((g >> (8 - PNG_DITHER_GREEN_BITS)) & +- ((1 << PNG_DITHER_GREEN_BITS) - 1)) << +- (PNG_DITHER_BLUE_BITS)) | +- ((b >> (8 - PNG_DITHER_BLUE_BITS)) & +- ((1 << PNG_DITHER_BLUE_BITS) - 1)); +- +- *dp++ = palette_lookup[p]; +- } +- row_info->color_type = PNG_COLOR_TYPE_PALETTE; +- row_info->channels = 1; +- row_info->pixel_depth = row_info->bit_depth; +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width); +- } +- else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE && +- dither_lookup && row_info->bit_depth == 8) +- { +- sp = row; +- for (i = 0; i < row_width; i++, sp++) +- { +- *sp = dither_lookup[*sp]; +- } +- } +- } +-} +-#endif +- +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-#if defined(PNG_READ_GAMMA_SUPPORTED) +-static int png_gamma_shift[] = +- {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0}; +- +-/* We build the 8- or 16-bit gamma tables here. Note that for 16-bit +- * tables, we don't make a full table if we are reducing to 8-bit in +- * the future. Note also how the gamma_16 tables are segmented so that +- * we don't need to allocate > 64K chunks for a full 16-bit table. +- */ +-void /* PRIVATE */ +-png_build_gamma_table(png_structp png_ptr) +-{ +- png_debug(1, "in png_build_gamma_table\n"); +- if(png_ptr->gamma != 0.0) +- { +- if (png_ptr->bit_depth <= 8) +- { +- int i; +- double g; +- +- if (png_ptr->screen_gamma > .000001) +- g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); +- else +- g = 1.0; +- +- png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)256); +- +- for (i = 0; i < 256; i++) +- { +- png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0, +- g) * 255.0 + .5); +- } +- +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ +- defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +- if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY)) +- { +- +- g = 1.0 / (png_ptr->gamma); +- +- png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)256); +- +- for (i = 0; i < 256; i++) +- { +- png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0, +- g) * 255.0 + .5); +- } +- +- +- png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)256); +- +- if(png_ptr->screen_gamma > 0.000001) +- g = 1.0 / png_ptr->screen_gamma; +- else +- g = png_ptr->gamma; /* probably doing rgb_to_gray */ +- +- for (i = 0; i < 256; i++) +- { +- png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0, +- g) * 255.0 + .5); +- +- } +- } +-#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */ +- } +- else +- { +- double g; +- int i, j, shift, num; +- int sig_bit; +- png_uint_32 ig; +- +- if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) +- { +- sig_bit = (int)png_ptr->sig_bit.red; +- if ((int)png_ptr->sig_bit.green > sig_bit) +- sig_bit = png_ptr->sig_bit.green; +- if ((int)png_ptr->sig_bit.blue > sig_bit) +- sig_bit = png_ptr->sig_bit.blue; +- } +- else +- { +- sig_bit = (int)png_ptr->sig_bit.gray; +- } +- +- if (sig_bit > 0) +- shift = 16 - sig_bit; +- else +- shift = 0; +- +- if (png_ptr->transformations & PNG_16_TO_8) +- { +- if (shift < (16 - PNG_MAX_GAMMA_8)) +- shift = (16 - PNG_MAX_GAMMA_8); +- } +- +- if (shift > 8) +- shift = 8; +- if (shift < 0) +- shift = 0; +- +- png_ptr->gamma_shift = (png_byte)shift; +- +- num = (1 << (8 - shift)); +- +- if (png_ptr->screen_gamma > .000001) +- g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); +- else +- g = 1.0; +- +- png_ptr->gamma_16_table = (png_uint_16pp)png_malloc(png_ptr, +- (png_uint_32)(num * png_sizeof (png_uint_16p))); +- +- if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND)) +- { +- double fin, fout; +- png_uint_32 last, max; +- +- for (i = 0; i < num; i++) +- { +- png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(256 * png_sizeof (png_uint_16))); +- } +- +- g = 1.0 / g; +- last = 0; +- for (i = 0; i < 256; i++) +- { +- fout = ((double)i + 0.5) / 256.0; +- fin = pow(fout, g); +- max = (png_uint_32)(fin * (double)((png_uint_32)num << 8)); +- while (last <= max) +- { +- png_ptr->gamma_16_table[(int)(last & (0xff >> shift))] +- [(int)(last >> (8 - shift))] = (png_uint_16)( +- (png_uint_16)i | ((png_uint_16)i << 8)); +- last++; +- } +- } +- while (last < ((png_uint_32)num << 8)) +- { +- png_ptr->gamma_16_table[(int)(last & (0xff >> shift))] +- [(int)(last >> (8 - shift))] = (png_uint_16)65535L; +- last++; +- } +- } +- else +- { +- for (i = 0; i < num; i++) +- { +- png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(256 * png_sizeof (png_uint_16))); +- +- ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4); +- for (j = 0; j < 256; j++) +- { +- png_ptr->gamma_16_table[i][j] = +- (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) / +- 65535.0, g) * 65535.0 + .5); +- } +- } +- } +- +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ +- defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +- if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY)) +- { +- +- g = 1.0 / (png_ptr->gamma); +- +- png_ptr->gamma_16_to_1 = (png_uint_16pp)png_malloc(png_ptr, +- (png_uint_32)(num * png_sizeof (png_uint_16p ))); +- +- for (i = 0; i < num; i++) +- { +- png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(256 * png_sizeof (png_uint_16))); +- +- ig = (((png_uint_32)i * +- (png_uint_32)png_gamma_shift[shift]) >> 4); +- for (j = 0; j < 256; j++) +- { +- png_ptr->gamma_16_to_1[i][j] = +- (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) / +- 65535.0, g) * 65535.0 + .5); +- } +- } +- +- if(png_ptr->screen_gamma > 0.000001) +- g = 1.0 / png_ptr->screen_gamma; +- else +- g = png_ptr->gamma; /* probably doing rgb_to_gray */ +- +- png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr, +- (png_uint_32)(num * png_sizeof (png_uint_16p))); +- +- for (i = 0; i < num; i++) +- { +- png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(256 * png_sizeof (png_uint_16))); +- +- ig = (((png_uint_32)i * +- (png_uint_32)png_gamma_shift[shift]) >> 4); +- for (j = 0; j < 256; j++) +- { +- png_ptr->gamma_16_from_1[i][j] = +- (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) / +- 65535.0, g) * 65535.0 + .5); +- } +- } +- } +-#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */ +- } +- } +-} +-#endif +-/* To do: install integer version of png_build_gamma_table here */ +-#endif +- +-#if defined(PNG_MNG_FEATURES_SUPPORTED) +-/* undoes intrapixel differencing */ +-void /* PRIVATE */ +-png_do_read_intrapixel(png_row_infop row_info, png_bytep row) +-{ +- png_debug(1, "in png_do_read_intrapixel\n"); +- if ( +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- row != NULL && row_info != NULL && +-#endif +- (row_info->color_type & PNG_COLOR_MASK_COLOR)) +- { +- int bytes_per_pixel; +- png_uint_32 row_width = row_info->width; +- if (row_info->bit_depth == 8) +- { +- png_bytep rp; +- png_uint_32 i; +- +- if (row_info->color_type == PNG_COLOR_TYPE_RGB) +- bytes_per_pixel = 3; +- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- bytes_per_pixel = 4; +- else +- return; +- +- for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) +- { +- *(rp) = (png_byte)((256 + *rp + *(rp+1))&0xff); +- *(rp+2) = (png_byte)((256 + *(rp+2) + *(rp+1))&0xff); +- } +- } +- else if (row_info->bit_depth == 16) +- { +- png_bytep rp; +- png_uint_32 i; +- +- if (row_info->color_type == PNG_COLOR_TYPE_RGB) +- bytes_per_pixel = 6; +- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- bytes_per_pixel = 8; +- else +- return; +- +- for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) +- { +- png_uint_32 s0 = (*(rp ) << 8) | *(rp+1); +- png_uint_32 s1 = (*(rp+2) << 8) | *(rp+3); +- png_uint_32 s2 = (*(rp+4) << 8) | *(rp+5); +- png_uint_32 red = (png_uint_32)((s0+s1+65536L) & 0xffffL); +- png_uint_32 blue = (png_uint_32)((s2+s1+65536L) & 0xffffL); +- *(rp ) = (png_byte)((red >> 8) & 0xff); +- *(rp+1) = (png_byte)(red & 0xff); +- *(rp+4) = (png_byte)((blue >> 8) & 0xff); +- *(rp+5) = (png_byte)(blue & 0xff); +- } +- } +- } +-} +-#endif /* PNG_MNG_FEATURES_SUPPORTED */ +diff --git a/thirdparty/libpng/pngrutil.c b/thirdparty/libpng/pngrutil.c +deleted file mode 100644 +index ce52219..0000000 +--- a/thirdparty/libpng/pngrutil.c ++++ /dev/null +@@ -1,3124 +0,0 @@ +-/* pngrutil.c - utilities to read a PNG file +- * +- * libpng version 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- * +- * This file contains routines that are only called from within +- * libpng itself during the course of reading an image. +- */ +- +-#define PNG_INTERNAL +-#include "png.h" +- +-#if defined(_WIN32_WCE) +-/* strtod() function is not supported on WindowsCE */ +-# ifdef PNG_FLOATING_POINT_SUPPORTED +-__inline double strtod(const char *nptr, char **endptr) +-{ +- double result = 0; +- int len; +- wchar_t *str, *end; +- +- len = MultiByteToWideChar(CP_ACP, 0, nptr, -1, NULL, 0); +- str = (wchar_t *)malloc(len * sizeof(wchar_t)); +- if ( NULL != str ) +- { +- MultiByteToWideChar(CP_ACP, 0, nptr, -1, str, len); +- result = wcstod(str, &end); +- len = WideCharToMultiByte(CP_ACP, 0, end, -1, NULL, 0, NULL, NULL); +- *endptr = (char *)nptr + (png_strlen(nptr) - len + 1); +- free(str); +- } +- return result; +-} +-# endif +-#endif +- +-png_uint_32 /* PRIVATE */ +-png_get_uint_31(png_structp png_ptr, png_bytep buf) +-{ +- png_uint_32 i = png_get_uint_32(buf); +- if (i > PNG_UINT_31_MAX) +- png_error(png_ptr, "PNG unsigned integer out of range.\n"); +- return (i); +-} +-#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED +-/* Grab an unsigned 32-bit integer from a buffer in big-endian format. */ +-png_uint_32 /* PRIVATE */ +-png_get_uint_32(png_bytep buf) +-{ +- png_uint_32 i = ((png_uint_32)(*buf) << 24) + +- ((png_uint_32)(*(buf + 1)) << 16) + +- ((png_uint_32)(*(buf + 2)) << 8) + +- (png_uint_32)(*(buf + 3)); +- +- return (i); +-} +- +-#if defined(PNG_READ_pCAL_SUPPORTED) || defined(PNG_READ_oFFs_SUPPORTED) +-/* Grab a signed 32-bit integer from a buffer in big-endian format. The +- * data is stored in the PNG file in two's complement format, and it is +- * assumed that the machine format for signed integers is the same. */ +-png_int_32 /* PRIVATE */ +-png_get_int_32(png_bytep buf) +-{ +- png_int_32 i = ((png_int_32)(*buf) << 24) + +- ((png_int_32)(*(buf + 1)) << 16) + +- ((png_int_32)(*(buf + 2)) << 8) + +- (png_int_32)(*(buf + 3)); +- +- return (i); +-} +-#endif /* PNG_READ_pCAL_SUPPORTED */ +- +-/* Grab an unsigned 16-bit integer from a buffer in big-endian format. */ +-png_uint_16 /* PRIVATE */ +-png_get_uint_16(png_bytep buf) +-{ +- png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) + +- (png_uint_16)(*(buf + 1))); +- +- return (i); +-} +-#endif /* PNG_READ_BIG_ENDIAN_SUPPORTED */ +- +-/* Read data, and (optionally) run it through the CRC. */ +-void /* PRIVATE */ +-png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length) +-{ +- png_read_data(png_ptr, buf, length); +- png_calculate_crc(png_ptr, buf, length); +-} +- +-/* Optionally skip data and then check the CRC. Depending on whether we +- are reading a ancillary or critical chunk, and how the program has set +- things up, we may calculate the CRC on the data and print a message. +- Returns '1' if there was a CRC error, '0' otherwise. */ +-int /* PRIVATE */ +-png_crc_finish(png_structp png_ptr, png_uint_32 skip) +-{ +- png_size_t i; +- png_size_t istop = png_ptr->zbuf_size; +- +- for (i = (png_size_t)skip; i > istop; i -= istop) +- { +- png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); +- } +- if (i) +- { +- png_crc_read(png_ptr, png_ptr->zbuf, i); +- } +- +- if (png_crc_error(png_ptr)) +- { +- if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */ +- !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) || +- (!(png_ptr->chunk_name[0] & 0x20) && /* Critical */ +- (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE))) +- { +- png_chunk_warning(png_ptr, "CRC error"); +- } +- else +- { +- png_chunk_error(png_ptr, "CRC error"); +- } +- return (1); +- } +- +- return (0); +-} +- +-/* Compare the CRC stored in the PNG file with that calculated by libpng from +- the data it has read thus far. */ +-int /* PRIVATE */ +-png_crc_error(png_structp png_ptr) +-{ +- png_byte crc_bytes[4]; +- png_uint_32 crc; +- int need_crc = 1; +- +- if (png_ptr->chunk_name[0] & 0x20) /* ancillary */ +- { +- if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == +- (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) +- need_crc = 0; +- } +- else /* critical */ +- { +- if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) +- need_crc = 0; +- } +- +- png_read_data(png_ptr, crc_bytes, 4); +- +- if (need_crc) +- { +- crc = png_get_uint_32(crc_bytes); +- return ((int)(crc != png_ptr->crc)); +- } +- else +- return (0); +-} +- +-#if defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_READ_iTXt_SUPPORTED) || \ +- defined(PNG_READ_iCCP_SUPPORTED) +-/* +- * Decompress trailing data in a chunk. The assumption is that chunkdata +- * points at an allocated area holding the contents of a chunk with a +- * trailing compressed part. What we get back is an allocated area +- * holding the original prefix part and an uncompressed version of the +- * trailing part (the malloc area passed in is freed). +- */ +-png_charp /* PRIVATE */ +-png_decompress_chunk(png_structp png_ptr, int comp_type, +- png_charp chunkdata, png_size_t chunklength, +- png_size_t prefix_size, png_size_t *newlength) +-{ +- static char msg[] = "Error decoding compressed text"; +- png_charp text; +- png_size_t text_size; +- +- if (comp_type == PNG_COMPRESSION_TYPE_BASE) +- { +- int ret = Z_OK; +- png_ptr->zstream.next_in = (png_bytep)(chunkdata + prefix_size); +- png_ptr->zstream.avail_in = (uInt)(chunklength - prefix_size); +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- +- text_size = 0; +- text = NULL; +- +- while (png_ptr->zstream.avail_in) +- { +- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); +- if (ret != Z_OK && ret != Z_STREAM_END) +- { +- if (png_ptr->zstream.msg != NULL) +- png_warning(png_ptr, png_ptr->zstream.msg); +- else +- png_warning(png_ptr, msg); +- inflateReset(&png_ptr->zstream); +- png_ptr->zstream.avail_in = 0; +- +- if (text == NULL) +- { +- text_size = prefix_size + png_sizeof(msg) + 1; +- text = (png_charp)png_malloc_warn(png_ptr, text_size); +- if (text == NULL) +- { +- png_free(png_ptr,chunkdata); +- png_error(png_ptr,"Not enough memory to decompress chunk"); +- } +- png_memcpy(text, chunkdata, prefix_size); +- } +- +- text[text_size - 1] = 0x00; +- +- /* Copy what we can of the error message into the text chunk */ +- text_size = (png_size_t)(chunklength - (text - chunkdata) - 1); +- text_size = png_sizeof(msg) > text_size ? text_size : +- png_sizeof(msg); +- png_memcpy(text + prefix_size, msg, text_size + 1); +- break; +- } +- if (!png_ptr->zstream.avail_out || ret == Z_STREAM_END) +- { +- if (text == NULL) +- { +- text_size = prefix_size + +- png_ptr->zbuf_size - png_ptr->zstream.avail_out; +- text = (png_charp)png_malloc_warn(png_ptr, text_size + 1); +- if (text == NULL) +- { +- png_free(png_ptr,chunkdata); +- png_error(png_ptr,"Not enough memory to decompress chunk."); +- } +- png_memcpy(text + prefix_size, png_ptr->zbuf, +- text_size - prefix_size); +- png_memcpy(text, chunkdata, prefix_size); +- *(text + text_size) = 0x00; +- } +- else +- { +- png_charp tmp; +- +- tmp = text; +- text = (png_charp)png_malloc_warn(png_ptr, +- (png_uint_32)(text_size + +- png_ptr->zbuf_size - png_ptr->zstream.avail_out + 1)); +- if (text == NULL) +- { +- png_free(png_ptr, tmp); +- png_free(png_ptr, chunkdata); +- png_error(png_ptr,"Not enough memory to decompress chunk.."); +- } +- png_memcpy(text, tmp, text_size); +- png_free(png_ptr, tmp); +- png_memcpy(text + text_size, png_ptr->zbuf, +- (png_ptr->zbuf_size - png_ptr->zstream.avail_out)); +- text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out; +- *(text + text_size) = 0x00; +- } +- if (ret == Z_STREAM_END) +- break; +- else +- { +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- } +- } +- } +- if (ret != Z_STREAM_END) +- { +-#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) +- char umsg[50]; +- +- if (ret == Z_BUF_ERROR) +- sprintf(umsg,"Buffer error in compressed datastream in %s chunk", +- png_ptr->chunk_name); +- else if (ret == Z_DATA_ERROR) +- sprintf(umsg,"Data error in compressed datastream in %s chunk", +- png_ptr->chunk_name); +- else +- sprintf(umsg,"Incomplete compressed datastream in %s chunk", +- png_ptr->chunk_name); +- png_warning(png_ptr, umsg); +-#else +- png_warning(png_ptr, +- "Incomplete compressed datastream in chunk other than IDAT"); +-#endif +- text_size=prefix_size; +- if (text == NULL) +- { +- text = (png_charp)png_malloc_warn(png_ptr, text_size+1); +- if (text == NULL) +- { +- png_free(png_ptr, chunkdata); +- png_error(png_ptr,"Not enough memory for text."); +- } +- png_memcpy(text, chunkdata, prefix_size); +- } +- *(text + text_size) = 0x00; +- } +- +- inflateReset(&png_ptr->zstream); +- png_ptr->zstream.avail_in = 0; +- +- png_free(png_ptr, chunkdata); +- chunkdata = text; +- *newlength=text_size; +- } +- else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */ +- { +-#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) +- char umsg[50]; +- +- sprintf(umsg, "Unknown zTXt compression type %d", comp_type); +- png_warning(png_ptr, umsg); +-#else +- png_warning(png_ptr, "Unknown zTXt compression type"); +-#endif +- +- *(chunkdata + prefix_size) = 0x00; +- *newlength=prefix_size; +- } +- +- return chunkdata; +-} +-#endif +- +-/* read and check the IDHR chunk */ +-void /* PRIVATE */ +-png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_byte buf[13]; +- png_uint_32 width, height; +- int bit_depth, color_type, compression_type, filter_type; +- int interlace_type; +- +- png_debug(1, "in png_handle_IHDR\n"); +- +- if (png_ptr->mode & PNG_HAVE_IHDR) +- png_error(png_ptr, "Out of place IHDR"); +- +- /* check the length */ +- if (length != 13) +- png_error(png_ptr, "Invalid IHDR chunk"); +- +- png_ptr->mode |= PNG_HAVE_IHDR; +- +- png_crc_read(png_ptr, buf, 13); +- png_crc_finish(png_ptr, 0); +- +- width = png_get_uint_31(png_ptr, buf); +- height = png_get_uint_31(png_ptr, buf + 4); +- bit_depth = buf[8]; +- color_type = buf[9]; +- compression_type = buf[10]; +- filter_type = buf[11]; +- interlace_type = buf[12]; +- +- /* set internal variables */ +- png_ptr->width = width; +- png_ptr->height = height; +- png_ptr->bit_depth = (png_byte)bit_depth; +- png_ptr->interlaced = (png_byte)interlace_type; +- png_ptr->color_type = (png_byte)color_type; +-#if defined(PNG_MNG_FEATURES_SUPPORTED) +- png_ptr->filter_type = (png_byte)filter_type; +-#endif +- png_ptr->compression_type = (png_byte)compression_type; +- +- /* find number of channels */ +- switch (png_ptr->color_type) +- { +- case PNG_COLOR_TYPE_GRAY: +- case PNG_COLOR_TYPE_PALETTE: +- png_ptr->channels = 1; +- break; +- case PNG_COLOR_TYPE_RGB: +- png_ptr->channels = 3; +- break; +- case PNG_COLOR_TYPE_GRAY_ALPHA: +- png_ptr->channels = 2; +- break; +- case PNG_COLOR_TYPE_RGB_ALPHA: +- png_ptr->channels = 4; +- break; +- } +- +- /* set up other useful info */ +- png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth * +- png_ptr->channels); +- png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,png_ptr->width); +- png_debug1(3,"bit_depth = %d\n", png_ptr->bit_depth); +- png_debug1(3,"channels = %d\n", png_ptr->channels); +- png_debug1(3,"rowbytes = %lu\n", png_ptr->rowbytes); +- png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, +- color_type, interlace_type, compression_type, filter_type); +-} +- +-/* read and check the palette */ +-void /* PRIVATE */ +-png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_color palette[PNG_MAX_PALETTE_LENGTH]; +- int num, i; +-#ifndef PNG_NO_POINTER_INDEXING +- png_colorp pal_ptr; +-#endif +- +- png_debug(1, "in png_handle_PLTE\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before PLTE"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- png_warning(png_ptr, "Invalid PLTE after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (png_ptr->mode & PNG_HAVE_PLTE) +- png_error(png_ptr, "Duplicate PLTE chunk"); +- +- png_ptr->mode |= PNG_HAVE_PLTE; +- +- if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR)) +- { +- png_warning(png_ptr, +- "Ignoring PLTE chunk in grayscale PNG"); +- png_crc_finish(png_ptr, length); +- return; +- } +-#if !defined(PNG_READ_OPT_PLTE_SUPPORTED) +- if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE) +- { +- png_crc_finish(png_ptr, length); +- return; +- } +-#endif +- +- if (length > 3*PNG_MAX_PALETTE_LENGTH || length % 3) +- { +- if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE) +- { +- png_warning(png_ptr, "Invalid palette chunk"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else +- { +- png_error(png_ptr, "Invalid palette chunk"); +- } +- } +- +- num = (int)length / 3; +- +-#ifndef PNG_NO_POINTER_INDEXING +- for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++) +- { +- png_byte buf[3]; +- +- png_crc_read(png_ptr, buf, 3); +- pal_ptr->red = buf[0]; +- pal_ptr->green = buf[1]; +- pal_ptr->blue = buf[2]; +- } +-#else +- for (i = 0; i < num; i++) +- { +- png_byte buf[3]; +- +- png_crc_read(png_ptr, buf, 3); +- /* don't depend upon png_color being any order */ +- palette[i].red = buf[0]; +- palette[i].green = buf[1]; +- palette[i].blue = buf[2]; +- } +-#endif +- +- /* If we actually NEED the PLTE chunk (ie for a paletted image), we do +- whatever the normal CRC configuration tells us. However, if we +- have an RGB image, the PLTE can be considered ancillary, so +- we will act as though it is. */ +-#if !defined(PNG_READ_OPT_PLTE_SUPPORTED) +- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +-#endif +- { +- png_crc_finish(png_ptr, 0); +- } +-#if !defined(PNG_READ_OPT_PLTE_SUPPORTED) +- else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */ +- { +- /* If we don't want to use the data from an ancillary chunk, +- we have two options: an error abort, or a warning and we +- ignore the data in this chunk (which should be OK, since +- it's considered ancillary for a RGB or RGBA image). */ +- if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE)) +- { +- if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) +- { +- png_chunk_error(png_ptr, "CRC error"); +- } +- else +- { +- png_chunk_warning(png_ptr, "CRC error"); +- return; +- } +- } +- /* Otherwise, we (optionally) emit a warning and use the chunk. */ +- else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) +- { +- png_chunk_warning(png_ptr, "CRC error"); +- } +- } +-#endif +- +- png_set_PLTE(png_ptr, info_ptr, palette, num); +- +-#if defined(PNG_READ_tRNS_SUPPORTED) +- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- { +- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) +- { +- if (png_ptr->num_trans > (png_uint_16)num) +- { +- png_warning(png_ptr, "Truncating incorrect tRNS chunk length"); +- png_ptr->num_trans = (png_uint_16)num; +- } +- if (info_ptr->num_trans > (png_uint_16)num) +- { +- png_warning(png_ptr, "Truncating incorrect info tRNS chunk length"); +- info_ptr->num_trans = (png_uint_16)num; +- } +- } +- } +-#endif +- +-} +- +-void /* PRIVATE */ +-png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_debug(1, "in png_handle_IEND\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT)) +- { +- png_error(png_ptr, "No image in file"); +- } +- +- png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND); +- +- if (length != 0) +- { +- png_warning(png_ptr, "Incorrect IEND chunk length"); +- } +- png_crc_finish(png_ptr, length); +- +- if (&info_ptr == NULL) /* quiet compiler warnings about unused info_ptr */ +- return; +-} +- +-#if defined(PNG_READ_gAMA_SUPPORTED) +-void /* PRIVATE */ +-png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_fixed_point igamma; +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- float file_gamma; +-#endif +- png_byte buf[4]; +- +- png_debug(1, "in png_handle_gAMA\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before gAMA"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- png_warning(png_ptr, "Invalid gAMA after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (png_ptr->mode & PNG_HAVE_PLTE) +- /* Should be an error, but we can cope with it */ +- png_warning(png_ptr, "Out of place gAMA chunk"); +- +- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) +-#if defined(PNG_READ_sRGB_SUPPORTED) +- && !(info_ptr->valid & PNG_INFO_sRGB) +-#endif +- ) +- { +- png_warning(png_ptr, "Duplicate gAMA chunk"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- if (length != 4) +- { +- png_warning(png_ptr, "Incorrect gAMA chunk length"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- png_crc_read(png_ptr, buf, 4); +- if (png_crc_finish(png_ptr, 0)) +- return; +- +- igamma = (png_fixed_point)png_get_uint_32(buf); +- /* check for zero gamma */ +- if (igamma == 0) +- { +- png_warning(png_ptr, +- "Ignoring gAMA chunk with gamma=0"); +- return; +- } +- +-#if defined(PNG_READ_sRGB_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_sRGB) +- if (PNG_OUT_OF_RANGE(igamma, 45500L, 500)) +- { +- png_warning(png_ptr, +- "Ignoring incorrect gAMA value when sRGB is also present"); +-#ifndef PNG_NO_CONSOLE_IO +- fprintf(stderr, "gamma = (%d/100000)\n", (int)igamma); +-#endif +- return; +- } +-#endif /* PNG_READ_sRGB_SUPPORTED */ +- +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- file_gamma = (float)igamma / (float)100000.0; +-# ifdef PNG_READ_GAMMA_SUPPORTED +- png_ptr->gamma = file_gamma; +-# endif +- png_set_gAMA(png_ptr, info_ptr, file_gamma); +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +- png_set_gAMA_fixed(png_ptr, info_ptr, igamma); +-#endif +-} +-#endif +- +-#if defined(PNG_READ_sBIT_SUPPORTED) +-void /* PRIVATE */ +-png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_size_t truelen; +- png_byte buf[4]; +- +- png_debug(1, "in png_handle_sBIT\n"); +- +- buf[0] = buf[1] = buf[2] = buf[3] = 0; +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before sBIT"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- png_warning(png_ptr, "Invalid sBIT after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (png_ptr->mode & PNG_HAVE_PLTE) +- { +- /* Should be an error, but we can cope with it */ +- png_warning(png_ptr, "Out of place sBIT chunk"); +- } +- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)) +- { +- png_warning(png_ptr, "Duplicate sBIT chunk"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- truelen = 3; +- else +- truelen = (png_size_t)png_ptr->channels; +- +- if (length != truelen || length > 4) +- { +- png_warning(png_ptr, "Incorrect sBIT chunk length"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- png_crc_read(png_ptr, buf, truelen); +- if (png_crc_finish(png_ptr, 0)) +- return; +- +- if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) +- { +- png_ptr->sig_bit.red = buf[0]; +- png_ptr->sig_bit.green = buf[1]; +- png_ptr->sig_bit.blue = buf[2]; +- png_ptr->sig_bit.alpha = buf[3]; +- } +- else +- { +- png_ptr->sig_bit.gray = buf[0]; +- png_ptr->sig_bit.red = buf[0]; +- png_ptr->sig_bit.green = buf[0]; +- png_ptr->sig_bit.blue = buf[0]; +- png_ptr->sig_bit.alpha = buf[1]; +- } +- png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit)); +-} +-#endif +- +-#if defined(PNG_READ_cHRM_SUPPORTED) +-void /* PRIVATE */ +-png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_byte buf[4]; +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; +-#endif +- png_fixed_point int_x_white, int_y_white, int_x_red, int_y_red, int_x_green, +- int_y_green, int_x_blue, int_y_blue; +- +- png_uint_32 uint_x, uint_y; +- +- png_debug(1, "in png_handle_cHRM\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before cHRM"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- png_warning(png_ptr, "Invalid cHRM after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (png_ptr->mode & PNG_HAVE_PLTE) +- /* Should be an error, but we can cope with it */ +- png_warning(png_ptr, "Missing PLTE before cHRM"); +- +- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM) +-#if defined(PNG_READ_sRGB_SUPPORTED) +- && !(info_ptr->valid & PNG_INFO_sRGB) +-#endif +- ) +- { +- png_warning(png_ptr, "Duplicate cHRM chunk"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- if (length != 32) +- { +- png_warning(png_ptr, "Incorrect cHRM chunk length"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- png_crc_read(png_ptr, buf, 4); +- uint_x = png_get_uint_32(buf); +- +- png_crc_read(png_ptr, buf, 4); +- uint_y = png_get_uint_32(buf); +- +- if (uint_x > 80000L || uint_y > 80000L || +- uint_x + uint_y > 100000L) +- { +- png_warning(png_ptr, "Invalid cHRM white point"); +- png_crc_finish(png_ptr, 24); +- return; +- } +- int_x_white = (png_fixed_point)uint_x; +- int_y_white = (png_fixed_point)uint_y; +- +- png_crc_read(png_ptr, buf, 4); +- uint_x = png_get_uint_32(buf); +- +- png_crc_read(png_ptr, buf, 4); +- uint_y = png_get_uint_32(buf); +- +- if (uint_x > 80000L || uint_y > 80000L || +- uint_x + uint_y > 100000L) +- { +- png_warning(png_ptr, "Invalid cHRM red point"); +- png_crc_finish(png_ptr, 16); +- return; +- } +- int_x_red = (png_fixed_point)uint_x; +- int_y_red = (png_fixed_point)uint_y; +- +- png_crc_read(png_ptr, buf, 4); +- uint_x = png_get_uint_32(buf); +- +- png_crc_read(png_ptr, buf, 4); +- uint_y = png_get_uint_32(buf); +- +- if (uint_x > 80000L || uint_y > 80000L || +- uint_x + uint_y > 100000L) +- { +- png_warning(png_ptr, "Invalid cHRM green point"); +- png_crc_finish(png_ptr, 8); +- return; +- } +- int_x_green = (png_fixed_point)uint_x; +- int_y_green = (png_fixed_point)uint_y; +- +- png_crc_read(png_ptr, buf, 4); +- uint_x = png_get_uint_32(buf); +- +- png_crc_read(png_ptr, buf, 4); +- uint_y = png_get_uint_32(buf); +- +- if (uint_x > 80000L || uint_y > 80000L || +- uint_x + uint_y > 100000L) +- { +- png_warning(png_ptr, "Invalid cHRM blue point"); +- png_crc_finish(png_ptr, 0); +- return; +- } +- int_x_blue = (png_fixed_point)uint_x; +- int_y_blue = (png_fixed_point)uint_y; +- +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- white_x = (float)int_x_white / (float)100000.0; +- white_y = (float)int_y_white / (float)100000.0; +- red_x = (float)int_x_red / (float)100000.0; +- red_y = (float)int_y_red / (float)100000.0; +- green_x = (float)int_x_green / (float)100000.0; +- green_y = (float)int_y_green / (float)100000.0; +- blue_x = (float)int_x_blue / (float)100000.0; +- blue_y = (float)int_y_blue / (float)100000.0; +-#endif +- +-#if defined(PNG_READ_sRGB_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_sRGB) +- { +- if (PNG_OUT_OF_RANGE(int_x_white, 31270, 1000) || +- PNG_OUT_OF_RANGE(int_y_white, 32900, 1000) || +- PNG_OUT_OF_RANGE(int_x_red, 64000L, 1000) || +- PNG_OUT_OF_RANGE(int_y_red, 33000, 1000) || +- PNG_OUT_OF_RANGE(int_x_green, 30000, 1000) || +- PNG_OUT_OF_RANGE(int_y_green, 60000L, 1000) || +- PNG_OUT_OF_RANGE(int_x_blue, 15000, 1000) || +- PNG_OUT_OF_RANGE(int_y_blue, 6000, 1000)) +- { +- +- png_warning(png_ptr, +- "Ignoring incorrect cHRM value when sRGB is also present"); +-#ifndef PNG_NO_CONSOLE_IO +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- fprintf(stderr,"wx=%f, wy=%f, rx=%f, ry=%f\n", +- white_x, white_y, red_x, red_y); +- fprintf(stderr,"gx=%f, gy=%f, bx=%f, by=%f\n", +- green_x, green_y, blue_x, blue_y); +-#else +- fprintf(stderr,"wx=%ld, wy=%ld, rx=%ld, ry=%ld\n", +- int_x_white, int_y_white, int_x_red, int_y_red); +- fprintf(stderr,"gx=%ld, gy=%ld, bx=%ld, by=%ld\n", +- int_x_green, int_y_green, int_x_blue, int_y_blue); +-#endif +-#endif /* PNG_NO_CONSOLE_IO */ +- } +- png_crc_finish(png_ptr, 0); +- return; +- } +-#endif /* PNG_READ_sRGB_SUPPORTED */ +- +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- png_set_cHRM(png_ptr, info_ptr, +- white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y); +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +- png_set_cHRM_fixed(png_ptr, info_ptr, +- int_x_white, int_y_white, int_x_red, int_y_red, int_x_green, +- int_y_green, int_x_blue, int_y_blue); +-#endif +- if (png_crc_finish(png_ptr, 0)) +- return; +-} +-#endif +- +-#if defined(PNG_READ_sRGB_SUPPORTED) +-void /* PRIVATE */ +-png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- int intent; +- png_byte buf[1]; +- +- png_debug(1, "in png_handle_sRGB\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before sRGB"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- png_warning(png_ptr, "Invalid sRGB after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (png_ptr->mode & PNG_HAVE_PLTE) +- /* Should be an error, but we can cope with it */ +- png_warning(png_ptr, "Out of place sRGB chunk"); +- +- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)) +- { +- png_warning(png_ptr, "Duplicate sRGB chunk"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- if (length != 1) +- { +- png_warning(png_ptr, "Incorrect sRGB chunk length"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- png_crc_read(png_ptr, buf, 1); +- if (png_crc_finish(png_ptr, 0)) +- return; +- +- intent = buf[0]; +- /* check for bad intent */ +- if (intent >= PNG_sRGB_INTENT_LAST) +- { +- png_warning(png_ptr, "Unknown sRGB intent"); +- return; +- } +- +-#if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED) +- if ((info_ptr->valid & PNG_INFO_gAMA)) +- { +- png_fixed_point igamma; +-#ifdef PNG_FIXED_POINT_SUPPORTED +- igamma=info_ptr->int_gamma; +-#else +-# ifdef PNG_FLOATING_POINT_SUPPORTED +- igamma=(png_fixed_point)(info_ptr->gamma * 100000.); +-# endif +-#endif +- if (PNG_OUT_OF_RANGE(igamma, 45500L, 500)) +- { +- png_warning(png_ptr, +- "Ignoring incorrect gAMA value when sRGB is also present"); +-#ifndef PNG_NO_CONSOLE_IO +-# ifdef PNG_FIXED_POINT_SUPPORTED +- fprintf(stderr,"incorrect gamma=(%d/100000)\n",(int)png_ptr->int_gamma); +-# else +-# ifdef PNG_FLOATING_POINT_SUPPORTED +- fprintf(stderr,"incorrect gamma=%f\n",png_ptr->gamma); +-# endif +-# endif +-#endif +- } +- } +-#endif /* PNG_READ_gAMA_SUPPORTED */ +- +-#ifdef PNG_READ_cHRM_SUPPORTED +-#ifdef PNG_FIXED_POINT_SUPPORTED +- if (info_ptr->valid & PNG_INFO_cHRM) +- if (PNG_OUT_OF_RANGE(info_ptr->int_x_white, 31270, 1000) || +- PNG_OUT_OF_RANGE(info_ptr->int_y_white, 32900, 1000) || +- PNG_OUT_OF_RANGE(info_ptr->int_x_red, 64000L, 1000) || +- PNG_OUT_OF_RANGE(info_ptr->int_y_red, 33000, 1000) || +- PNG_OUT_OF_RANGE(info_ptr->int_x_green, 30000, 1000) || +- PNG_OUT_OF_RANGE(info_ptr->int_y_green, 60000L, 1000) || +- PNG_OUT_OF_RANGE(info_ptr->int_x_blue, 15000, 1000) || +- PNG_OUT_OF_RANGE(info_ptr->int_y_blue, 6000, 1000)) +- { +- png_warning(png_ptr, +- "Ignoring incorrect cHRM value when sRGB is also present"); +- } +-#endif /* PNG_FIXED_POINT_SUPPORTED */ +-#endif /* PNG_READ_cHRM_SUPPORTED */ +- +- png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent); +-} +-#endif /* PNG_READ_sRGB_SUPPORTED */ +- +-#if defined(PNG_READ_iCCP_SUPPORTED) +-void /* PRIVATE */ +-png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-/* Note: this does not properly handle chunks that are > 64K under DOS */ +-{ +- png_charp chunkdata; +- png_byte compression_type; +- png_bytep pC; +- png_charp profile; +- png_uint_32 skip = 0; +- png_uint_32 profile_size, profile_length; +- png_size_t slength, prefix_length, data_length; +- +- png_debug(1, "in png_handle_iCCP\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before iCCP"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- png_warning(png_ptr, "Invalid iCCP after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (png_ptr->mode & PNG_HAVE_PLTE) +- /* Should be an error, but we can cope with it */ +- png_warning(png_ptr, "Out of place iCCP chunk"); +- +- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)) +- { +- png_warning(png_ptr, "Duplicate iCCP chunk"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +-#ifdef PNG_MAX_MALLOC_64K +- if (length > (png_uint_32)65535L) +- { +- png_warning(png_ptr, "iCCP chunk too large to fit in memory"); +- skip = length - (png_uint_32)65535L; +- length = (png_uint_32)65535L; +- } +-#endif +- +- chunkdata = (png_charp)png_malloc(png_ptr, length + 1); +- slength = (png_size_t)length; +- png_crc_read(png_ptr, (png_bytep)chunkdata, slength); +- +- if (png_crc_finish(png_ptr, skip)) +- { +- png_free(png_ptr, chunkdata); +- return; +- } +- +- chunkdata[slength] = 0x00; +- +- for (profile = chunkdata; *profile; profile++) +- /* empty loop to find end of name */ ; +- +- ++profile; +- +- /* there should be at least one zero (the compression type byte) +- following the separator, and we should be on it */ +- if ( profile >= chunkdata + slength) +- { +- png_free(png_ptr, chunkdata); +- png_warning(png_ptr, "Malformed iCCP chunk"); +- return; +- } +- +- /* compression_type should always be zero */ +- compression_type = *profile++; +- if (compression_type) +- { +- png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk"); +- compression_type=0x00; /* Reset it to zero (libpng-1.0.6 through 1.0.8 +- wrote nonzero) */ +- } +- +- prefix_length = profile - chunkdata; +- chunkdata = png_decompress_chunk(png_ptr, compression_type, chunkdata, +- slength, prefix_length, &data_length); +- +- profile_length = data_length - prefix_length; +- +- if ( prefix_length > data_length || profile_length < 4) +- { +- png_free(png_ptr, chunkdata); +- png_warning(png_ptr, "Profile size field missing from iCCP chunk"); +- return; +- } +- +- /* Check the profile_size recorded in the first 32 bits of the ICC profile */ +- pC = (png_bytep)(chunkdata+prefix_length); +- profile_size = ((*(pC ))<<24) | +- ((*(pC+1))<<16) | +- ((*(pC+2))<< 8) | +- ((*(pC+3)) ); +- +- if(profile_size < profile_length) +- profile_length = profile_size; +- +- if(profile_size > profile_length) +- { +- png_free(png_ptr, chunkdata); +- png_warning(png_ptr, "Ignoring truncated iCCP profile.\n"); +- return; +- } +- +- png_set_iCCP(png_ptr, info_ptr, chunkdata, compression_type, +- chunkdata + prefix_length, profile_length); +- png_free(png_ptr, chunkdata); +-} +-#endif /* PNG_READ_iCCP_SUPPORTED */ +- +-#if defined(PNG_READ_sPLT_SUPPORTED) +-void /* PRIVATE */ +-png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-/* Note: this does not properly handle chunks that are > 64K under DOS */ +-{ +- png_bytep chunkdata; +- png_bytep entry_start; +- png_sPLT_t new_palette; +-#ifdef PNG_NO_POINTER_INDEXING +- png_sPLT_entryp pp; +-#endif +- int data_length, entry_size, i; +- png_uint_32 skip = 0; +- png_size_t slength; +- +- png_debug(1, "in png_handle_sPLT\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before sPLT"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- png_warning(png_ptr, "Invalid sPLT after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +-#ifdef PNG_MAX_MALLOC_64K +- if (length > (png_uint_32)65535L) +- { +- png_warning(png_ptr, "sPLT chunk too large to fit in memory"); +- skip = length - (png_uint_32)65535L; +- length = (png_uint_32)65535L; +- } +-#endif +- +- chunkdata = (png_bytep)png_malloc(png_ptr, length + 1); +- slength = (png_size_t)length; +- png_crc_read(png_ptr, (png_bytep)chunkdata, slength); +- +- if (png_crc_finish(png_ptr, skip)) +- { +- png_free(png_ptr, chunkdata); +- return; +- } +- +- chunkdata[slength] = 0x00; +- +- for (entry_start = chunkdata; *entry_start; entry_start++) +- /* empty loop to find end of name */ ; +- ++entry_start; +- +- /* a sample depth should follow the separator, and we should be on it */ +- if (entry_start > chunkdata + slength) +- { +- png_free(png_ptr, chunkdata); +- png_warning(png_ptr, "malformed sPLT chunk"); +- return; +- } +- +- new_palette.depth = *entry_start++; +- entry_size = (new_palette.depth == 8 ? 6 : 10); +- data_length = (slength - (entry_start - chunkdata)); +- +- /* integrity-check the data length */ +- if (data_length % entry_size) +- { +- png_free(png_ptr, chunkdata); +- png_warning(png_ptr, "sPLT chunk has bad length"); +- return; +- } +- +- new_palette.nentries = (png_uint_32) (data_length / entry_size); +- if ((png_uint_32) new_palette.nentries > (png_uint_32) (PNG_SIZE_MAX / +- png_sizeof(png_sPLT_entry))) +- { +- png_warning(png_ptr, "sPLT chunk too long"); +- return; +- } +- new_palette.entries = (png_sPLT_entryp)png_malloc_warn( +- png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry)); +- if (new_palette.entries == NULL) +- { +- png_warning(png_ptr, "sPLT chunk requires too much memory"); +- return; +- } +- +-#ifndef PNG_NO_POINTER_INDEXING +- for (i = 0; i < new_palette.nentries; i++) +- { +- png_sPLT_entryp pp = new_palette.entries + i; +- +- if (new_palette.depth == 8) +- { +- pp->red = *entry_start++; +- pp->green = *entry_start++; +- pp->blue = *entry_start++; +- pp->alpha = *entry_start++; +- } +- else +- { +- pp->red = png_get_uint_16(entry_start); entry_start += 2; +- pp->green = png_get_uint_16(entry_start); entry_start += 2; +- pp->blue = png_get_uint_16(entry_start); entry_start += 2; +- pp->alpha = png_get_uint_16(entry_start); entry_start += 2; +- } +- pp->frequency = png_get_uint_16(entry_start); entry_start += 2; +- } +-#else +- pp = new_palette.entries; +- for (i = 0; i < new_palette.nentries; i++) +- { +- +- if (new_palette.depth == 8) +- { +- pp[i].red = *entry_start++; +- pp[i].green = *entry_start++; +- pp[i].blue = *entry_start++; +- pp[i].alpha = *entry_start++; +- } +- else +- { +- pp[i].red = png_get_uint_16(entry_start); entry_start += 2; +- pp[i].green = png_get_uint_16(entry_start); entry_start += 2; +- pp[i].blue = png_get_uint_16(entry_start); entry_start += 2; +- pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2; +- } +- pp->frequency = png_get_uint_16(entry_start); entry_start += 2; +- } +-#endif +- +- /* discard all chunk data except the name and stash that */ +- new_palette.name = (png_charp)chunkdata; +- +- png_set_sPLT(png_ptr, info_ptr, &new_palette, 1); +- +- png_free(png_ptr, chunkdata); +- png_free(png_ptr, new_palette.entries); +-} +-#endif /* PNG_READ_sPLT_SUPPORTED */ +- +-#if defined(PNG_READ_tRNS_SUPPORTED) +-void /* PRIVATE */ +-png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_byte readbuf[PNG_MAX_PALETTE_LENGTH]; +- +- png_debug(1, "in png_handle_tRNS\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before tRNS"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- png_warning(png_ptr, "Invalid tRNS after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) +- { +- png_warning(png_ptr, "Duplicate tRNS chunk"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) +- { +- png_byte buf[2]; +- +- if (length != 2) +- { +- png_warning(png_ptr, "Incorrect tRNS chunk length"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- png_crc_read(png_ptr, buf, 2); +- png_ptr->num_trans = 1; +- png_ptr->trans_values.gray = png_get_uint_16(buf); +- } +- else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) +- { +- png_byte buf[6]; +- +- if (length != 6) +- { +- png_warning(png_ptr, "Incorrect tRNS chunk length"); +- png_crc_finish(png_ptr, length); +- return; +- } +- png_crc_read(png_ptr, buf, (png_size_t)length); +- png_ptr->num_trans = 1; +- png_ptr->trans_values.red = png_get_uint_16(buf); +- png_ptr->trans_values.green = png_get_uint_16(buf + 2); +- png_ptr->trans_values.blue = png_get_uint_16(buf + 4); +- } +- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- { +- if (!(png_ptr->mode & PNG_HAVE_PLTE)) +- { +- /* Should be an error, but we can cope with it. */ +- png_warning(png_ptr, "Missing PLTE before tRNS"); +- } +- if (length > (png_uint_32)png_ptr->num_palette || +- length > PNG_MAX_PALETTE_LENGTH) +- { +- png_warning(png_ptr, "Incorrect tRNS chunk length"); +- png_crc_finish(png_ptr, length); +- return; +- } +- if (length == 0) +- { +- png_warning(png_ptr, "Zero length tRNS chunk"); +- png_crc_finish(png_ptr, length); +- return; +- } +- png_crc_read(png_ptr, readbuf, (png_size_t)length); +- png_ptr->num_trans = (png_uint_16)length; +- } +- else +- { +- png_warning(png_ptr, "tRNS chunk not allowed with alpha channel"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- if (png_crc_finish(png_ptr, 0)) +- return; +- +- png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans, +- &(png_ptr->trans_values)); +-} +-#endif +- +-#if defined(PNG_READ_bKGD_SUPPORTED) +-void /* PRIVATE */ +-png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_size_t truelen; +- png_byte buf[6]; +- +- png_debug(1, "in png_handle_bKGD\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before bKGD"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- png_warning(png_ptr, "Invalid bKGD after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && +- !(png_ptr->mode & PNG_HAVE_PLTE)) +- { +- png_warning(png_ptr, "Missing PLTE before bKGD"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)) +- { +- png_warning(png_ptr, "Duplicate bKGD chunk"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- truelen = 1; +- else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) +- truelen = 6; +- else +- truelen = 2; +- +- if (length != truelen) +- { +- png_warning(png_ptr, "Incorrect bKGD chunk length"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- png_crc_read(png_ptr, buf, truelen); +- if (png_crc_finish(png_ptr, 0)) +- return; +- +- /* We convert the index value into RGB components so that we can allow +- * arbitrary RGB values for background when we have transparency, and +- * so it is easy to determine the RGB values of the background color +- * from the info_ptr struct. */ +- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- { +- png_ptr->background.index = buf[0]; +- if(info_ptr->num_palette) +- { +- if(buf[0] > info_ptr->num_palette) +- { +- png_warning(png_ptr, "Incorrect bKGD chunk index value"); +- return; +- } +- png_ptr->background.red = +- (png_uint_16)png_ptr->palette[buf[0]].red; +- png_ptr->background.green = +- (png_uint_16)png_ptr->palette[buf[0]].green; +- png_ptr->background.blue = +- (png_uint_16)png_ptr->palette[buf[0]].blue; +- } +- } +- else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */ +- { +- png_ptr->background.red = +- png_ptr->background.green = +- png_ptr->background.blue = +- png_ptr->background.gray = png_get_uint_16(buf); +- } +- else +- { +- png_ptr->background.red = png_get_uint_16(buf); +- png_ptr->background.green = png_get_uint_16(buf + 2); +- png_ptr->background.blue = png_get_uint_16(buf + 4); +- } +- +- png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background)); +-} +-#endif +- +-#if defined(PNG_READ_hIST_SUPPORTED) +-void /* PRIVATE */ +-png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- unsigned int num, i; +- png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH]; +- +- png_debug(1, "in png_handle_hIST\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before hIST"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- png_warning(png_ptr, "Invalid hIST after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (!(png_ptr->mode & PNG_HAVE_PLTE)) +- { +- png_warning(png_ptr, "Missing PLTE before hIST"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)) +- { +- png_warning(png_ptr, "Duplicate hIST chunk"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- num = length / 2 ; +- if (num != (unsigned int) png_ptr->num_palette || num > +- (unsigned int) PNG_MAX_PALETTE_LENGTH) +- { +- png_warning(png_ptr, "Incorrect hIST chunk length"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- for (i = 0; i < num; i++) +- { +- png_byte buf[2]; +- +- png_crc_read(png_ptr, buf, 2); +- readbuf[i] = png_get_uint_16(buf); +- } +- +- if (png_crc_finish(png_ptr, 0)) +- return; +- +- png_set_hIST(png_ptr, info_ptr, readbuf); +-} +-#endif +- +-#if defined(PNG_READ_pHYs_SUPPORTED) +-void /* PRIVATE */ +-png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_byte buf[9]; +- png_uint_32 res_x, res_y; +- int unit_type; +- +- png_debug(1, "in png_handle_pHYs\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before pHYs"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- png_warning(png_ptr, "Invalid pHYs after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) +- { +- png_warning(png_ptr, "Duplicate pHYs chunk"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- if (length != 9) +- { +- png_warning(png_ptr, "Incorrect pHYs chunk length"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- png_crc_read(png_ptr, buf, 9); +- if (png_crc_finish(png_ptr, 0)) +- return; +- +- res_x = png_get_uint_32(buf); +- res_y = png_get_uint_32(buf + 4); +- unit_type = buf[8]; +- png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type); +-} +-#endif +- +-#if defined(PNG_READ_oFFs_SUPPORTED) +-void /* PRIVATE */ +-png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_byte buf[9]; +- png_int_32 offset_x, offset_y; +- int unit_type; +- +- png_debug(1, "in png_handle_oFFs\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before oFFs"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- png_warning(png_ptr, "Invalid oFFs after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) +- { +- png_warning(png_ptr, "Duplicate oFFs chunk"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- if (length != 9) +- { +- png_warning(png_ptr, "Incorrect oFFs chunk length"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- png_crc_read(png_ptr, buf, 9); +- if (png_crc_finish(png_ptr, 0)) +- return; +- +- offset_x = png_get_int_32(buf); +- offset_y = png_get_int_32(buf + 4); +- unit_type = buf[8]; +- png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type); +-} +-#endif +- +-#if defined(PNG_READ_pCAL_SUPPORTED) +-/* read the pCAL chunk (described in the PNG Extensions document) */ +-void /* PRIVATE */ +-png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_charp purpose; +- png_int_32 X0, X1; +- png_byte type, nparams; +- png_charp buf, units, endptr; +- png_charpp params; +- png_size_t slength; +- int i; +- +- png_debug(1, "in png_handle_pCAL\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before pCAL"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- png_warning(png_ptr, "Invalid pCAL after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)) +- { +- png_warning(png_ptr, "Duplicate pCAL chunk"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- png_debug1(2, "Allocating and reading pCAL chunk data (%lu bytes)\n", +- length + 1); +- purpose = (png_charp)png_malloc_warn(png_ptr, length + 1); +- if (purpose == NULL) +- { +- png_warning(png_ptr, "No memory for pCAL purpose."); +- return; +- } +- slength = (png_size_t)length; +- png_crc_read(png_ptr, (png_bytep)purpose, slength); +- +- if (png_crc_finish(png_ptr, 0)) +- { +- png_free(png_ptr, purpose); +- return; +- } +- +- purpose[slength] = 0x00; /* null terminate the last string */ +- +- png_debug(3, "Finding end of pCAL purpose string\n"); +- for (buf = purpose; *buf; buf++) +- /* empty loop */ ; +- +- endptr = purpose + slength; +- +- /* We need to have at least 12 bytes after the purpose string +- in order to get the parameter information. */ +- if (endptr <= buf + 12) +- { +- png_warning(png_ptr, "Invalid pCAL data"); +- png_free(png_ptr, purpose); +- return; +- } +- +- png_debug(3, "Reading pCAL X0, X1, type, nparams, and units\n"); +- X0 = png_get_int_32((png_bytep)buf+1); +- X1 = png_get_int_32((png_bytep)buf+5); +- type = buf[9]; +- nparams = buf[10]; +- units = buf + 11; +- +- png_debug(3, "Checking pCAL equation type and number of parameters\n"); +- /* Check that we have the right number of parameters for known +- equation types. */ +- if ((type == PNG_EQUATION_LINEAR && nparams != 2) || +- (type == PNG_EQUATION_BASE_E && nparams != 3) || +- (type == PNG_EQUATION_ARBITRARY && nparams != 3) || +- (type == PNG_EQUATION_HYPERBOLIC && nparams != 4)) +- { +- png_warning(png_ptr, "Invalid pCAL parameters for equation type"); +- png_free(png_ptr, purpose); +- return; +- } +- else if (type >= PNG_EQUATION_LAST) +- { +- png_warning(png_ptr, "Unrecognized equation type for pCAL chunk"); +- } +- +- for (buf = units; *buf; buf++) +- /* Empty loop to move past the units string. */ ; +- +- png_debug(3, "Allocating pCAL parameters array\n"); +- params = (png_charpp)png_malloc_warn(png_ptr, (png_uint_32)(nparams +- *png_sizeof(png_charp))) ; +- if (params == NULL) +- { +- png_free(png_ptr, purpose); +- png_warning(png_ptr, "No memory for pCAL params."); +- return; +- } +- +- /* Get pointers to the start of each parameter string. */ +- for (i = 0; i < (int)nparams; i++) +- { +- buf++; /* Skip the null string terminator from previous parameter. */ +- +- png_debug1(3, "Reading pCAL parameter %d\n", i); +- for (params[i] = buf; *buf != 0x00 && buf <= endptr; buf++) +- /* Empty loop to move past each parameter string */ ; +- +- /* Make sure we haven't run out of data yet */ +- if (buf > endptr) +- { +- png_warning(png_ptr, "Invalid pCAL data"); +- png_free(png_ptr, purpose); +- png_free(png_ptr, params); +- return; +- } +- } +- +- png_set_pCAL(png_ptr, info_ptr, purpose, X0, X1, type, nparams, +- units, params); +- +- png_free(png_ptr, purpose); +- png_free(png_ptr, params); +-} +-#endif +- +-#if defined(PNG_READ_sCAL_SUPPORTED) +-/* read the sCAL chunk */ +-void /* PRIVATE */ +-png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_charp buffer, ep; +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- double width, height; +- png_charp vp; +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +- png_charp swidth, sheight; +-#endif +-#endif +- png_size_t slength; +- +- png_debug(1, "in png_handle_sCAL\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before sCAL"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- png_warning(png_ptr, "Invalid sCAL after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL)) +- { +- png_warning(png_ptr, "Duplicate sCAL chunk"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)\n", +- length + 1); +- buffer = (png_charp)png_malloc_warn(png_ptr, length + 1); +- if (buffer == NULL) +- { +- png_warning(png_ptr, "Out of memory while processing sCAL chunk"); +- return; +- } +- slength = (png_size_t)length; +- png_crc_read(png_ptr, (png_bytep)buffer, slength); +- +- if (png_crc_finish(png_ptr, 0)) +- { +- png_free(png_ptr, buffer); +- return; +- } +- +- buffer[slength] = 0x00; /* null terminate the last string */ +- +- ep = buffer + 1; /* skip unit byte */ +- +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- width = strtod(ep, &vp); +- if (*vp) +- { +- png_warning(png_ptr, "malformed width string in sCAL chunk"); +- return; +- } +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +- swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1); +- if (swidth == NULL) +- { +- png_warning(png_ptr, "Out of memory while processing sCAL chunk width"); +- return; +- } +- png_memcpy(swidth, ep, (png_size_t)png_strlen(ep)); +-#endif +-#endif +- +- for (ep = buffer; *ep; ep++) +- /* empty loop */ ; +- ep++; +- +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- height = strtod(ep, &vp); +- if (*vp) +- { +- png_warning(png_ptr, "malformed height string in sCAL chunk"); +- return; +- } +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +- sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1); +- if (swidth == NULL) +- { +- png_warning(png_ptr, "Out of memory while processing sCAL chunk height"); +- return; +- } +- png_memcpy(sheight, ep, (png_size_t)png_strlen(ep)); +-#endif +-#endif +- +- if (buffer + slength < ep +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- || width <= 0. || height <= 0. +-#endif +- ) +- { +- png_warning(png_ptr, "Invalid sCAL data"); +- png_free(png_ptr, buffer); +-#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) +- png_free(png_ptr, swidth); +- png_free(png_ptr, sheight); +-#endif +- return; +- } +- +- +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- png_set_sCAL(png_ptr, info_ptr, buffer[0], width, height); +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +- png_set_sCAL_s(png_ptr, info_ptr, buffer[0], swidth, sheight); +-#endif +-#endif +- +- png_free(png_ptr, buffer); +-#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) +- png_free(png_ptr, swidth); +- png_free(png_ptr, sheight); +-#endif +-} +-#endif +- +-#if defined(PNG_READ_tIME_SUPPORTED) +-void /* PRIVATE */ +-png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_byte buf[7]; +- png_time mod_time; +- +- png_debug(1, "in png_handle_tIME\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Out of place tIME chunk"); +- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)) +- { +- png_warning(png_ptr, "Duplicate tIME chunk"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- if (png_ptr->mode & PNG_HAVE_IDAT) +- png_ptr->mode |= PNG_AFTER_IDAT; +- +- if (length != 7) +- { +- png_warning(png_ptr, "Incorrect tIME chunk length"); +- png_crc_finish(png_ptr, length); +- return; +- } +- +- png_crc_read(png_ptr, buf, 7); +- if (png_crc_finish(png_ptr, 0)) +- return; +- +- mod_time.second = buf[6]; +- mod_time.minute = buf[5]; +- mod_time.hour = buf[4]; +- mod_time.day = buf[3]; +- mod_time.month = buf[2]; +- mod_time.year = png_get_uint_16(buf); +- +- png_set_tIME(png_ptr, info_ptr, &mod_time); +-} +-#endif +- +-#if defined(PNG_READ_tEXt_SUPPORTED) +-/* Note: this does not properly handle chunks that are > 64K under DOS */ +-void /* PRIVATE */ +-png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_textp text_ptr; +- png_charp key; +- png_charp text; +- png_uint_32 skip = 0; +- png_size_t slength; +- int ret; +- +- png_debug(1, "in png_handle_tEXt\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before tEXt"); +- +- if (png_ptr->mode & PNG_HAVE_IDAT) +- png_ptr->mode |= PNG_AFTER_IDAT; +- +-#ifdef PNG_MAX_MALLOC_64K +- if (length > (png_uint_32)65535L) +- { +- png_warning(png_ptr, "tEXt chunk too large to fit in memory"); +- skip = length - (png_uint_32)65535L; +- length = (png_uint_32)65535L; +- } +-#endif +- +- key = (png_charp)png_malloc_warn(png_ptr, length + 1); +- if (key == NULL) +- { +- png_warning(png_ptr, "No memory to process text chunk."); +- return; +- } +- slength = (png_size_t)length; +- png_crc_read(png_ptr, (png_bytep)key, slength); +- +- if (png_crc_finish(png_ptr, skip)) +- { +- png_free(png_ptr, key); +- return; +- } +- +- key[slength] = 0x00; +- +- for (text = key; *text; text++) +- /* empty loop to find end of key */ ; +- +- if (text != key + slength) +- text++; +- +- text_ptr = (png_textp)png_malloc_warn(png_ptr, +- (png_uint_32)png_sizeof(png_text)); +- if (text_ptr == NULL) +- { +- png_warning(png_ptr, "Not enough memory to process text chunk."); +- png_free(png_ptr, key); +- return; +- } +- text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; +- text_ptr->key = key; +-#ifdef PNG_iTXt_SUPPORTED +- text_ptr->lang = NULL; +- text_ptr->lang_key = NULL; +- text_ptr->itxt_length = 0; +-#endif +- text_ptr->text = text; +- text_ptr->text_length = png_strlen(text); +- +- ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1); +- +- png_free(png_ptr, key); +- png_free(png_ptr, text_ptr); +- if (ret) +- png_warning(png_ptr, "Insufficient memory to process text chunk."); +-} +-#endif +- +-#if defined(PNG_READ_zTXt_SUPPORTED) +-/* note: this does not correctly handle chunks that are > 64K under DOS */ +-void /* PRIVATE */ +-png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_textp text_ptr; +- png_charp chunkdata; +- png_charp text; +- int comp_type; +- int ret; +- png_size_t slength, prefix_len, data_len; +- +- png_debug(1, "in png_handle_zTXt\n"); +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before zTXt"); +- +- if (png_ptr->mode & PNG_HAVE_IDAT) +- png_ptr->mode |= PNG_AFTER_IDAT; +- +-#ifdef PNG_MAX_MALLOC_64K +- /* We will no doubt have problems with chunks even half this size, but +- there is no hard and fast rule to tell us where to stop. */ +- if (length > (png_uint_32)65535L) +- { +- png_warning(png_ptr,"zTXt chunk too large to fit in memory"); +- png_crc_finish(png_ptr, length); +- return; +- } +-#endif +- +- chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); +- if (chunkdata == NULL) +- { +- png_warning(png_ptr,"Out of memory processing zTXt chunk."); +- return; +- } +- slength = (png_size_t)length; +- png_crc_read(png_ptr, (png_bytep)chunkdata, slength); +- if (png_crc_finish(png_ptr, 0)) +- { +- png_free(png_ptr, chunkdata); +- return; +- } +- +- chunkdata[slength] = 0x00; +- +- for (text = chunkdata; *text; text++) +- /* empty loop */ ; +- +- /* zTXt must have some text after the chunkdataword */ +- if (text == chunkdata + slength) +- { +- comp_type = PNG_TEXT_COMPRESSION_NONE; +- png_warning(png_ptr, "Zero length zTXt chunk"); +- } +- else +- { +- comp_type = *(++text); +- if (comp_type != PNG_TEXT_COMPRESSION_zTXt) +- { +- png_warning(png_ptr, "Unknown compression type in zTXt chunk"); +- comp_type = PNG_TEXT_COMPRESSION_zTXt; +- } +- text++; /* skip the compression_method byte */ +- } +- prefix_len = text - chunkdata; +- +- chunkdata = (png_charp)png_decompress_chunk(png_ptr, comp_type, chunkdata, +- (png_size_t)length, prefix_len, &data_len); +- +- text_ptr = (png_textp)png_malloc_warn(png_ptr, +- (png_uint_32)png_sizeof(png_text)); +- if (text_ptr == NULL) +- { +- png_warning(png_ptr,"Not enough memory to process zTXt chunk."); +- png_free(png_ptr, chunkdata); +- return; +- } +- text_ptr->compression = comp_type; +- text_ptr->key = chunkdata; +-#ifdef PNG_iTXt_SUPPORTED +- text_ptr->lang = NULL; +- text_ptr->lang_key = NULL; +- text_ptr->itxt_length = 0; +-#endif +- text_ptr->text = chunkdata + prefix_len; +- text_ptr->text_length = data_len; +- +- ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1); +- +- png_free(png_ptr, text_ptr); +- png_free(png_ptr, chunkdata); +- if (ret) +- png_error(png_ptr, "Insufficient memory to store zTXt chunk."); +-} +-#endif +- +-#if defined(PNG_READ_iTXt_SUPPORTED) +-/* note: this does not correctly handle chunks that are > 64K under DOS */ +-void /* PRIVATE */ +-png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_textp text_ptr; +- png_charp chunkdata; +- png_charp key, lang, text, lang_key; +- int comp_flag; +- int comp_type = 0; +- int ret; +- png_size_t slength, prefix_len, data_len; +- +- png_debug(1, "in png_handle_iTXt\n"); +- +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before iTXt"); +- +- if (png_ptr->mode & PNG_HAVE_IDAT) +- png_ptr->mode |= PNG_AFTER_IDAT; +- +-#ifdef PNG_MAX_MALLOC_64K +- /* We will no doubt have problems with chunks even half this size, but +- there is no hard and fast rule to tell us where to stop. */ +- if (length > (png_uint_32)65535L) +- { +- png_warning(png_ptr,"iTXt chunk too large to fit in memory"); +- png_crc_finish(png_ptr, length); +- return; +- } +-#endif +- +- chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); +- if (chunkdata == NULL) +- { +- png_warning(png_ptr, "No memory to process iTXt chunk."); +- return; +- } +- slength = (png_size_t)length; +- png_crc_read(png_ptr, (png_bytep)chunkdata, slength); +- if (png_crc_finish(png_ptr, 0)) +- { +- png_free(png_ptr, chunkdata); +- return; +- } +- +- chunkdata[slength] = 0x00; +- +- for (lang = chunkdata; *lang; lang++) +- /* empty loop */ ; +- lang++; /* skip NUL separator */ +- +- /* iTXt must have a language tag (possibly empty), two compression bytes, +- translated keyword (possibly empty), and possibly some text after the +- keyword */ +- +- if (lang >= chunkdata + slength) +- { +- comp_flag = PNG_TEXT_COMPRESSION_NONE; +- png_warning(png_ptr, "Zero length iTXt chunk"); +- } +- else +- { +- comp_flag = *lang++; +- comp_type = *lang++; +- } +- +- for (lang_key = lang; *lang_key; lang_key++) +- /* empty loop */ ; +- lang_key++; /* skip NUL separator */ +- +- for (text = lang_key; *text; text++) +- /* empty loop */ ; +- text++; /* skip NUL separator */ +- +- prefix_len = text - chunkdata; +- +- key=chunkdata; +- if (comp_flag) +- chunkdata = png_decompress_chunk(png_ptr, comp_type, chunkdata, +- (size_t)length, prefix_len, &data_len); +- else +- data_len=png_strlen(chunkdata + prefix_len); +- text_ptr = (png_textp)png_malloc_warn(png_ptr, +- (png_uint_32)png_sizeof(png_text)); +- if (text_ptr == NULL) +- { +- png_warning(png_ptr,"Not enough memory to process iTXt chunk."); +- png_free(png_ptr, chunkdata); +- return; +- } +- text_ptr->compression = (int)comp_flag + 1; +- text_ptr->lang_key = chunkdata+(lang_key-key); +- text_ptr->lang = chunkdata+(lang-key); +- text_ptr->itxt_length = data_len; +- text_ptr->text_length = 0; +- text_ptr->key = chunkdata; +- text_ptr->text = chunkdata + prefix_len; +- +- ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1); +- +- png_free(png_ptr, text_ptr); +- png_free(png_ptr, chunkdata); +- if (ret) +- png_error(png_ptr, "Insufficient memory to store iTXt chunk."); +-} +-#endif +- +-/* This function is called when we haven't found a handler for a +- chunk. If there isn't a problem with the chunk itself (ie bad +- chunk name, CRC, or a critical chunk), the chunk is silently ignored +- -- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which +- case it will be saved away to be written out later. */ +-void /* PRIVATE */ +-png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_uint_32 skip = 0; +- +- png_debug(1, "in png_handle_unknown\n"); +- +- if (png_ptr->mode & PNG_HAVE_IDAT) +- { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_IDAT; +-#endif +- if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* not an IDAT */ +- png_ptr->mode |= PNG_AFTER_IDAT; +- } +- +- png_check_chunk_name(png_ptr, png_ptr->chunk_name); +- +- if (!(png_ptr->chunk_name[0] & 0x20)) +- { +-#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) +- if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != +- PNG_HANDLE_CHUNK_ALWAYS +-#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) +- && png_ptr->read_user_chunk_fn == NULL +-#endif +- ) +-#endif +- png_chunk_error(png_ptr, "unknown critical chunk"); +- } +- +-#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) +- if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) +- { +- png_unknown_chunk chunk; +- +-#ifdef PNG_MAX_MALLOC_64K +- if (length > (png_uint_32)65535L) +- { +- png_warning(png_ptr, "unknown chunk too large to fit in memory"); +- skip = length - (png_uint_32)65535L; +- length = (png_uint_32)65535L; +- } +-#endif +- png_strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name); +- chunk.data = (png_bytep)png_malloc(png_ptr, length); +- chunk.size = (png_size_t)length; +- png_crc_read(png_ptr, (png_bytep)chunk.data, length); +-#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) +- if(png_ptr->read_user_chunk_fn != NULL) +- { +- /* callback to user unknown chunk handler */ +- if ((*(png_ptr->read_user_chunk_fn)) (png_ptr, &chunk) <= 0) +- { +- if (!(png_ptr->chunk_name[0] & 0x20)) +- if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != +- PNG_HANDLE_CHUNK_ALWAYS) +- { +- png_free(png_ptr, chunk.data); +- png_chunk_error(png_ptr, "unknown critical chunk"); +- } +- png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); +- } +- } +- else +-#endif +- png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); +- png_free(png_ptr, chunk.data); +- } +- else +-#endif +- skip = length; +- +- png_crc_finish(png_ptr, skip); +- +-#if !defined(PNG_READ_USER_CHUNKS_SUPPORTED) +- if (&info_ptr == NULL) /* quiet compiler warnings about unused info_ptr */ +- return; +-#endif +-} +- +-/* This function is called to verify that a chunk name is valid. +- This function can't have the "critical chunk check" incorporated +- into it, since in the future we will need to be able to call user +- functions to handle unknown critical chunks after we check that +- the chunk name itself is valid. */ +- +-#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97)) +- +-void /* PRIVATE */ +-png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name) +-{ +- png_debug(1, "in png_check_chunk_name\n"); +- if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) || +- isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3])) +- { +- png_chunk_error(png_ptr, "invalid chunk type"); +- } +-} +- +-/* Combines the row recently read in with the existing pixels in the +- row. This routine takes care of alpha and transparency if requested. +- This routine also handles the two methods of progressive display +- of interlaced images, depending on the mask value. +- The mask value describes which pixels are to be combined with +- the row. The pattern always repeats every 8 pixels, so just 8 +- bits are needed. A one indicates the pixel is to be combined, +- a zero indicates the pixel is to be skipped. This is in addition +- to any alpha or transparency value associated with the pixel. If +- you want all pixels to be combined, pass 0xff (255) in mask. */ +-#ifndef PNG_HAVE_ASSEMBLER_COMBINE_ROW +-void /* PRIVATE */ +-png_combine_row(png_structp png_ptr, png_bytep row, int mask) +-{ +- png_debug(1,"in png_combine_row\n"); +- if (mask == 0xff) +- { +- png_memcpy(row, png_ptr->row_buf + 1, +- PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width)); +- } +- else +- { +- switch (png_ptr->row_info.pixel_depth) +- { +- case 1: +- { +- png_bytep sp = png_ptr->row_buf + 1; +- png_bytep dp = row; +- int s_inc, s_start, s_end; +- int m = 0x80; +- int shift; +- png_uint_32 i; +- png_uint_32 row_width = png_ptr->width; +- +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_PACKSWAP) +- { +- s_start = 0; +- s_end = 7; +- s_inc = 1; +- } +- else +-#endif +- { +- s_start = 7; +- s_end = 0; +- s_inc = -1; +- } +- +- shift = s_start; +- +- for (i = 0; i < row_width; i++) +- { +- if (m & mask) +- { +- int value; +- +- value = (*sp >> shift) & 0x01; +- *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); +- *dp |= (png_byte)(value << shift); +- } +- +- if (shift == s_end) +- { +- shift = s_start; +- sp++; +- dp++; +- } +- else +- shift += s_inc; +- +- if (m == 1) +- m = 0x80; +- else +- m >>= 1; +- } +- break; +- } +- case 2: +- { +- png_bytep sp = png_ptr->row_buf + 1; +- png_bytep dp = row; +- int s_start, s_end, s_inc; +- int m = 0x80; +- int shift; +- png_uint_32 i; +- png_uint_32 row_width = png_ptr->width; +- int value; +- +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_PACKSWAP) +- { +- s_start = 0; +- s_end = 6; +- s_inc = 2; +- } +- else +-#endif +- { +- s_start = 6; +- s_end = 0; +- s_inc = -2; +- } +- +- shift = s_start; +- +- for (i = 0; i < row_width; i++) +- { +- if (m & mask) +- { +- value = (*sp >> shift) & 0x03; +- *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); +- *dp |= (png_byte)(value << shift); +- } +- +- if (shift == s_end) +- { +- shift = s_start; +- sp++; +- dp++; +- } +- else +- shift += s_inc; +- if (m == 1) +- m = 0x80; +- else +- m >>= 1; +- } +- break; +- } +- case 4: +- { +- png_bytep sp = png_ptr->row_buf + 1; +- png_bytep dp = row; +- int s_start, s_end, s_inc; +- int m = 0x80; +- int shift; +- png_uint_32 i; +- png_uint_32 row_width = png_ptr->width; +- int value; +- +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_PACKSWAP) +- { +- s_start = 0; +- s_end = 4; +- s_inc = 4; +- } +- else +-#endif +- { +- s_start = 4; +- s_end = 0; +- s_inc = -4; +- } +- shift = s_start; +- +- for (i = 0; i < row_width; i++) +- { +- if (m & mask) +- { +- value = (*sp >> shift) & 0xf; +- *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); +- *dp |= (png_byte)(value << shift); +- } +- +- if (shift == s_end) +- { +- shift = s_start; +- sp++; +- dp++; +- } +- else +- shift += s_inc; +- if (m == 1) +- m = 0x80; +- else +- m >>= 1; +- } +- break; +- } +- default: +- { +- png_bytep sp = png_ptr->row_buf + 1; +- png_bytep dp = row; +- png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); +- png_uint_32 i; +- png_uint_32 row_width = png_ptr->width; +- png_byte m = 0x80; +- +- +- for (i = 0; i < row_width; i++) +- { +- if (m & mask) +- { +- png_memcpy(dp, sp, pixel_bytes); +- } +- +- sp += pixel_bytes; +- dp += pixel_bytes; +- +- if (m == 1) +- m = 0x80; +- else +- m >>= 1; +- } +- break; +- } +- } +- } +-} +-#endif /* !PNG_HAVE_ASSEMBLER_COMBINE_ROW */ +- +-#ifdef PNG_READ_INTERLACING_SUPPORTED +-#ifndef PNG_HAVE_ASSEMBLER_READ_INTERLACE /* else in pngvcrd.c, pnggccrd.c */ +-/* OLD pre-1.0.9 interface: +-void png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass, +- png_uint_32 transformations) +- */ +-void /* PRIVATE */ +-png_do_read_interlace(png_structp png_ptr) +-{ +- png_row_infop row_info = &(png_ptr->row_info); +- png_bytep row = png_ptr->row_buf + 1; +- int pass = png_ptr->pass; +- png_uint_32 transformations = png_ptr->transformations; +-#ifdef PNG_USE_LOCAL_ARRAYS +- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ +- /* offset to next interlace block */ +- const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; +-#endif +- +- png_debug(1,"in png_do_read_interlace (stock C version)\n"); +- if (row != NULL && row_info != NULL) +- { +- png_uint_32 final_width; +- +- final_width = row_info->width * png_pass_inc[pass]; +- +- switch (row_info->pixel_depth) +- { +- case 1: +- { +- png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3); +- png_bytep dp = row + (png_size_t)((final_width - 1) >> 3); +- int sshift, dshift; +- int s_start, s_end, s_inc; +- int jstop = png_pass_inc[pass]; +- png_byte v; +- png_uint_32 i; +- int j; +- +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (transformations & PNG_PACKSWAP) +- { +- sshift = (int)((row_info->width + 7) & 0x07); +- dshift = (int)((final_width + 7) & 0x07); +- s_start = 7; +- s_end = 0; +- s_inc = -1; +- } +- else +-#endif +- { +- sshift = 7 - (int)((row_info->width + 7) & 0x07); +- dshift = 7 - (int)((final_width + 7) & 0x07); +- s_start = 0; +- s_end = 7; +- s_inc = 1; +- } +- +- for (i = 0; i < row_info->width; i++) +- { +- v = (png_byte)((*sp >> sshift) & 0x01); +- for (j = 0; j < jstop; j++) +- { +- *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff); +- *dp |= (png_byte)(v << dshift); +- if (dshift == s_end) +- { +- dshift = s_start; +- dp--; +- } +- else +- dshift += s_inc; +- } +- if (sshift == s_end) +- { +- sshift = s_start; +- sp--; +- } +- else +- sshift += s_inc; +- } +- break; +- } +- case 2: +- { +- png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2); +- png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2); +- int sshift, dshift; +- int s_start, s_end, s_inc; +- int jstop = png_pass_inc[pass]; +- png_uint_32 i; +- +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (transformations & PNG_PACKSWAP) +- { +- sshift = (int)(((row_info->width + 3) & 0x03) << 1); +- dshift = (int)(((final_width + 3) & 0x03) << 1); +- s_start = 6; +- s_end = 0; +- s_inc = -2; +- } +- else +-#endif +- { +- sshift = (int)((3 - ((row_info->width + 3) & 0x03)) << 1); +- dshift = (int)((3 - ((final_width + 3) & 0x03)) << 1); +- s_start = 0; +- s_end = 6; +- s_inc = 2; +- } +- +- for (i = 0; i < row_info->width; i++) +- { +- png_byte v; +- int j; +- +- v = (png_byte)((*sp >> sshift) & 0x03); +- for (j = 0; j < jstop; j++) +- { +- *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff); +- *dp |= (png_byte)(v << dshift); +- if (dshift == s_end) +- { +- dshift = s_start; +- dp--; +- } +- else +- dshift += s_inc; +- } +- if (sshift == s_end) +- { +- sshift = s_start; +- sp--; +- } +- else +- sshift += s_inc; +- } +- break; +- } +- case 4: +- { +- png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1); +- png_bytep dp = row + (png_size_t)((final_width - 1) >> 1); +- int sshift, dshift; +- int s_start, s_end, s_inc; +- png_uint_32 i; +- int jstop = png_pass_inc[pass]; +- +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (transformations & PNG_PACKSWAP) +- { +- sshift = (int)(((row_info->width + 1) & 0x01) << 2); +- dshift = (int)(((final_width + 1) & 0x01) << 2); +- s_start = 4; +- s_end = 0; +- s_inc = -4; +- } +- else +-#endif +- { +- sshift = (int)((1 - ((row_info->width + 1) & 0x01)) << 2); +- dshift = (int)((1 - ((final_width + 1) & 0x01)) << 2); +- s_start = 0; +- s_end = 4; +- s_inc = 4; +- } +- +- for (i = 0; i < row_info->width; i++) +- { +- png_byte v = (png_byte)((*sp >> sshift) & 0xf); +- int j; +- +- for (j = 0; j < jstop; j++) +- { +- *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff); +- *dp |= (png_byte)(v << dshift); +- if (dshift == s_end) +- { +- dshift = s_start; +- dp--; +- } +- else +- dshift += s_inc; +- } +- if (sshift == s_end) +- { +- sshift = s_start; +- sp--; +- } +- else +- sshift += s_inc; +- } +- break; +- } +- default: +- { +- png_size_t pixel_bytes = (row_info->pixel_depth >> 3); +- png_bytep sp = row + (png_size_t)(row_info->width - 1) * pixel_bytes; +- png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes; +- +- int jstop = png_pass_inc[pass]; +- png_uint_32 i; +- +- for (i = 0; i < row_info->width; i++) +- { +- png_byte v[8]; +- int j; +- +- png_memcpy(v, sp, pixel_bytes); +- for (j = 0; j < jstop; j++) +- { +- png_memcpy(dp, v, pixel_bytes); +- dp -= pixel_bytes; +- } +- sp -= pixel_bytes; +- } +- break; +- } +- } +- row_info->width = final_width; +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,final_width); +- } +-#if !defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (&transformations == NULL) /* silence compiler warning */ +- return; +-#endif +-} +-#endif /* !PNG_HAVE_ASSEMBLER_READ_INTERLACE */ +-#endif /* PNG_READ_INTERLACING_SUPPORTED */ +- +-#ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW +-void /* PRIVATE */ +-png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row, +- png_bytep prev_row, int filter) +-{ +- png_debug(1, "in png_read_filter_row\n"); +- png_debug2(2,"row = %lu, filter = %d\n", png_ptr->row_number, filter); +- switch (filter) +- { +- case PNG_FILTER_VALUE_NONE: +- break; +- case PNG_FILTER_VALUE_SUB: +- { +- png_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; +- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; +- png_bytep rp = row + bpp; +- png_bytep lp = row; +- +- for (i = bpp; i < istop; i++) +- { +- *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff); +- rp++; +- } +- break; +- } +- case PNG_FILTER_VALUE_UP: +- { +- png_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; +- png_bytep rp = row; +- png_bytep pp = prev_row; +- +- for (i = 0; i < istop; i++) +- { +- *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); +- rp++; +- } +- break; +- } +- case PNG_FILTER_VALUE_AVG: +- { +- png_uint_32 i; +- png_bytep rp = row; +- png_bytep pp = prev_row; +- png_bytep lp = row; +- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; +- png_uint_32 istop = row_info->rowbytes - bpp; +- +- for (i = 0; i < bpp; i++) +- { +- *rp = (png_byte)(((int)(*rp) + +- ((int)(*pp++) / 2 )) & 0xff); +- rp++; +- } +- +- for (i = 0; i < istop; i++) +- { +- *rp = (png_byte)(((int)(*rp) + +- (int)(*pp++ + *lp++) / 2 ) & 0xff); +- rp++; +- } +- break; +- } +- case PNG_FILTER_VALUE_PAETH: +- { +- png_uint_32 i; +- png_bytep rp = row; +- png_bytep pp = prev_row; +- png_bytep lp = row; +- png_bytep cp = prev_row; +- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; +- png_uint_32 istop=row_info->rowbytes - bpp; +- +- for (i = 0; i < bpp; i++) +- { +- *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); +- rp++; +- } +- +- for (i = 0; i < istop; i++) /* use leftover rp,pp */ +- { +- int a, b, c, pa, pb, pc, p; +- +- a = *lp++; +- b = *pp++; +- c = *cp++; +- +- p = b - c; +- pc = a - c; +- +-#ifdef PNG_USE_ABS +- pa = abs(p); +- pb = abs(pc); +- pc = abs(p + pc); +-#else +- pa = p < 0 ? -p : p; +- pb = pc < 0 ? -pc : pc; +- pc = (p + pc) < 0 ? -(p + pc) : p + pc; +-#endif +- +- /* +- if (pa <= pb && pa <= pc) +- p = a; +- else if (pb <= pc) +- p = b; +- else +- p = c; +- */ +- +- p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; +- +- *rp = (png_byte)(((int)(*rp) + p) & 0xff); +- rp++; +- } +- break; +- } +- default: +- png_warning(png_ptr, "Ignoring bad adaptive filter type"); +- *row=0; +- break; +- } +-} +-#endif /* !PNG_HAVE_ASSEMBLER_READ_FILTER_ROW */ +- +-void /* PRIVATE */ +-png_read_finish_row(png_structp png_ptr) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ +- +- /* start of interlace block */ +- const int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; +- +- /* offset to next interlace block */ +- const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; +- +- /* start of interlace block in the y direction */ +- const int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; +- +- /* offset to next interlace block in the y direction */ +- const int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; +-#endif +- +- png_debug(1, "in png_read_finish_row\n"); +- png_ptr->row_number++; +- if (png_ptr->row_number < png_ptr->num_rows) +- return; +- +- if (png_ptr->interlaced) +- { +- png_ptr->row_number = 0; +- png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1); +- do +- { +- png_ptr->pass++; +- if (png_ptr->pass >= 7) +- break; +- png_ptr->iwidth = (png_ptr->width + +- png_pass_inc[png_ptr->pass] - 1 - +- png_pass_start[png_ptr->pass]) / +- png_pass_inc[png_ptr->pass]; +- +- png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, +- png_ptr->iwidth) + 1; +- +- if (!(png_ptr->transformations & PNG_INTERLACE)) +- { +- png_ptr->num_rows = (png_ptr->height + +- png_pass_yinc[png_ptr->pass] - 1 - +- png_pass_ystart[png_ptr->pass]) / +- png_pass_yinc[png_ptr->pass]; +- if (!(png_ptr->num_rows)) +- continue; +- } +- else /* if (png_ptr->transformations & PNG_INTERLACE) */ +- break; +- } while (png_ptr->iwidth == 0); +- +- if (png_ptr->pass < 7) +- return; +- } +- +- if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) +- { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_IDAT; +-#endif +- char extra; +- int ret; +- +- png_ptr->zstream.next_out = (Byte *)&extra; +- png_ptr->zstream.avail_out = (uInt)1; +- for(;;) +- { +- if (!(png_ptr->zstream.avail_in)) +- { +- while (!png_ptr->idat_size) +- { +- png_byte chunk_length[4]; +- +- png_crc_finish(png_ptr, 0); +- +- png_read_data(png_ptr, chunk_length, 4); +- png_ptr->idat_size = png_get_uint_31(png_ptr, chunk_length); +- png_reset_crc(png_ptr); +- png_crc_read(png_ptr, png_ptr->chunk_name, 4); +- if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4)) +- png_error(png_ptr, "Not enough image data"); +- +- } +- png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; +- png_ptr->zstream.next_in = png_ptr->zbuf; +- if (png_ptr->zbuf_size > png_ptr->idat_size) +- png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; +- png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in); +- png_ptr->idat_size -= png_ptr->zstream.avail_in; +- } +- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); +- if (ret == Z_STREAM_END) +- { +- if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in || +- png_ptr->idat_size) +- png_warning(png_ptr, "Extra compressed data"); +- png_ptr->mode |= PNG_AFTER_IDAT; +- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; +- break; +- } +- if (ret != Z_OK) +- png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : +- "Decompression Error"); +- +- if (!(png_ptr->zstream.avail_out)) +- { +- png_warning(png_ptr, "Extra compressed data."); +- png_ptr->mode |= PNG_AFTER_IDAT; +- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; +- break; +- } +- +- } +- png_ptr->zstream.avail_out = 0; +- } +- +- if (png_ptr->idat_size || png_ptr->zstream.avail_in) +- png_warning(png_ptr, "Extra compression data"); +- +- inflateReset(&png_ptr->zstream); +- +- png_ptr->mode |= PNG_AFTER_IDAT; +-} +- +-void /* PRIVATE */ +-png_read_start_row(png_structp png_ptr) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ +- +- /* start of interlace block */ +- const int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; +- +- /* offset to next interlace block */ +- const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; +- +- /* start of interlace block in the y direction */ +- const int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; +- +- /* offset to next interlace block in the y direction */ +- const int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; +-#endif +- +- int max_pixel_depth; +- png_uint_32 row_bytes; +- +- png_debug(1, "in png_read_start_row\n"); +- png_ptr->zstream.avail_in = 0; +- png_init_read_transformations(png_ptr); +- if (png_ptr->interlaced) +- { +- if (!(png_ptr->transformations & PNG_INTERLACE)) +- png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 - +- png_pass_ystart[0]) / png_pass_yinc[0]; +- else +- png_ptr->num_rows = png_ptr->height; +- +- png_ptr->iwidth = (png_ptr->width + +- png_pass_inc[png_ptr->pass] - 1 - +- png_pass_start[png_ptr->pass]) / +- png_pass_inc[png_ptr->pass]; +- +- row_bytes = PNG_ROWBYTES(png_ptr->pixel_depth,png_ptr->iwidth) + 1; +- +- png_ptr->irowbytes = (png_size_t)row_bytes; +- if((png_uint_32)png_ptr->irowbytes != row_bytes) +- png_error(png_ptr, "Rowbytes overflow in png_read_start_row"); +- } +- else +- { +- png_ptr->num_rows = png_ptr->height; +- png_ptr->iwidth = png_ptr->width; +- png_ptr->irowbytes = png_ptr->rowbytes + 1; +- } +- max_pixel_depth = png_ptr->pixel_depth; +- +-#if defined(PNG_READ_PACK_SUPPORTED) +- if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8) +- max_pixel_depth = 8; +-#endif +- +-#if defined(PNG_READ_EXPAND_SUPPORTED) +- if (png_ptr->transformations & PNG_EXPAND) +- { +- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- { +- if (png_ptr->num_trans) +- max_pixel_depth = 32; +- else +- max_pixel_depth = 24; +- } +- else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) +- { +- if (max_pixel_depth < 8) +- max_pixel_depth = 8; +- if (png_ptr->num_trans) +- max_pixel_depth *= 2; +- } +- else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) +- { +- if (png_ptr->num_trans) +- { +- max_pixel_depth *= 4; +- max_pixel_depth /= 3; +- } +- } +- } +-#endif +- +-#if defined(PNG_READ_FILLER_SUPPORTED) +- if (png_ptr->transformations & (PNG_FILLER)) +- { +- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- max_pixel_depth = 32; +- else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) +- { +- if (max_pixel_depth <= 8) +- max_pixel_depth = 16; +- else +- max_pixel_depth = 32; +- } +- else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) +- { +- if (max_pixel_depth <= 32) +- max_pixel_depth = 32; +- else +- max_pixel_depth = 64; +- } +- } +-#endif +- +-#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +- if (png_ptr->transformations & PNG_GRAY_TO_RGB) +- { +- if ( +-#if defined(PNG_READ_EXPAND_SUPPORTED) +- (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) || +-#endif +-#if defined(PNG_READ_FILLER_SUPPORTED) +- (png_ptr->transformations & (PNG_FILLER)) || +-#endif +- png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) +- { +- if (max_pixel_depth <= 16) +- max_pixel_depth = 32; +- else +- max_pixel_depth = 64; +- } +- else +- { +- if (max_pixel_depth <= 8) +- { +- if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- max_pixel_depth = 32; +- else +- max_pixel_depth = 24; +- } +- else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- max_pixel_depth = 64; +- else +- max_pixel_depth = 48; +- } +- } +-#endif +- +-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \ +-defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) +- if(png_ptr->transformations & PNG_USER_TRANSFORM) +- { +- int user_pixel_depth=png_ptr->user_transform_depth* +- png_ptr->user_transform_channels; +- if(user_pixel_depth > max_pixel_depth) +- max_pixel_depth=user_pixel_depth; +- } +-#endif +- +- /* align the width on the next larger 8 pixels. Mainly used +- for interlacing */ +- row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7)); +- /* calculate the maximum bytes needed, adding a byte and a pixel +- for safety's sake */ +- row_bytes = PNG_ROWBYTES(max_pixel_depth,row_bytes) + +- 1 + ((max_pixel_depth + 7) >> 3); +-#ifdef PNG_MAX_MALLOC_64K +- if (row_bytes > (png_uint_32)65536L) +- png_error(png_ptr, "This image requires a row greater than 64KB"); +-#endif +- png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes+64); +- png_ptr->row_buf = png_ptr->big_row_buf+32; +-#if defined(PNG_DEBUG) && defined(PNG_USE_PNGGCCRD) +- png_ptr->row_buf_size = row_bytes; +-#endif +- +-#ifdef PNG_MAX_MALLOC_64K +- if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L) +- png_error(png_ptr, "This image requires a row greater than 64KB"); +-#endif +- if ((png_uint_32)png_ptr->rowbytes + 1 > PNG_SIZE_MAX) +- png_error(png_ptr, "Row has too many bytes to allocate in memory."); +- png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)( +- png_ptr->rowbytes + 1)); +- +- png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1); +- +- png_debug1(3, "width = %lu,\n", png_ptr->width); +- png_debug1(3, "height = %lu,\n", png_ptr->height); +- png_debug1(3, "iwidth = %lu,\n", png_ptr->iwidth); +- png_debug1(3, "num_rows = %lu\n", png_ptr->num_rows); +- png_debug1(3, "rowbytes = %lu,\n", png_ptr->rowbytes); +- png_debug1(3, "irowbytes = %lu,\n", png_ptr->irowbytes); +- +- png_ptr->flags |= PNG_FLAG_ROW_INIT; +-} +diff --git a/thirdparty/libpng/pngset.c b/thirdparty/libpng/pngset.c +deleted file mode 100644 +index b9677a1..0000000 +--- a/thirdparty/libpng/pngset.c ++++ /dev/null +@@ -1,1219 +0,0 @@ +- +-/* pngset.c - storage of image information into info struct +- * +- * libpng 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- * +- * The functions here are used during reads to store data from the file +- * into the info struct, and during writes to store application data +- * into the info struct for writing into the file. This abstracts the +- * info struct and allows us to change the structure in the future. +- */ +- +-#define PNG_INTERNAL +-#include "png.h" +- +-#if defined(PNG_bKGD_SUPPORTED) +-void PNGAPI +-png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background) +-{ +- png_debug1(1, "in %s storage function\n", "bKGD"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16)); +- info_ptr->valid |= PNG_INFO_bKGD; +-} +-#endif +- +-#if defined(PNG_cHRM_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-void PNGAPI +-png_set_cHRM(png_structp png_ptr, png_infop info_ptr, +- double white_x, double white_y, double red_x, double red_y, +- double green_x, double green_y, double blue_x, double blue_y) +-{ +- png_debug1(1, "in %s storage function\n", "cHRM"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- if (white_x < 0.0 || white_y < 0.0 || +- red_x < 0.0 || red_y < 0.0 || +- green_x < 0.0 || green_y < 0.0 || +- blue_x < 0.0 || blue_y < 0.0) +- { +- png_warning(png_ptr, +- "Ignoring attempt to set negative chromaticity value"); +- return; +- } +- if (white_x > 21474.83 || white_y > 21474.83 || +- red_x > 21474.83 || red_y > 21474.83 || +- green_x > 21474.83 || green_y > 21474.83 || +- blue_x > 21474.83 || blue_y > 21474.83) +- { +- png_warning(png_ptr, +- "Ignoring attempt to set chromaticity value exceeding 21474.83"); +- return; +- } +- +- info_ptr->x_white = (float)white_x; +- info_ptr->y_white = (float)white_y; +- info_ptr->x_red = (float)red_x; +- info_ptr->y_red = (float)red_y; +- info_ptr->x_green = (float)green_x; +- info_ptr->y_green = (float)green_y; +- info_ptr->x_blue = (float)blue_x; +- info_ptr->y_blue = (float)blue_y; +-#ifdef PNG_FIXED_POINT_SUPPORTED +- info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5); +- info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5); +- info_ptr->int_x_red = (png_fixed_point)( red_x*100000.+0.5); +- info_ptr->int_y_red = (png_fixed_point)( red_y*100000.+0.5); +- info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5); +- info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5); +- info_ptr->int_x_blue = (png_fixed_point)( blue_x*100000.+0.5); +- info_ptr->int_y_blue = (png_fixed_point)( blue_y*100000.+0.5); +-#endif +- info_ptr->valid |= PNG_INFO_cHRM; +-} +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +-void PNGAPI +-png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr, +- png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x, +- png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y, +- png_fixed_point blue_x, png_fixed_point blue_y) +-{ +- png_debug1(1, "in %s storage function\n", "cHRM"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- if (white_x < 0 || white_y < 0 || +- red_x < 0 || red_y < 0 || +- green_x < 0 || green_y < 0 || +- blue_x < 0 || blue_y < 0) +- { +- png_warning(png_ptr, +- "Ignoring attempt to set negative chromaticity value"); +- return; +- } +- if (white_x > (double) PNG_UINT_31_MAX || +- white_y > (double) PNG_UINT_31_MAX || +- red_x > (double) PNG_UINT_31_MAX || +- red_y > (double) PNG_UINT_31_MAX || +- green_x > (double) PNG_UINT_31_MAX || +- green_y > (double) PNG_UINT_31_MAX || +- blue_x > (double) PNG_UINT_31_MAX || +- blue_y > (double) PNG_UINT_31_MAX) +- { +- png_warning(png_ptr, +- "Ignoring attempt to set chromaticity value exceeding 21474.83"); +- return; +- } +- info_ptr->int_x_white = white_x; +- info_ptr->int_y_white = white_y; +- info_ptr->int_x_red = red_x; +- info_ptr->int_y_red = red_y; +- info_ptr->int_x_green = green_x; +- info_ptr->int_y_green = green_y; +- info_ptr->int_x_blue = blue_x; +- info_ptr->int_y_blue = blue_y; +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- info_ptr->x_white = (float)(white_x/100000.); +- info_ptr->y_white = (float)(white_y/100000.); +- info_ptr->x_red = (float)( red_x/100000.); +- info_ptr->y_red = (float)( red_y/100000.); +- info_ptr->x_green = (float)(green_x/100000.); +- info_ptr->y_green = (float)(green_y/100000.); +- info_ptr->x_blue = (float)( blue_x/100000.); +- info_ptr->y_blue = (float)( blue_y/100000.); +-#endif +- info_ptr->valid |= PNG_INFO_cHRM; +-} +-#endif +-#endif +- +-#if defined(PNG_gAMA_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-void PNGAPI +-png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma) +-{ +- double gamma; +- png_debug1(1, "in %s storage function\n", "gAMA"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- /* Check for overflow */ +- if (file_gamma > 21474.83) +- { +- png_warning(png_ptr, "Limiting gamma to 21474.83"); +- gamma=21474.83; +- } +- else +- gamma=file_gamma; +- info_ptr->gamma = (float)gamma; +-#ifdef PNG_FIXED_POINT_SUPPORTED +- info_ptr->int_gamma = (int)(gamma*100000.+.5); +-#endif +- info_ptr->valid |= PNG_INFO_gAMA; +- if(gamma == 0.0) +- png_warning(png_ptr, "Setting gamma=0"); +-} +-#endif +-void PNGAPI +-png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point +- int_gamma) +-{ +- png_fixed_point gamma; +- +- png_debug1(1, "in %s storage function\n", "gAMA"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- if (int_gamma > (png_fixed_point) PNG_UINT_31_MAX) +- { +- png_warning(png_ptr, "Limiting gamma to 21474.83"); +- gamma=PNG_UINT_31_MAX; +- } +- else +- { +- if (int_gamma < 0) +- { +- png_warning(png_ptr, "Setting negative gamma to zero"); +- gamma=0; +- } +- else +- gamma=int_gamma; +- } +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- info_ptr->gamma = (float)(gamma/100000.); +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +- info_ptr->int_gamma = gamma; +-#endif +- info_ptr->valid |= PNG_INFO_gAMA; +- if(gamma == 0) +- png_warning(png_ptr, "Setting gamma=0"); +-} +-#endif +- +-#if defined(PNG_hIST_SUPPORTED) +-void PNGAPI +-png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist) +-{ +- int i; +- +- png_debug1(1, "in %s storage function\n", "hIST"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- if (info_ptr->num_palette == 0) +- { +- png_warning(png_ptr, +- "Palette size 0, hIST allocation skipped."); +- return; +- } +- +-#ifdef PNG_FREE_ME_SUPPORTED +- png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0); +-#endif +- /* Changed from info->num_palette to 256 in version 1.2.1 */ +- png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr, +- (png_uint_32)(256 * png_sizeof (png_uint_16))); +- if (png_ptr->hist == NULL) +- { +- png_warning(png_ptr, "Insufficient memory for hIST chunk data."); +- return; +- } +- +- for (i = 0; i < info_ptr->num_palette; i++) +- png_ptr->hist[i] = hist[i]; +- info_ptr->hist = png_ptr->hist; +- info_ptr->valid |= PNG_INFO_hIST; +- +-#ifdef PNG_FREE_ME_SUPPORTED +- info_ptr->free_me |= PNG_FREE_HIST; +-#else +- png_ptr->flags |= PNG_FLAG_FREE_HIST; +-#endif +-} +-#endif +- +-void PNGAPI +-png_set_IHDR(png_structp png_ptr, png_infop info_ptr, +- png_uint_32 width, png_uint_32 height, int bit_depth, +- int color_type, int interlace_type, int compression_type, +- int filter_type) +-{ +- png_debug1(1, "in %s storage function\n", "IHDR"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- /* check for width and height valid values */ +- if (width == 0 || height == 0) +- png_error(png_ptr, "Image width or height is zero in IHDR"); +-#ifdef PNG_SET_USER_LIMITS_SUPPORTED +- if (width > png_ptr->user_width_max || height > png_ptr->user_height_max) +- png_error(png_ptr, "image size exceeds user limits in IHDR"); +-#else +- if (width > PNG_USER_WIDTH_MAX || height > PNG_USER_HEIGHT_MAX) +- png_error(png_ptr, "image size exceeds user limits in IHDR"); +-#endif +- if (width > PNG_UINT_31_MAX || height > PNG_UINT_31_MAX) +- png_error(png_ptr, "Invalid image size in IHDR"); +- if ( width > (PNG_UINT_32_MAX +- >> 3) /* 8-byte RGBA pixels */ +- - 64 /* bigrowbuf hack */ +- - 1 /* filter byte */ +- - 7*8 /* rounding of width to multiple of 8 pixels */ +- - 8) /* extra max_pixel_depth pad */ +- png_warning(png_ptr, "Width is too large for libpng to process pixels"); +- +- /* check other values */ +- if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 && +- bit_depth != 8 && bit_depth != 16) +- png_error(png_ptr, "Invalid bit depth in IHDR"); +- +- if (color_type < 0 || color_type == 1 || +- color_type == 5 || color_type > 6) +- png_error(png_ptr, "Invalid color type in IHDR"); +- +- if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) || +- ((color_type == PNG_COLOR_TYPE_RGB || +- color_type == PNG_COLOR_TYPE_GRAY_ALPHA || +- color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8)) +- png_error(png_ptr, "Invalid color type/bit depth combination in IHDR"); +- +- if (interlace_type >= PNG_INTERLACE_LAST) +- png_error(png_ptr, "Unknown interlace method in IHDR"); +- +- if (compression_type != PNG_COMPRESSION_TYPE_BASE) +- png_error(png_ptr, "Unknown compression method in IHDR"); +- +-#if defined(PNG_MNG_FEATURES_SUPPORTED) +- /* Accept filter_method 64 (intrapixel differencing) only if +- * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and +- * 2. Libpng did not read a PNG signature (this filter_method is only +- * used in PNG datastreams that are embedded in MNG datastreams) and +- * 3. The application called png_permit_mng_features with a mask that +- * included PNG_FLAG_MNG_FILTER_64 and +- * 4. The filter_method is 64 and +- * 5. The color_type is RGB or RGBA +- */ +- if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&png_ptr->mng_features_permitted) +- png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n"); +- if(filter_type != PNG_FILTER_TYPE_BASE) +- { +- if(!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && +- (filter_type == PNG_INTRAPIXEL_DIFFERENCING) && +- ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) && +- (color_type == PNG_COLOR_TYPE_RGB || +- color_type == PNG_COLOR_TYPE_RGB_ALPHA))) +- png_error(png_ptr, "Unknown filter method in IHDR"); +- if(png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) +- png_warning(png_ptr, "Invalid filter method in IHDR"); +- } +-#else +- if(filter_type != PNG_FILTER_TYPE_BASE) +- png_error(png_ptr, "Unknown filter method in IHDR"); +-#endif +- +- info_ptr->width = width; +- info_ptr->height = height; +- info_ptr->bit_depth = (png_byte)bit_depth; +- info_ptr->color_type =(png_byte) color_type; +- info_ptr->compression_type = (png_byte)compression_type; +- info_ptr->filter_type = (png_byte)filter_type; +- info_ptr->interlace_type = (png_byte)interlace_type; +- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- info_ptr->channels = 1; +- else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) +- info_ptr->channels = 3; +- else +- info_ptr->channels = 1; +- if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) +- info_ptr->channels++; +- info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth); +- +- /* check for potential overflow */ +- if ( width > (PNG_UINT_32_MAX +- >> 3) /* 8-byte RGBA pixels */ +- - 64 /* bigrowbuf hack */ +- - 1 /* filter byte */ +- - 7*8 /* rounding of width to multiple of 8 pixels */ +- - 8) /* extra max_pixel_depth pad */ +- info_ptr->rowbytes = (png_size_t)0; +- else +- info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth,width); +-} +- +-#if defined(PNG_oFFs_SUPPORTED) +-void PNGAPI +-png_set_oFFs(png_structp png_ptr, png_infop info_ptr, +- png_int_32 offset_x, png_int_32 offset_y, int unit_type) +-{ +- png_debug1(1, "in %s storage function\n", "oFFs"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- info_ptr->x_offset = offset_x; +- info_ptr->y_offset = offset_y; +- info_ptr->offset_unit_type = (png_byte)unit_type; +- info_ptr->valid |= PNG_INFO_oFFs; +-} +-#endif +- +-#if defined(PNG_pCAL_SUPPORTED) +-void PNGAPI +-png_set_pCAL(png_structp png_ptr, png_infop info_ptr, +- png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams, +- png_charp units, png_charpp params) +-{ +- png_uint_32 length; +- int i; +- +- png_debug1(1, "in %s storage function\n", "pCAL"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- length = png_strlen(purpose) + 1; +- png_debug1(3, "allocating purpose for info (%lu bytes)\n", length); +- info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length); +- if (info_ptr->pcal_purpose == NULL) +- { +- png_warning(png_ptr, "Insufficient memory for pCAL purpose."); +- return; +- } +- png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length); +- +- png_debug(3, "storing X0, X1, type, and nparams in info\n"); +- info_ptr->pcal_X0 = X0; +- info_ptr->pcal_X1 = X1; +- info_ptr->pcal_type = (png_byte)type; +- info_ptr->pcal_nparams = (png_byte)nparams; +- +- length = png_strlen(units) + 1; +- png_debug1(3, "allocating units for info (%lu bytes)\n", length); +- info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length); +- if (info_ptr->pcal_units == NULL) +- { +- png_warning(png_ptr, "Insufficient memory for pCAL units."); +- return; +- } +- png_memcpy(info_ptr->pcal_units, units, (png_size_t)length); +- +- info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr, +- (png_uint_32)((nparams + 1) * png_sizeof(png_charp))); +- if (info_ptr->pcal_params == NULL) +- { +- png_warning(png_ptr, "Insufficient memory for pCAL params."); +- return; +- } +- +- info_ptr->pcal_params[nparams] = NULL; +- +- for (i = 0; i < nparams; i++) +- { +- length = png_strlen(params[i]) + 1; +- png_debug2(3, "allocating parameter %d for info (%lu bytes)\n", i, length); +- info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length); +- if (info_ptr->pcal_params[i] == NULL) +- { +- png_warning(png_ptr, "Insufficient memory for pCAL parameter."); +- return; +- } +- png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length); +- } +- +- info_ptr->valid |= PNG_INFO_pCAL; +-#ifdef PNG_FREE_ME_SUPPORTED +- info_ptr->free_me |= PNG_FREE_PCAL; +-#endif +-} +-#endif +- +-#if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-void PNGAPI +-png_set_sCAL(png_structp png_ptr, png_infop info_ptr, +- int unit, double width, double height) +-{ +- png_debug1(1, "in %s storage function\n", "sCAL"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- info_ptr->scal_unit = (png_byte)unit; +- info_ptr->scal_pixel_width = width; +- info_ptr->scal_pixel_height = height; +- +- info_ptr->valid |= PNG_INFO_sCAL; +-} +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +-void PNGAPI +-png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr, +- int unit, png_charp swidth, png_charp sheight) +-{ +- png_uint_32 length; +- +- png_debug1(1, "in %s storage function\n", "sCAL"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- info_ptr->scal_unit = (png_byte)unit; +- +- length = png_strlen(swidth) + 1; +- png_debug1(3, "allocating unit for info (%d bytes)\n", length); +- info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length); +- if (info_ptr->scal_s_width == NULL) +- { +- png_warning(png_ptr, "Memory allocation failed while processing sCAL."); +- } +- png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length); +- +- length = png_strlen(sheight) + 1; +- png_debug1(3, "allocating unit for info (%d bytes)\n", length); +- info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length); +- if (info_ptr->scal_s_height == NULL) +- { +- png_free (png_ptr, info_ptr->scal_s_width); +- png_warning(png_ptr, "Memory allocation failed while processing sCAL."); +- } +- png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length); +- +- info_ptr->valid |= PNG_INFO_sCAL; +-#ifdef PNG_FREE_ME_SUPPORTED +- info_ptr->free_me |= PNG_FREE_SCAL; +-#endif +-} +-#endif +-#endif +-#endif +- +-#if defined(PNG_pHYs_SUPPORTED) +-void PNGAPI +-png_set_pHYs(png_structp png_ptr, png_infop info_ptr, +- png_uint_32 res_x, png_uint_32 res_y, int unit_type) +-{ +- png_debug1(1, "in %s storage function\n", "pHYs"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- info_ptr->x_pixels_per_unit = res_x; +- info_ptr->y_pixels_per_unit = res_y; +- info_ptr->phys_unit_type = (png_byte)unit_type; +- info_ptr->valid |= PNG_INFO_pHYs; +-} +-#endif +- +-void PNGAPI +-png_set_PLTE(png_structp png_ptr, png_infop info_ptr, +- png_colorp palette, int num_palette) +-{ +- +- png_debug1(1, "in %s storage function\n", "PLTE"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- /* +- * It may not actually be necessary to set png_ptr->palette here; +- * we do it for backward compatibility with the way the png_handle_tRNS +- * function used to do the allocation. +- */ +-#ifdef PNG_FREE_ME_SUPPORTED +- png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0); +-#endif +- +- /* Changed in libpng-1.2.1 to allocate 256 instead of num_palette entries, +- in case of an invalid PNG file that has too-large sample values. */ +- png_ptr->palette = (png_colorp)png_malloc(png_ptr, +- 256 * png_sizeof(png_color)); +- png_memset(png_ptr->palette, 0, 256 * png_sizeof(png_color)); +- png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof (png_color)); +- info_ptr->palette = png_ptr->palette; +- info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette; +- +-#ifdef PNG_FREE_ME_SUPPORTED +- info_ptr->free_me |= PNG_FREE_PLTE; +-#else +- png_ptr->flags |= PNG_FLAG_FREE_PLTE; +-#endif +- +- info_ptr->valid |= PNG_INFO_PLTE; +-} +- +-#if defined(PNG_sBIT_SUPPORTED) +-void PNGAPI +-png_set_sBIT(png_structp png_ptr, png_infop info_ptr, +- png_color_8p sig_bit) +-{ +- png_debug1(1, "in %s storage function\n", "sBIT"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof (png_color_8)); +- info_ptr->valid |= PNG_INFO_sBIT; +-} +-#endif +- +-#if defined(PNG_sRGB_SUPPORTED) +-void PNGAPI +-png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent) +-{ +- png_debug1(1, "in %s storage function\n", "sRGB"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- info_ptr->srgb_intent = (png_byte)intent; +- info_ptr->valid |= PNG_INFO_sRGB; +-} +- +-void PNGAPI +-png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr, +- int intent) +-{ +-#if defined(PNG_gAMA_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- float file_gamma; +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +- png_fixed_point int_file_gamma; +-#endif +-#endif +-#if defined(PNG_cHRM_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +- png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, +- int_green_y, int_blue_x, int_blue_y; +-#endif +-#endif +- png_debug1(1, "in %s storage function\n", "sRGB_gAMA_and_cHRM"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- png_set_sRGB(png_ptr, info_ptr, intent); +- +-#if defined(PNG_gAMA_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- file_gamma = (float).45455; +- png_set_gAMA(png_ptr, info_ptr, file_gamma); +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +- int_file_gamma = 45455L; +- png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma); +-#endif +-#endif +- +-#if defined(PNG_cHRM_SUPPORTED) +-#ifdef PNG_FIXED_POINT_SUPPORTED +- int_white_x = 31270L; +- int_white_y = 32900L; +- int_red_x = 64000L; +- int_red_y = 33000L; +- int_green_x = 30000L; +- int_green_y = 60000L; +- int_blue_x = 15000L; +- int_blue_y = 6000L; +- +- png_set_cHRM_fixed(png_ptr, info_ptr, +- int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, int_green_y, +- int_blue_x, int_blue_y); +-#endif +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- white_x = (float).3127; +- white_y = (float).3290; +- red_x = (float).64; +- red_y = (float).33; +- green_x = (float).30; +- green_y = (float).60; +- blue_x = (float).15; +- blue_y = (float).06; +- +- png_set_cHRM(png_ptr, info_ptr, +- white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y); +-#endif +-#endif +-} +-#endif +- +- +-#if defined(PNG_iCCP_SUPPORTED) +-void PNGAPI +-png_set_iCCP(png_structp png_ptr, png_infop info_ptr, +- png_charp name, int compression_type, +- png_charp profile, png_uint_32 proflen) +-{ +- png_charp new_iccp_name; +- png_charp new_iccp_profile; +- +- png_debug1(1, "in %s storage function\n", "iCCP"); +- if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL) +- return; +- +- new_iccp_name = (png_charp)png_malloc_warn(png_ptr, png_strlen(name)+1); +- if (new_iccp_name == NULL) +- { +- png_warning(png_ptr, "Insufficient memory to process iCCP chunk."); +- return; +- } +- png_strcpy(new_iccp_name, name); +- new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen); +- if (new_iccp_profile == NULL) +- { +- png_free (png_ptr, new_iccp_name); +- png_warning(png_ptr, "Insufficient memory to process iCCP profile."); +- return; +- } +- png_memcpy(new_iccp_profile, profile, (png_size_t)proflen); +- +- png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0); +- +- info_ptr->iccp_proflen = proflen; +- info_ptr->iccp_name = new_iccp_name; +- info_ptr->iccp_profile = new_iccp_profile; +- /* Compression is always zero but is here so the API and info structure +- * does not have to change if we introduce multiple compression types */ +- info_ptr->iccp_compression = (png_byte)compression_type; +-#ifdef PNG_FREE_ME_SUPPORTED +- info_ptr->free_me |= PNG_FREE_ICCP; +-#endif +- info_ptr->valid |= PNG_INFO_iCCP; +-} +-#endif +- +-#if defined(PNG_TEXT_SUPPORTED) +-void PNGAPI +-png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, +- int num_text) +-{ +- int ret; +- ret=png_set_text_2(png_ptr, info_ptr, text_ptr, num_text); +- if (ret) +- png_error(png_ptr, "Insufficient memory to store text"); +-} +- +-int /* PRIVATE */ +-png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, +- int num_text) +-{ +- int i; +- +- png_debug1(1, "in %s storage function\n", (png_ptr->chunk_name[0] == '\0' ? +- "text" : (png_const_charp)png_ptr->chunk_name)); +- +- if (png_ptr == NULL || info_ptr == NULL || num_text == 0) +- return(0); +- +- /* Make sure we have enough space in the "text" array in info_struct +- * to hold all of the incoming text_ptr objects. +- */ +- if (info_ptr->num_text + num_text > info_ptr->max_text) +- { +- if (info_ptr->text != NULL) +- { +- png_textp old_text; +- int old_max; +- +- old_max = info_ptr->max_text; +- info_ptr->max_text = info_ptr->num_text + num_text + 8; +- old_text = info_ptr->text; +- info_ptr->text = (png_textp)png_malloc_warn(png_ptr, +- (png_uint_32)(info_ptr->max_text * png_sizeof (png_text))); +- if (info_ptr->text == NULL) +- { +- png_free(png_ptr, old_text); +- return(1); +- } +- png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max * +- png_sizeof(png_text))); +- png_free(png_ptr, old_text); +- } +- else +- { +- info_ptr->max_text = num_text + 8; +- info_ptr->num_text = 0; +- info_ptr->text = (png_textp)png_malloc_warn(png_ptr, +- (png_uint_32)(info_ptr->max_text * png_sizeof (png_text))); +- if (info_ptr->text == NULL) +- return(1); +-#ifdef PNG_FREE_ME_SUPPORTED +- info_ptr->free_me |= PNG_FREE_TEXT; +-#endif +- } +- png_debug1(3, "allocated %d entries for info_ptr->text\n", +- info_ptr->max_text); +- } +- for (i = 0; i < num_text; i++) +- { +- png_size_t text_length,key_len; +- png_size_t lang_len,lang_key_len; +- png_textp textp = &(info_ptr->text[info_ptr->num_text]); +- +- if (text_ptr[i].key == NULL) +- continue; +- +- key_len = png_strlen(text_ptr[i].key); +- +- if(text_ptr[i].compression <= 0) +- { +- lang_len = 0; +- lang_key_len = 0; +- } +- else +-#ifdef PNG_iTXt_SUPPORTED +- { +- /* set iTXt data */ +- if (text_ptr[i].lang != NULL) +- lang_len = png_strlen(text_ptr[i].lang); +- else +- lang_len = 0; +- if (text_ptr[i].lang_key != NULL) +- lang_key_len = png_strlen(text_ptr[i].lang_key); +- else +- lang_key_len = 0; +- } +-#else +- { +- png_warning(png_ptr, "iTXt chunk not supported."); +- continue; +- } +-#endif +- +- if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0') +- { +- text_length = 0; +-#ifdef PNG_iTXt_SUPPORTED +- if(text_ptr[i].compression > 0) +- textp->compression = PNG_ITXT_COMPRESSION_NONE; +- else +-#endif +- textp->compression = PNG_TEXT_COMPRESSION_NONE; +- } +- else +- { +- text_length = png_strlen(text_ptr[i].text); +- textp->compression = text_ptr[i].compression; +- } +- +- textp->key = (png_charp)png_malloc_warn(png_ptr, +- (png_uint_32)(key_len + text_length + lang_len + lang_key_len + 4)); +- if (textp->key == NULL) +- return(1); +- png_debug2(2, "Allocated %lu bytes at %x in png_set_text\n", +- (png_uint_32)(key_len + lang_len + lang_key_len + text_length + 4), +- (int)textp->key); +- +- png_memcpy(textp->key, text_ptr[i].key, +- (png_size_t)(key_len)); +- *(textp->key+key_len) = '\0'; +-#ifdef PNG_iTXt_SUPPORTED +- if (text_ptr[i].compression > 0) +- { +- textp->lang=textp->key + key_len + 1; +- png_memcpy(textp->lang, text_ptr[i].lang, lang_len); +- *(textp->lang+lang_len) = '\0'; +- textp->lang_key=textp->lang + lang_len + 1; +- png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len); +- *(textp->lang_key+lang_key_len) = '\0'; +- textp->text=textp->lang_key + lang_key_len + 1; +- } +- else +-#endif +- { +-#ifdef PNG_iTXt_SUPPORTED +- textp->lang=NULL; +- textp->lang_key=NULL; +-#endif +- textp->text=textp->key + key_len + 1; +- } +- if(text_length) +- png_memcpy(textp->text, text_ptr[i].text, +- (png_size_t)(text_length)); +- *(textp->text+text_length) = '\0'; +- +-#ifdef PNG_iTXt_SUPPORTED +- if(textp->compression > 0) +- { +- textp->text_length = 0; +- textp->itxt_length = text_length; +- } +- else +-#endif +- { +- textp->text_length = text_length; +-#ifdef PNG_iTXt_SUPPORTED +- textp->itxt_length = 0; +-#endif +- } +- info_ptr->text[info_ptr->num_text]= *textp; +- info_ptr->num_text++; +- png_debug1(3, "transferred text chunk %d\n", info_ptr->num_text); +- } +- return(0); +-} +-#endif +- +-#if defined(PNG_tIME_SUPPORTED) +-void PNGAPI +-png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time) +-{ +- png_debug1(1, "in %s storage function\n", "tIME"); +- if (png_ptr == NULL || info_ptr == NULL || +- (png_ptr->mode & PNG_WROTE_tIME)) +- return; +- +- png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof (png_time)); +- info_ptr->valid |= PNG_INFO_tIME; +-} +-#endif +- +-#if defined(PNG_tRNS_SUPPORTED) +-void PNGAPI +-png_set_tRNS(png_structp png_ptr, png_infop info_ptr, +- png_bytep trans, int num_trans, png_color_16p trans_values) +-{ +- png_debug1(1, "in %s storage function\n", "tRNS"); +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- if (trans != NULL) +- { +- /* +- * It may not actually be necessary to set png_ptr->trans here; +- * we do it for backward compatibility with the way the png_handle_tRNS +- * function used to do the allocation. +- */ +-#ifdef PNG_FREE_ME_SUPPORTED +- png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0); +-#endif +- /* Changed from num_trans to 256 in version 1.2.1 */ +- png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)256); +- png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans); +-#ifdef PNG_FREE_ME_SUPPORTED +- info_ptr->free_me |= PNG_FREE_TRNS; +-#else +- png_ptr->flags |= PNG_FLAG_FREE_TRNS; +-#endif +- } +- +- if (trans_values != NULL) +- { +- png_memcpy(&(info_ptr->trans_values), trans_values, +- png_sizeof(png_color_16)); +- if (num_trans == 0) +- num_trans = 1; +- } +- info_ptr->num_trans = (png_uint_16)num_trans; +- info_ptr->valid |= PNG_INFO_tRNS; +-} +-#endif +- +-#if defined(PNG_sPLT_SUPPORTED) +-void PNGAPI +-png_set_sPLT(png_structp png_ptr, +- png_infop info_ptr, png_sPLT_tp entries, int nentries) +-{ +- png_sPLT_tp np; +- int i; +- +- np = (png_sPLT_tp)png_malloc_warn(png_ptr, +- (info_ptr->splt_palettes_num + nentries) * png_sizeof(png_sPLT_t)); +- if (np == NULL) +- { +- png_warning(png_ptr, "No memory for sPLT palettes."); +- return; +- } +- +- png_memcpy(np, info_ptr->splt_palettes, +- info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t)); +- png_free(png_ptr, info_ptr->splt_palettes); +- info_ptr->splt_palettes=NULL; +- +- for (i = 0; i < nentries; i++) +- { +- png_sPLT_tp to = np + info_ptr->splt_palettes_num + i; +- png_sPLT_tp from = entries + i; +- +- to->name = (png_charp)png_malloc(png_ptr, +- png_strlen(from->name) + 1); +- /* TODO: use png_malloc_warn */ +- png_strcpy(to->name, from->name); +- to->entries = (png_sPLT_entryp)png_malloc(png_ptr, +- from->nentries * png_sizeof(png_sPLT_t)); +- /* TODO: use png_malloc_warn */ +- png_memcpy(to->entries, from->entries, +- from->nentries * png_sizeof(png_sPLT_t)); +- to->nentries = from->nentries; +- to->depth = from->depth; +- } +- +- info_ptr->splt_palettes = np; +- info_ptr->splt_palettes_num += nentries; +- info_ptr->valid |= PNG_INFO_sPLT; +-#ifdef PNG_FREE_ME_SUPPORTED +- info_ptr->free_me |= PNG_FREE_SPLT; +-#endif +-} +-#endif /* PNG_sPLT_SUPPORTED */ +- +-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +-void PNGAPI +-png_set_unknown_chunks(png_structp png_ptr, +- png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns) +-{ +- png_unknown_chunkp np; +- int i; +- +- if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0) +- return; +- +- np = (png_unknown_chunkp)png_malloc_warn(png_ptr, +- (info_ptr->unknown_chunks_num + num_unknowns) * +- png_sizeof(png_unknown_chunk)); +- if (np == NULL) +- { +- png_warning(png_ptr, "Out of memory while processing unknown chunk."); +- return; +- } +- +- png_memcpy(np, info_ptr->unknown_chunks, +- info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk)); +- png_free(png_ptr, info_ptr->unknown_chunks); +- info_ptr->unknown_chunks=NULL; +- +- for (i = 0; i < num_unknowns; i++) +- { +- png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i; +- png_unknown_chunkp from = unknowns + i; +- +- png_strncpy((png_charp)to->name, (png_charp)from->name, 5); +- to->data = (png_bytep)png_malloc_warn(png_ptr, from->size); +- if (to->data == NULL) +- { +- png_warning(png_ptr, "Out of memory processing unknown chunk."); +- } +- else +- { +- png_memcpy(to->data, from->data, from->size); +- to->size = from->size; +- +- /* note our location in the read or write sequence */ +- to->location = (png_byte)(png_ptr->mode & 0xff); +- } +- } +- +- info_ptr->unknown_chunks = np; +- info_ptr->unknown_chunks_num += num_unknowns; +-#ifdef PNG_FREE_ME_SUPPORTED +- info_ptr->free_me |= PNG_FREE_UNKN; +-#endif +-} +-void PNGAPI +-png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr, +- int chunk, int location) +-{ +- if(png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk < +- (int)info_ptr->unknown_chunks_num) +- info_ptr->unknown_chunks[chunk].location = (png_byte)location; +-} +-#endif +- +-#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ +- defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) +-void PNGAPI +-png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted) +-{ +- /* This function is deprecated in favor of png_permit_mng_features() +- and will be removed from libpng-2.0.0 */ +- png_debug(1, "in png_permit_empty_plte, DEPRECATED.\n"); +- if (png_ptr == NULL) +- return; +- png_ptr->mng_features_permitted = (png_byte) +- ((png_ptr->mng_features_permitted & (~(PNG_FLAG_MNG_EMPTY_PLTE))) | +- ((empty_plte_permitted & PNG_FLAG_MNG_EMPTY_PLTE))); +-} +-#endif +- +-#if defined(PNG_MNG_FEATURES_SUPPORTED) +-png_uint_32 PNGAPI +-png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features) +-{ +- png_debug(1, "in png_permit_mng_features\n"); +- if (png_ptr == NULL) +- return (png_uint_32)0; +- png_ptr->mng_features_permitted = +- (png_byte)(mng_features & PNG_ALL_MNG_FEATURES); +- return (png_uint_32)png_ptr->mng_features_permitted; +-} +-#endif +- +-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +-void PNGAPI +-png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep +- chunk_list, int num_chunks) +-{ +- png_bytep new_list, p; +- int i, old_num_chunks; +- if (num_chunks == 0) +- { +- if(keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE) +- png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS; +- else +- png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS; +- +- if(keep == PNG_HANDLE_CHUNK_ALWAYS) +- png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS; +- else +- png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS; +- return; +- } +- if (chunk_list == NULL) +- return; +- old_num_chunks=png_ptr->num_chunk_list; +- new_list=(png_bytep)png_malloc(png_ptr, +- (png_uint_32)(5*(num_chunks+old_num_chunks))); +- if(png_ptr->chunk_list != NULL) +- { +- png_memcpy(new_list, png_ptr->chunk_list, +- (png_size_t)(5*old_num_chunks)); +- png_free(png_ptr, png_ptr->chunk_list); +- png_ptr->chunk_list=NULL; +- } +- png_memcpy(new_list+5*old_num_chunks, chunk_list, +- (png_size_t)(5*num_chunks)); +- for (p=new_list+5*old_num_chunks+4, i=0; inum_chunk_list=old_num_chunks+num_chunks; +- png_ptr->chunk_list=new_list; +-#ifdef PNG_FREE_ME_SUPPORTED +- png_ptr->free_me |= PNG_FREE_LIST; +-#endif +-} +-#endif +- +-#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) +-void PNGAPI +-png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr, +- png_user_chunk_ptr read_user_chunk_fn) +-{ +- png_debug(1, "in png_set_read_user_chunk_fn\n"); +- png_ptr->read_user_chunk_fn = read_user_chunk_fn; +- png_ptr->user_chunk_ptr = user_chunk_ptr; +-} +-#endif +- +-#if defined(PNG_INFO_IMAGE_SUPPORTED) +-void PNGAPI +-png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers) +-{ +- png_debug1(1, "in %s storage function\n", "rows"); +- +- if (png_ptr == NULL || info_ptr == NULL) +- return; +- +- if(info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers)) +- png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); +- info_ptr->row_pointers = row_pointers; +- if(row_pointers) +- info_ptr->valid |= PNG_INFO_IDAT; +-} +-#endif +- +-#ifdef PNG_WRITE_SUPPORTED +-void PNGAPI +-png_set_compression_buffer_size(png_structp png_ptr, png_uint_32 size) +-{ +- if(png_ptr->zbuf) +- png_free(png_ptr, png_ptr->zbuf); +- png_ptr->zbuf_size = (png_size_t)size; +- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size); +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +-} +-#endif +- +-void PNGAPI +-png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask) +-{ +- if (png_ptr && info_ptr) +- info_ptr->valid &= ~(mask); +-} +- +- +-#ifndef PNG_1_0_X +-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED +-/* this function was added to libpng 1.2.0 and should always exist by default */ +-void PNGAPI +-png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags) +-{ +- png_uint_32 settable_asm_flags; +- png_uint_32 settable_mmx_flags; +- +- settable_mmx_flags = +-#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW +- PNG_ASM_FLAG_MMX_READ_COMBINE_ROW | +-#endif +-#ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE +- PNG_ASM_FLAG_MMX_READ_INTERLACE | +-#endif +-#ifdef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW +- PNG_ASM_FLAG_MMX_READ_FILTER_SUB | +- PNG_ASM_FLAG_MMX_READ_FILTER_UP | +- PNG_ASM_FLAG_MMX_READ_FILTER_AVG | +- PNG_ASM_FLAG_MMX_READ_FILTER_PAETH | +-#endif +- 0; +- +- /* could be some non-MMX ones in the future, but not currently: */ +- settable_asm_flags = settable_mmx_flags; +- +- if (!(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_COMPILED) || +- !(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU)) +- { +- /* clear all MMX flags if MMX isn't supported */ +- settable_asm_flags &= ~settable_mmx_flags; +- png_ptr->asm_flags &= ~settable_mmx_flags; +- } +- +- /* we're replacing the settable bits with those passed in by the user, +- * so first zero them out of the master copy, then logical-OR in the +- * allowed subset that was requested */ +- +- png_ptr->asm_flags &= ~settable_asm_flags; /* zero them */ +- png_ptr->asm_flags |= (asm_flags & settable_asm_flags); /* set them */ +-} +-#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */ +- +-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED +-/* this function was added to libpng 1.2.0 */ +-void PNGAPI +-png_set_mmx_thresholds (png_structp png_ptr, +- png_byte mmx_bitdepth_threshold, +- png_uint_32 mmx_rowbytes_threshold) +-{ +- png_ptr->mmx_bitdepth_threshold = mmx_bitdepth_threshold; +- png_ptr->mmx_rowbytes_threshold = mmx_rowbytes_threshold; +-} +-#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */ +- +-#ifdef PNG_SET_USER_LIMITS_SUPPORTED +-/* this function was added to libpng 1.2.6 */ +-void PNGAPI +-png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max, +- png_uint_32 user_height_max) +-{ +- /* Images with dimensions larger than these limits will be +- * rejected by png_set_IHDR(). To accept any PNG datastream +- * regardless of dimensions, set both limits to 0x7ffffffL. +- */ +- png_ptr->user_width_max = user_width_max; +- png_ptr->user_height_max = user_height_max; +-} +-#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */ +- +-#endif /* ?PNG_1_0_X */ +diff --git a/thirdparty/libpng/pngtrans.c b/thirdparty/libpng/pngtrans.c +deleted file mode 100644 +index f279f9e..0000000 +--- a/thirdparty/libpng/pngtrans.c ++++ /dev/null +@@ -1,644 +0,0 @@ +- +-/* pngtrans.c - transforms the data in a row (used by both readers and writers) +- * +- * libpng 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- */ +- +-#define PNG_INTERNAL +-#include "png.h" +- +-#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +-/* turn on BGR-to-RGB mapping */ +-void PNGAPI +-png_set_bgr(png_structp png_ptr) +-{ +- png_debug(1, "in png_set_bgr\n"); +- png_ptr->transformations |= PNG_BGR; +-} +-#endif +- +-#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +-/* turn on 16 bit byte swapping */ +-void PNGAPI +-png_set_swap(png_structp png_ptr) +-{ +- png_debug(1, "in png_set_swap\n"); +- if (png_ptr->bit_depth == 16) +- png_ptr->transformations |= PNG_SWAP_BYTES; +-} +-#endif +- +-#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) +-/* turn on pixel packing */ +-void PNGAPI +-png_set_packing(png_structp png_ptr) +-{ +- png_debug(1, "in png_set_packing\n"); +- if (png_ptr->bit_depth < 8) +- { +- png_ptr->transformations |= PNG_PACK; +- png_ptr->usr_bit_depth = 8; +- } +-} +-#endif +- +-#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) +-/* turn on packed pixel swapping */ +-void PNGAPI +-png_set_packswap(png_structp png_ptr) +-{ +- png_debug(1, "in png_set_packswap\n"); +- if (png_ptr->bit_depth < 8) +- png_ptr->transformations |= PNG_PACKSWAP; +-} +-#endif +- +-#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) +-void PNGAPI +-png_set_shift(png_structp png_ptr, png_color_8p true_bits) +-{ +- png_debug(1, "in png_set_shift\n"); +- png_ptr->transformations |= PNG_SHIFT; +- png_ptr->shift = *true_bits; +-} +-#endif +- +-#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ +- defined(PNG_WRITE_INTERLACING_SUPPORTED) +-int PNGAPI +-png_set_interlace_handling(png_structp png_ptr) +-{ +- png_debug(1, "in png_set_interlace handling\n"); +- if (png_ptr->interlaced) +- { +- png_ptr->transformations |= PNG_INTERLACE; +- return (7); +- } +- +- return (1); +-} +-#endif +- +-#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +-/* Add a filler byte on read, or remove a filler or alpha byte on write. +- * The filler type has changed in v0.95 to allow future 2-byte fillers +- * for 48-bit input data, as well as to avoid problems with some compilers +- * that don't like bytes as parameters. +- */ +-void PNGAPI +-png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc) +-{ +- png_debug(1, "in png_set_filler\n"); +- png_ptr->transformations |= PNG_FILLER; +- png_ptr->filler = (png_byte)filler; +- if (filler_loc == PNG_FILLER_AFTER) +- png_ptr->flags |= PNG_FLAG_FILLER_AFTER; +- else +- png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER; +- +- /* This should probably go in the "do_read_filler" routine. +- * I attempted to do that in libpng-1.0.1a but that caused problems +- * so I restored it in libpng-1.0.2a +- */ +- +- if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) +- { +- png_ptr->usr_channels = 4; +- } +- +- /* Also I added this in libpng-1.0.2a (what happens when we expand +- * a less-than-8-bit grayscale to GA? */ +- +- if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8) +- { +- png_ptr->usr_channels = 2; +- } +-} +- +-#if !defined(PNG_1_0_X) +-/* Added to libpng-1.2.7 */ +-void PNGAPI +-png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc) +-{ +- png_debug(1, "in png_set_add_alpha\n"); +- png_set_filler(png_ptr, filler, filler_loc); +- png_ptr->transformations |= PNG_ADD_ALPHA; +-} +-#endif +- +-#endif +- +-#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ +- defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +-void PNGAPI +-png_set_swap_alpha(png_structp png_ptr) +-{ +- png_debug(1, "in png_set_swap_alpha\n"); +- png_ptr->transformations |= PNG_SWAP_ALPHA; +-} +-#endif +- +-#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ +- defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +-void PNGAPI +-png_set_invert_alpha(png_structp png_ptr) +-{ +- png_debug(1, "in png_set_invert_alpha\n"); +- png_ptr->transformations |= PNG_INVERT_ALPHA; +-} +-#endif +- +-#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +-void PNGAPI +-png_set_invert_mono(png_structp png_ptr) +-{ +- png_debug(1, "in png_set_invert_mono\n"); +- png_ptr->transformations |= PNG_INVERT_MONO; +-} +- +-/* invert monochrome grayscale data */ +-void /* PRIVATE */ +-png_do_invert(png_row_infop row_info, png_bytep row) +-{ +- png_debug(1, "in png_do_invert\n"); +- /* This test removed from libpng version 1.0.13 and 1.2.0: +- * if (row_info->bit_depth == 1 && +- */ +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- if (row == NULL || row_info == NULL) +- return; +-#endif +- if (row_info->color_type == PNG_COLOR_TYPE_GRAY) +- { +- png_bytep rp = row; +- png_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; +- +- for (i = 0; i < istop; i++) +- { +- *rp = (png_byte)(~(*rp)); +- rp++; +- } +- } +- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && +- row_info->bit_depth == 8) +- { +- png_bytep rp = row; +- png_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; +- +- for (i = 0; i < istop; i+=2) +- { +- *rp = (png_byte)(~(*rp)); +- rp+=2; +- } +- } +- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && +- row_info->bit_depth == 16) +- { +- png_bytep rp = row; +- png_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; +- +- for (i = 0; i < istop; i+=4) +- { +- *rp = (png_byte)(~(*rp)); +- *(rp+1) = (png_byte)(~(*(rp+1))); +- rp+=4; +- } +- } +-} +-#endif +- +-#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +-/* swaps byte order on 16 bit depth images */ +-void /* PRIVATE */ +-png_do_swap(png_row_infop row_info, png_bytep row) +-{ +- png_debug(1, "in png_do_swap\n"); +- if ( +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- row != NULL && row_info != NULL && +-#endif +- row_info->bit_depth == 16) +- { +- png_bytep rp = row; +- png_uint_32 i; +- png_uint_32 istop= row_info->width * row_info->channels; +- +- for (i = 0; i < istop; i++, rp += 2) +- { +- png_byte t = *rp; +- *rp = *(rp + 1); +- *(rp + 1) = t; +- } +- } +-} +-#endif +- +-#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) +-static png_byte onebppswaptable[256] = { +- 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, +- 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, +- 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, +- 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, +- 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, +- 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, +- 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, +- 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, +- 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, +- 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, +- 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, +- 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, +- 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, +- 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, +- 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, +- 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, +- 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, +- 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, +- 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, +- 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, +- 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, +- 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, +- 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, +- 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, +- 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, +- 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, +- 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, +- 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, +- 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, +- 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, +- 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, +- 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF +-}; +- +-static png_byte twobppswaptable[256] = { +- 0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0, +- 0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0, +- 0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4, +- 0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4, +- 0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8, +- 0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8, +- 0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC, +- 0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC, +- 0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1, +- 0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1, +- 0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5, +- 0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5, +- 0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9, +- 0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9, +- 0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD, +- 0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD, +- 0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2, +- 0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2, +- 0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6, +- 0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6, +- 0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA, +- 0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA, +- 0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE, +- 0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE, +- 0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3, +- 0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3, +- 0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7, +- 0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7, +- 0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB, +- 0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB, +- 0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF, +- 0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF +-}; +- +-static png_byte fourbppswaptable[256] = { +- 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, +- 0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, +- 0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71, +- 0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1, +- 0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72, +- 0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2, +- 0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73, +- 0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3, +- 0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74, +- 0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4, +- 0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75, +- 0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5, +- 0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76, +- 0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6, +- 0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77, +- 0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7, +- 0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78, +- 0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8, +- 0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79, +- 0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9, +- 0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A, +- 0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA, +- 0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B, +- 0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB, +- 0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C, +- 0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC, +- 0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D, +- 0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD, +- 0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E, +- 0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE, +- 0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F, +- 0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF +-}; +- +-/* swaps pixel packing order within bytes */ +-void /* PRIVATE */ +-png_do_packswap(png_row_infop row_info, png_bytep row) +-{ +- png_debug(1, "in png_do_packswap\n"); +- if ( +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- row != NULL && row_info != NULL && +-#endif +- row_info->bit_depth < 8) +- { +- png_bytep rp, end, table; +- +- end = row + row_info->rowbytes; +- +- if (row_info->bit_depth == 1) +- table = onebppswaptable; +- else if (row_info->bit_depth == 2) +- table = twobppswaptable; +- else if (row_info->bit_depth == 4) +- table = fourbppswaptable; +- else +- return; +- +- for (rp = row; rp < end; rp++) +- *rp = table[*rp]; +- } +-} +-#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */ +- +-#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ +- defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +-/* remove filler or alpha byte(s) */ +-void /* PRIVATE */ +-png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags) +-{ +- png_debug(1, "in png_do_strip_filler\n"); +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- if (row != NULL && row_info != NULL) +-#endif +- { +- png_bytep sp=row; +- png_bytep dp=row; +- png_uint_32 row_width=row_info->width; +- png_uint_32 i; +- +- if (row_info->color_type == PNG_COLOR_TYPE_RGB && +- row_info->channels == 4) +- { +- if (row_info->bit_depth == 8) +- { +- /* This converts from RGBX or RGBA to RGB */ +- if (flags & PNG_FLAG_FILLER_AFTER) +- { +- dp+=3; sp+=4; +- for (i = 1; i < row_width; i++) +- { +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- sp++; +- } +- } +- /* This converts from XRGB or ARGB to RGB */ +- else +- { +- for (i = 0; i < row_width; i++) +- { +- sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- } +- } +- row_info->pixel_depth = 24; +- row_info->rowbytes = row_width * 3; +- } +- else /* if (row_info->bit_depth == 16) */ +- { +- if (flags & PNG_FLAG_FILLER_AFTER) +- { +- /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */ +- sp += 8; dp += 6; +- for (i = 1; i < row_width; i++) +- { +- /* This could be (although png_memcpy is probably slower): +- png_memcpy(dp, sp, 6); +- sp += 8; +- dp += 6; +- */ +- +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- sp += 2; +- } +- } +- else +- { +- /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */ +- for (i = 0; i < row_width; i++) +- { +- /* This could be (although png_memcpy is probably slower): +- png_memcpy(dp, sp, 6); +- sp += 8; +- dp += 6; +- */ +- +- sp+=2; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- } +- } +- row_info->pixel_depth = 48; +- row_info->rowbytes = row_width * 6; +- } +- row_info->channels = 3; +- } +- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY && +- row_info->channels == 2) +- { +- if (row_info->bit_depth == 8) +- { +- /* This converts from GX or GA to G */ +- if (flags & PNG_FLAG_FILLER_AFTER) +- { +- for (i = 0; i < row_width; i++) +- { +- *dp++ = *sp++; +- sp++; +- } +- } +- /* This converts from XG or AG to G */ +- else +- { +- for (i = 0; i < row_width; i++) +- { +- sp++; +- *dp++ = *sp++; +- } +- } +- row_info->pixel_depth = 8; +- row_info->rowbytes = row_width; +- } +- else /* if (row_info->bit_depth == 16) */ +- { +- if (flags & PNG_FLAG_FILLER_AFTER) +- { +- /* This converts from GGXX or GGAA to GG */ +- sp += 4; dp += 2; +- for (i = 1; i < row_width; i++) +- { +- *dp++ = *sp++; +- *dp++ = *sp++; +- sp += 2; +- } +- } +- else +- { +- /* This converts from XXGG or AAGG to GG */ +- for (i = 0; i < row_width; i++) +- { +- sp += 2; +- *dp++ = *sp++; +- *dp++ = *sp++; +- } +- } +- row_info->pixel_depth = 16; +- row_info->rowbytes = row_width * 2; +- } +- row_info->channels = 1; +- } +- } +-} +-#endif +- +-#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +-/* swaps red and blue bytes within a pixel */ +-void /* PRIVATE */ +-png_do_bgr(png_row_infop row_info, png_bytep row) +-{ +- png_debug(1, "in png_do_bgr\n"); +- if ( +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- row != NULL && row_info != NULL && +-#endif +- (row_info->color_type & PNG_COLOR_MASK_COLOR)) +- { +- png_uint_32 row_width = row_info->width; +- if (row_info->bit_depth == 8) +- { +- if (row_info->color_type == PNG_COLOR_TYPE_RGB) +- { +- png_bytep rp; +- png_uint_32 i; +- +- for (i = 0, rp = row; i < row_width; i++, rp += 3) +- { +- png_byte save = *rp; +- *rp = *(rp + 2); +- *(rp + 2) = save; +- } +- } +- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- { +- png_bytep rp; +- png_uint_32 i; +- +- for (i = 0, rp = row; i < row_width; i++, rp += 4) +- { +- png_byte save = *rp; +- *rp = *(rp + 2); +- *(rp + 2) = save; +- } +- } +- } +- else if (row_info->bit_depth == 16) +- { +- if (row_info->color_type == PNG_COLOR_TYPE_RGB) +- { +- png_bytep rp; +- png_uint_32 i; +- +- for (i = 0, rp = row; i < row_width; i++, rp += 6) +- { +- png_byte save = *rp; +- *rp = *(rp + 4); +- *(rp + 4) = save; +- save = *(rp + 1); +- *(rp + 1) = *(rp + 5); +- *(rp + 5) = save; +- } +- } +- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- { +- png_bytep rp; +- png_uint_32 i; +- +- for (i = 0, rp = row; i < row_width; i++, rp += 8) +- { +- png_byte save = *rp; +- *rp = *(rp + 4); +- *(rp + 4) = save; +- save = *(rp + 1); +- *(rp + 1) = *(rp + 5); +- *(rp + 5) = save; +- } +- } +- } +- } +-} +-#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */ +- +-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_LEGACY_SUPPORTED) +-void PNGAPI +-png_set_user_transform_info(png_structp png_ptr, png_voidp +- user_transform_ptr, int user_transform_depth, int user_transform_channels) +-{ +- png_debug(1, "in png_set_user_transform_info\n"); +-#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) +- png_ptr->user_transform_ptr = user_transform_ptr; +- png_ptr->user_transform_depth = (png_byte)user_transform_depth; +- png_ptr->user_transform_channels = (png_byte)user_transform_channels; +-#else +- if(user_transform_ptr || user_transform_depth || user_transform_channels) +- png_warning(png_ptr, +- "This version of libpng does not support user transform info"); +-#endif +-} +-#endif +- +-/* This function returns a pointer to the user_transform_ptr associated with +- * the user transform functions. The application should free any memory +- * associated with this pointer before png_write_destroy and png_read_destroy +- * are called. +- */ +-png_voidp PNGAPI +-png_get_user_transform_ptr(png_structp png_ptr) +-{ +-#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) +- return ((png_voidp)png_ptr->user_transform_ptr); +-#else +- if(png_ptr) +- return (NULL); +- return (NULL); +-#endif +-} +diff --git a/thirdparty/libpng/pngvcrd.c b/thirdparty/libpng/pngvcrd.c +deleted file mode 100644 +index 05cfacb..0000000 +--- a/thirdparty/libpng/pngvcrd.c ++++ /dev/null +@@ -1,3903 +0,0 @@ +-/* pngvcrd.c - mixed C/assembler version of utilities to read a PNG file +- * +- * For Intel x86 CPU and Microsoft Visual C++ compiler +- * +- * libpng version 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * Copyright (c) 1998, Intel Corporation +- * +- * Contributed by Nirav Chhatrapati, Intel Corporation, 1998 +- * Interface to libpng contributed by Gilles Vollant, 1999 +- * +- * +- * In png_do_read_interlace() in libpng versions 1.0.3a through 1.0.4d, +- * a sign error in the post-MMX cleanup code for each pixel_depth resulted +- * in bad pixels at the beginning of some rows of some images, and also +- * (due to out-of-range memory reads and writes) caused heap corruption +- * when compiled with MSVC 6.0. The error was fixed in version 1.0.4e. +- * +- * [png_read_filter_row_mmx_avg() bpp == 2 bugfix, GRR 20000916] +- * +- * [runtime MMX configuration, GRR 20010102] +- * +- */ +- +-#define PNG_INTERNAL +-#include "png.h" +- +-#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD) +- +-static int mmx_supported=2; +- +- +-int PNGAPI +-png_mmx_support(void) +-{ +- int mmx_supported_local = 0; +- _asm { +- push ebx //CPUID will trash these +- push ecx +- push edx +- +- pushfd //Save Eflag to stack +- pop eax //Get Eflag from stack into eax +- mov ecx, eax //Make another copy of Eflag in ecx +- xor eax, 0x200000 //Toggle ID bit in Eflag [i.e. bit(21)] +- push eax //Save modified Eflag back to stack +- +- popfd //Restored modified value back to Eflag reg +- pushfd //Save Eflag to stack +- pop eax //Get Eflag from stack +- push ecx // save original Eflag to stack +- popfd // restore original Eflag +- xor eax, ecx //Compare the new Eflag with the original Eflag +- jz NOT_SUPPORTED //If the same, CPUID instruction is not supported, +- //skip following instructions and jump to +- //NOT_SUPPORTED label +- +- xor eax, eax //Set eax to zero +- +- _asm _emit 0x0f //CPUID instruction (two bytes opcode) +- _asm _emit 0xa2 +- +- cmp eax, 1 //make sure eax return non-zero value +- jl NOT_SUPPORTED //If eax is zero, mmx not supported +- +- xor eax, eax //set eax to zero +- inc eax //Now increment eax to 1. This instruction is +- //faster than the instruction "mov eax, 1" +- +- _asm _emit 0x0f //CPUID instruction +- _asm _emit 0xa2 +- +- and edx, 0x00800000 //mask out all bits but mmx bit(24) +- cmp edx, 0 // 0 = mmx not supported +- jz NOT_SUPPORTED // non-zero = Yes, mmx IS supported +- +- mov mmx_supported_local, 1 //set return value to 1 +- +-NOT_SUPPORTED: +- mov eax, mmx_supported_local //move return value to eax +- pop edx //CPUID trashed these +- pop ecx +- pop ebx +- } +- +- //mmx_supported_local=0; // test code for force don't support MMX +- //printf("MMX : %u (1=MMX supported)\n",mmx_supported_local); +- +- mmx_supported = mmx_supported_local; +- return mmx_supported_local; +-} +- +-/* Combines the row recently read in with the previous row. +- This routine takes care of alpha and transparency if requested. +- This routine also handles the two methods of progressive display +- of interlaced images, depending on the mask value. +- The mask value describes which pixels are to be combined with +- the row. The pattern always repeats every 8 pixels, so just 8 +- bits are needed. A one indicates the pixel is to be combined; a +- zero indicates the pixel is to be skipped. This is in addition +- to any alpha or transparency value associated with the pixel. If +- you want all pixels to be combined, pass 0xff (255) in mask. */ +- +-/* Use this routine for x86 platform - uses faster MMX routine if machine +- supports MMX */ +- +-void /* PRIVATE */ +-png_combine_row(png_structp png_ptr, png_bytep row, int mask) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; +-#endif +- +- png_debug(1,"in png_combine_row_asm\n"); +- +- if (mmx_supported == 2) { +-#if !defined(PNG_1_0_X) +- /* this should have happened in png_init_mmx_flags() already */ +- png_warning(png_ptr, "asm_flags may not have been initialized"); +-#endif +- png_mmx_support(); +- } +- +- if (mask == 0xff) +- { +- png_memcpy(row, png_ptr->row_buf + 1, +- (png_size_t)PNG_ROWBYTES(png_ptr->row_info.pixel_depth, +- png_ptr->width)); +- } +- /* GRR: add "else if (mask == 0)" case? +- * or does png_combine_row() not even get called in that case? */ +- else +- { +- switch (png_ptr->row_info.pixel_depth) +- { +- case 1: +- { +- png_bytep sp; +- png_bytep dp; +- int s_inc, s_start, s_end; +- int m; +- int shift; +- png_uint_32 i; +- +- sp = png_ptr->row_buf + 1; +- dp = row; +- m = 0x80; +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_PACKSWAP) +- { +- s_start = 0; +- s_end = 7; +- s_inc = 1; +- } +- else +-#endif +- { +- s_start = 7; +- s_end = 0; +- s_inc = -1; +- } +- +- shift = s_start; +- +- for (i = 0; i < png_ptr->width; i++) +- { +- if (m & mask) +- { +- int value; +- +- value = (*sp >> shift) & 0x1; +- *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); +- *dp |= (png_byte)(value << shift); +- } +- +- if (shift == s_end) +- { +- shift = s_start; +- sp++; +- dp++; +- } +- else +- shift += s_inc; +- +- if (m == 1) +- m = 0x80; +- else +- m >>= 1; +- } +- break; +- } +- +- case 2: +- { +- png_bytep sp; +- png_bytep dp; +- int s_start, s_end, s_inc; +- int m; +- int shift; +- png_uint_32 i; +- int value; +- +- sp = png_ptr->row_buf + 1; +- dp = row; +- m = 0x80; +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_PACKSWAP) +- { +- s_start = 0; +- s_end = 6; +- s_inc = 2; +- } +- else +-#endif +- { +- s_start = 6; +- s_end = 0; +- s_inc = -2; +- } +- +- shift = s_start; +- +- for (i = 0; i < png_ptr->width; i++) +- { +- if (m & mask) +- { +- value = (*sp >> shift) & 0x3; +- *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); +- *dp |= (png_byte)(value << shift); +- } +- +- if (shift == s_end) +- { +- shift = s_start; +- sp++; +- dp++; +- } +- else +- shift += s_inc; +- if (m == 1) +- m = 0x80; +- else +- m >>= 1; +- } +- break; +- } +- +- case 4: +- { +- png_bytep sp; +- png_bytep dp; +- int s_start, s_end, s_inc; +- int m; +- int shift; +- png_uint_32 i; +- int value; +- +- sp = png_ptr->row_buf + 1; +- dp = row; +- m = 0x80; +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_PACKSWAP) +- { +- s_start = 0; +- s_end = 4; +- s_inc = 4; +- } +- else +-#endif +- { +- s_start = 4; +- s_end = 0; +- s_inc = -4; +- } +- shift = s_start; +- +- for (i = 0; i < png_ptr->width; i++) +- { +- if (m & mask) +- { +- value = (*sp >> shift) & 0xf; +- *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); +- *dp |= (png_byte)(value << shift); +- } +- +- if (shift == s_end) +- { +- shift = s_start; +- sp++; +- dp++; +- } +- else +- shift += s_inc; +- if (m == 1) +- m = 0x80; +- else +- m >>= 1; +- } +- break; +- } +- +- case 8: +- { +- png_bytep srcptr; +- png_bytep dstptr; +- png_uint_32 len; +- int m; +- int diff, unmask; +- +- __int64 mask0=0x0102040810204080; +- +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) +- /* && mmx_supported */ ) +-#else +- if (mmx_supported) +-#endif +- { +- srcptr = png_ptr->row_buf + 1; +- dstptr = row; +- m = 0x80; +- unmask = ~mask; +- len = png_ptr->width &~7; //reduce to multiple of 8 +- diff = png_ptr->width & 7; //amount lost +- +- _asm +- { +- movd mm7, unmask //load bit pattern +- psubb mm6,mm6 //zero mm6 +- punpcklbw mm7,mm7 +- punpcklwd mm7,mm7 +- punpckldq mm7,mm7 //fill register with 8 masks +- +- movq mm0,mask0 +- +- pand mm0,mm7 //nonzero if keep byte +- pcmpeqb mm0,mm6 //zeros->1s, v versa +- +- mov ecx,len //load length of line (pixels) +- mov esi,srcptr //load source +- mov ebx,dstptr //load dest +- cmp ecx,0 //lcr +- je mainloop8end +- +-mainloop8: +- movq mm4,[esi] +- pand mm4,mm0 +- movq mm6,mm0 +- pandn mm6,[ebx] +- por mm4,mm6 +- movq [ebx],mm4 +- +- add esi,8 //inc by 8 bytes processed +- add ebx,8 +- sub ecx,8 //dec by 8 pixels processed +- +- ja mainloop8 +-mainloop8end: +- +- mov ecx,diff +- cmp ecx,0 +- jz end8 +- +- mov edx,mask +- sal edx,24 //make low byte the high byte +- +-secondloop8: +- sal edx,1 //move high bit to CF +- jnc skip8 //if CF = 0 +- mov al,[esi] +- mov [ebx],al +-skip8: +- inc esi +- inc ebx +- +- dec ecx +- jnz secondloop8 +-end8: +- emms +- } +- } +- else /* mmx not supported - use modified C routine */ +- { +- register unsigned int incr1, initial_val, final_val; +- png_size_t pixel_bytes; +- png_uint_32 i; +- register int disp = png_pass_inc[png_ptr->pass]; +- int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; +- +- pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); +- srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* +- pixel_bytes; +- dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; +- initial_val = offset_table[png_ptr->pass]*pixel_bytes; +- final_val = png_ptr->width*pixel_bytes; +- incr1 = (disp)*pixel_bytes; +- for (i = initial_val; i < final_val; i += incr1) +- { +- png_memcpy(dstptr, srcptr, pixel_bytes); +- srcptr += incr1; +- dstptr += incr1; +- } +- } /* end of else */ +- +- break; +- } // end 8 bpp +- +- case 16: +- { +- png_bytep srcptr; +- png_bytep dstptr; +- png_uint_32 len; +- int unmask, diff; +- __int64 mask1=0x0101020204040808, +- mask0=0x1010202040408080; +- +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) +- /* && mmx_supported */ ) +-#else +- if (mmx_supported) +-#endif +- { +- srcptr = png_ptr->row_buf + 1; +- dstptr = row; +- +- unmask = ~mask; +- len = (png_ptr->width)&~7; +- diff = (png_ptr->width)&7; +- _asm +- { +- movd mm7, unmask //load bit pattern +- psubb mm6,mm6 //zero mm6 +- punpcklbw mm7,mm7 +- punpcklwd mm7,mm7 +- punpckldq mm7,mm7 //fill register with 8 masks +- +- movq mm0,mask0 +- movq mm1,mask1 +- +- pand mm0,mm7 +- pand mm1,mm7 +- +- pcmpeqb mm0,mm6 +- pcmpeqb mm1,mm6 +- +- mov ecx,len //load length of line +- mov esi,srcptr //load source +- mov ebx,dstptr //load dest +- cmp ecx,0 //lcr +- jz mainloop16end +- +-mainloop16: +- movq mm4,[esi] +- pand mm4,mm0 +- movq mm6,mm0 +- movq mm7,[ebx] +- pandn mm6,mm7 +- por mm4,mm6 +- movq [ebx],mm4 +- +- movq mm5,[esi+8] +- pand mm5,mm1 +- movq mm7,mm1 +- movq mm6,[ebx+8] +- pandn mm7,mm6 +- por mm5,mm7 +- movq [ebx+8],mm5 +- +- add esi,16 //inc by 16 bytes processed +- add ebx,16 +- sub ecx,8 //dec by 8 pixels processed +- +- ja mainloop16 +- +-mainloop16end: +- mov ecx,diff +- cmp ecx,0 +- jz end16 +- +- mov edx,mask +- sal edx,24 //make low byte the high byte +-secondloop16: +- sal edx,1 //move high bit to CF +- jnc skip16 //if CF = 0 +- mov ax,[esi] +- mov [ebx],ax +-skip16: +- add esi,2 +- add ebx,2 +- +- dec ecx +- jnz secondloop16 +-end16: +- emms +- } +- } +- else /* mmx not supported - use modified C routine */ +- { +- register unsigned int incr1, initial_val, final_val; +- png_size_t pixel_bytes; +- png_uint_32 i; +- register int disp = png_pass_inc[png_ptr->pass]; +- int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; +- +- pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); +- srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* +- pixel_bytes; +- dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; +- initial_val = offset_table[png_ptr->pass]*pixel_bytes; +- final_val = png_ptr->width*pixel_bytes; +- incr1 = (disp)*pixel_bytes; +- for (i = initial_val; i < final_val; i += incr1) +- { +- png_memcpy(dstptr, srcptr, pixel_bytes); +- srcptr += incr1; +- dstptr += incr1; +- } +- } /* end of else */ +- +- break; +- } // end 16 bpp +- +- case 24: +- { +- png_bytep srcptr; +- png_bytep dstptr; +- png_uint_32 len; +- int unmask, diff; +- +- __int64 mask2=0x0101010202020404, //24bpp +- mask1=0x0408080810101020, +- mask0=0x2020404040808080; +- +- srcptr = png_ptr->row_buf + 1; +- dstptr = row; +- +- unmask = ~mask; +- len = (png_ptr->width)&~7; +- diff = (png_ptr->width)&7; +- +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) +- /* && mmx_supported */ ) +-#else +- if (mmx_supported) +-#endif +- { +- _asm +- { +- movd mm7, unmask //load bit pattern +- psubb mm6,mm6 //zero mm6 +- punpcklbw mm7,mm7 +- punpcklwd mm7,mm7 +- punpckldq mm7,mm7 //fill register with 8 masks +- +- movq mm0,mask0 +- movq mm1,mask1 +- movq mm2,mask2 +- +- pand mm0,mm7 +- pand mm1,mm7 +- pand mm2,mm7 +- +- pcmpeqb mm0,mm6 +- pcmpeqb mm1,mm6 +- pcmpeqb mm2,mm6 +- +- mov ecx,len //load length of line +- mov esi,srcptr //load source +- mov ebx,dstptr //load dest +- cmp ecx,0 +- jz mainloop24end +- +-mainloop24: +- movq mm4,[esi] +- pand mm4,mm0 +- movq mm6,mm0 +- movq mm7,[ebx] +- pandn mm6,mm7 +- por mm4,mm6 +- movq [ebx],mm4 +- +- +- movq mm5,[esi+8] +- pand mm5,mm1 +- movq mm7,mm1 +- movq mm6,[ebx+8] +- pandn mm7,mm6 +- por mm5,mm7 +- movq [ebx+8],mm5 +- +- movq mm6,[esi+16] +- pand mm6,mm2 +- movq mm4,mm2 +- movq mm7,[ebx+16] +- pandn mm4,mm7 +- por mm6,mm4 +- movq [ebx+16],mm6 +- +- add esi,24 //inc by 24 bytes processed +- add ebx,24 +- sub ecx,8 //dec by 8 pixels processed +- +- ja mainloop24 +- +-mainloop24end: +- mov ecx,diff +- cmp ecx,0 +- jz end24 +- +- mov edx,mask +- sal edx,24 //make low byte the high byte +-secondloop24: +- sal edx,1 //move high bit to CF +- jnc skip24 //if CF = 0 +- mov ax,[esi] +- mov [ebx],ax +- xor eax,eax +- mov al,[esi+2] +- mov [ebx+2],al +-skip24: +- add esi,3 +- add ebx,3 +- +- dec ecx +- jnz secondloop24 +- +-end24: +- emms +- } +- } +- else /* mmx not supported - use modified C routine */ +- { +- register unsigned int incr1, initial_val, final_val; +- png_size_t pixel_bytes; +- png_uint_32 i; +- register int disp = png_pass_inc[png_ptr->pass]; +- int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; +- +- pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); +- srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* +- pixel_bytes; +- dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; +- initial_val = offset_table[png_ptr->pass]*pixel_bytes; +- final_val = png_ptr->width*pixel_bytes; +- incr1 = (disp)*pixel_bytes; +- for (i = initial_val; i < final_val; i += incr1) +- { +- png_memcpy(dstptr, srcptr, pixel_bytes); +- srcptr += incr1; +- dstptr += incr1; +- } +- } /* end of else */ +- +- break; +- } // end 24 bpp +- +- case 32: +- { +- png_bytep srcptr; +- png_bytep dstptr; +- png_uint_32 len; +- int unmask, diff; +- +- __int64 mask3=0x0101010102020202, //32bpp +- mask2=0x0404040408080808, +- mask1=0x1010101020202020, +- mask0=0x4040404080808080; +- +- srcptr = png_ptr->row_buf + 1; +- dstptr = row; +- +- unmask = ~mask; +- len = (png_ptr->width)&~7; +- diff = (png_ptr->width)&7; +- +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) +- /* && mmx_supported */ ) +-#else +- if (mmx_supported) +-#endif +- { +- _asm +- { +- movd mm7, unmask //load bit pattern +- psubb mm6,mm6 //zero mm6 +- punpcklbw mm7,mm7 +- punpcklwd mm7,mm7 +- punpckldq mm7,mm7 //fill register with 8 masks +- +- movq mm0,mask0 +- movq mm1,mask1 +- movq mm2,mask2 +- movq mm3,mask3 +- +- pand mm0,mm7 +- pand mm1,mm7 +- pand mm2,mm7 +- pand mm3,mm7 +- +- pcmpeqb mm0,mm6 +- pcmpeqb mm1,mm6 +- pcmpeqb mm2,mm6 +- pcmpeqb mm3,mm6 +- +- mov ecx,len //load length of line +- mov esi,srcptr //load source +- mov ebx,dstptr //load dest +- +- cmp ecx,0 //lcr +- jz mainloop32end +- +-mainloop32: +- movq mm4,[esi] +- pand mm4,mm0 +- movq mm6,mm0 +- movq mm7,[ebx] +- pandn mm6,mm7 +- por mm4,mm6 +- movq [ebx],mm4 +- +- movq mm5,[esi+8] +- pand mm5,mm1 +- movq mm7,mm1 +- movq mm6,[ebx+8] +- pandn mm7,mm6 +- por mm5,mm7 +- movq [ebx+8],mm5 +- +- movq mm6,[esi+16] +- pand mm6,mm2 +- movq mm4,mm2 +- movq mm7,[ebx+16] +- pandn mm4,mm7 +- por mm6,mm4 +- movq [ebx+16],mm6 +- +- movq mm7,[esi+24] +- pand mm7,mm3 +- movq mm5,mm3 +- movq mm4,[ebx+24] +- pandn mm5,mm4 +- por mm7,mm5 +- movq [ebx+24],mm7 +- +- add esi,32 //inc by 32 bytes processed +- add ebx,32 +- sub ecx,8 //dec by 8 pixels processed +- +- ja mainloop32 +- +-mainloop32end: +- mov ecx,diff +- cmp ecx,0 +- jz end32 +- +- mov edx,mask +- sal edx,24 //make low byte the high byte +-secondloop32: +- sal edx,1 //move high bit to CF +- jnc skip32 //if CF = 0 +- mov eax,[esi] +- mov [ebx],eax +-skip32: +- add esi,4 +- add ebx,4 +- +- dec ecx +- jnz secondloop32 +- +-end32: +- emms +- } +- } +- else /* mmx _not supported - Use modified C routine */ +- { +- register unsigned int incr1, initial_val, final_val; +- png_size_t pixel_bytes; +- png_uint_32 i; +- register int disp = png_pass_inc[png_ptr->pass]; +- int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; +- +- pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); +- srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* +- pixel_bytes; +- dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; +- initial_val = offset_table[png_ptr->pass]*pixel_bytes; +- final_val = png_ptr->width*pixel_bytes; +- incr1 = (disp)*pixel_bytes; +- for (i = initial_val; i < final_val; i += incr1) +- { +- png_memcpy(dstptr, srcptr, pixel_bytes); +- srcptr += incr1; +- dstptr += incr1; +- } +- } /* end of else */ +- +- break; +- } // end 32 bpp +- +- case 48: +- { +- png_bytep srcptr; +- png_bytep dstptr; +- png_uint_32 len; +- int unmask, diff; +- +- __int64 mask5=0x0101010101010202, +- mask4=0x0202020204040404, +- mask3=0x0404080808080808, +- mask2=0x1010101010102020, +- mask1=0x2020202040404040, +- mask0=0x4040808080808080; +- +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) +- /* && mmx_supported */ ) +-#else +- if (mmx_supported) +-#endif +- { +- srcptr = png_ptr->row_buf + 1; +- dstptr = row; +- +- unmask = ~mask; +- len = (png_ptr->width)&~7; +- diff = (png_ptr->width)&7; +- _asm +- { +- movd mm7, unmask //load bit pattern +- psubb mm6,mm6 //zero mm6 +- punpcklbw mm7,mm7 +- punpcklwd mm7,mm7 +- punpckldq mm7,mm7 //fill register with 8 masks +- +- movq mm0,mask0 +- movq mm1,mask1 +- movq mm2,mask2 +- movq mm3,mask3 +- movq mm4,mask4 +- movq mm5,mask5 +- +- pand mm0,mm7 +- pand mm1,mm7 +- pand mm2,mm7 +- pand mm3,mm7 +- pand mm4,mm7 +- pand mm5,mm7 +- +- pcmpeqb mm0,mm6 +- pcmpeqb mm1,mm6 +- pcmpeqb mm2,mm6 +- pcmpeqb mm3,mm6 +- pcmpeqb mm4,mm6 +- pcmpeqb mm5,mm6 +- +- mov ecx,len //load length of line +- mov esi,srcptr //load source +- mov ebx,dstptr //load dest +- +- cmp ecx,0 +- jz mainloop48end +- +-mainloop48: +- movq mm7,[esi] +- pand mm7,mm0 +- movq mm6,mm0 +- pandn mm6,[ebx] +- por mm7,mm6 +- movq [ebx],mm7 +- +- movq mm6,[esi+8] +- pand mm6,mm1 +- movq mm7,mm1 +- pandn mm7,[ebx+8] +- por mm6,mm7 +- movq [ebx+8],mm6 +- +- movq mm6,[esi+16] +- pand mm6,mm2 +- movq mm7,mm2 +- pandn mm7,[ebx+16] +- por mm6,mm7 +- movq [ebx+16],mm6 +- +- movq mm7,[esi+24] +- pand mm7,mm3 +- movq mm6,mm3 +- pandn mm6,[ebx+24] +- por mm7,mm6 +- movq [ebx+24],mm7 +- +- movq mm6,[esi+32] +- pand mm6,mm4 +- movq mm7,mm4 +- pandn mm7,[ebx+32] +- por mm6,mm7 +- movq [ebx+32],mm6 +- +- movq mm7,[esi+40] +- pand mm7,mm5 +- movq mm6,mm5 +- pandn mm6,[ebx+40] +- por mm7,mm6 +- movq [ebx+40],mm7 +- +- add esi,48 //inc by 32 bytes processed +- add ebx,48 +- sub ecx,8 //dec by 8 pixels processed +- +- ja mainloop48 +-mainloop48end: +- +- mov ecx,diff +- cmp ecx,0 +- jz end48 +- +- mov edx,mask +- sal edx,24 //make low byte the high byte +- +-secondloop48: +- sal edx,1 //move high bit to CF +- jnc skip48 //if CF = 0 +- mov eax,[esi] +- mov [ebx],eax +-skip48: +- add esi,4 +- add ebx,4 +- +- dec ecx +- jnz secondloop48 +- +-end48: +- emms +- } +- } +- else /* mmx _not supported - Use modified C routine */ +- { +- register unsigned int incr1, initial_val, final_val; +- png_size_t pixel_bytes; +- png_uint_32 i; +- register int disp = png_pass_inc[png_ptr->pass]; +- int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; +- +- pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); +- srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* +- pixel_bytes; +- dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; +- initial_val = offset_table[png_ptr->pass]*pixel_bytes; +- final_val = png_ptr->width*pixel_bytes; +- incr1 = (disp)*pixel_bytes; +- for (i = initial_val; i < final_val; i += incr1) +- { +- png_memcpy(dstptr, srcptr, pixel_bytes); +- srcptr += incr1; +- dstptr += incr1; +- } +- } /* end of else */ +- +- break; +- } // end 48 bpp +- +- default: +- { +- png_bytep sptr; +- png_bytep dp; +- png_size_t pixel_bytes; +- int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; +- unsigned int i; +- register int disp = png_pass_inc[png_ptr->pass]; // get the offset +- register unsigned int incr1, initial_val, final_val; +- +- pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); +- sptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* +- pixel_bytes; +- dp = row + offset_table[png_ptr->pass]*pixel_bytes; +- initial_val = offset_table[png_ptr->pass]*pixel_bytes; +- final_val = png_ptr->width*pixel_bytes; +- incr1 = (disp)*pixel_bytes; +- for (i = initial_val; i < final_val; i += incr1) +- { +- png_memcpy(dp, sptr, pixel_bytes); +- sptr += incr1; +- dp += incr1; +- } +- break; +- } +- } /* end switch (png_ptr->row_info.pixel_depth) */ +- } /* end if (non-trivial mask) */ +- +-} /* end png_combine_row() */ +- +- +-#if defined(PNG_READ_INTERLACING_SUPPORTED) +- +-void /* PRIVATE */ +-png_do_read_interlace(png_structp png_ptr) +-{ +- png_row_infop row_info = &(png_ptr->row_info); +- png_bytep row = png_ptr->row_buf + 1; +- int pass = png_ptr->pass; +- png_uint_32 transformations = png_ptr->transformations; +-#ifdef PNG_USE_LOCAL_ARRAYS +- const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; +-#endif +- +- png_debug(1,"in png_do_read_interlace\n"); +- +- if (mmx_supported == 2) { +-#if !defined(PNG_1_0_X) +- /* this should have happened in png_init_mmx_flags() already */ +- png_warning(png_ptr, "asm_flags may not have been initialized"); +-#endif +- png_mmx_support(); +- } +- +- if (row != NULL && row_info != NULL) +- { +- png_uint_32 final_width; +- +- final_width = row_info->width * png_pass_inc[pass]; +- +- switch (row_info->pixel_depth) +- { +- case 1: +- { +- png_bytep sp, dp; +- int sshift, dshift; +- int s_start, s_end, s_inc; +- png_byte v; +- png_uint_32 i; +- int j; +- +- sp = row + (png_size_t)((row_info->width - 1) >> 3); +- dp = row + (png_size_t)((final_width - 1) >> 3); +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (transformations & PNG_PACKSWAP) +- { +- sshift = (int)((row_info->width + 7) & 7); +- dshift = (int)((final_width + 7) & 7); +- s_start = 7; +- s_end = 0; +- s_inc = -1; +- } +- else +-#endif +- { +- sshift = 7 - (int)((row_info->width + 7) & 7); +- dshift = 7 - (int)((final_width + 7) & 7); +- s_start = 0; +- s_end = 7; +- s_inc = 1; +- } +- +- for (i = row_info->width; i; i--) +- { +- v = (png_byte)((*sp >> sshift) & 0x1); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff); +- *dp |= (png_byte)(v << dshift); +- if (dshift == s_end) +- { +- dshift = s_start; +- dp--; +- } +- else +- dshift += s_inc; +- } +- if (sshift == s_end) +- { +- sshift = s_start; +- sp--; +- } +- else +- sshift += s_inc; +- } +- break; +- } +- +- case 2: +- { +- png_bytep sp, dp; +- int sshift, dshift; +- int s_start, s_end, s_inc; +- png_uint_32 i; +- +- sp = row + (png_size_t)((row_info->width - 1) >> 2); +- dp = row + (png_size_t)((final_width - 1) >> 2); +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (transformations & PNG_PACKSWAP) +- { +- sshift = (png_size_t)(((row_info->width + 3) & 3) << 1); +- dshift = (png_size_t)(((final_width + 3) & 3) << 1); +- s_start = 6; +- s_end = 0; +- s_inc = -2; +- } +- else +-#endif +- { +- sshift = (png_size_t)((3 - ((row_info->width + 3) & 3)) << 1); +- dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1); +- s_start = 0; +- s_end = 6; +- s_inc = 2; +- } +- +- for (i = row_info->width; i; i--) +- { +- png_byte v; +- int j; +- +- v = (png_byte)((*sp >> sshift) & 0x3); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff); +- *dp |= (png_byte)(v << dshift); +- if (dshift == s_end) +- { +- dshift = s_start; +- dp--; +- } +- else +- dshift += s_inc; +- } +- if (sshift == s_end) +- { +- sshift = s_start; +- sp--; +- } +- else +- sshift += s_inc; +- } +- break; +- } +- +- case 4: +- { +- png_bytep sp, dp; +- int sshift, dshift; +- int s_start, s_end, s_inc; +- png_uint_32 i; +- +- sp = row + (png_size_t)((row_info->width - 1) >> 1); +- dp = row + (png_size_t)((final_width - 1) >> 1); +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (transformations & PNG_PACKSWAP) +- { +- sshift = (png_size_t)(((row_info->width + 1) & 1) << 2); +- dshift = (png_size_t)(((final_width + 1) & 1) << 2); +- s_start = 4; +- s_end = 0; +- s_inc = -4; +- } +- else +-#endif +- { +- sshift = (png_size_t)((1 - ((row_info->width + 1) & 1)) << 2); +- dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2); +- s_start = 0; +- s_end = 4; +- s_inc = 4; +- } +- +- for (i = row_info->width; i; i--) +- { +- png_byte v; +- int j; +- +- v = (png_byte)((*sp >> sshift) & 0xf); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff); +- *dp |= (png_byte)(v << dshift); +- if (dshift == s_end) +- { +- dshift = s_start; +- dp--; +- } +- else +- dshift += s_inc; +- } +- if (sshift == s_end) +- { +- sshift = s_start; +- sp--; +- } +- else +- sshift += s_inc; +- } +- break; +- } +- +- default: // This is the place where the routine is modified +- { +- __int64 const4 = 0x0000000000FFFFFF; +- // __int64 const5 = 0x000000FFFFFF0000; // unused... +- __int64 const6 = 0x00000000000000FF; +- png_bytep sptr, dp; +- png_uint_32 i; +- png_size_t pixel_bytes; +- int width = row_info->width; +- +- pixel_bytes = (row_info->pixel_depth >> 3); +- +- sptr = row + (width - 1) * pixel_bytes; +- dp = row + (final_width - 1) * pixel_bytes; +- // New code by Nirav Chhatrapati - Intel Corporation +- // sign fix by GRR +- // NOTE: there is NO MMX code for 48-bit and 64-bit images +- +- // use MMX routine if machine supports it +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE) +- /* && mmx_supported */ ) +-#else +- if (mmx_supported) +-#endif +- { +- if (pixel_bytes == 3) +- { +- if (((pass == 0) || (pass == 1)) && width) +- { +- _asm +- { +- mov esi, sptr +- mov edi, dp +- mov ecx, width +- sub edi, 21 // (png_pass_inc[pass] - 1)*pixel_bytes +-loop_pass0: +- movd mm0, [esi] ; X X X X X v2 v1 v0 +- pand mm0, const4 ; 0 0 0 0 0 v2 v1 v0 +- movq mm1, mm0 ; 0 0 0 0 0 v2 v1 v0 +- psllq mm0, 16 ; 0 0 0 v2 v1 v0 0 0 +- movq mm2, mm0 ; 0 0 0 v2 v1 v0 0 0 +- psllq mm0, 24 ; v2 v1 v0 0 0 0 0 0 +- psrlq mm1, 8 ; 0 0 0 0 0 0 v2 v1 +- por mm0, mm2 ; v2 v1 v0 v2 v1 v0 0 0 +- por mm0, mm1 ; v2 v1 v0 v2 v1 v0 v2 v1 +- movq mm3, mm0 ; v2 v1 v0 v2 v1 v0 v2 v1 +- psllq mm0, 16 ; v0 v2 v1 v0 v2 v1 0 0 +- movq mm4, mm3 ; v2 v1 v0 v2 v1 v0 v2 v1 +- punpckhdq mm3, mm0 ; v0 v2 v1 v0 v2 v1 v0 v2 +- movq [edi+16] , mm4 +- psrlq mm0, 32 ; 0 0 0 0 v0 v2 v1 v0 +- movq [edi+8] , mm3 +- punpckldq mm0, mm4 ; v1 v0 v2 v1 v0 v2 v1 v0 +- sub esi, 3 +- movq [edi], mm0 +- sub edi, 24 +- //sub esi, 3 +- dec ecx +- jnz loop_pass0 +- EMMS +- } +- } +- else if (((pass == 2) || (pass == 3)) && width) +- { +- _asm +- { +- mov esi, sptr +- mov edi, dp +- mov ecx, width +- sub edi, 9 // (png_pass_inc[pass] - 1)*pixel_bytes +-loop_pass2: +- movd mm0, [esi] ; X X X X X v2 v1 v0 +- pand mm0, const4 ; 0 0 0 0 0 v2 v1 v0 +- movq mm1, mm0 ; 0 0 0 0 0 v2 v1 v0 +- psllq mm0, 16 ; 0 0 0 v2 v1 v0 0 0 +- movq mm2, mm0 ; 0 0 0 v2 v1 v0 0 0 +- psllq mm0, 24 ; v2 v1 v0 0 0 0 0 0 +- psrlq mm1, 8 ; 0 0 0 0 0 0 v2 v1 +- por mm0, mm2 ; v2 v1 v0 v2 v1 v0 0 0 +- por mm0, mm1 ; v2 v1 v0 v2 v1 v0 v2 v1 +- movq [edi+4], mm0 ; move to memory +- psrlq mm0, 16 ; 0 0 v2 v1 v0 v2 v1 v0 +- movd [edi], mm0 ; move to memory +- sub esi, 3 +- sub edi, 12 +- dec ecx +- jnz loop_pass2 +- EMMS +- } +- } +- else if (width) /* && ((pass == 4) || (pass == 5)) */ +- { +- int width_mmx = ((width >> 1) << 1) - 8; +- if (width_mmx < 0) +- width_mmx = 0; +- width -= width_mmx; // 8 or 9 pix, 24 or 27 bytes +- if (width_mmx) +- { +- _asm +- { +- mov esi, sptr +- mov edi, dp +- mov ecx, width_mmx +- sub esi, 3 +- sub edi, 9 +-loop_pass4: +- movq mm0, [esi] ; X X v2 v1 v0 v5 v4 v3 +- movq mm7, mm0 ; X X v2 v1 v0 v5 v4 v3 +- movq mm6, mm0 ; X X v2 v1 v0 v5 v4 v3 +- psllq mm0, 24 ; v1 v0 v5 v4 v3 0 0 0 +- pand mm7, const4 ; 0 0 0 0 0 v5 v4 v3 +- psrlq mm6, 24 ; 0 0 0 X X v2 v1 v0 +- por mm0, mm7 ; v1 v0 v5 v4 v3 v5 v4 v3 +- movq mm5, mm6 ; 0 0 0 X X v2 v1 v0 +- psllq mm6, 8 ; 0 0 X X v2 v1 v0 0 +- movq [edi], mm0 ; move quad to memory +- psrlq mm5, 16 ; 0 0 0 0 0 X X v2 +- pand mm5, const6 ; 0 0 0 0 0 0 0 v2 +- por mm6, mm5 ; 0 0 X X v2 v1 v0 v2 +- movd [edi+8], mm6 ; move double to memory +- sub esi, 6 +- sub edi, 12 +- sub ecx, 2 +- jnz loop_pass4 +- EMMS +- } +- } +- +- sptr -= width_mmx*3; +- dp -= width_mmx*6; +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- +- png_memcpy(v, sptr, 3); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, 3); +- dp -= 3; +- } +- sptr -= 3; +- } +- } +- } /* end of pixel_bytes == 3 */ +- +- else if (pixel_bytes == 1) +- { +- if (((pass == 0) || (pass == 1)) && width) +- { +- int width_mmx = ((width >> 2) << 2); +- width -= width_mmx; +- if (width_mmx) +- { +- _asm +- { +- mov esi, sptr +- mov edi, dp +- mov ecx, width_mmx +- sub edi, 31 +- sub esi, 3 +-loop1_pass0: +- movd mm0, [esi] ; X X X X v0 v1 v2 v3 +- movq mm1, mm0 ; X X X X v0 v1 v2 v3 +- punpcklbw mm0, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 +- movq mm2, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 +- punpcklwd mm0, mm0 ; v2 v2 v2 v2 v3 v3 v3 v3 +- movq mm3, mm0 ; v2 v2 v2 v2 v3 v3 v3 v3 +- punpckldq mm0, mm0 ; v3 v3 v3 v3 v3 v3 v3 v3 +- punpckhdq mm3, mm3 ; v2 v2 v2 v2 v2 v2 v2 v2 +- movq [edi], mm0 ; move to memory v3 +- punpckhwd mm2, mm2 ; v0 v0 v0 v0 v1 v1 v1 v1 +- movq [edi+8], mm3 ; move to memory v2 +- movq mm4, mm2 ; v0 v0 v0 v0 v1 v1 v1 v1 +- punpckldq mm2, mm2 ; v1 v1 v1 v1 v1 v1 v1 v1 +- punpckhdq mm4, mm4 ; v0 v0 v0 v0 v0 v0 v0 v0 +- movq [edi+16], mm2 ; move to memory v1 +- movq [edi+24], mm4 ; move to memory v0 +- sub esi, 4 +- sub edi, 32 +- sub ecx, 4 +- jnz loop1_pass0 +- EMMS +- } +- } +- +- sptr -= width_mmx; +- dp -= width_mmx*8; +- for (i = width; i; i--) +- { +- int j; +- +- /* I simplified this part in version 1.0.4e +- * here and in several other instances where +- * pixel_bytes == 1 -- GR-P +- * +- * Original code: +- * +- * png_byte v[8]; +- * png_memcpy(v, sptr, pixel_bytes); +- * for (j = 0; j < png_pass_inc[pass]; j++) +- * { +- * png_memcpy(dp, v, pixel_bytes); +- * dp -= pixel_bytes; +- * } +- * sptr -= pixel_bytes; +- * +- * Replacement code is in the next three lines: +- */ +- +- for (j = 0; j < png_pass_inc[pass]; j++) +- *dp-- = *sptr; +- sptr--; +- } +- } +- else if (((pass == 2) || (pass == 3)) && width) +- { +- int width_mmx = ((width >> 2) << 2); +- width -= width_mmx; +- if (width_mmx) +- { +- _asm +- { +- mov esi, sptr +- mov edi, dp +- mov ecx, width_mmx +- sub edi, 15 +- sub esi, 3 +-loop1_pass2: +- movd mm0, [esi] ; X X X X v0 v1 v2 v3 +- punpcklbw mm0, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 +- movq mm1, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 +- punpcklwd mm0, mm0 ; v2 v2 v2 v2 v3 v3 v3 v3 +- punpckhwd mm1, mm1 ; v0 v0 v0 v0 v1 v1 v1 v1 +- movq [edi], mm0 ; move to memory v2 and v3 +- sub esi, 4 +- movq [edi+8], mm1 ; move to memory v1 and v0 +- sub edi, 16 +- sub ecx, 4 +- jnz loop1_pass2 +- EMMS +- } +- } +- +- sptr -= width_mmx; +- dp -= width_mmx*4; +- for (i = width; i; i--) +- { +- int j; +- +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- *dp-- = *sptr; +- } +- sptr --; +- } +- } +- else if (width) /* && ((pass == 4) || (pass == 5))) */ +- { +- int width_mmx = ((width >> 3) << 3); +- width -= width_mmx; +- if (width_mmx) +- { +- _asm +- { +- mov esi, sptr +- mov edi, dp +- mov ecx, width_mmx +- sub edi, 15 +- sub esi, 7 +-loop1_pass4: +- movq mm0, [esi] ; v0 v1 v2 v3 v4 v5 v6 v7 +- movq mm1, mm0 ; v0 v1 v2 v3 v4 v5 v6 v7 +- punpcklbw mm0, mm0 ; v4 v4 v5 v5 v6 v6 v7 v7 +- //movq mm1, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 +- punpckhbw mm1, mm1 ;v0 v0 v1 v1 v2 v2 v3 v3 +- movq [edi+8], mm1 ; move to memory v0 v1 v2 and v3 +- sub esi, 8 +- movq [edi], mm0 ; move to memory v4 v5 v6 and v7 +- //sub esi, 4 +- sub edi, 16 +- sub ecx, 8 +- jnz loop1_pass4 +- EMMS +- } +- } +- +- sptr -= width_mmx; +- dp -= width_mmx*2; +- for (i = width; i; i--) +- { +- int j; +- +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- *dp-- = *sptr; +- } +- sptr --; +- } +- } +- } /* end of pixel_bytes == 1 */ +- +- else if (pixel_bytes == 2) +- { +- if (((pass == 0) || (pass == 1)) && width) +- { +- int width_mmx = ((width >> 1) << 1); +- width -= width_mmx; +- if (width_mmx) +- { +- _asm +- { +- mov esi, sptr +- mov edi, dp +- mov ecx, width_mmx +- sub esi, 2 +- sub edi, 30 +-loop2_pass0: +- movd mm0, [esi] ; X X X X v1 v0 v3 v2 +- punpcklwd mm0, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 +- movq mm1, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 +- punpckldq mm0, mm0 ; v3 v2 v3 v2 v3 v2 v3 v2 +- punpckhdq mm1, mm1 ; v1 v0 v1 v0 v1 v0 v1 v0 +- movq [edi], mm0 +- movq [edi + 8], mm0 +- movq [edi + 16], mm1 +- movq [edi + 24], mm1 +- sub esi, 4 +- sub edi, 32 +- sub ecx, 2 +- jnz loop2_pass0 +- EMMS +- } +- } +- +- sptr -= (width_mmx*2 - 2); // sign fixed +- dp -= (width_mmx*16 - 2); // sign fixed +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- sptr -= 2; +- png_memcpy(v, sptr, 2); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- dp -= 2; +- png_memcpy(dp, v, 2); +- } +- } +- } +- else if (((pass == 2) || (pass == 3)) && width) +- { +- int width_mmx = ((width >> 1) << 1) ; +- width -= width_mmx; +- if (width_mmx) +- { +- _asm +- { +- mov esi, sptr +- mov edi, dp +- mov ecx, width_mmx +- sub esi, 2 +- sub edi, 14 +-loop2_pass2: +- movd mm0, [esi] ; X X X X v1 v0 v3 v2 +- punpcklwd mm0, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 +- movq mm1, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 +- punpckldq mm0, mm0 ; v3 v2 v3 v2 v3 v2 v3 v2 +- punpckhdq mm1, mm1 ; v1 v0 v1 v0 v1 v0 v1 v0 +- movq [edi], mm0 +- sub esi, 4 +- movq [edi + 8], mm1 +- //sub esi, 4 +- sub edi, 16 +- sub ecx, 2 +- jnz loop2_pass2 +- EMMS +- } +- } +- +- sptr -= (width_mmx*2 - 2); // sign fixed +- dp -= (width_mmx*8 - 2); // sign fixed +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- sptr -= 2; +- png_memcpy(v, sptr, 2); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- dp -= 2; +- png_memcpy(dp, v, 2); +- } +- } +- } +- else if (width) // pass == 4 or 5 +- { +- int width_mmx = ((width >> 1) << 1) ; +- width -= width_mmx; +- if (width_mmx) +- { +- _asm +- { +- mov esi, sptr +- mov edi, dp +- mov ecx, width_mmx +- sub esi, 2 +- sub edi, 6 +-loop2_pass4: +- movd mm0, [esi] ; X X X X v1 v0 v3 v2 +- punpcklwd mm0, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 +- sub esi, 4 +- movq [edi], mm0 +- sub edi, 8 +- sub ecx, 2 +- jnz loop2_pass4 +- EMMS +- } +- } +- +- sptr -= (width_mmx*2 - 2); // sign fixed +- dp -= (width_mmx*4 - 2); // sign fixed +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- sptr -= 2; +- png_memcpy(v, sptr, 2); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- dp -= 2; +- png_memcpy(dp, v, 2); +- } +- } +- } +- } /* end of pixel_bytes == 2 */ +- +- else if (pixel_bytes == 4) +- { +- if (((pass == 0) || (pass == 1)) && width) +- { +- int width_mmx = ((width >> 1) << 1) ; +- width -= width_mmx; +- if (width_mmx) +- { +- _asm +- { +- mov esi, sptr +- mov edi, dp +- mov ecx, width_mmx +- sub esi, 4 +- sub edi, 60 +-loop4_pass0: +- movq mm0, [esi] ; v3 v2 v1 v0 v7 v6 v5 v4 +- movq mm1, mm0 ; v3 v2 v1 v0 v7 v6 v5 v4 +- punpckldq mm0, mm0 ; v7 v6 v5 v4 v7 v6 v5 v4 +- punpckhdq mm1, mm1 ; v3 v2 v1 v0 v3 v2 v1 v0 +- movq [edi], mm0 +- movq [edi + 8], mm0 +- movq [edi + 16], mm0 +- movq [edi + 24], mm0 +- movq [edi+32], mm1 +- movq [edi + 40], mm1 +- movq [edi+ 48], mm1 +- sub esi, 8 +- movq [edi + 56], mm1 +- sub edi, 64 +- sub ecx, 2 +- jnz loop4_pass0 +- EMMS +- } +- } +- +- sptr -= (width_mmx*4 - 4); // sign fixed +- dp -= (width_mmx*32 - 4); // sign fixed +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- sptr -= 4; +- png_memcpy(v, sptr, 4); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- dp -= 4; +- png_memcpy(dp, v, 4); +- } +- } +- } +- else if (((pass == 2) || (pass == 3)) && width) +- { +- int width_mmx = ((width >> 1) << 1) ; +- width -= width_mmx; +- if (width_mmx) +- { +- _asm +- { +- mov esi, sptr +- mov edi, dp +- mov ecx, width_mmx +- sub esi, 4 +- sub edi, 28 +-loop4_pass2: +- movq mm0, [esi] ; v3 v2 v1 v0 v7 v6 v5 v4 +- movq mm1, mm0 ; v3 v2 v1 v0 v7 v6 v5 v4 +- punpckldq mm0, mm0 ; v7 v6 v5 v4 v7 v6 v5 v4 +- punpckhdq mm1, mm1 ; v3 v2 v1 v0 v3 v2 v1 v0 +- movq [edi], mm0 +- movq [edi + 8], mm0 +- movq [edi+16], mm1 +- movq [edi + 24], mm1 +- sub esi, 8 +- sub edi, 32 +- sub ecx, 2 +- jnz loop4_pass2 +- EMMS +- } +- } +- +- sptr -= (width_mmx*4 - 4); // sign fixed +- dp -= (width_mmx*16 - 4); // sign fixed +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- sptr -= 4; +- png_memcpy(v, sptr, 4); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- dp -= 4; +- png_memcpy(dp, v, 4); +- } +- } +- } +- else if (width) // pass == 4 or 5 +- { +- int width_mmx = ((width >> 1) << 1) ; +- width -= width_mmx; +- if (width_mmx) +- { +- _asm +- { +- mov esi, sptr +- mov edi, dp +- mov ecx, width_mmx +- sub esi, 4 +- sub edi, 12 +-loop4_pass4: +- movq mm0, [esi] ; v3 v2 v1 v0 v7 v6 v5 v4 +- movq mm1, mm0 ; v3 v2 v1 v0 v7 v6 v5 v4 +- punpckldq mm0, mm0 ; v7 v6 v5 v4 v7 v6 v5 v4 +- punpckhdq mm1, mm1 ; v3 v2 v1 v0 v3 v2 v1 v0 +- movq [edi], mm0 +- sub esi, 8 +- movq [edi + 8], mm1 +- sub edi, 16 +- sub ecx, 2 +- jnz loop4_pass4 +- EMMS +- } +- } +- +- sptr -= (width_mmx*4 - 4); // sign fixed +- dp -= (width_mmx*8 - 4); // sign fixed +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- sptr -= 4; +- png_memcpy(v, sptr, 4); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- dp -= 4; +- png_memcpy(dp, v, 4); +- } +- } +- } +- +- } /* end of pixel_bytes == 4 */ +- +- else if (pixel_bytes == 6) +- { +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- png_memcpy(v, sptr, 6); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, 6); +- dp -= 6; +- } +- sptr -= 6; +- } +- } /* end of pixel_bytes == 6 */ +- +- else +- { +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- png_memcpy(v, sptr, pixel_bytes); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, pixel_bytes); +- dp -= pixel_bytes; +- } +- sptr-= pixel_bytes; +- } +- } +- } /* end of mmx_supported */ +- +- else /* MMX not supported: use modified C code - takes advantage +- * of inlining of memcpy for a constant */ +- { +- if (pixel_bytes == 1) +- { +- for (i = width; i; i--) +- { +- int j; +- for (j = 0; j < png_pass_inc[pass]; j++) +- *dp-- = *sptr; +- sptr--; +- } +- } +- else if (pixel_bytes == 3) +- { +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- png_memcpy(v, sptr, pixel_bytes); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, pixel_bytes); +- dp -= pixel_bytes; +- } +- sptr -= pixel_bytes; +- } +- } +- else if (pixel_bytes == 2) +- { +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- png_memcpy(v, sptr, pixel_bytes); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, pixel_bytes); +- dp -= pixel_bytes; +- } +- sptr -= pixel_bytes; +- } +- } +- else if (pixel_bytes == 4) +- { +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- png_memcpy(v, sptr, pixel_bytes); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, pixel_bytes); +- dp -= pixel_bytes; +- } +- sptr -= pixel_bytes; +- } +- } +- else if (pixel_bytes == 6) +- { +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- png_memcpy(v, sptr, pixel_bytes); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, pixel_bytes); +- dp -= pixel_bytes; +- } +- sptr -= pixel_bytes; +- } +- } +- else +- { +- for (i = width; i; i--) +- { +- png_byte v[8]; +- int j; +- png_memcpy(v, sptr, pixel_bytes); +- for (j = 0; j < png_pass_inc[pass]; j++) +- { +- png_memcpy(dp, v, pixel_bytes); +- dp -= pixel_bytes; +- } +- sptr -= pixel_bytes; +- } +- } +- +- } /* end of MMX not supported */ +- break; +- } +- } /* end switch (row_info->pixel_depth) */ +- +- row_info->width = final_width; +- +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,final_width); +- } +- +-} +- +-#endif /* PNG_READ_INTERLACING_SUPPORTED */ +- +- +-// These variables are utilized in the functions below. They are declared +-// globally here to ensure alignment on 8-byte boundaries. +- +-union uAll { +- __int64 use; +- double align; +-} LBCarryMask = {0x0101010101010101}, +- HBClearMask = {0x7f7f7f7f7f7f7f7f}, +- ActiveMask, ActiveMask2, ActiveMaskEnd, ShiftBpp, ShiftRem; +- +- +-// Optimized code for PNG Average filter decoder +-void /* PRIVATE */ +-png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row +- , png_bytep prev_row) +-{ +- int bpp; +- png_uint_32 FullLength; +- png_uint_32 MMXLength; +- //png_uint_32 len; +- int diff; +- +- bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel +- FullLength = row_info->rowbytes; // # of bytes to filter +- _asm { +- // Init address pointers and offset +- mov edi, row // edi ==> Avg(x) +- xor ebx, ebx // ebx ==> x +- mov edx, edi +- mov esi, prev_row // esi ==> Prior(x) +- sub edx, bpp // edx ==> Raw(x-bpp) +- +- xor eax, eax +- // Compute the Raw value for the first bpp bytes +- // Raw(x) = Avg(x) + (Prior(x)/2) +-davgrlp: +- mov al, [esi + ebx] // Load al with Prior(x) +- inc ebx +- shr al, 1 // divide by 2 +- add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx +- cmp ebx, bpp +- mov [edi+ebx-1], al // Write back Raw(x); +- // mov does not affect flags; -1 to offset inc ebx +- jb davgrlp +- // get # of bytes to alignment +- mov diff, edi // take start of row +- add diff, ebx // add bpp +- add diff, 0xf // add 7 + 8 to incr past alignment boundary +- and diff, 0xfffffff8 // mask to alignment boundary +- sub diff, edi // subtract from start ==> value ebx at alignment +- jz davggo +- // fix alignment +- // Compute the Raw value for the bytes upto the alignment boundary +- // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) +- xor ecx, ecx +-davglp1: +- xor eax, eax +- mov cl, [esi + ebx] // load cl with Prior(x) +- mov al, [edx + ebx] // load al with Raw(x-bpp) +- add ax, cx +- inc ebx +- shr ax, 1 // divide by 2 +- add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx +- cmp ebx, diff // Check if at alignment boundary +- mov [edi+ebx-1], al // Write back Raw(x); +- // mov does not affect flags; -1 to offset inc ebx +- jb davglp1 // Repeat until at alignment boundary +-davggo: +- mov eax, FullLength +- mov ecx, eax +- sub eax, ebx // subtract alignment fix +- and eax, 0x00000007 // calc bytes over mult of 8 +- sub ecx, eax // drop over bytes from original length +- mov MMXLength, ecx +- } // end _asm block +- // Now do the math for the rest of the row +- switch ( bpp ) +- { +- case 3: +- { +- ActiveMask.use = 0x0000000000ffffff; +- ShiftBpp.use = 24; // == 3 * 8 +- ShiftRem.use = 40; // == 64 - 24 +- _asm { +- // Re-init address pointers and offset +- movq mm7, ActiveMask +- mov ebx, diff // ebx ==> x = offset to alignment boundary +- movq mm5, LBCarryMask +- mov edi, row // edi ==> Avg(x) +- movq mm4, HBClearMask +- mov esi, prev_row // esi ==> Prior(x) +- // PRIME the pump (load the first Raw(x-bpp) data set +- movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes +- // (we correct position in loop below) +-davg3lp: +- movq mm0, [edi + ebx] // Load mm0 with Avg(x) +- // Add (Prev_row/2) to Average +- movq mm3, mm5 +- psrlq mm2, ShiftRem // Correct position Raw(x-bpp) data +- movq mm1, [esi + ebx] // Load mm1 with Prior(x) +- movq mm6, mm7 +- pand mm3, mm1 // get lsb for each prev_row byte +- psrlq mm1, 1 // divide prev_row bytes by 2 +- pand mm1, mm4 // clear invalid bit 7 of each byte +- paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte +- // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry +- movq mm1, mm3 // now use mm1 for getting LBCarrys +- pand mm1, mm2 // get LBCarrys for each byte where both +- // lsb's were == 1 (Only valid for active group) +- psrlq mm2, 1 // divide raw bytes by 2 +- pand mm2, mm4 // clear invalid bit 7 of each byte +- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte +- pand mm2, mm6 // Leave only Active Group 1 bytes to add to Avg +- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active +- // byte +- // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry +- psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 3-5 +- movq mm2, mm0 // mov updated Raws to mm2 +- psllq mm2, ShiftBpp // shift data to position correctly +- movq mm1, mm3 // now use mm1 for getting LBCarrys +- pand mm1, mm2 // get LBCarrys for each byte where both +- // lsb's were == 1 (Only valid for active group) +- psrlq mm2, 1 // divide raw bytes by 2 +- pand mm2, mm4 // clear invalid bit 7 of each byte +- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte +- pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg +- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active +- // byte +- +- // Add 3rd active group (Raw(x-bpp)/2) to Average with LBCarry +- psllq mm6, ShiftBpp // shift the mm6 mask to cover the last two +- // bytes +- movq mm2, mm0 // mov updated Raws to mm2 +- psllq mm2, ShiftBpp // shift data to position correctly +- // Data only needs to be shifted once here to +- // get the correct x-bpp offset. +- movq mm1, mm3 // now use mm1 for getting LBCarrys +- pand mm1, mm2 // get LBCarrys for each byte where both +- // lsb's were == 1 (Only valid for active group) +- psrlq mm2, 1 // divide raw bytes by 2 +- pand mm2, mm4 // clear invalid bit 7 of each byte +- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte +- pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg +- add ebx, 8 +- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active +- // byte +- +- // Now ready to write back to memory +- movq [edi + ebx - 8], mm0 +- // Move updated Raw(x) to use as Raw(x-bpp) for next loop +- cmp ebx, MMXLength +- movq mm2, mm0 // mov updated Raw(x) to mm2 +- jb davg3lp +- } // end _asm block +- } +- break; +- +- case 6: +- case 4: +- case 7: +- case 5: +- { +- ActiveMask.use = 0xffffffffffffffff; // use shift below to clear +- // appropriate inactive bytes +- ShiftBpp.use = bpp << 3; +- ShiftRem.use = 64 - ShiftBpp.use; +- _asm { +- movq mm4, HBClearMask +- // Re-init address pointers and offset +- mov ebx, diff // ebx ==> x = offset to alignment boundary +- // Load ActiveMask and clear all bytes except for 1st active group +- movq mm7, ActiveMask +- mov edi, row // edi ==> Avg(x) +- psrlq mm7, ShiftRem +- mov esi, prev_row // esi ==> Prior(x) +- movq mm6, mm7 +- movq mm5, LBCarryMask +- psllq mm6, ShiftBpp // Create mask for 2nd active group +- // PRIME the pump (load the first Raw(x-bpp) data set +- movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes +- // (we correct position in loop below) +-davg4lp: +- movq mm0, [edi + ebx] +- psrlq mm2, ShiftRem // shift data to position correctly +- movq mm1, [esi + ebx] +- // Add (Prev_row/2) to Average +- movq mm3, mm5 +- pand mm3, mm1 // get lsb for each prev_row byte +- psrlq mm1, 1 // divide prev_row bytes by 2 +- pand mm1, mm4 // clear invalid bit 7 of each byte +- paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte +- // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry +- movq mm1, mm3 // now use mm1 for getting LBCarrys +- pand mm1, mm2 // get LBCarrys for each byte where both +- // lsb's were == 1 (Only valid for active group) +- psrlq mm2, 1 // divide raw bytes by 2 +- pand mm2, mm4 // clear invalid bit 7 of each byte +- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte +- pand mm2, mm7 // Leave only Active Group 1 bytes to add to Avg +- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active +- // byte +- // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry +- movq mm2, mm0 // mov updated Raws to mm2 +- psllq mm2, ShiftBpp // shift data to position correctly +- add ebx, 8 +- movq mm1, mm3 // now use mm1 for getting LBCarrys +- pand mm1, mm2 // get LBCarrys for each byte where both +- // lsb's were == 1 (Only valid for active group) +- psrlq mm2, 1 // divide raw bytes by 2 +- pand mm2, mm4 // clear invalid bit 7 of each byte +- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte +- pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg +- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active +- // byte +- cmp ebx, MMXLength +- // Now ready to write back to memory +- movq [edi + ebx - 8], mm0 +- // Prep Raw(x-bpp) for next loop +- movq mm2, mm0 // mov updated Raws to mm2 +- jb davg4lp +- } // end _asm block +- } +- break; +- case 2: +- { +- ActiveMask.use = 0x000000000000ffff; +- ShiftBpp.use = 16; // == 2 * 8 [BUGFIX] +- ShiftRem.use = 48; // == 64 - 16 [BUGFIX] +- _asm { +- // Load ActiveMask +- movq mm7, ActiveMask +- // Re-init address pointers and offset +- mov ebx, diff // ebx ==> x = offset to alignment boundary +- movq mm5, LBCarryMask +- mov edi, row // edi ==> Avg(x) +- movq mm4, HBClearMask +- mov esi, prev_row // esi ==> Prior(x) +- // PRIME the pump (load the first Raw(x-bpp) data set +- movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes +- // (we correct position in loop below) +-davg2lp: +- movq mm0, [edi + ebx] +- psrlq mm2, ShiftRem // shift data to position correctly [BUGFIX] +- movq mm1, [esi + ebx] +- // Add (Prev_row/2) to Average +- movq mm3, mm5 +- pand mm3, mm1 // get lsb for each prev_row byte +- psrlq mm1, 1 // divide prev_row bytes by 2 +- pand mm1, mm4 // clear invalid bit 7 of each byte +- movq mm6, mm7 +- paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte +- // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry +- movq mm1, mm3 // now use mm1 for getting LBCarrys +- pand mm1, mm2 // get LBCarrys for each byte where both +- // lsb's were == 1 (Only valid for active group) +- psrlq mm2, 1 // divide raw bytes by 2 +- pand mm2, mm4 // clear invalid bit 7 of each byte +- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte +- pand mm2, mm6 // Leave only Active Group 1 bytes to add to Avg +- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte +- // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry +- psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 2 & 3 +- movq mm2, mm0 // mov updated Raws to mm2 +- psllq mm2, ShiftBpp // shift data to position correctly +- movq mm1, mm3 // now use mm1 for getting LBCarrys +- pand mm1, mm2 // get LBCarrys for each byte where both +- // lsb's were == 1 (Only valid for active group) +- psrlq mm2, 1 // divide raw bytes by 2 +- pand mm2, mm4 // clear invalid bit 7 of each byte +- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte +- pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg +- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte +- +- // Add rdd active group (Raw(x-bpp)/2) to Average with LBCarry +- psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 4 & 5 +- movq mm2, mm0 // mov updated Raws to mm2 +- psllq mm2, ShiftBpp // shift data to position correctly +- // Data only needs to be shifted once here to +- // get the correct x-bpp offset. +- movq mm1, mm3 // now use mm1 for getting LBCarrys +- pand mm1, mm2 // get LBCarrys for each byte where both +- // lsb's were == 1 (Only valid for active group) +- psrlq mm2, 1 // divide raw bytes by 2 +- pand mm2, mm4 // clear invalid bit 7 of each byte +- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte +- pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg +- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte +- +- // Add 4th active group (Raw(x-bpp)/2) to Average with LBCarry +- psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 6 & 7 +- movq mm2, mm0 // mov updated Raws to mm2 +- psllq mm2, ShiftBpp // shift data to position correctly +- // Data only needs to be shifted once here to +- // get the correct x-bpp offset. +- add ebx, 8 +- movq mm1, mm3 // now use mm1 for getting LBCarrys +- pand mm1, mm2 // get LBCarrys for each byte where both +- // lsb's were == 1 (Only valid for active group) +- psrlq mm2, 1 // divide raw bytes by 2 +- pand mm2, mm4 // clear invalid bit 7 of each byte +- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte +- pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg +- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte +- +- cmp ebx, MMXLength +- // Now ready to write back to memory +- movq [edi + ebx - 8], mm0 +- // Prep Raw(x-bpp) for next loop +- movq mm2, mm0 // mov updated Raws to mm2 +- jb davg2lp +- } // end _asm block +- } +- break; +- +- case 1: // bpp == 1 +- { +- _asm { +- // Re-init address pointers and offset +- mov ebx, diff // ebx ==> x = offset to alignment boundary +- mov edi, row // edi ==> Avg(x) +- cmp ebx, FullLength // Test if offset at end of array +- jnb davg1end +- // Do Paeth decode for remaining bytes +- mov esi, prev_row // esi ==> Prior(x) +- mov edx, edi +- xor ecx, ecx // zero ecx before using cl & cx in loop below +- sub edx, bpp // edx ==> Raw(x-bpp) +-davg1lp: +- // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) +- xor eax, eax +- mov cl, [esi + ebx] // load cl with Prior(x) +- mov al, [edx + ebx] // load al with Raw(x-bpp) +- add ax, cx +- inc ebx +- shr ax, 1 // divide by 2 +- add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx +- cmp ebx, FullLength // Check if at end of array +- mov [edi+ebx-1], al // Write back Raw(x); +- // mov does not affect flags; -1 to offset inc ebx +- jb davg1lp +-davg1end: +- } // end _asm block +- } +- return; +- +- case 8: // bpp == 8 +- { +- _asm { +- // Re-init address pointers and offset +- mov ebx, diff // ebx ==> x = offset to alignment boundary +- movq mm5, LBCarryMask +- mov edi, row // edi ==> Avg(x) +- movq mm4, HBClearMask +- mov esi, prev_row // esi ==> Prior(x) +- // PRIME the pump (load the first Raw(x-bpp) data set +- movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes +- // (NO NEED to correct position in loop below) +-davg8lp: +- movq mm0, [edi + ebx] +- movq mm3, mm5 +- movq mm1, [esi + ebx] +- add ebx, 8 +- pand mm3, mm1 // get lsb for each prev_row byte +- psrlq mm1, 1 // divide prev_row bytes by 2 +- pand mm3, mm2 // get LBCarrys for each byte where both +- // lsb's were == 1 +- psrlq mm2, 1 // divide raw bytes by 2 +- pand mm1, mm4 // clear invalid bit 7 of each byte +- paddb mm0, mm3 // add LBCarrys to Avg for each byte +- pand mm2, mm4 // clear invalid bit 7 of each byte +- paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte +- paddb mm0, mm2 // add (Raw/2) to Avg for each byte +- cmp ebx, MMXLength +- movq [edi + ebx - 8], mm0 +- movq mm2, mm0 // reuse as Raw(x-bpp) +- jb davg8lp +- } // end _asm block +- } +- break; +- default: // bpp greater than 8 +- { +- _asm { +- movq mm5, LBCarryMask +- // Re-init address pointers and offset +- mov ebx, diff // ebx ==> x = offset to alignment boundary +- mov edi, row // edi ==> Avg(x) +- movq mm4, HBClearMask +- mov edx, edi +- mov esi, prev_row // esi ==> Prior(x) +- sub edx, bpp // edx ==> Raw(x-bpp) +-davgAlp: +- movq mm0, [edi + ebx] +- movq mm3, mm5 +- movq mm1, [esi + ebx] +- pand mm3, mm1 // get lsb for each prev_row byte +- movq mm2, [edx + ebx] +- psrlq mm1, 1 // divide prev_row bytes by 2 +- pand mm3, mm2 // get LBCarrys for each byte where both +- // lsb's were == 1 +- psrlq mm2, 1 // divide raw bytes by 2 +- pand mm1, mm4 // clear invalid bit 7 of each byte +- paddb mm0, mm3 // add LBCarrys to Avg for each byte +- pand mm2, mm4 // clear invalid bit 7 of each byte +- paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte +- add ebx, 8 +- paddb mm0, mm2 // add (Raw/2) to Avg for each byte +- cmp ebx, MMXLength +- movq [edi + ebx - 8], mm0 +- jb davgAlp +- } // end _asm block +- } +- break; +- } // end switch ( bpp ) +- +- _asm { +- // MMX acceleration complete now do clean-up +- // Check if any remaining bytes left to decode +- mov ebx, MMXLength // ebx ==> x = offset bytes remaining after MMX +- mov edi, row // edi ==> Avg(x) +- cmp ebx, FullLength // Test if offset at end of array +- jnb davgend +- // Do Paeth decode for remaining bytes +- mov esi, prev_row // esi ==> Prior(x) +- mov edx, edi +- xor ecx, ecx // zero ecx before using cl & cx in loop below +- sub edx, bpp // edx ==> Raw(x-bpp) +-davglp2: +- // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) +- xor eax, eax +- mov cl, [esi + ebx] // load cl with Prior(x) +- mov al, [edx + ebx] // load al with Raw(x-bpp) +- add ax, cx +- inc ebx +- shr ax, 1 // divide by 2 +- add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx +- cmp ebx, FullLength // Check if at end of array +- mov [edi+ebx-1], al // Write back Raw(x); +- // mov does not affect flags; -1 to offset inc ebx +- jb davglp2 +-davgend: +- emms // End MMX instructions; prep for possible FP instrs. +- } // end _asm block +-} +- +-// Optimized code for PNG Paeth filter decoder +-void /* PRIVATE */ +-png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row, +- png_bytep prev_row) +-{ +- png_uint_32 FullLength; +- png_uint_32 MMXLength; +- //png_uint_32 len; +- int bpp; +- int diff; +- //int ptemp; +- int patemp, pbtemp, pctemp; +- +- bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel +- FullLength = row_info->rowbytes; // # of bytes to filter +- _asm +- { +- xor ebx, ebx // ebx ==> x offset +- mov edi, row +- xor edx, edx // edx ==> x-bpp offset +- mov esi, prev_row +- xor eax, eax +- +- // Compute the Raw value for the first bpp bytes +- // Note: the formula works out to be always +- // Paeth(x) = Raw(x) + Prior(x) where x < bpp +-dpthrlp: +- mov al, [edi + ebx] +- add al, [esi + ebx] +- inc ebx +- cmp ebx, bpp +- mov [edi + ebx - 1], al +- jb dpthrlp +- // get # of bytes to alignment +- mov diff, edi // take start of row +- add diff, ebx // add bpp +- xor ecx, ecx +- add diff, 0xf // add 7 + 8 to incr past alignment boundary +- and diff, 0xfffffff8 // mask to alignment boundary +- sub diff, edi // subtract from start ==> value ebx at alignment +- jz dpthgo +- // fix alignment +-dpthlp1: +- xor eax, eax +- // pav = p - a = (a + b - c) - a = b - c +- mov al, [esi + ebx] // load Prior(x) into al +- mov cl, [esi + edx] // load Prior(x-bpp) into cl +- sub eax, ecx // subtract Prior(x-bpp) +- mov patemp, eax // Save pav for later use +- xor eax, eax +- // pbv = p - b = (a + b - c) - b = a - c +- mov al, [edi + edx] // load Raw(x-bpp) into al +- sub eax, ecx // subtract Prior(x-bpp) +- mov ecx, eax +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- add eax, patemp // pcv = pav + pbv +- // pc = abs(pcv) +- test eax, 0x80000000 +- jz dpthpca +- neg eax // reverse sign of neg values +-dpthpca: +- mov pctemp, eax // save pc for later use +- // pb = abs(pbv) +- test ecx, 0x80000000 +- jz dpthpba +- neg ecx // reverse sign of neg values +-dpthpba: +- mov pbtemp, ecx // save pb for later use +- // pa = abs(pav) +- mov eax, patemp +- test eax, 0x80000000 +- jz dpthpaa +- neg eax // reverse sign of neg values +-dpthpaa: +- mov patemp, eax // save pa for later use +- // test if pa <= pb +- cmp eax, ecx +- jna dpthabb +- // pa > pb; now test if pb <= pc +- cmp ecx, pctemp +- jna dpthbbc +- // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) +- mov cl, [esi + edx] // load Prior(x-bpp) into cl +- jmp dpthpaeth +-dpthbbc: +- // pb <= pc; Raw(x) = Paeth(x) + Prior(x) +- mov cl, [esi + ebx] // load Prior(x) into cl +- jmp dpthpaeth +-dpthabb: +- // pa <= pb; now test if pa <= pc +- cmp eax, pctemp +- jna dpthabc +- // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) +- mov cl, [esi + edx] // load Prior(x-bpp) into cl +- jmp dpthpaeth +-dpthabc: +- // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) +- mov cl, [edi + edx] // load Raw(x-bpp) into cl +-dpthpaeth: +- inc ebx +- inc edx +- // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 +- add [edi + ebx - 1], cl +- cmp ebx, diff +- jb dpthlp1 +-dpthgo: +- mov ecx, FullLength +- mov eax, ecx +- sub eax, ebx // subtract alignment fix +- and eax, 0x00000007 // calc bytes over mult of 8 +- sub ecx, eax // drop over bytes from original length +- mov MMXLength, ecx +- } // end _asm block +- // Now do the math for the rest of the row +- switch ( bpp ) +- { +- case 3: +- { +- ActiveMask.use = 0x0000000000ffffff; +- ActiveMaskEnd.use = 0xffff000000000000; +- ShiftBpp.use = 24; // == bpp(3) * 8 +- ShiftRem.use = 40; // == 64 - 24 +- _asm +- { +- mov ebx, diff +- mov edi, row +- mov esi, prev_row +- pxor mm0, mm0 +- // PRIME the pump (load the first Raw(x-bpp) data set +- movq mm1, [edi+ebx-8] +-dpth3lp: +- psrlq mm1, ShiftRem // shift last 3 bytes to 1st 3 bytes +- movq mm2, [esi + ebx] // load b=Prior(x) +- punpcklbw mm1, mm0 // Unpack High bytes of a +- movq mm3, [esi+ebx-8] // Prep c=Prior(x-bpp) bytes +- punpcklbw mm2, mm0 // Unpack High bytes of b +- psrlq mm3, ShiftRem // shift last 3 bytes to 1st 3 bytes +- // pav = p - a = (a + b - c) - a = b - c +- movq mm4, mm2 +- punpcklbw mm3, mm0 // Unpack High bytes of c +- // pbv = p - b = (a + b - c) - b = a - c +- movq mm5, mm1 +- psubw mm4, mm3 +- pxor mm7, mm7 +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- movq mm6, mm4 +- psubw mm5, mm3 +- +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 +- paddw mm6, mm5 +- pand mm0, mm4 // Only pav bytes < 0 in mm7 +- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 +- psubw mm4, mm0 +- pand mm7, mm5 // Only pbv bytes < 0 in mm0 +- psubw mm4, mm0 +- psubw mm5, mm7 +- pxor mm0, mm0 +- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 +- pand mm0, mm6 // Only pav bytes < 0 in mm7 +- psubw mm5, mm7 +- psubw mm6, mm0 +- // test pa <= pb +- movq mm7, mm4 +- psubw mm6, mm0 +- pcmpgtw mm7, mm5 // pa > pb? +- movq mm0, mm7 +- // use mm7 mask to merge pa & pb +- pand mm5, mm7 +- // use mm0 mask copy to merge a & b +- pand mm2, mm0 +- pandn mm7, mm4 +- pandn mm0, mm1 +- paddw mm7, mm5 +- paddw mm0, mm2 +- // test ((pa <= pb)? pa:pb) <= pc +- pcmpgtw mm7, mm6 // pab > pc? +- pxor mm1, mm1 +- pand mm3, mm7 +- pandn mm7, mm0 +- paddw mm7, mm3 +- pxor mm0, mm0 +- packuswb mm7, mm1 +- movq mm3, [esi + ebx] // load c=Prior(x-bpp) +- pand mm7, ActiveMask +- movq mm2, mm3 // load b=Prior(x) step 1 +- paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) +- punpcklbw mm3, mm0 // Unpack High bytes of c +- movq [edi + ebx], mm7 // write back updated value +- movq mm1, mm7 // Now mm1 will be used as Raw(x-bpp) +- // Now do Paeth for 2nd set of bytes (3-5) +- psrlq mm2, ShiftBpp // load b=Prior(x) step 2 +- punpcklbw mm1, mm0 // Unpack High bytes of a +- pxor mm7, mm7 +- punpcklbw mm2, mm0 // Unpack High bytes of b +- // pbv = p - b = (a + b - c) - b = a - c +- movq mm5, mm1 +- // pav = p - a = (a + b - c) - a = b - c +- movq mm4, mm2 +- psubw mm5, mm3 +- psubw mm4, mm3 +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = +- // pav + pbv = pbv + pav +- movq mm6, mm5 +- paddw mm6, mm4 +- +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- pcmpgtw mm0, mm5 // Create mask pbv bytes < 0 +- pcmpgtw mm7, mm4 // Create mask pav bytes < 0 +- pand mm0, mm5 // Only pbv bytes < 0 in mm0 +- pand mm7, mm4 // Only pav bytes < 0 in mm7 +- psubw mm5, mm0 +- psubw mm4, mm7 +- psubw mm5, mm0 +- psubw mm4, mm7 +- pxor mm0, mm0 +- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 +- pand mm0, mm6 // Only pav bytes < 0 in mm7 +- psubw mm6, mm0 +- // test pa <= pb +- movq mm7, mm4 +- psubw mm6, mm0 +- pcmpgtw mm7, mm5 // pa > pb? +- movq mm0, mm7 +- // use mm7 mask to merge pa & pb +- pand mm5, mm7 +- // use mm0 mask copy to merge a & b +- pand mm2, mm0 +- pandn mm7, mm4 +- pandn mm0, mm1 +- paddw mm7, mm5 +- paddw mm0, mm2 +- // test ((pa <= pb)? pa:pb) <= pc +- pcmpgtw mm7, mm6 // pab > pc? +- movq mm2, [esi + ebx] // load b=Prior(x) +- pand mm3, mm7 +- pandn mm7, mm0 +- pxor mm1, mm1 +- paddw mm7, mm3 +- pxor mm0, mm0 +- packuswb mm7, mm1 +- movq mm3, mm2 // load c=Prior(x-bpp) step 1 +- pand mm7, ActiveMask +- punpckhbw mm2, mm0 // Unpack High bytes of b +- psllq mm7, ShiftBpp // Shift bytes to 2nd group of 3 bytes +- // pav = p - a = (a + b - c) - a = b - c +- movq mm4, mm2 +- paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) +- psllq mm3, ShiftBpp // load c=Prior(x-bpp) step 2 +- movq [edi + ebx], mm7 // write back updated value +- movq mm1, mm7 +- punpckhbw mm3, mm0 // Unpack High bytes of c +- psllq mm1, ShiftBpp // Shift bytes +- // Now mm1 will be used as Raw(x-bpp) +- // Now do Paeth for 3rd, and final, set of bytes (6-7) +- pxor mm7, mm7 +- punpckhbw mm1, mm0 // Unpack High bytes of a +- psubw mm4, mm3 +- // pbv = p - b = (a + b - c) - b = a - c +- movq mm5, mm1 +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- movq mm6, mm4 +- psubw mm5, mm3 +- pxor mm0, mm0 +- paddw mm6, mm5 +- +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 +- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 +- pand mm0, mm4 // Only pav bytes < 0 in mm7 +- pand mm7, mm5 // Only pbv bytes < 0 in mm0 +- psubw mm4, mm0 +- psubw mm5, mm7 +- psubw mm4, mm0 +- psubw mm5, mm7 +- pxor mm0, mm0 +- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 +- pand mm0, mm6 // Only pav bytes < 0 in mm7 +- psubw mm6, mm0 +- // test pa <= pb +- movq mm7, mm4 +- psubw mm6, mm0 +- pcmpgtw mm7, mm5 // pa > pb? +- movq mm0, mm7 +- // use mm0 mask copy to merge a & b +- pand mm2, mm0 +- // use mm7 mask to merge pa & pb +- pand mm5, mm7 +- pandn mm0, mm1 +- pandn mm7, mm4 +- paddw mm0, mm2 +- paddw mm7, mm5 +- // test ((pa <= pb)? pa:pb) <= pc +- pcmpgtw mm7, mm6 // pab > pc? +- pand mm3, mm7 +- pandn mm7, mm0 +- paddw mm7, mm3 +- pxor mm1, mm1 +- packuswb mm1, mm7 +- // Step ebx to next set of 8 bytes and repeat loop til done +- add ebx, 8 +- pand mm1, ActiveMaskEnd +- paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) +- +- cmp ebx, MMXLength +- pxor mm0, mm0 // pxor does not affect flags +- movq [edi + ebx - 8], mm1 // write back updated value +- // mm1 will be used as Raw(x-bpp) next loop +- // mm3 ready to be used as Prior(x-bpp) next loop +- jb dpth3lp +- } // end _asm block +- } +- break; +- +- case 6: +- case 7: +- case 5: +- { +- ActiveMask.use = 0x00000000ffffffff; +- ActiveMask2.use = 0xffffffff00000000; +- ShiftBpp.use = bpp << 3; // == bpp * 8 +- ShiftRem.use = 64 - ShiftBpp.use; +- _asm +- { +- mov ebx, diff +- mov edi, row +- mov esi, prev_row +- // PRIME the pump (load the first Raw(x-bpp) data set +- movq mm1, [edi+ebx-8] +- pxor mm0, mm0 +-dpth6lp: +- // Must shift to position Raw(x-bpp) data +- psrlq mm1, ShiftRem +- // Do first set of 4 bytes +- movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes +- punpcklbw mm1, mm0 // Unpack Low bytes of a +- movq mm2, [esi + ebx] // load b=Prior(x) +- punpcklbw mm2, mm0 // Unpack Low bytes of b +- // Must shift to position Prior(x-bpp) data +- psrlq mm3, ShiftRem +- // pav = p - a = (a + b - c) - a = b - c +- movq mm4, mm2 +- punpcklbw mm3, mm0 // Unpack Low bytes of c +- // pbv = p - b = (a + b - c) - b = a - c +- movq mm5, mm1 +- psubw mm4, mm3 +- pxor mm7, mm7 +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- movq mm6, mm4 +- psubw mm5, mm3 +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 +- paddw mm6, mm5 +- pand mm0, mm4 // Only pav bytes < 0 in mm7 +- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 +- psubw mm4, mm0 +- pand mm7, mm5 // Only pbv bytes < 0 in mm0 +- psubw mm4, mm0 +- psubw mm5, mm7 +- pxor mm0, mm0 +- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 +- pand mm0, mm6 // Only pav bytes < 0 in mm7 +- psubw mm5, mm7 +- psubw mm6, mm0 +- // test pa <= pb +- movq mm7, mm4 +- psubw mm6, mm0 +- pcmpgtw mm7, mm5 // pa > pb? +- movq mm0, mm7 +- // use mm7 mask to merge pa & pb +- pand mm5, mm7 +- // use mm0 mask copy to merge a & b +- pand mm2, mm0 +- pandn mm7, mm4 +- pandn mm0, mm1 +- paddw mm7, mm5 +- paddw mm0, mm2 +- // test ((pa <= pb)? pa:pb) <= pc +- pcmpgtw mm7, mm6 // pab > pc? +- pxor mm1, mm1 +- pand mm3, mm7 +- pandn mm7, mm0 +- paddw mm7, mm3 +- pxor mm0, mm0 +- packuswb mm7, mm1 +- movq mm3, [esi + ebx - 8] // load c=Prior(x-bpp) +- pand mm7, ActiveMask +- psrlq mm3, ShiftRem +- movq mm2, [esi + ebx] // load b=Prior(x) step 1 +- paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) +- movq mm6, mm2 +- movq [edi + ebx], mm7 // write back updated value +- movq mm1, [edi+ebx-8] +- psllq mm6, ShiftBpp +- movq mm5, mm7 +- psrlq mm1, ShiftRem +- por mm3, mm6 +- psllq mm5, ShiftBpp +- punpckhbw mm3, mm0 // Unpack High bytes of c +- por mm1, mm5 +- // Do second set of 4 bytes +- punpckhbw mm2, mm0 // Unpack High bytes of b +- punpckhbw mm1, mm0 // Unpack High bytes of a +- // pav = p - a = (a + b - c) - a = b - c +- movq mm4, mm2 +- // pbv = p - b = (a + b - c) - b = a - c +- movq mm5, mm1 +- psubw mm4, mm3 +- pxor mm7, mm7 +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- movq mm6, mm4 +- psubw mm5, mm3 +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 +- paddw mm6, mm5 +- pand mm0, mm4 // Only pav bytes < 0 in mm7 +- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 +- psubw mm4, mm0 +- pand mm7, mm5 // Only pbv bytes < 0 in mm0 +- psubw mm4, mm0 +- psubw mm5, mm7 +- pxor mm0, mm0 +- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 +- pand mm0, mm6 // Only pav bytes < 0 in mm7 +- psubw mm5, mm7 +- psubw mm6, mm0 +- // test pa <= pb +- movq mm7, mm4 +- psubw mm6, mm0 +- pcmpgtw mm7, mm5 // pa > pb? +- movq mm0, mm7 +- // use mm7 mask to merge pa & pb +- pand mm5, mm7 +- // use mm0 mask copy to merge a & b +- pand mm2, mm0 +- pandn mm7, mm4 +- pandn mm0, mm1 +- paddw mm7, mm5 +- paddw mm0, mm2 +- // test ((pa <= pb)? pa:pb) <= pc +- pcmpgtw mm7, mm6 // pab > pc? +- pxor mm1, mm1 +- pand mm3, mm7 +- pandn mm7, mm0 +- pxor mm1, mm1 +- paddw mm7, mm3 +- pxor mm0, mm0 +- // Step ex to next set of 8 bytes and repeat loop til done +- add ebx, 8 +- packuswb mm1, mm7 +- paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) +- cmp ebx, MMXLength +- movq [edi + ebx - 8], mm1 // write back updated value +- // mm1 will be used as Raw(x-bpp) next loop +- jb dpth6lp +- } // end _asm block +- } +- break; +- +- case 4: +- { +- ActiveMask.use = 0x00000000ffffffff; +- _asm { +- mov ebx, diff +- mov edi, row +- mov esi, prev_row +- pxor mm0, mm0 +- // PRIME the pump (load the first Raw(x-bpp) data set +- movq mm1, [edi+ebx-8] // Only time should need to read +- // a=Raw(x-bpp) bytes +-dpth4lp: +- // Do first set of 4 bytes +- movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes +- punpckhbw mm1, mm0 // Unpack Low bytes of a +- movq mm2, [esi + ebx] // load b=Prior(x) +- punpcklbw mm2, mm0 // Unpack High bytes of b +- // pav = p - a = (a + b - c) - a = b - c +- movq mm4, mm2 +- punpckhbw mm3, mm0 // Unpack High bytes of c +- // pbv = p - b = (a + b - c) - b = a - c +- movq mm5, mm1 +- psubw mm4, mm3 +- pxor mm7, mm7 +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- movq mm6, mm4 +- psubw mm5, mm3 +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 +- paddw mm6, mm5 +- pand mm0, mm4 // Only pav bytes < 0 in mm7 +- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 +- psubw mm4, mm0 +- pand mm7, mm5 // Only pbv bytes < 0 in mm0 +- psubw mm4, mm0 +- psubw mm5, mm7 +- pxor mm0, mm0 +- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 +- pand mm0, mm6 // Only pav bytes < 0 in mm7 +- psubw mm5, mm7 +- psubw mm6, mm0 +- // test pa <= pb +- movq mm7, mm4 +- psubw mm6, mm0 +- pcmpgtw mm7, mm5 // pa > pb? +- movq mm0, mm7 +- // use mm7 mask to merge pa & pb +- pand mm5, mm7 +- // use mm0 mask copy to merge a & b +- pand mm2, mm0 +- pandn mm7, mm4 +- pandn mm0, mm1 +- paddw mm7, mm5 +- paddw mm0, mm2 +- // test ((pa <= pb)? pa:pb) <= pc +- pcmpgtw mm7, mm6 // pab > pc? +- pxor mm1, mm1 +- pand mm3, mm7 +- pandn mm7, mm0 +- paddw mm7, mm3 +- pxor mm0, mm0 +- packuswb mm7, mm1 +- movq mm3, [esi + ebx] // load c=Prior(x-bpp) +- pand mm7, ActiveMask +- movq mm2, mm3 // load b=Prior(x) step 1 +- paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) +- punpcklbw mm3, mm0 // Unpack High bytes of c +- movq [edi + ebx], mm7 // write back updated value +- movq mm1, mm7 // Now mm1 will be used as Raw(x-bpp) +- // Do second set of 4 bytes +- punpckhbw mm2, mm0 // Unpack Low bytes of b +- punpcklbw mm1, mm0 // Unpack Low bytes of a +- // pav = p - a = (a + b - c) - a = b - c +- movq mm4, mm2 +- // pbv = p - b = (a + b - c) - b = a - c +- movq mm5, mm1 +- psubw mm4, mm3 +- pxor mm7, mm7 +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- movq mm6, mm4 +- psubw mm5, mm3 +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 +- paddw mm6, mm5 +- pand mm0, mm4 // Only pav bytes < 0 in mm7 +- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 +- psubw mm4, mm0 +- pand mm7, mm5 // Only pbv bytes < 0 in mm0 +- psubw mm4, mm0 +- psubw mm5, mm7 +- pxor mm0, mm0 +- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 +- pand mm0, mm6 // Only pav bytes < 0 in mm7 +- psubw mm5, mm7 +- psubw mm6, mm0 +- // test pa <= pb +- movq mm7, mm4 +- psubw mm6, mm0 +- pcmpgtw mm7, mm5 // pa > pb? +- movq mm0, mm7 +- // use mm7 mask to merge pa & pb +- pand mm5, mm7 +- // use mm0 mask copy to merge a & b +- pand mm2, mm0 +- pandn mm7, mm4 +- pandn mm0, mm1 +- paddw mm7, mm5 +- paddw mm0, mm2 +- // test ((pa <= pb)? pa:pb) <= pc +- pcmpgtw mm7, mm6 // pab > pc? +- pxor mm1, mm1 +- pand mm3, mm7 +- pandn mm7, mm0 +- pxor mm1, mm1 +- paddw mm7, mm3 +- pxor mm0, mm0 +- // Step ex to next set of 8 bytes and repeat loop til done +- add ebx, 8 +- packuswb mm1, mm7 +- paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) +- cmp ebx, MMXLength +- movq [edi + ebx - 8], mm1 // write back updated value +- // mm1 will be used as Raw(x-bpp) next loop +- jb dpth4lp +- } // end _asm block +- } +- break; +- case 8: // bpp == 8 +- { +- ActiveMask.use = 0x00000000ffffffff; +- _asm { +- mov ebx, diff +- mov edi, row +- mov esi, prev_row +- pxor mm0, mm0 +- // PRIME the pump (load the first Raw(x-bpp) data set +- movq mm1, [edi+ebx-8] // Only time should need to read +- // a=Raw(x-bpp) bytes +-dpth8lp: +- // Do first set of 4 bytes +- movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes +- punpcklbw mm1, mm0 // Unpack Low bytes of a +- movq mm2, [esi + ebx] // load b=Prior(x) +- punpcklbw mm2, mm0 // Unpack Low bytes of b +- // pav = p - a = (a + b - c) - a = b - c +- movq mm4, mm2 +- punpcklbw mm3, mm0 // Unpack Low bytes of c +- // pbv = p - b = (a + b - c) - b = a - c +- movq mm5, mm1 +- psubw mm4, mm3 +- pxor mm7, mm7 +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- movq mm6, mm4 +- psubw mm5, mm3 +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 +- paddw mm6, mm5 +- pand mm0, mm4 // Only pav bytes < 0 in mm7 +- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 +- psubw mm4, mm0 +- pand mm7, mm5 // Only pbv bytes < 0 in mm0 +- psubw mm4, mm0 +- psubw mm5, mm7 +- pxor mm0, mm0 +- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 +- pand mm0, mm6 // Only pav bytes < 0 in mm7 +- psubw mm5, mm7 +- psubw mm6, mm0 +- // test pa <= pb +- movq mm7, mm4 +- psubw mm6, mm0 +- pcmpgtw mm7, mm5 // pa > pb? +- movq mm0, mm7 +- // use mm7 mask to merge pa & pb +- pand mm5, mm7 +- // use mm0 mask copy to merge a & b +- pand mm2, mm0 +- pandn mm7, mm4 +- pandn mm0, mm1 +- paddw mm7, mm5 +- paddw mm0, mm2 +- // test ((pa <= pb)? pa:pb) <= pc +- pcmpgtw mm7, mm6 // pab > pc? +- pxor mm1, mm1 +- pand mm3, mm7 +- pandn mm7, mm0 +- paddw mm7, mm3 +- pxor mm0, mm0 +- packuswb mm7, mm1 +- movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes +- pand mm7, ActiveMask +- movq mm2, [esi + ebx] // load b=Prior(x) +- paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) +- punpckhbw mm3, mm0 // Unpack High bytes of c +- movq [edi + ebx], mm7 // write back updated value +- movq mm1, [edi+ebx-8] // read a=Raw(x-bpp) bytes +- +- // Do second set of 4 bytes +- punpckhbw mm2, mm0 // Unpack High bytes of b +- punpckhbw mm1, mm0 // Unpack High bytes of a +- // pav = p - a = (a + b - c) - a = b - c +- movq mm4, mm2 +- // pbv = p - b = (a + b - c) - b = a - c +- movq mm5, mm1 +- psubw mm4, mm3 +- pxor mm7, mm7 +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- movq mm6, mm4 +- psubw mm5, mm3 +- // pa = abs(p-a) = abs(pav) +- // pb = abs(p-b) = abs(pbv) +- // pc = abs(p-c) = abs(pcv) +- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 +- paddw mm6, mm5 +- pand mm0, mm4 // Only pav bytes < 0 in mm7 +- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 +- psubw mm4, mm0 +- pand mm7, mm5 // Only pbv bytes < 0 in mm0 +- psubw mm4, mm0 +- psubw mm5, mm7 +- pxor mm0, mm0 +- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 +- pand mm0, mm6 // Only pav bytes < 0 in mm7 +- psubw mm5, mm7 +- psubw mm6, mm0 +- // test pa <= pb +- movq mm7, mm4 +- psubw mm6, mm0 +- pcmpgtw mm7, mm5 // pa > pb? +- movq mm0, mm7 +- // use mm7 mask to merge pa & pb +- pand mm5, mm7 +- // use mm0 mask copy to merge a & b +- pand mm2, mm0 +- pandn mm7, mm4 +- pandn mm0, mm1 +- paddw mm7, mm5 +- paddw mm0, mm2 +- // test ((pa <= pb)? pa:pb) <= pc +- pcmpgtw mm7, mm6 // pab > pc? +- pxor mm1, mm1 +- pand mm3, mm7 +- pandn mm7, mm0 +- pxor mm1, mm1 +- paddw mm7, mm3 +- pxor mm0, mm0 +- // Step ex to next set of 8 bytes and repeat loop til done +- add ebx, 8 +- packuswb mm1, mm7 +- paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) +- cmp ebx, MMXLength +- movq [edi + ebx - 8], mm1 // write back updated value +- // mm1 will be used as Raw(x-bpp) next loop +- jb dpth8lp +- } // end _asm block +- } +- break; +- +- case 1: // bpp = 1 +- case 2: // bpp = 2 +- default: // bpp > 8 +- { +- _asm { +- mov ebx, diff +- cmp ebx, FullLength +- jnb dpthdend +- mov edi, row +- mov esi, prev_row +- // Do Paeth decode for remaining bytes +- mov edx, ebx +- xor ecx, ecx // zero ecx before using cl & cx in loop below +- sub edx, bpp // Set edx = ebx - bpp +-dpthdlp: +- xor eax, eax +- // pav = p - a = (a + b - c) - a = b - c +- mov al, [esi + ebx] // load Prior(x) into al +- mov cl, [esi + edx] // load Prior(x-bpp) into cl +- sub eax, ecx // subtract Prior(x-bpp) +- mov patemp, eax // Save pav for later use +- xor eax, eax +- // pbv = p - b = (a + b - c) - b = a - c +- mov al, [edi + edx] // load Raw(x-bpp) into al +- sub eax, ecx // subtract Prior(x-bpp) +- mov ecx, eax +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- add eax, patemp // pcv = pav + pbv +- // pc = abs(pcv) +- test eax, 0x80000000 +- jz dpthdpca +- neg eax // reverse sign of neg values +-dpthdpca: +- mov pctemp, eax // save pc for later use +- // pb = abs(pbv) +- test ecx, 0x80000000 +- jz dpthdpba +- neg ecx // reverse sign of neg values +-dpthdpba: +- mov pbtemp, ecx // save pb for later use +- // pa = abs(pav) +- mov eax, patemp +- test eax, 0x80000000 +- jz dpthdpaa +- neg eax // reverse sign of neg values +-dpthdpaa: +- mov patemp, eax // save pa for later use +- // test if pa <= pb +- cmp eax, ecx +- jna dpthdabb +- // pa > pb; now test if pb <= pc +- cmp ecx, pctemp +- jna dpthdbbc +- // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) +- mov cl, [esi + edx] // load Prior(x-bpp) into cl +- jmp dpthdpaeth +-dpthdbbc: +- // pb <= pc; Raw(x) = Paeth(x) + Prior(x) +- mov cl, [esi + ebx] // load Prior(x) into cl +- jmp dpthdpaeth +-dpthdabb: +- // pa <= pb; now test if pa <= pc +- cmp eax, pctemp +- jna dpthdabc +- // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) +- mov cl, [esi + edx] // load Prior(x-bpp) into cl +- jmp dpthdpaeth +-dpthdabc: +- // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) +- mov cl, [edi + edx] // load Raw(x-bpp) into cl +-dpthdpaeth: +- inc ebx +- inc edx +- // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 +- add [edi + ebx - 1], cl +- cmp ebx, FullLength +- jb dpthdlp +-dpthdend: +- } // end _asm block +- } +- return; // No need to go further with this one +- } // end switch ( bpp ) +- _asm +- { +- // MMX acceleration complete now do clean-up +- // Check if any remaining bytes left to decode +- mov ebx, MMXLength +- cmp ebx, FullLength +- jnb dpthend +- mov edi, row +- mov esi, prev_row +- // Do Paeth decode for remaining bytes +- mov edx, ebx +- xor ecx, ecx // zero ecx before using cl & cx in loop below +- sub edx, bpp // Set edx = ebx - bpp +-dpthlp2: +- xor eax, eax +- // pav = p - a = (a + b - c) - a = b - c +- mov al, [esi + ebx] // load Prior(x) into al +- mov cl, [esi + edx] // load Prior(x-bpp) into cl +- sub eax, ecx // subtract Prior(x-bpp) +- mov patemp, eax // Save pav for later use +- xor eax, eax +- // pbv = p - b = (a + b - c) - b = a - c +- mov al, [edi + edx] // load Raw(x-bpp) into al +- sub eax, ecx // subtract Prior(x-bpp) +- mov ecx, eax +- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv +- add eax, patemp // pcv = pav + pbv +- // pc = abs(pcv) +- test eax, 0x80000000 +- jz dpthpca2 +- neg eax // reverse sign of neg values +-dpthpca2: +- mov pctemp, eax // save pc for later use +- // pb = abs(pbv) +- test ecx, 0x80000000 +- jz dpthpba2 +- neg ecx // reverse sign of neg values +-dpthpba2: +- mov pbtemp, ecx // save pb for later use +- // pa = abs(pav) +- mov eax, patemp +- test eax, 0x80000000 +- jz dpthpaa2 +- neg eax // reverse sign of neg values +-dpthpaa2: +- mov patemp, eax // save pa for later use +- // test if pa <= pb +- cmp eax, ecx +- jna dpthabb2 +- // pa > pb; now test if pb <= pc +- cmp ecx, pctemp +- jna dpthbbc2 +- // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) +- mov cl, [esi + edx] // load Prior(x-bpp) into cl +- jmp dpthpaeth2 +-dpthbbc2: +- // pb <= pc; Raw(x) = Paeth(x) + Prior(x) +- mov cl, [esi + ebx] // load Prior(x) into cl +- jmp dpthpaeth2 +-dpthabb2: +- // pa <= pb; now test if pa <= pc +- cmp eax, pctemp +- jna dpthabc2 +- // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) +- mov cl, [esi + edx] // load Prior(x-bpp) into cl +- jmp dpthpaeth2 +-dpthabc2: +- // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) +- mov cl, [edi + edx] // load Raw(x-bpp) into cl +-dpthpaeth2: +- inc ebx +- inc edx +- // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 +- add [edi + ebx - 1], cl +- cmp ebx, FullLength +- jb dpthlp2 +-dpthend: +- emms // End MMX instructions; prep for possible FP instrs. +- } // end _asm block +-} +- +-// Optimized code for PNG Sub filter decoder +-void /* PRIVATE */ +-png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row) +-{ +- //int test; +- int bpp; +- png_uint_32 FullLength; +- png_uint_32 MMXLength; +- int diff; +- +- bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel +- FullLength = row_info->rowbytes - bpp; // # of bytes to filter +- _asm { +- mov edi, row +- mov esi, edi // lp = row +- add edi, bpp // rp = row + bpp +- xor eax, eax +- // get # of bytes to alignment +- mov diff, edi // take start of row +- add diff, 0xf // add 7 + 8 to incr past +- // alignment boundary +- xor ebx, ebx +- and diff, 0xfffffff8 // mask to alignment boundary +- sub diff, edi // subtract from start ==> value +- // ebx at alignment +- jz dsubgo +- // fix alignment +-dsublp1: +- mov al, [esi+ebx] +- add [edi+ebx], al +- inc ebx +- cmp ebx, diff +- jb dsublp1 +-dsubgo: +- mov ecx, FullLength +- mov edx, ecx +- sub edx, ebx // subtract alignment fix +- and edx, 0x00000007 // calc bytes over mult of 8 +- sub ecx, edx // drop over bytes from length +- mov MMXLength, ecx +- } // end _asm block +- +- // Now do the math for the rest of the row +- switch ( bpp ) +- { +- case 3: +- { +- ActiveMask.use = 0x0000ffffff000000; +- ShiftBpp.use = 24; // == 3 * 8 +- ShiftRem.use = 40; // == 64 - 24 +- _asm { +- mov edi, row +- movq mm7, ActiveMask // Load ActiveMask for 2nd active byte group +- mov esi, edi // lp = row +- add edi, bpp // rp = row + bpp +- movq mm6, mm7 +- mov ebx, diff +- psllq mm6, ShiftBpp // Move mask in mm6 to cover 3rd active +- // byte group +- // PRIME the pump (load the first Raw(x-bpp) data set +- movq mm1, [edi+ebx-8] +-dsub3lp: +- psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes +- // no need for mask; shift clears inactive bytes +- // Add 1st active group +- movq mm0, [edi+ebx] +- paddb mm0, mm1 +- // Add 2nd active group +- movq mm1, mm0 // mov updated Raws to mm1 +- psllq mm1, ShiftBpp // shift data to position correctly +- pand mm1, mm7 // mask to use only 2nd active group +- paddb mm0, mm1 +- // Add 3rd active group +- movq mm1, mm0 // mov updated Raws to mm1 +- psllq mm1, ShiftBpp // shift data to position correctly +- pand mm1, mm6 // mask to use only 3rd active group +- add ebx, 8 +- paddb mm0, mm1 +- cmp ebx, MMXLength +- movq [edi+ebx-8], mm0 // Write updated Raws back to array +- // Prep for doing 1st add at top of loop +- movq mm1, mm0 +- jb dsub3lp +- } // end _asm block +- } +- break; +- +- case 1: +- { +- // Placed here just in case this is a duplicate of the +- // non-MMX code for the SUB filter in png_read_filter_row below +- // +- // png_bytep rp; +- // png_bytep lp; +- // png_uint_32 i; +- // bpp = (row_info->pixel_depth + 7) >> 3; +- // for (i = (png_uint_32)bpp, rp = row + bpp, lp = row; +- // i < row_info->rowbytes; i++, rp++, lp++) +- // { +- // *rp = (png_byte)(((int)(*rp) + (int)(*lp)) & 0xff); +- // } +- _asm { +- mov ebx, diff +- mov edi, row +- cmp ebx, FullLength +- jnb dsub1end +- mov esi, edi // lp = row +- xor eax, eax +- add edi, bpp // rp = row + bpp +-dsub1lp: +- mov al, [esi+ebx] +- add [edi+ebx], al +- inc ebx +- cmp ebx, FullLength +- jb dsub1lp +-dsub1end: +- } // end _asm block +- } +- return; +- +- case 6: +- case 7: +- case 4: +- case 5: +- { +- ShiftBpp.use = bpp << 3; +- ShiftRem.use = 64 - ShiftBpp.use; +- _asm { +- mov edi, row +- mov ebx, diff +- mov esi, edi // lp = row +- add edi, bpp // rp = row + bpp +- // PRIME the pump (load the first Raw(x-bpp) data set +- movq mm1, [edi+ebx-8] +-dsub4lp: +- psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes +- // no need for mask; shift clears inactive bytes +- movq mm0, [edi+ebx] +- paddb mm0, mm1 +- // Add 2nd active group +- movq mm1, mm0 // mov updated Raws to mm1 +- psllq mm1, ShiftBpp // shift data to position correctly +- // there is no need for any mask +- // since shift clears inactive bits/bytes +- add ebx, 8 +- paddb mm0, mm1 +- cmp ebx, MMXLength +- movq [edi+ebx-8], mm0 +- movq mm1, mm0 // Prep for doing 1st add at top of loop +- jb dsub4lp +- } // end _asm block +- } +- break; +- +- case 2: +- { +- ActiveMask.use = 0x00000000ffff0000; +- ShiftBpp.use = 16; // == 2 * 8 +- ShiftRem.use = 48; // == 64 - 16 +- _asm { +- movq mm7, ActiveMask // Load ActiveMask for 2nd active byte group +- mov ebx, diff +- movq mm6, mm7 +- mov edi, row +- psllq mm6, ShiftBpp // Move mask in mm6 to cover 3rd active +- // byte group +- mov esi, edi // lp = row +- movq mm5, mm6 +- add edi, bpp // rp = row + bpp +- psllq mm5, ShiftBpp // Move mask in mm5 to cover 4th active +- // byte group +- // PRIME the pump (load the first Raw(x-bpp) data set +- movq mm1, [edi+ebx-8] +-dsub2lp: +- // Add 1st active group +- psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes +- // no need for mask; shift clears inactive +- // bytes +- movq mm0, [edi+ebx] +- paddb mm0, mm1 +- // Add 2nd active group +- movq mm1, mm0 // mov updated Raws to mm1 +- psllq mm1, ShiftBpp // shift data to position correctly +- pand mm1, mm7 // mask to use only 2nd active group +- paddb mm0, mm1 +- // Add 3rd active group +- movq mm1, mm0 // mov updated Raws to mm1 +- psllq mm1, ShiftBpp // shift data to position correctly +- pand mm1, mm6 // mask to use only 3rd active group +- paddb mm0, mm1 +- // Add 4th active group +- movq mm1, mm0 // mov updated Raws to mm1 +- psllq mm1, ShiftBpp // shift data to position correctly +- pand mm1, mm5 // mask to use only 4th active group +- add ebx, 8 +- paddb mm0, mm1 +- cmp ebx, MMXLength +- movq [edi+ebx-8], mm0 // Write updated Raws back to array +- movq mm1, mm0 // Prep for doing 1st add at top of loop +- jb dsub2lp +- } // end _asm block +- } +- break; +- case 8: +- { +- _asm { +- mov edi, row +- mov ebx, diff +- mov esi, edi // lp = row +- add edi, bpp // rp = row + bpp +- mov ecx, MMXLength +- movq mm7, [edi+ebx-8] // PRIME the pump (load the first +- // Raw(x-bpp) data set +- and ecx, 0x0000003f // calc bytes over mult of 64 +-dsub8lp: +- movq mm0, [edi+ebx] // Load Sub(x) for 1st 8 bytes +- paddb mm0, mm7 +- movq mm1, [edi+ebx+8] // Load Sub(x) for 2nd 8 bytes +- movq [edi+ebx], mm0 // Write Raw(x) for 1st 8 bytes +- // Now mm0 will be used as Raw(x-bpp) for +- // the 2nd group of 8 bytes. This will be +- // repeated for each group of 8 bytes with +- // the 8th group being used as the Raw(x-bpp) +- // for the 1st group of the next loop. +- paddb mm1, mm0 +- movq mm2, [edi+ebx+16] // Load Sub(x) for 3rd 8 bytes +- movq [edi+ebx+8], mm1 // Write Raw(x) for 2nd 8 bytes +- paddb mm2, mm1 +- movq mm3, [edi+ebx+24] // Load Sub(x) for 4th 8 bytes +- movq [edi+ebx+16], mm2 // Write Raw(x) for 3rd 8 bytes +- paddb mm3, mm2 +- movq mm4, [edi+ebx+32] // Load Sub(x) for 5th 8 bytes +- movq [edi+ebx+24], mm3 // Write Raw(x) for 4th 8 bytes +- paddb mm4, mm3 +- movq mm5, [edi+ebx+40] // Load Sub(x) for 6th 8 bytes +- movq [edi+ebx+32], mm4 // Write Raw(x) for 5th 8 bytes +- paddb mm5, mm4 +- movq mm6, [edi+ebx+48] // Load Sub(x) for 7th 8 bytes +- movq [edi+ebx+40], mm5 // Write Raw(x) for 6th 8 bytes +- paddb mm6, mm5 +- movq mm7, [edi+ebx+56] // Load Sub(x) for 8th 8 bytes +- movq [edi+ebx+48], mm6 // Write Raw(x) for 7th 8 bytes +- add ebx, 64 +- paddb mm7, mm6 +- cmp ebx, ecx +- movq [edi+ebx-8], mm7 // Write Raw(x) for 8th 8 bytes +- jb dsub8lp +- cmp ebx, MMXLength +- jnb dsub8lt8 +-dsub8lpA: +- movq mm0, [edi+ebx] +- add ebx, 8 +- paddb mm0, mm7 +- cmp ebx, MMXLength +- movq [edi+ebx-8], mm0 // use -8 to offset early add to ebx +- movq mm7, mm0 // Move calculated Raw(x) data to mm1 to +- // be the new Raw(x-bpp) for the next loop +- jb dsub8lpA +-dsub8lt8: +- } // end _asm block +- } +- break; +- +- default: // bpp greater than 8 bytes +- { +- _asm { +- mov ebx, diff +- mov edi, row +- mov esi, edi // lp = row +- add edi, bpp // rp = row + bpp +-dsubAlp: +- movq mm0, [edi+ebx] +- movq mm1, [esi+ebx] +- add ebx, 8 +- paddb mm0, mm1 +- cmp ebx, MMXLength +- movq [edi+ebx-8], mm0 // mov does not affect flags; -8 to offset +- // add ebx +- jb dsubAlp +- } // end _asm block +- } +- break; +- +- } // end switch ( bpp ) +- +- _asm { +- mov ebx, MMXLength +- mov edi, row +- cmp ebx, FullLength +- jnb dsubend +- mov esi, edi // lp = row +- xor eax, eax +- add edi, bpp // rp = row + bpp +-dsublp2: +- mov al, [esi+ebx] +- add [edi+ebx], al +- inc ebx +- cmp ebx, FullLength +- jb dsublp2 +-dsubend: +- emms // End MMX instructions; prep for possible FP instrs. +- } // end _asm block +-} +- +-// Optimized code for PNG Up filter decoder +-void /* PRIVATE */ +-png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row, +- png_bytep prev_row) +-{ +- png_uint_32 len; +- len = row_info->rowbytes; // # of bytes to filter +- _asm { +- mov edi, row +- // get # of bytes to alignment +- mov ecx, edi +- xor ebx, ebx +- add ecx, 0x7 +- xor eax, eax +- and ecx, 0xfffffff8 +- mov esi, prev_row +- sub ecx, edi +- jz dupgo +- // fix alignment +-duplp1: +- mov al, [edi+ebx] +- add al, [esi+ebx] +- inc ebx +- cmp ebx, ecx +- mov [edi + ebx-1], al // mov does not affect flags; -1 to offset inc ebx +- jb duplp1 +-dupgo: +- mov ecx, len +- mov edx, ecx +- sub edx, ebx // subtract alignment fix +- and edx, 0x0000003f // calc bytes over mult of 64 +- sub ecx, edx // drop over bytes from length +- // Unrolled loop - use all MMX registers and interleave to reduce +- // number of branch instructions (loops) and reduce partial stalls +-duploop: +- movq mm1, [esi+ebx] +- movq mm0, [edi+ebx] +- movq mm3, [esi+ebx+8] +- paddb mm0, mm1 +- movq mm2, [edi+ebx+8] +- movq [edi+ebx], mm0 +- paddb mm2, mm3 +- movq mm5, [esi+ebx+16] +- movq [edi+ebx+8], mm2 +- movq mm4, [edi+ebx+16] +- movq mm7, [esi+ebx+24] +- paddb mm4, mm5 +- movq mm6, [edi+ebx+24] +- movq [edi+ebx+16], mm4 +- paddb mm6, mm7 +- movq mm1, [esi+ebx+32] +- movq [edi+ebx+24], mm6 +- movq mm0, [edi+ebx+32] +- movq mm3, [esi+ebx+40] +- paddb mm0, mm1 +- movq mm2, [edi+ebx+40] +- movq [edi+ebx+32], mm0 +- paddb mm2, mm3 +- movq mm5, [esi+ebx+48] +- movq [edi+ebx+40], mm2 +- movq mm4, [edi+ebx+48] +- movq mm7, [esi+ebx+56] +- paddb mm4, mm5 +- movq mm6, [edi+ebx+56] +- movq [edi+ebx+48], mm4 +- add ebx, 64 +- paddb mm6, mm7 +- cmp ebx, ecx +- movq [edi+ebx-8], mm6 // (+56)movq does not affect flags; +- // -8 to offset add ebx +- jb duploop +- +- cmp edx, 0 // Test for bytes over mult of 64 +- jz dupend +- +- +- // 2 lines added by lcreeve@netins.net +- // (mail 11 Jul 98 in png-implement list) +- cmp edx, 8 //test for less than 8 bytes +- jb duplt8 +- +- +- add ecx, edx +- and edx, 0x00000007 // calc bytes over mult of 8 +- sub ecx, edx // drop over bytes from length +- jz duplt8 +- // Loop using MMX registers mm0 & mm1 to update 8 bytes simultaneously +-duplpA: +- movq mm1, [esi+ebx] +- movq mm0, [edi+ebx] +- add ebx, 8 +- paddb mm0, mm1 +- cmp ebx, ecx +- movq [edi+ebx-8], mm0 // movq does not affect flags; -8 to offset add ebx +- jb duplpA +- cmp edx, 0 // Test for bytes over mult of 8 +- jz dupend +-duplt8: +- xor eax, eax +- add ecx, edx // move over byte count into counter +- // Loop using x86 registers to update remaining bytes +-duplp2: +- mov al, [edi + ebx] +- add al, [esi + ebx] +- inc ebx +- cmp ebx, ecx +- mov [edi + ebx-1], al // mov does not affect flags; -1 to offset inc ebx +- jb duplp2 +-dupend: +- // Conversion of filtered row completed +- emms // End MMX instructions; prep for possible FP instrs. +- } // end _asm block +-} +- +- +-// Optimized png_read_filter_row routines +-void /* PRIVATE */ +-png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep +- row, png_bytep prev_row, int filter) +-{ +-#ifdef PNG_DEBUG +- char filnm[10]; +-#endif +- +- if (mmx_supported == 2) { +-#if !defined(PNG_1_0_X) +- /* this should have happened in png_init_mmx_flags() already */ +- png_warning(png_ptr, "asm_flags may not have been initialized"); +-#endif +- png_mmx_support(); +- } +- +-#ifdef PNG_DEBUG +- png_debug(1, "in png_read_filter_row\n"); +- switch (filter) +- { +- case 0: sprintf(filnm, "none"); +- break; +-#if !defined(PNG_1_0_X) +- case 1: sprintf(filnm, "sub-%s", +- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "MMX" : "x86"); +- break; +- case 2: sprintf(filnm, "up-%s", +- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "MMX" : "x86"); +- break; +- case 3: sprintf(filnm, "avg-%s", +- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "MMX" : "x86"); +- break; +- case 4: sprintf(filnm, "Paeth-%s", +- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "MMX":"x86"); +- break; +-#else +- case 1: sprintf(filnm, "sub"); +- break; +- case 2: sprintf(filnm, "up"); +- break; +- case 3: sprintf(filnm, "avg"); +- break; +- case 4: sprintf(filnm, "Paeth"); +- break; +-#endif +- default: sprintf(filnm, "unknw"); +- break; +- } +- png_debug2(0,"row=%5d, %s, ", png_ptr->row_number, filnm); +- png_debug2(0, "pd=%2d, b=%d, ", (int)row_info->pixel_depth, +- (int)((row_info->pixel_depth + 7) >> 3)); +- png_debug1(0,"len=%8d, ", row_info->rowbytes); +-#endif /* PNG_DEBUG */ +- +- switch (filter) +- { +- case PNG_FILTER_VALUE_NONE: +- break; +- +- case PNG_FILTER_VALUE_SUB: +- { +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB) && +- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && +- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) +-#else +- if (mmx_supported) +-#endif +- { +- png_read_filter_row_mmx_sub(row_info, row); +- } +- else +- { +- png_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; +- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; +- png_bytep rp = row + bpp; +- png_bytep lp = row; +- +- for (i = bpp; i < istop; i++) +- { +- *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff); +- rp++; +- } +- } +- break; +- } +- +- case PNG_FILTER_VALUE_UP: +- { +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP) && +- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && +- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) +-#else +- if (mmx_supported) +-#endif +- { +- png_read_filter_row_mmx_up(row_info, row, prev_row); +- } +- else +- { +- png_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; +- png_bytep rp = row; +- png_bytep pp = prev_row; +- +- for (i = 0; i < istop; ++i) +- { +- *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); +- rp++; +- } +- } +- break; +- } +- +- case PNG_FILTER_VALUE_AVG: +- { +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG) && +- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && +- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) +-#else +- if (mmx_supported) +-#endif +- { +- png_read_filter_row_mmx_avg(row_info, row, prev_row); +- } +- else +- { +- png_uint_32 i; +- png_bytep rp = row; +- png_bytep pp = prev_row; +- png_bytep lp = row; +- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; +- png_uint_32 istop = row_info->rowbytes - bpp; +- +- for (i = 0; i < bpp; i++) +- { +- *rp = (png_byte)(((int)(*rp) + +- ((int)(*pp++) >> 1)) & 0xff); +- rp++; +- } +- +- for (i = 0; i < istop; i++) +- { +- *rp = (png_byte)(((int)(*rp) + +- ((int)(*pp++ + *lp++) >> 1)) & 0xff); +- rp++; +- } +- } +- break; +- } +- +- case PNG_FILTER_VALUE_PAETH: +- { +-#if !defined(PNG_1_0_X) +- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH) && +- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && +- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) +-#else +- if (mmx_supported) +-#endif +- { +- png_read_filter_row_mmx_paeth(row_info, row, prev_row); +- } +- else +- { +- png_uint_32 i; +- png_bytep rp = row; +- png_bytep pp = prev_row; +- png_bytep lp = row; +- png_bytep cp = prev_row; +- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; +- png_uint_32 istop=row_info->rowbytes - bpp; +- +- for (i = 0; i < bpp; i++) +- { +- *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); +- rp++; +- } +- +- for (i = 0; i < istop; i++) // use leftover rp,pp +- { +- int a, b, c, pa, pb, pc, p; +- +- a = *lp++; +- b = *pp++; +- c = *cp++; +- +- p = b - c; +- pc = a - c; +- +-#ifdef PNG_USE_ABS +- pa = abs(p); +- pb = abs(pc); +- pc = abs(p + pc); +-#else +- pa = p < 0 ? -p : p; +- pb = pc < 0 ? -pc : pc; +- pc = (p + pc) < 0 ? -(p + pc) : p + pc; +-#endif +- +- /* +- if (pa <= pb && pa <= pc) +- p = a; +- else if (pb <= pc) +- p = b; +- else +- p = c; +- */ +- +- p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; +- +- *rp = (png_byte)(((int)(*rp) + p) & 0xff); +- rp++; +- } +- } +- break; +- } +- +- default: +- png_warning(png_ptr, "Ignoring bad row filter type"); +- *row=0; +- break; +- } +-} +- +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED && PNG_USE_PNGVCRD */ +diff --git a/thirdparty/libpng/pngwio.c b/thirdparty/libpng/pngwio.c +deleted file mode 100644 +index adc57b3..0000000 +--- a/thirdparty/libpng/pngwio.c ++++ /dev/null +@@ -1,228 +0,0 @@ +- +-/* pngwio.c - functions for data output +- * +- * libpng 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- * +- * This file provides a location for all output. Users who need +- * special handling are expected to write functions that have the same +- * arguments as these and perform similar functions, but that possibly +- * use different output methods. Note that you shouldn't change these +- * functions, but rather write replacement functions and then change +- * them at run time with png_set_write_fn(...). +- */ +- +-#define PNG_INTERNAL +-#include "png.h" +-#ifdef PNG_WRITE_SUPPORTED +- +-/* Write the data to whatever output you are using. The default routine +- writes to a file pointer. Note that this routine sometimes gets called +- with very small lengths, so you should implement some kind of simple +- buffering if you are using unbuffered writes. This should never be asked +- to write more than 64K on a 16 bit machine. */ +- +-void /* PRIVATE */ +-png_write_data(png_structp png_ptr, png_bytep data, png_size_t length) +-{ +- if (png_ptr->write_data_fn != NULL ) +- (*(png_ptr->write_data_fn))(png_ptr, data, length); +- else +- png_error(png_ptr, "Call to NULL write function"); +-} +- +-#if !defined(PNG_NO_STDIO) +-/* This is the function that does the actual writing of data. If you are +- not writing to a standard C stream, you should create a replacement +- write_data function and use it at run time with png_set_write_fn(), rather +- than changing the library. */ +-#ifndef USE_FAR_KEYWORD +-void PNGAPI +-png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) +-{ +- png_uint_32 check; +- +-#if defined(_WIN32_WCE) +- if ( !WriteFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) +- check = 0; +-#else +- check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr)); +-#endif +- if (check != length) +- png_error(png_ptr, "Write Error"); +-} +-#else +-/* this is the model-independent version. Since the standard I/O library +- can't handle far buffers in the medium and small models, we have to copy +- the data. +-*/ +- +-#define NEAR_BUF_SIZE 1024 +-#define MIN(a,b) (a <= b ? a : b) +- +-void PNGAPI +-png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) +-{ +- png_uint_32 check; +- png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */ +- png_FILE_p io_ptr; +- +- /* Check if data really is near. If so, use usual code. */ +- near_data = (png_byte *)CVT_PTR_NOCHECK(data); +- io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); +- if ((png_bytep)near_data == data) +- { +-#if defined(_WIN32_WCE) +- if ( !WriteFile(io_ptr, near_data, length, &check, NULL) ) +- check = 0; +-#else +- check = fwrite(near_data, 1, length, io_ptr); +-#endif +- } +- else +- { +- png_byte buf[NEAR_BUF_SIZE]; +- png_size_t written, remaining, err; +- check = 0; +- remaining = length; +- do +- { +- written = MIN(NEAR_BUF_SIZE, remaining); +- png_memcpy(buf, data, written); /* copy far buffer to near buffer */ +-#if defined(_WIN32_WCE) +- if ( !WriteFile(io_ptr, buf, written, &err, NULL) ) +- err = 0; +-#else +- err = fwrite(buf, 1, written, io_ptr); +-#endif +- if (err != written) +- break; +- else +- check += err; +- data += written; +- remaining -= written; +- } +- while (remaining != 0); +- } +- if (check != length) +- png_error(png_ptr, "Write Error"); +-} +- +-#endif +-#endif +- +-/* This function is called to output any data pending writing (normally +- to disk). After png_flush is called, there should be no data pending +- writing in any buffers. */ +-#if defined(PNG_WRITE_FLUSH_SUPPORTED) +-void /* PRIVATE */ +-png_flush(png_structp png_ptr) +-{ +- if (png_ptr->output_flush_fn != NULL) +- (*(png_ptr->output_flush_fn))(png_ptr); +-} +- +-#if !defined(PNG_NO_STDIO) +-void PNGAPI +-png_default_flush(png_structp png_ptr) +-{ +-#if !defined(_WIN32_WCE) +- png_FILE_p io_ptr; +- io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr)); +- if (io_ptr != NULL) +- fflush(io_ptr); +-#endif +-} +-#endif +-#endif +- +-/* This function allows the application to supply new output functions for +- libpng if standard C streams aren't being used. +- +- This function takes as its arguments: +- png_ptr - pointer to a png output data structure +- io_ptr - pointer to user supplied structure containing info about +- the output functions. May be NULL. +- write_data_fn - pointer to a new output function that takes as its +- arguments a pointer to a png_struct, a pointer to +- data to be written, and a 32-bit unsigned int that is +- the number of bytes to be written. The new write +- function should call png_error(png_ptr, "Error msg") +- to exit and output any fatal error messages. +- flush_data_fn - pointer to a new flush function that takes as its +- arguments a pointer to a png_struct. After a call to +- the flush function, there should be no data in any buffers +- or pending transmission. If the output method doesn't do +- any buffering of ouput, a function prototype must still be +- supplied although it doesn't have to do anything. If +- PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile +- time, output_flush_fn will be ignored, although it must be +- supplied for compatibility. */ +-void PNGAPI +-png_set_write_fn(png_structp png_ptr, png_voidp io_ptr, +- png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn) +-{ +- png_ptr->io_ptr = io_ptr; +- +-#if !defined(PNG_NO_STDIO) +- if (write_data_fn != NULL) +- png_ptr->write_data_fn = write_data_fn; +- else +- png_ptr->write_data_fn = png_default_write_data; +-#else +- png_ptr->write_data_fn = write_data_fn; +-#endif +- +-#if defined(PNG_WRITE_FLUSH_SUPPORTED) +-#if !defined(PNG_NO_STDIO) +- if (output_flush_fn != NULL) +- png_ptr->output_flush_fn = output_flush_fn; +- else +- png_ptr->output_flush_fn = png_default_flush; +-#else +- png_ptr->output_flush_fn = output_flush_fn; +-#endif +-#endif /* PNG_WRITE_FLUSH_SUPPORTED */ +- +- /* It is an error to read while writing a png file */ +- if (png_ptr->read_data_fn != NULL) +- { +- png_ptr->read_data_fn = NULL; +- png_warning(png_ptr, +- "Attempted to set both read_data_fn and write_data_fn in"); +- png_warning(png_ptr, +- "the same structure. Resetting read_data_fn to NULL."); +- } +-} +- +-#if defined(USE_FAR_KEYWORD) +-#if defined(_MSC_VER) +-void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check) +-{ +- void *near_ptr; +- void FAR *far_ptr; +- FP_OFF(near_ptr) = FP_OFF(ptr); +- far_ptr = (void FAR *)near_ptr; +- if(check != 0) +- if(FP_SEG(ptr) != FP_SEG(far_ptr)) +- png_error(png_ptr,"segment lost in conversion"); +- return(near_ptr); +-} +-# else +-void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check) +-{ +- void *near_ptr; +- void FAR *far_ptr; +- near_ptr = (void FAR *)ptr; +- far_ptr = (void FAR *)near_ptr; +- if(check != 0) +- if(far_ptr != ptr) +- png_error(png_ptr,"segment lost in conversion"); +- return(near_ptr); +-} +-# endif +-# endif +-#endif /* PNG_WRITE_SUPPORTED */ +diff --git a/thirdparty/libpng/pngwrite.c b/thirdparty/libpng/pngwrite.c +deleted file mode 100644 +index f422173..0000000 +--- a/thirdparty/libpng/pngwrite.c ++++ /dev/null +@@ -1,1464 +0,0 @@ +- +-/* pngwrite.c - general routines to write a PNG file +- * +- * libpng 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- */ +- +-/* get internal access to png.h */ +-#define PNG_INTERNAL +-#include "png.h" +-#ifdef PNG_WRITE_SUPPORTED +- +-/* Writes all the PNG information. This is the suggested way to use the +- * library. If you have a new chunk to add, make a function to write it, +- * and put it in the correct location here. If you want the chunk written +- * after the image data, put it in png_write_end(). I strongly encourage +- * you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing +- * the chunk, as that will keep the code from breaking if you want to just +- * write a plain PNG file. If you have long comments, I suggest writing +- * them in png_write_end(), and compressing them. +- */ +-void PNGAPI +-png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr) +-{ +- png_debug(1, "in png_write_info_before_PLTE\n"); +- if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) +- { +- png_write_sig(png_ptr); /* write PNG signature */ +-#if defined(PNG_MNG_FEATURES_SUPPORTED) +- if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted)) +- { +- png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n"); +- png_ptr->mng_features_permitted=0; +- } +-#endif +- /* write IHDR information. */ +- png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height, +- info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type, +- info_ptr->filter_type, +-#if defined(PNG_WRITE_INTERLACING_SUPPORTED) +- info_ptr->interlace_type); +-#else +- 0); +-#endif +- /* the rest of these check to see if the valid field has the appropriate +- flag set, and if it does, writes the chunk. */ +-#if defined(PNG_WRITE_gAMA_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_gAMA) +- { +-# ifdef PNG_FLOATING_POINT_SUPPORTED +- png_write_gAMA(png_ptr, info_ptr->gamma); +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +- png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma); +-# endif +-#endif +- } +-#endif +-#if defined(PNG_WRITE_sRGB_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_sRGB) +- png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent); +-#endif +-#if defined(PNG_WRITE_iCCP_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_iCCP) +- png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE, +- info_ptr->iccp_profile, (int)info_ptr->iccp_proflen); +-#endif +-#if defined(PNG_WRITE_sBIT_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_sBIT) +- png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type); +-#endif +-#if defined(PNG_WRITE_cHRM_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_cHRM) +- { +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- png_write_cHRM(png_ptr, +- info_ptr->x_white, info_ptr->y_white, +- info_ptr->x_red, info_ptr->y_red, +- info_ptr->x_green, info_ptr->y_green, +- info_ptr->x_blue, info_ptr->y_blue); +-#else +-# ifdef PNG_FIXED_POINT_SUPPORTED +- png_write_cHRM_fixed(png_ptr, +- info_ptr->int_x_white, info_ptr->int_y_white, +- info_ptr->int_x_red, info_ptr->int_y_red, +- info_ptr->int_x_green, info_ptr->int_y_green, +- info_ptr->int_x_blue, info_ptr->int_y_blue); +-# endif +-#endif +- } +-#endif +-#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) +- if (info_ptr->unknown_chunks_num) +- { +- png_unknown_chunk *up; +- +- png_debug(5, "writing extra chunks\n"); +- +- for (up = info_ptr->unknown_chunks; +- up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; +- up++) +- { +- int keep=png_handle_as_unknown(png_ptr, up->name); +- if (keep != PNG_HANDLE_CHUNK_NEVER && +- up->location && !(up->location & PNG_HAVE_PLTE) && +- !(up->location & PNG_HAVE_IDAT) && +- ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS || +- (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) +- { +- png_write_chunk(png_ptr, up->name, up->data, up->size); +- } +- } +- } +-#endif +- png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE; +- } +-} +- +-void PNGAPI +-png_write_info(png_structp png_ptr, png_infop info_ptr) +-{ +-#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) +- int i; +-#endif +- +- png_debug(1, "in png_write_info\n"); +- +- png_write_info_before_PLTE(png_ptr, info_ptr); +- +- if (info_ptr->valid & PNG_INFO_PLTE) +- png_write_PLTE(png_ptr, info_ptr->palette, +- (png_uint_32)info_ptr->num_palette); +- else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- png_error(png_ptr, "Valid palette required for paletted images\n"); +- +-#if defined(PNG_WRITE_tRNS_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_tRNS) +- { +-#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +- /* invert the alpha channel (in tRNS) */ +- if ((png_ptr->transformations & PNG_INVERT_ALPHA) && +- info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- { +- int j; +- for (j=0; j<(int)info_ptr->num_trans; j++) +- info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]); +- } +-#endif +- png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values), +- info_ptr->num_trans, info_ptr->color_type); +- } +-#endif +-#if defined(PNG_WRITE_bKGD_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_bKGD) +- png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type); +-#endif +-#if defined(PNG_WRITE_hIST_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_hIST) +- png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette); +-#endif +-#if defined(PNG_WRITE_oFFs_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_oFFs) +- png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset, +- info_ptr->offset_unit_type); +-#endif +-#if defined(PNG_WRITE_pCAL_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_pCAL) +- png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0, +- info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams, +- info_ptr->pcal_units, info_ptr->pcal_params); +-#endif +-#if defined(PNG_WRITE_sCAL_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_sCAL) +-#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) +- png_write_sCAL(png_ptr, (int)info_ptr->scal_unit, +- info_ptr->scal_pixel_width, info_ptr->scal_pixel_height); +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +- png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit, +- info_ptr->scal_s_width, info_ptr->scal_s_height); +-#else +- png_warning(png_ptr, +- "png_write_sCAL not supported; sCAL chunk not written.\n"); +-#endif +-#endif +-#endif +-#if defined(PNG_WRITE_pHYs_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_pHYs) +- png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit, +- info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type); +-#endif +-#if defined(PNG_WRITE_tIME_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_tIME) +- { +- png_write_tIME(png_ptr, &(info_ptr->mod_time)); +- png_ptr->mode |= PNG_WROTE_tIME; +- } +-#endif +-#if defined(PNG_WRITE_sPLT_SUPPORTED) +- if (info_ptr->valid & PNG_INFO_sPLT) +- for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) +- png_write_sPLT(png_ptr, info_ptr->splt_palettes + i); +-#endif +-#if defined(PNG_WRITE_TEXT_SUPPORTED) +- /* Check to see if we need to write text chunks */ +- for (i = 0; i < info_ptr->num_text; i++) +- { +- png_debug2(2, "Writing header text chunk %d, type %d\n", i, +- info_ptr->text[i].compression); +- /* an internationalized chunk? */ +- if (info_ptr->text[i].compression > 0) +- { +-#if defined(PNG_WRITE_iTXt_SUPPORTED) +- /* write international chunk */ +- png_write_iTXt(png_ptr, +- info_ptr->text[i].compression, +- info_ptr->text[i].key, +- info_ptr->text[i].lang, +- info_ptr->text[i].lang_key, +- info_ptr->text[i].text); +-#else +- png_warning(png_ptr, "Unable to write international text\n"); +-#endif +- /* Mark this chunk as written */ +- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; +- } +- /* If we want a compressed text chunk */ +- else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt) +- { +-#if defined(PNG_WRITE_zTXt_SUPPORTED) +- /* write compressed chunk */ +- png_write_zTXt(png_ptr, info_ptr->text[i].key, +- info_ptr->text[i].text, 0, +- info_ptr->text[i].compression); +-#else +- png_warning(png_ptr, "Unable to write compressed text\n"); +-#endif +- /* Mark this chunk as written */ +- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR; +- } +- else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) +- { +-#if defined(PNG_WRITE_tEXt_SUPPORTED) +- /* write uncompressed chunk */ +- png_write_tEXt(png_ptr, info_ptr->text[i].key, +- info_ptr->text[i].text, +- 0); +-#else +- png_warning(png_ptr, "Unable to write uncompressed text\n"); +-#endif +- /* Mark this chunk as written */ +- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; +- } +- } +-#endif +-#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) +- if (info_ptr->unknown_chunks_num) +- { +- png_unknown_chunk *up; +- +- png_debug(5, "writing extra chunks\n"); +- +- for (up = info_ptr->unknown_chunks; +- up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; +- up++) +- { +- int keep=png_handle_as_unknown(png_ptr, up->name); +- if (keep != PNG_HANDLE_CHUNK_NEVER && +- up->location && (up->location & PNG_HAVE_PLTE) && +- !(up->location & PNG_HAVE_IDAT) && +- ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS || +- (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) +- { +- png_write_chunk(png_ptr, up->name, up->data, up->size); +- } +- } +- } +-#endif +-} +- +-/* Writes the end of the PNG file. If you don't want to write comments or +- * time information, you can pass NULL for info. If you already wrote these +- * in png_write_info(), do not write them again here. If you have long +- * comments, I suggest writing them here, and compressing them. +- */ +-void PNGAPI +-png_write_end(png_structp png_ptr, png_infop info_ptr) +-{ +- png_debug(1, "in png_write_end\n"); +- if (!(png_ptr->mode & PNG_HAVE_IDAT)) +- png_error(png_ptr, "No IDATs written into file"); +- +- /* see if user wants us to write information chunks */ +- if (info_ptr != NULL) +- { +-#if defined(PNG_WRITE_TEXT_SUPPORTED) +- int i; /* local index variable */ +-#endif +-#if defined(PNG_WRITE_tIME_SUPPORTED) +- /* check to see if user has supplied a time chunk */ +- if ((info_ptr->valid & PNG_INFO_tIME) && +- !(png_ptr->mode & PNG_WROTE_tIME)) +- png_write_tIME(png_ptr, &(info_ptr->mod_time)); +-#endif +-#if defined(PNG_WRITE_TEXT_SUPPORTED) +- /* loop through comment chunks */ +- for (i = 0; i < info_ptr->num_text; i++) +- { +- png_debug2(2, "Writing trailer text chunk %d, type %d\n", i, +- info_ptr->text[i].compression); +- /* an internationalized chunk? */ +- if (info_ptr->text[i].compression > 0) +- { +-#if defined(PNG_WRITE_iTXt_SUPPORTED) +- /* write international chunk */ +- png_write_iTXt(png_ptr, +- info_ptr->text[i].compression, +- info_ptr->text[i].key, +- info_ptr->text[i].lang, +- info_ptr->text[i].lang_key, +- info_ptr->text[i].text); +-#else +- png_warning(png_ptr, "Unable to write international text\n"); +-#endif +- /* Mark this chunk as written */ +- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; +- } +- else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt) +- { +-#if defined(PNG_WRITE_zTXt_SUPPORTED) +- /* write compressed chunk */ +- png_write_zTXt(png_ptr, info_ptr->text[i].key, +- info_ptr->text[i].text, 0, +- info_ptr->text[i].compression); +-#else +- png_warning(png_ptr, "Unable to write compressed text\n"); +-#endif +- /* Mark this chunk as written */ +- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR; +- } +- else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) +- { +-#if defined(PNG_WRITE_tEXt_SUPPORTED) +- /* write uncompressed chunk */ +- png_write_tEXt(png_ptr, info_ptr->text[i].key, +- info_ptr->text[i].text, 0); +-#else +- png_warning(png_ptr, "Unable to write uncompressed text\n"); +-#endif +- +- /* Mark this chunk as written */ +- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; +- } +- } +-#endif +-#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) +- if (info_ptr->unknown_chunks_num) +- { +- png_unknown_chunk *up; +- +- png_debug(5, "writing extra chunks\n"); +- +- for (up = info_ptr->unknown_chunks; +- up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; +- up++) +- { +- int keep=png_handle_as_unknown(png_ptr, up->name); +- if (keep != PNG_HANDLE_CHUNK_NEVER && +- up->location && (up->location & PNG_AFTER_IDAT) && +- ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS || +- (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) +- { +- png_write_chunk(png_ptr, up->name, up->data, up->size); +- } +- } +- } +-#endif +- } +- +- png_ptr->mode |= PNG_AFTER_IDAT; +- +- /* write end of PNG file */ +- png_write_IEND(png_ptr); +-#if 0 +-/* This flush, added in libpng-1.0.8, causes some applications to crash +- because they do not set png_ptr->output_flush_fn */ +- png_flush(png_ptr); +-#endif +-} +- +-#if defined(PNG_WRITE_tIME_SUPPORTED) +-#if !defined(_WIN32_WCE) +-/* "time.h" functions are not supported on WindowsCE */ +-void PNGAPI +-png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime) +-{ +- png_debug(1, "in png_convert_from_struct_tm\n"); +- ptime->year = (png_uint_16)(1900 + ttime->tm_year); +- ptime->month = (png_byte)(ttime->tm_mon + 1); +- ptime->day = (png_byte)ttime->tm_mday; +- ptime->hour = (png_byte)ttime->tm_hour; +- ptime->minute = (png_byte)ttime->tm_min; +- ptime->second = (png_byte)ttime->tm_sec; +-} +- +-void PNGAPI +-png_convert_from_time_t(png_timep ptime, time_t ttime) +-{ +- struct tm *tbuf; +- +- png_debug(1, "in png_convert_from_time_t\n"); +- tbuf = gmtime(&ttime); +- png_convert_from_struct_tm(ptime, tbuf); +-} +-#endif +-#endif +- +-/* Initialize png_ptr structure, and allocate any memory needed */ +-png_structp PNGAPI +-png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn) +-{ +-#ifdef PNG_USER_MEM_SUPPORTED +- return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn, +- warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL)); +-} +- +-/* Alternate initialize png_ptr structure, and allocate any memory needed */ +-png_structp PNGAPI +-png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, +- png_malloc_ptr malloc_fn, png_free_ptr free_fn) +-{ +-#endif /* PNG_USER_MEM_SUPPORTED */ +- png_structp png_ptr; +-#ifdef PNG_SETJMP_SUPPORTED +-#ifdef USE_FAR_KEYWORD +- jmp_buf jmpbuf; +-#endif +-#endif +- int i; +- png_debug(1, "in png_create_write_struct\n"); +-#ifdef PNG_USER_MEM_SUPPORTED +- png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, +- (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr); +-#else +- png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); +-#endif /* PNG_USER_MEM_SUPPORTED */ +- if (png_ptr == NULL) +- return (NULL); +- +-#if !defined(PNG_1_0_X) +-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED +- png_init_mmx_flags(png_ptr); /* 1.2.0 addition */ +-#endif +-#endif /* PNG_1_0_X */ +- +- /* added at libpng-1.2.6 */ +-#ifdef PNG_SET_USER_LIMITS_SUPPORTED +- png_ptr->user_width_max=PNG_USER_WIDTH_MAX; +- png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; +-#endif +- +-#ifdef PNG_SETJMP_SUPPORTED +-#ifdef USE_FAR_KEYWORD +- if (setjmp(jmpbuf)) +-#else +- if (setjmp(png_ptr->jmpbuf)) +-#endif +- { +- png_free(png_ptr, png_ptr->zbuf); +- png_ptr->zbuf=NULL; +- png_destroy_struct(png_ptr); +- return (NULL); +- } +-#ifdef USE_FAR_KEYWORD +- png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf)); +-#endif +-#endif +- +-#ifdef PNG_USER_MEM_SUPPORTED +- png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); +-#endif /* PNG_USER_MEM_SUPPORTED */ +- png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); +- +- i=0; +- do +- { +- if(user_png_ver[i] != png_libpng_ver[i]) +- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; +- } while (png_libpng_ver[i++]); +- +- if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) +- { +- /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so +- * we must recompile any applications that use any older library version. +- * For versions after libpng 1.0, we will be compatible, so we need +- * only check the first digit. +- */ +- if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || +- (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || +- (user_png_ver[0] == '0' && user_png_ver[2] < '9')) +- { +-#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) +- char msg[80]; +- if (user_png_ver) +- { +- sprintf(msg, "Application was compiled with png.h from libpng-%.20s", +- user_png_ver); +- png_warning(png_ptr, msg); +- } +- sprintf(msg, "Application is running with png.c from libpng-%.20s", +- png_libpng_ver); +- png_warning(png_ptr, msg); +-#endif +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +- png_ptr->flags=0; +-#endif +- png_error(png_ptr, +- "Incompatible libpng version in application and library"); +- } +- } +- +- /* initialize zbuf - compression buffer */ +- png_ptr->zbuf_size = PNG_ZBUF_SIZE; +- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)png_ptr->zbuf_size); +- +- png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL, +- png_flush_ptr_NULL); +- +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) +- png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT, +- 1, png_doublep_NULL, png_doublep_NULL); +-#endif +- +-#ifdef PNG_SETJMP_SUPPORTED +-/* Applications that neglect to set up their own setjmp() and then encounter +- a png_error() will longjmp here. Since the jmpbuf is then meaningless we +- abort instead of returning. */ +-#ifdef USE_FAR_KEYWORD +- if (setjmp(jmpbuf)) +- PNG_ABORT(); +- png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf)); +-#else +- if (setjmp(png_ptr->jmpbuf)) +- PNG_ABORT(); +-#endif +-#endif +- return (png_ptr); +-} +- +-/* Initialize png_ptr structure, and allocate any memory needed */ +-#undef png_write_init +-void PNGAPI +-png_write_init(png_structp png_ptr) +-{ +- /* We only come here via pre-1.0.7-compiled applications */ +- png_write_init_2(png_ptr, "1.0.6 or earlier", 0, 0); +-} +- +-void PNGAPI +-png_write_init_2(png_structp png_ptr, png_const_charp user_png_ver, +- png_size_t png_struct_size, png_size_t png_info_size) +-{ +- /* We only come here via pre-1.0.12-compiled applications */ +-#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) +- if(png_sizeof(png_struct) > png_struct_size || +- png_sizeof(png_info) > png_info_size) +- { +- char msg[80]; +- png_ptr->warning_fn=NULL; +- if (user_png_ver) +- { +- sprintf(msg, "Application was compiled with png.h from libpng-%.20s", +- user_png_ver); +- png_warning(png_ptr, msg); +- } +- sprintf(msg, "Application is running with png.c from libpng-%.20s", +- png_libpng_ver); +- png_warning(png_ptr, msg); +- } +-#endif +- if(png_sizeof(png_struct) > png_struct_size) +- { +- png_ptr->error_fn=NULL; +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +- png_ptr->flags=0; +-#endif +- png_error(png_ptr, +- "The png struct allocated by the application for writing is too small."); +- } +- if(png_sizeof(png_info) > png_info_size) +- { +- png_ptr->error_fn=NULL; +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +- png_ptr->flags=0; +-#endif +- png_error(png_ptr, +- "The info struct allocated by the application for writing is too small."); +- } +- png_write_init_3(&png_ptr, user_png_ver, png_struct_size); +-} +- +- +-void PNGAPI +-png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver, +- png_size_t png_struct_size) +-{ +- png_structp png_ptr=*ptr_ptr; +-#ifdef PNG_SETJMP_SUPPORTED +- jmp_buf tmp_jmp; /* to save current jump buffer */ +-#endif +- int i = 0; +- do +- { +- if (user_png_ver[i] != png_libpng_ver[i]) +- { +-#ifdef PNG_LEGACY_SUPPORTED +- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; +-#else +- png_ptr->warning_fn=NULL; +- png_warning(png_ptr, +- "Application uses deprecated png_write_init() and should be recompiled."); +- break; +-#endif +- } +- } while (png_libpng_ver[i++]); +- +- png_debug(1, "in png_write_init_3\n"); +- +-#ifdef PNG_SETJMP_SUPPORTED +- /* save jump buffer and error functions */ +- png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf)); +-#endif +- +- if (png_sizeof(png_struct) > png_struct_size) +- { +- png_destroy_struct(png_ptr); +- png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); +- *ptr_ptr = png_ptr; +- } +- +- /* reset all variables to 0 */ +- png_memset(png_ptr, 0, png_sizeof (png_struct)); +- +- /* added at libpng-1.2.6 */ +-#ifdef PNG_SET_USER_LIMITS_SUPPORTED +- png_ptr->user_width_max=PNG_USER_WIDTH_MAX; +- png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; +-#endif +- +-#if !defined(PNG_1_0_X) +-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED +- png_init_mmx_flags(png_ptr); /* 1.2.0 addition */ +-#endif +-#endif /* PNG_1_0_X */ +- +-#ifdef PNG_SETJMP_SUPPORTED +- /* restore jump buffer */ +- png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf)); +-#endif +- +- png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL, +- png_flush_ptr_NULL); +- +- /* initialize zbuf - compression buffer */ +- png_ptr->zbuf_size = PNG_ZBUF_SIZE; +- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)png_ptr->zbuf_size); +- +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) +- png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT, +- 1, png_doublep_NULL, png_doublep_NULL); +-#endif +-} +- +-/* Write a few rows of image data. If the image is interlaced, +- * either you will have to write the 7 sub images, or, if you +- * have called png_set_interlace_handling(), you will have to +- * "write" the image seven times. +- */ +-void PNGAPI +-png_write_rows(png_structp png_ptr, png_bytepp row, +- png_uint_32 num_rows) +-{ +- png_uint_32 i; /* row counter */ +- png_bytepp rp; /* row pointer */ +- +- png_debug(1, "in png_write_rows\n"); +- /* loop through the rows */ +- for (i = 0, rp = row; i < num_rows; i++, rp++) +- { +- png_write_row(png_ptr, *rp); +- } +-} +- +-/* Write the image. You only need to call this function once, even +- * if you are writing an interlaced image. +- */ +-void PNGAPI +-png_write_image(png_structp png_ptr, png_bytepp image) +-{ +- png_uint_32 i; /* row index */ +- int pass, num_pass; /* pass variables */ +- png_bytepp rp; /* points to current row */ +- +- png_debug(1, "in png_write_image\n"); +-#if defined(PNG_WRITE_INTERLACING_SUPPORTED) +- /* intialize interlace handling. If image is not interlaced, +- this will set pass to 1 */ +- num_pass = png_set_interlace_handling(png_ptr); +-#else +- num_pass = 1; +-#endif +- /* loop through passes */ +- for (pass = 0; pass < num_pass; pass++) +- { +- /* loop through image */ +- for (i = 0, rp = image; i < png_ptr->height; i++, rp++) +- { +- png_write_row(png_ptr, *rp); +- } +- } +-} +- +-/* called by user to write a row of image data */ +-void PNGAPI +-png_write_row(png_structp png_ptr, png_bytep row) +-{ +- png_debug2(1, "in png_write_row (row %ld, pass %d)\n", +- png_ptr->row_number, png_ptr->pass); +- /* initialize transformations and other stuff if first time */ +- if (png_ptr->row_number == 0 && png_ptr->pass == 0) +- { +- /* make sure we wrote the header info */ +- if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) +- png_error(png_ptr, +- "png_write_info was never called before png_write_row."); +- +- /* check for transforms that have been set but were defined out */ +-#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED) +- if (png_ptr->transformations & PNG_INVERT_MONO) +- png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined."); +-#endif +-#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED) +- if (png_ptr->transformations & PNG_FILLER) +- png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined."); +-#endif +-#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_PACKSWAP) +- png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined."); +-#endif +-#if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED) +- if (png_ptr->transformations & PNG_PACK) +- png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined."); +-#endif +-#if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED) +- if (png_ptr->transformations & PNG_SHIFT) +- png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined."); +-#endif +-#if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED) +- if (png_ptr->transformations & PNG_BGR) +- png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined."); +-#endif +-#if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_SWAP_BYTES) +- png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined."); +-#endif +- +- png_write_start_row(png_ptr); +- } +- +-#if defined(PNG_WRITE_INTERLACING_SUPPORTED) +- /* if interlaced and not interested in row, return */ +- if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) +- { +- switch (png_ptr->pass) +- { +- case 0: +- if (png_ptr->row_number & 0x07) +- { +- png_write_finish_row(png_ptr); +- return; +- } +- break; +- case 1: +- if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) +- { +- png_write_finish_row(png_ptr); +- return; +- } +- break; +- case 2: +- if ((png_ptr->row_number & 0x07) != 4) +- { +- png_write_finish_row(png_ptr); +- return; +- } +- break; +- case 3: +- if ((png_ptr->row_number & 0x03) || png_ptr->width < 3) +- { +- png_write_finish_row(png_ptr); +- return; +- } +- break; +- case 4: +- if ((png_ptr->row_number & 0x03) != 2) +- { +- png_write_finish_row(png_ptr); +- return; +- } +- break; +- case 5: +- if ((png_ptr->row_number & 0x01) || png_ptr->width < 2) +- { +- png_write_finish_row(png_ptr); +- return; +- } +- break; +- case 6: +- if (!(png_ptr->row_number & 0x01)) +- { +- png_write_finish_row(png_ptr); +- return; +- } +- break; +- } +- } +-#endif +- +- /* set up row info for transformations */ +- png_ptr->row_info.color_type = png_ptr->color_type; +- png_ptr->row_info.width = png_ptr->usr_width; +- png_ptr->row_info.channels = png_ptr->usr_channels; +- png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth; +- png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth * +- png_ptr->row_info.channels); +- +- png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, +- png_ptr->row_info.width); +- +- png_debug1(3, "row_info->color_type = %d\n", png_ptr->row_info.color_type); +- png_debug1(3, "row_info->width = %lu\n", png_ptr->row_info.width); +- png_debug1(3, "row_info->channels = %d\n", png_ptr->row_info.channels); +- png_debug1(3, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth); +- png_debug1(3, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth); +- png_debug1(3, "row_info->rowbytes = %lu\n", png_ptr->row_info.rowbytes); +- +- /* Copy user's row into buffer, leaving room for filter byte. */ +- png_memcpy_check(png_ptr, png_ptr->row_buf + 1, row, +- png_ptr->row_info.rowbytes); +- +-#if defined(PNG_WRITE_INTERLACING_SUPPORTED) +- /* handle interlacing */ +- if (png_ptr->interlaced && png_ptr->pass < 6 && +- (png_ptr->transformations & PNG_INTERLACE)) +- { +- png_do_write_interlace(&(png_ptr->row_info), +- png_ptr->row_buf + 1, png_ptr->pass); +- /* this should always get caught above, but still ... */ +- if (!(png_ptr->row_info.width)) +- { +- png_write_finish_row(png_ptr); +- return; +- } +- } +-#endif +- +- /* handle other transformations */ +- if (png_ptr->transformations) +- png_do_write_transformations(png_ptr); +- +-#if defined(PNG_MNG_FEATURES_SUPPORTED) +- /* Write filter_method 64 (intrapixel differencing) only if +- * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and +- * 2. Libpng did not write a PNG signature (this filter_method is only +- * used in PNG datastreams that are embedded in MNG datastreams) and +- * 3. The application called png_permit_mng_features with a mask that +- * included PNG_FLAG_MNG_FILTER_64 and +- * 4. The filter_method is 64 and +- * 5. The color_type is RGB or RGBA +- */ +- if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && +- (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) +- { +- /* Intrapixel differencing */ +- png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1); +- } +-#endif +- +- /* Find a filter if necessary, filter the row and write it out. */ +- png_write_find_filter(png_ptr, &(png_ptr->row_info)); +- +- if (png_ptr->write_row_fn != NULL) +- (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); +-} +- +-#if defined(PNG_WRITE_FLUSH_SUPPORTED) +-/* Set the automatic flush interval or 0 to turn flushing off */ +-void PNGAPI +-png_set_flush(png_structp png_ptr, int nrows) +-{ +- png_debug(1, "in png_set_flush\n"); +- png_ptr->flush_dist = (nrows < 0 ? 0 : nrows); +-} +- +-/* flush the current output buffers now */ +-void PNGAPI +-png_write_flush(png_structp png_ptr) +-{ +- int wrote_IDAT; +- +- png_debug(1, "in png_write_flush\n"); +- /* We have already written out all of the data */ +- if (png_ptr->row_number >= png_ptr->num_rows) +- return; +- +- do +- { +- int ret; +- +- /* compress the data */ +- ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH); +- wrote_IDAT = 0; +- +- /* check for compression errors */ +- if (ret != Z_OK) +- { +- if (png_ptr->zstream.msg != NULL) +- png_error(png_ptr, png_ptr->zstream.msg); +- else +- png_error(png_ptr, "zlib error"); +- } +- +- if (!(png_ptr->zstream.avail_out)) +- { +- /* write the IDAT and reset the zlib output buffer */ +- png_write_IDAT(png_ptr, png_ptr->zbuf, +- png_ptr->zbuf_size); +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- wrote_IDAT = 1; +- } +- } while(wrote_IDAT == 1); +- +- /* If there is any data left to be output, write it into a new IDAT */ +- if (png_ptr->zbuf_size != png_ptr->zstream.avail_out) +- { +- /* write the IDAT and reset the zlib output buffer */ +- png_write_IDAT(png_ptr, png_ptr->zbuf, +- png_ptr->zbuf_size - png_ptr->zstream.avail_out); +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- } +- png_ptr->flush_rows = 0; +- png_flush(png_ptr); +-} +-#endif /* PNG_WRITE_FLUSH_SUPPORTED */ +- +-/* free all memory used by the write */ +-void PNGAPI +-png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr) +-{ +- png_structp png_ptr = NULL; +- png_infop info_ptr = NULL; +-#ifdef PNG_USER_MEM_SUPPORTED +- png_free_ptr free_fn = NULL; +- png_voidp mem_ptr = NULL; +-#endif +- +- png_debug(1, "in png_destroy_write_struct\n"); +- if (png_ptr_ptr != NULL) +- { +- png_ptr = *png_ptr_ptr; +-#ifdef PNG_USER_MEM_SUPPORTED +- free_fn = png_ptr->free_fn; +- mem_ptr = png_ptr->mem_ptr; +-#endif +- } +- +- if (info_ptr_ptr != NULL) +- info_ptr = *info_ptr_ptr; +- +- if (info_ptr != NULL) +- { +- png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); +- +-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +- if (png_ptr->num_chunk_list) +- { +- png_free(png_ptr, png_ptr->chunk_list); +- png_ptr->chunk_list=NULL; +- png_ptr->num_chunk_list=0; +- } +-#endif +- +-#ifdef PNG_USER_MEM_SUPPORTED +- png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn, +- (png_voidp)mem_ptr); +-#else +- png_destroy_struct((png_voidp)info_ptr); +-#endif +- *info_ptr_ptr = NULL; +- } +- +- if (png_ptr != NULL) +- { +- png_write_destroy(png_ptr); +-#ifdef PNG_USER_MEM_SUPPORTED +- png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, +- (png_voidp)mem_ptr); +-#else +- png_destroy_struct((png_voidp)png_ptr); +-#endif +- *png_ptr_ptr = NULL; +- } +-} +- +- +-/* Free any memory used in png_ptr struct (old method) */ +-void /* PRIVATE */ +-png_write_destroy(png_structp png_ptr) +-{ +-#ifdef PNG_SETJMP_SUPPORTED +- jmp_buf tmp_jmp; /* save jump buffer */ +-#endif +- png_error_ptr error_fn; +- png_error_ptr warning_fn; +- png_voidp error_ptr; +-#ifdef PNG_USER_MEM_SUPPORTED +- png_free_ptr free_fn; +-#endif +- +- png_debug(1, "in png_write_destroy\n"); +- /* free any memory zlib uses */ +- deflateEnd(&png_ptr->zstream); +- +- /* free our memory. png_free checks NULL for us. */ +- png_free(png_ptr, png_ptr->zbuf); +- png_free(png_ptr, png_ptr->row_buf); +- png_free(png_ptr, png_ptr->prev_row); +- png_free(png_ptr, png_ptr->sub_row); +- png_free(png_ptr, png_ptr->up_row); +- png_free(png_ptr, png_ptr->avg_row); +- png_free(png_ptr, png_ptr->paeth_row); +- +-#if defined(PNG_TIME_RFC1123_SUPPORTED) +- png_free(png_ptr, png_ptr->time_buffer); +-#endif +- +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) +- png_free(png_ptr, png_ptr->prev_filters); +- png_free(png_ptr, png_ptr->filter_weights); +- png_free(png_ptr, png_ptr->inv_filter_weights); +- png_free(png_ptr, png_ptr->filter_costs); +- png_free(png_ptr, png_ptr->inv_filter_costs); +-#endif +- +-#ifdef PNG_SETJMP_SUPPORTED +- /* reset structure */ +- png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf)); +-#endif +- +- error_fn = png_ptr->error_fn; +- warning_fn = png_ptr->warning_fn; +- error_ptr = png_ptr->error_ptr; +-#ifdef PNG_USER_MEM_SUPPORTED +- free_fn = png_ptr->free_fn; +-#endif +- +- png_memset(png_ptr, 0, png_sizeof (png_struct)); +- +- png_ptr->error_fn = error_fn; +- png_ptr->warning_fn = warning_fn; +- png_ptr->error_ptr = error_ptr; +-#ifdef PNG_USER_MEM_SUPPORTED +- png_ptr->free_fn = free_fn; +-#endif +- +-#ifdef PNG_SETJMP_SUPPORTED +- png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf)); +-#endif +-} +- +-/* Allow the application to select one or more row filters to use. */ +-void PNGAPI +-png_set_filter(png_structp png_ptr, int method, int filters) +-{ +- png_debug(1, "in png_set_filter\n"); +-#if defined(PNG_MNG_FEATURES_SUPPORTED) +- if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && +- (method == PNG_INTRAPIXEL_DIFFERENCING)) +- method = PNG_FILTER_TYPE_BASE; +-#endif +- if (method == PNG_FILTER_TYPE_BASE) +- { +- switch (filters & (PNG_ALL_FILTERS | 0x07)) +- { +- case 5: +- case 6: +- case 7: png_warning(png_ptr, "Unknown row filter for method 0"); +- case PNG_FILTER_VALUE_NONE: png_ptr->do_filter=PNG_FILTER_NONE; break; +- case PNG_FILTER_VALUE_SUB: png_ptr->do_filter=PNG_FILTER_SUB; break; +- case PNG_FILTER_VALUE_UP: png_ptr->do_filter=PNG_FILTER_UP; break; +- case PNG_FILTER_VALUE_AVG: png_ptr->do_filter=PNG_FILTER_AVG; break; +- case PNG_FILTER_VALUE_PAETH: png_ptr->do_filter=PNG_FILTER_PAETH;break; +- default: png_ptr->do_filter = (png_byte)filters; break; +- } +- +- /* If we have allocated the row_buf, this means we have already started +- * with the image and we should have allocated all of the filter buffers +- * that have been selected. If prev_row isn't already allocated, then +- * it is too late to start using the filters that need it, since we +- * will be missing the data in the previous row. If an application +- * wants to start and stop using particular filters during compression, +- * it should start out with all of the filters, and then add and +- * remove them after the start of compression. +- */ +- if (png_ptr->row_buf != NULL) +- { +- if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL) +- { +- png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, +- (png_ptr->rowbytes + 1)); +- png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB; +- } +- +- if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL) +- { +- if (png_ptr->prev_row == NULL) +- { +- png_warning(png_ptr, "Can't add Up filter after starting"); +- png_ptr->do_filter &= ~PNG_FILTER_UP; +- } +- else +- { +- png_ptr->up_row = (png_bytep)png_malloc(png_ptr, +- (png_ptr->rowbytes + 1)); +- png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; +- } +- } +- +- if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL) +- { +- if (png_ptr->prev_row == NULL) +- { +- png_warning(png_ptr, "Can't add Average filter after starting"); +- png_ptr->do_filter &= ~PNG_FILTER_AVG; +- } +- else +- { +- png_ptr->avg_row = (png_bytep)png_malloc(png_ptr, +- (png_ptr->rowbytes + 1)); +- png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG; +- } +- } +- +- if ((png_ptr->do_filter & PNG_FILTER_PAETH) && +- png_ptr->paeth_row == NULL) +- { +- if (png_ptr->prev_row == NULL) +- { +- png_warning(png_ptr, "Can't add Paeth filter after starting"); +- png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH); +- } +- else +- { +- png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr, +- (png_ptr->rowbytes + 1)); +- png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; +- } +- } +- +- if (png_ptr->do_filter == PNG_NO_FILTERS) +- png_ptr->do_filter = PNG_FILTER_NONE; +- } +- } +- else +- png_error(png_ptr, "Unknown custom filter method"); +-} +- +-/* This allows us to influence the way in which libpng chooses the "best" +- * filter for the current scanline. While the "minimum-sum-of-absolute- +- * differences metric is relatively fast and effective, there is some +- * question as to whether it can be improved upon by trying to keep the +- * filtered data going to zlib more consistent, hopefully resulting in +- * better compression. +- */ +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* GRR 970116 */ +-void PNGAPI +-png_set_filter_heuristics(png_structp png_ptr, int heuristic_method, +- int num_weights, png_doublep filter_weights, +- png_doublep filter_costs) +-{ +- int i; +- +- png_debug(1, "in png_set_filter_heuristics\n"); +- if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST) +- { +- png_warning(png_ptr, "Unknown filter heuristic method"); +- return; +- } +- +- if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT) +- { +- heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED; +- } +- +- if (num_weights < 0 || filter_weights == NULL || +- heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED) +- { +- num_weights = 0; +- } +- +- png_ptr->num_prev_filters = (png_byte)num_weights; +- png_ptr->heuristic_method = (png_byte)heuristic_method; +- +- if (num_weights > 0) +- { +- if (png_ptr->prev_filters == NULL) +- { +- png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)(png_sizeof(png_byte) * num_weights)); +- +- /* To make sure that the weighting starts out fairly */ +- for (i = 0; i < num_weights; i++) +- { +- png_ptr->prev_filters[i] = 255; +- } +- } +- +- if (png_ptr->filter_weights == NULL) +- { +- png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(png_sizeof(png_uint_16) * num_weights)); +- +- png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(png_sizeof(png_uint_16) * num_weights)); +- for (i = 0; i < num_weights; i++) +- { +- png_ptr->inv_filter_weights[i] = +- png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR; +- } +- } +- +- for (i = 0; i < num_weights; i++) +- { +- if (filter_weights[i] < 0.0) +- { +- png_ptr->inv_filter_weights[i] = +- png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR; +- } +- else +- { +- png_ptr->inv_filter_weights[i] = +- (png_uint_16)((double)PNG_WEIGHT_FACTOR*filter_weights[i]+0.5); +- png_ptr->filter_weights[i] = +- (png_uint_16)((double)PNG_WEIGHT_FACTOR/filter_weights[i]+0.5); +- } +- } +- } +- +- /* If, in the future, there are other filter methods, this would +- * need to be based on png_ptr->filter. +- */ +- if (png_ptr->filter_costs == NULL) +- { +- png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); +- +- png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); +- +- for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) +- { +- png_ptr->inv_filter_costs[i] = +- png_ptr->filter_costs[i] = PNG_COST_FACTOR; +- } +- } +- +- /* Here is where we set the relative costs of the different filters. We +- * should take the desired compression level into account when setting +- * the costs, so that Paeth, for instance, has a high relative cost at low +- * compression levels, while it has a lower relative cost at higher +- * compression settings. The filter types are in order of increasing +- * relative cost, so it would be possible to do this with an algorithm. +- */ +- for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) +- { +- if (filter_costs == NULL || filter_costs[i] < 0.0) +- { +- png_ptr->inv_filter_costs[i] = +- png_ptr->filter_costs[i] = PNG_COST_FACTOR; +- } +- else if (filter_costs[i] >= 1.0) +- { +- png_ptr->inv_filter_costs[i] = +- (png_uint_16)((double)PNG_COST_FACTOR / filter_costs[i] + 0.5); +- png_ptr->filter_costs[i] = +- (png_uint_16)((double)PNG_COST_FACTOR * filter_costs[i] + 0.5); +- } +- } +-} +-#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ +- +-void PNGAPI +-png_set_compression_level(png_structp png_ptr, int level) +-{ +- png_debug(1, "in png_set_compression_level\n"); +- png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL; +- png_ptr->zlib_level = level; +-} +- +-void PNGAPI +-png_set_compression_mem_level(png_structp png_ptr, int mem_level) +-{ +- png_debug(1, "in png_set_compression_mem_level\n"); +- png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL; +- png_ptr->zlib_mem_level = mem_level; +-} +- +-void PNGAPI +-png_set_compression_strategy(png_structp png_ptr, int strategy) +-{ +- png_debug(1, "in png_set_compression_strategy\n"); +- png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY; +- png_ptr->zlib_strategy = strategy; +-} +- +-void PNGAPI +-png_set_compression_window_bits(png_structp png_ptr, int window_bits) +-{ +- if (window_bits > 15) +- png_warning(png_ptr, "Only compression windows <= 32k supported by PNG"); +- else if (window_bits < 8) +- png_warning(png_ptr, "Only compression windows >= 256 supported by PNG"); +-#ifndef WBITS_8_OK +- /* avoid libpng bug with 256-byte windows */ +- if (window_bits == 8) +- { +- png_warning(png_ptr, "Compression window is being reset to 512"); +- window_bits=9; +- } +-#endif +- png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS; +- png_ptr->zlib_window_bits = window_bits; +-} +- +-void PNGAPI +-png_set_compression_method(png_structp png_ptr, int method) +-{ +- png_debug(1, "in png_set_compression_method\n"); +- if (method != 8) +- png_warning(png_ptr, "Only compression method 8 is supported by PNG"); +- png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD; +- png_ptr->zlib_method = method; +-} +- +-void PNGAPI +-png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn) +-{ +- png_ptr->write_row_fn = write_row_fn; +-} +- +-#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +-void PNGAPI +-png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr +- write_user_transform_fn) +-{ +- png_debug(1, "in png_set_write_user_transform_fn\n"); +- png_ptr->transformations |= PNG_USER_TRANSFORM; +- png_ptr->write_user_transform_fn = write_user_transform_fn; +-} +-#endif +- +- +-#if defined(PNG_INFO_IMAGE_SUPPORTED) +-void PNGAPI +-png_write_png(png_structp png_ptr, png_infop info_ptr, +- int transforms, voidp params) +-{ +-#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +- /* invert the alpha channel from opacity to transparency */ +- if (transforms & PNG_TRANSFORM_INVERT_ALPHA) +- png_set_invert_alpha(png_ptr); +-#endif +- +- /* Write the file header information. */ +- png_write_info(png_ptr, info_ptr); +- +- /* ------ these transformations don't touch the info structure ------- */ +- +-#if defined(PNG_WRITE_INVERT_SUPPORTED) +- /* invert monochrome pixels */ +- if (transforms & PNG_TRANSFORM_INVERT_MONO) +- png_set_invert_mono(png_ptr); +-#endif +- +-#if defined(PNG_WRITE_SHIFT_SUPPORTED) +- /* Shift the pixels up to a legal bit depth and fill in +- * as appropriate to correctly scale the image. +- */ +- if ((transforms & PNG_TRANSFORM_SHIFT) +- && (info_ptr->valid & PNG_INFO_sBIT)) +- png_set_shift(png_ptr, &info_ptr->sig_bit); +-#endif +- +-#if defined(PNG_WRITE_PACK_SUPPORTED) +- /* pack pixels into bytes */ +- if (transforms & PNG_TRANSFORM_PACKING) +- png_set_packing(png_ptr); +-#endif +- +-#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +- /* swap location of alpha bytes from ARGB to RGBA */ +- if (transforms & PNG_TRANSFORM_SWAP_ALPHA) +- png_set_swap_alpha(png_ptr); +-#endif +- +-#if defined(PNG_WRITE_FILLER_SUPPORTED) +- /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into +- * RGB (4 channels -> 3 channels). The second parameter is not used. +- */ +- if (transforms & PNG_TRANSFORM_STRIP_FILLER) +- png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); +-#endif +- +-#if defined(PNG_WRITE_BGR_SUPPORTED) +- /* flip BGR pixels to RGB */ +- if (transforms & PNG_TRANSFORM_BGR) +- png_set_bgr(png_ptr); +-#endif +- +-#if defined(PNG_WRITE_SWAP_SUPPORTED) +- /* swap bytes of 16-bit files to most significant byte first */ +- if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) +- png_set_swap(png_ptr); +-#endif +- +-#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) +- /* swap bits of 1, 2, 4 bit packed pixel formats */ +- if (transforms & PNG_TRANSFORM_PACKSWAP) +- png_set_packswap(png_ptr); +-#endif +- +- /* ----------------------- end of transformations ------------------- */ +- +- /* write the bits */ +- if (info_ptr->valid & PNG_INFO_IDAT) +- png_write_image(png_ptr, info_ptr->row_pointers); +- +- /* It is REQUIRED to call this to finish writing the rest of the file */ +- png_write_end(png_ptr, info_ptr); +- +- if(transforms == 0 || params == NULL) +- /* quiet compiler warnings */ return; +-} +-#endif +-#endif /* PNG_WRITE_SUPPORTED */ +diff --git a/thirdparty/libpng/pngwtran.c b/thirdparty/libpng/pngwtran.c +deleted file mode 100644 +index 94d8ecc..0000000 +--- a/thirdparty/libpng/pngwtran.c ++++ /dev/null +@@ -1,563 +0,0 @@ +- +-/* pngwtran.c - transforms the data in a row for PNG writers +- * +- * libpng version 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- */ +- +-#define PNG_INTERNAL +-#include "png.h" +-#ifdef PNG_WRITE_SUPPORTED +- +-/* Transform the data according to the user's wishes. The order of +- * transformations is significant. +- */ +-void /* PRIVATE */ +-png_do_write_transformations(png_structp png_ptr) +-{ +- png_debug(1, "in png_do_write_transformations\n"); +- +- if (png_ptr == NULL) +- return; +- +-#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +- if (png_ptr->transformations & PNG_USER_TRANSFORM) +- if(png_ptr->write_user_transform_fn != NULL) +- (*(png_ptr->write_user_transform_fn)) /* user write transform function */ +- (png_ptr, /* png_ptr */ +- &(png_ptr->row_info), /* row_info: */ +- /* png_uint_32 width; width of row */ +- /* png_uint_32 rowbytes; number of bytes in row */ +- /* png_byte color_type; color type of pixels */ +- /* png_byte bit_depth; bit depth of samples */ +- /* png_byte channels; number of channels (1-4) */ +- /* png_byte pixel_depth; bits per pixel (depth*channels) */ +- png_ptr->row_buf + 1); /* start of pixel data for row */ +-#endif +-#if defined(PNG_WRITE_FILLER_SUPPORTED) +- if (png_ptr->transformations & PNG_FILLER) +- png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, +- png_ptr->flags); +-#endif +-#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_PACKSWAP) +- png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +-#if defined(PNG_WRITE_PACK_SUPPORTED) +- if (png_ptr->transformations & PNG_PACK) +- png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1, +- (png_uint_32)png_ptr->bit_depth); +-#endif +-#if defined(PNG_WRITE_SWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_SWAP_BYTES) +- png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +-#if defined(PNG_WRITE_SHIFT_SUPPORTED) +- if (png_ptr->transformations & PNG_SHIFT) +- png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1, +- &(png_ptr->shift)); +-#endif +-#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +- if (png_ptr->transformations & PNG_INVERT_ALPHA) +- png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +-#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +- if (png_ptr->transformations & PNG_SWAP_ALPHA) +- png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +-#if defined(PNG_WRITE_BGR_SUPPORTED) +- if (png_ptr->transformations & PNG_BGR) +- png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +-#if defined(PNG_WRITE_INVERT_SUPPORTED) +- if (png_ptr->transformations & PNG_INVERT_MONO) +- png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +-} +- +-#if defined(PNG_WRITE_PACK_SUPPORTED) +-/* Pack pixels into bytes. Pass the true bit depth in bit_depth. The +- * row_info bit depth should be 8 (one pixel per byte). The channels +- * should be 1 (this only happens on grayscale and paletted images). +- */ +-void /* PRIVATE */ +-png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth) +-{ +- png_debug(1, "in png_do_pack\n"); +- if (row_info->bit_depth == 8 && +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- row != NULL && row_info != NULL && +-#endif +- row_info->channels == 1) +- { +- switch ((int)bit_depth) +- { +- case 1: +- { +- png_bytep sp, dp; +- int mask, v; +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- +- sp = row; +- dp = row; +- mask = 0x80; +- v = 0; +- +- for (i = 0; i < row_width; i++) +- { +- if (*sp != 0) +- v |= mask; +- sp++; +- if (mask > 1) +- mask >>= 1; +- else +- { +- mask = 0x80; +- *dp = (png_byte)v; +- dp++; +- v = 0; +- } +- } +- if (mask != 0x80) +- *dp = (png_byte)v; +- break; +- } +- case 2: +- { +- png_bytep sp, dp; +- int shift, v; +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- +- sp = row; +- dp = row; +- shift = 6; +- v = 0; +- for (i = 0; i < row_width; i++) +- { +- png_byte value; +- +- value = (png_byte)(*sp & 0x03); +- v |= (value << shift); +- if (shift == 0) +- { +- shift = 6; +- *dp = (png_byte)v; +- dp++; +- v = 0; +- } +- else +- shift -= 2; +- sp++; +- } +- if (shift != 6) +- *dp = (png_byte)v; +- break; +- } +- case 4: +- { +- png_bytep sp, dp; +- int shift, v; +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- +- sp = row; +- dp = row; +- shift = 4; +- v = 0; +- for (i = 0; i < row_width; i++) +- { +- png_byte value; +- +- value = (png_byte)(*sp & 0x0f); +- v |= (value << shift); +- +- if (shift == 0) +- { +- shift = 4; +- *dp = (png_byte)v; +- dp++; +- v = 0; +- } +- else +- shift -= 4; +- +- sp++; +- } +- if (shift != 4) +- *dp = (png_byte)v; +- break; +- } +- } +- row_info->bit_depth = (png_byte)bit_depth; +- row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels); +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, +- row_info->width); +- } +-} +-#endif +- +-#if defined(PNG_WRITE_SHIFT_SUPPORTED) +-/* Shift pixel values to take advantage of whole range. Pass the +- * true number of bits in bit_depth. The row should be packed +- * according to row_info->bit_depth. Thus, if you had a row of +- * bit depth 4, but the pixels only had values from 0 to 7, you +- * would pass 3 as bit_depth, and this routine would translate the +- * data to 0 to 15. +- */ +-void /* PRIVATE */ +-png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth) +-{ +- png_debug(1, "in png_do_shift\n"); +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- if (row != NULL && row_info != NULL && +-#else +- if ( +-#endif +- row_info->color_type != PNG_COLOR_TYPE_PALETTE) +- { +- int shift_start[4], shift_dec[4]; +- int channels = 0; +- +- if (row_info->color_type & PNG_COLOR_MASK_COLOR) +- { +- shift_start[channels] = row_info->bit_depth - bit_depth->red; +- shift_dec[channels] = bit_depth->red; +- channels++; +- shift_start[channels] = row_info->bit_depth - bit_depth->green; +- shift_dec[channels] = bit_depth->green; +- channels++; +- shift_start[channels] = row_info->bit_depth - bit_depth->blue; +- shift_dec[channels] = bit_depth->blue; +- channels++; +- } +- else +- { +- shift_start[channels] = row_info->bit_depth - bit_depth->gray; +- shift_dec[channels] = bit_depth->gray; +- channels++; +- } +- if (row_info->color_type & PNG_COLOR_MASK_ALPHA) +- { +- shift_start[channels] = row_info->bit_depth - bit_depth->alpha; +- shift_dec[channels] = bit_depth->alpha; +- channels++; +- } +- +- /* with low row depths, could only be grayscale, so one channel */ +- if (row_info->bit_depth < 8) +- { +- png_bytep bp = row; +- png_uint_32 i; +- png_byte mask; +- png_uint_32 row_bytes = row_info->rowbytes; +- +- if (bit_depth->gray == 1 && row_info->bit_depth == 2) +- mask = 0x55; +- else if (row_info->bit_depth == 4 && bit_depth->gray == 3) +- mask = 0x11; +- else +- mask = 0xff; +- +- for (i = 0; i < row_bytes; i++, bp++) +- { +- png_uint_16 v; +- int j; +- +- v = *bp; +- *bp = 0; +- for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0]) +- { +- if (j > 0) +- *bp |= (png_byte)((v << j) & 0xff); +- else +- *bp |= (png_byte)((v >> (-j)) & mask); +- } +- } +- } +- else if (row_info->bit_depth == 8) +- { +- png_bytep bp = row; +- png_uint_32 i; +- png_uint_32 istop = channels * row_info->width; +- +- for (i = 0; i < istop; i++, bp++) +- { +- +- png_uint_16 v; +- int j; +- int c = (int)(i%channels); +- +- v = *bp; +- *bp = 0; +- for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c]) +- { +- if (j > 0) +- *bp |= (png_byte)((v << j) & 0xff); +- else +- *bp |= (png_byte)((v >> (-j)) & 0xff); +- } +- } +- } +- else +- { +- png_bytep bp; +- png_uint_32 i; +- png_uint_32 istop = channels * row_info->width; +- +- for (bp = row, i = 0; i < istop; i++) +- { +- int c = (int)(i%channels); +- png_uint_16 value, v; +- int j; +- +- v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1)); +- value = 0; +- for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c]) +- { +- if (j > 0) +- value |= (png_uint_16)((v << j) & (png_uint_16)0xffff); +- else +- value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff); +- } +- *bp++ = (png_byte)(value >> 8); +- *bp++ = (png_byte)(value & 0xff); +- } +- } +- } +-} +-#endif +- +-#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +-void /* PRIVATE */ +-png_do_write_swap_alpha(png_row_infop row_info, png_bytep row) +-{ +- png_debug(1, "in png_do_write_swap_alpha\n"); +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- if (row != NULL && row_info != NULL) +-#endif +- { +- if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- { +- /* This converts from ARGB to RGBA */ +- if (row_info->bit_depth == 8) +- { +- png_bytep sp, dp; +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- for (i = 0, sp = dp = row; i < row_width; i++) +- { +- png_byte save = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = save; +- } +- } +- /* This converts from AARRGGBB to RRGGBBAA */ +- else +- { +- png_bytep sp, dp; +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- +- for (i = 0, sp = dp = row; i < row_width; i++) +- { +- png_byte save[2]; +- save[0] = *(sp++); +- save[1] = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = save[0]; +- *(dp++) = save[1]; +- } +- } +- } +- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) +- { +- /* This converts from AG to GA */ +- if (row_info->bit_depth == 8) +- { +- png_bytep sp, dp; +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- +- for (i = 0, sp = dp = row; i < row_width; i++) +- { +- png_byte save = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = save; +- } +- } +- /* This converts from AAGG to GGAA */ +- else +- { +- png_bytep sp, dp; +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- +- for (i = 0, sp = dp = row; i < row_width; i++) +- { +- png_byte save[2]; +- save[0] = *(sp++); +- save[1] = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = save[0]; +- *(dp++) = save[1]; +- } +- } +- } +- } +-} +-#endif +- +-#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +-void /* PRIVATE */ +-png_do_write_invert_alpha(png_row_infop row_info, png_bytep row) +-{ +- png_debug(1, "in png_do_write_invert_alpha\n"); +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- if (row != NULL && row_info != NULL) +-#endif +- { +- if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- { +- /* This inverts the alpha channel in RGBA */ +- if (row_info->bit_depth == 8) +- { +- png_bytep sp, dp; +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- for (i = 0, sp = dp = row; i < row_width; i++) +- { +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = (png_byte)(255 - *(sp++)); +- } +- } +- /* This inverts the alpha channel in RRGGBBAA */ +- else +- { +- png_bytep sp, dp; +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- +- for (i = 0, sp = dp = row; i < row_width; i++) +- { +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = (png_byte)(255 - *(sp++)); +- *(dp++) = (png_byte)(255 - *(sp++)); +- } +- } +- } +- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) +- { +- /* This inverts the alpha channel in GA */ +- if (row_info->bit_depth == 8) +- { +- png_bytep sp, dp; +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- +- for (i = 0, sp = dp = row; i < row_width; i++) +- { +- *(dp++) = *(sp++); +- *(dp++) = (png_byte)(255 - *(sp++)); +- } +- } +- /* This inverts the alpha channel in GGAA */ +- else +- { +- png_bytep sp, dp; +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- +- for (i = 0, sp = dp = row; i < row_width; i++) +- { +- *(dp++) = *(sp++); +- *(dp++) = *(sp++); +- *(dp++) = (png_byte)(255 - *(sp++)); +- *(dp++) = (png_byte)(255 - *(sp++)); +- } +- } +- } +- } +-} +-#endif +- +-#if defined(PNG_MNG_FEATURES_SUPPORTED) +-/* undoes intrapixel differencing */ +-void /* PRIVATE */ +-png_do_write_intrapixel(png_row_infop row_info, png_bytep row) +-{ +- png_debug(1, "in png_do_write_intrapixel\n"); +- if ( +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- row != NULL && row_info != NULL && +-#endif +- (row_info->color_type & PNG_COLOR_MASK_COLOR)) +- { +- int bytes_per_pixel; +- png_uint_32 row_width = row_info->width; +- if (row_info->bit_depth == 8) +- { +- png_bytep rp; +- png_uint_32 i; +- +- if (row_info->color_type == PNG_COLOR_TYPE_RGB) +- bytes_per_pixel = 3; +- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- bytes_per_pixel = 4; +- else +- return; +- +- for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) +- { +- *(rp) = (png_byte)((*rp - *(rp+1))&0xff); +- *(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff); +- } +- } +- else if (row_info->bit_depth == 16) +- { +- png_bytep rp; +- png_uint_32 i; +- +- if (row_info->color_type == PNG_COLOR_TYPE_RGB) +- bytes_per_pixel = 6; +- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- bytes_per_pixel = 8; +- else +- return; +- +- for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) +- { +- png_uint_32 s0 = (*(rp ) << 8) | *(rp+1); +- png_uint_32 s1 = (*(rp+2) << 8) | *(rp+3); +- png_uint_32 s2 = (*(rp+4) << 8) | *(rp+5); +- png_uint_32 red = (png_uint_32)((s0-s1) & 0xffffL); +- png_uint_32 blue = (png_uint_32)((s2-s1) & 0xffffL); +- *(rp ) = (png_byte)((red >> 8) & 0xff); +- *(rp+1) = (png_byte)(red & 0xff); +- *(rp+4) = (png_byte)((blue >> 8) & 0xff); +- *(rp+5) = (png_byte)(blue & 0xff); +- } +- } +- } +-} +-#endif /* PNG_MNG_FEATURES_SUPPORTED */ +-#endif /* PNG_WRITE_SUPPORTED */ +diff --git a/thirdparty/libpng/pngwutil.c b/thirdparty/libpng/pngwutil.c +deleted file mode 100644 +index 17938d2..0000000 +--- a/thirdparty/libpng/pngwutil.c ++++ /dev/null +@@ -1,2726 +0,0 @@ +- +-/* pngwutil.c - utilities to write a PNG file +- * +- * libpng version 1.2.7 - September 12, 2004 +- * For conditions of distribution and use, see copyright notice in png.h +- * Copyright (c) 1998-2004 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) +- */ +- +-#define PNG_INTERNAL +-#include "png.h" +-#ifdef PNG_WRITE_SUPPORTED +- +-/* Place a 32-bit number into a buffer in PNG byte order. We work +- * with unsigned numbers for convenience, although one supported +- * ancillary chunk uses signed (two's complement) numbers. +- */ +-void /* PRIVATE */ +-png_save_uint_32(png_bytep buf, png_uint_32 i) +-{ +- buf[0] = (png_byte)((i >> 24) & 0xff); +- buf[1] = (png_byte)((i >> 16) & 0xff); +- buf[2] = (png_byte)((i >> 8) & 0xff); +- buf[3] = (png_byte)(i & 0xff); +-} +- +-#if defined(PNG_WRITE_pCAL_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED) +-/* The png_save_int_32 function assumes integers are stored in two's +- * complement format. If this isn't the case, then this routine needs to +- * be modified to write data in two's complement format. +- */ +-void /* PRIVATE */ +-png_save_int_32(png_bytep buf, png_int_32 i) +-{ +- buf[0] = (png_byte)((i >> 24) & 0xff); +- buf[1] = (png_byte)((i >> 16) & 0xff); +- buf[2] = (png_byte)((i >> 8) & 0xff); +- buf[3] = (png_byte)(i & 0xff); +-} +-#endif +- +-/* Place a 16-bit number into a buffer in PNG byte order. +- * The parameter is declared unsigned int, not png_uint_16, +- * just to avoid potential problems on pre-ANSI C compilers. +- */ +-void /* PRIVATE */ +-png_save_uint_16(png_bytep buf, unsigned int i) +-{ +- buf[0] = (png_byte)((i >> 8) & 0xff); +- buf[1] = (png_byte)(i & 0xff); +-} +- +-/* Write a PNG chunk all at once. The type is an array of ASCII characters +- * representing the chunk name. The array must be at least 4 bytes in +- * length, and does not need to be null terminated. To be safe, pass the +- * pre-defined chunk names here, and if you need a new one, define it +- * where the others are defined. The length is the length of the data. +- * All the data must be present. If that is not possible, use the +- * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end() +- * functions instead. +- */ +-void PNGAPI +-png_write_chunk(png_structp png_ptr, png_bytep chunk_name, +- png_bytep data, png_size_t length) +-{ +- png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length); +- png_write_chunk_data(png_ptr, data, length); +- png_write_chunk_end(png_ptr); +-} +- +-/* Write the start of a PNG chunk. The type is the chunk type. +- * The total_length is the sum of the lengths of all the data you will be +- * passing in png_write_chunk_data(). +- */ +-void PNGAPI +-png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name, +- png_uint_32 length) +-{ +- png_byte buf[4]; +- png_debug2(0, "Writing %s chunk (%lu bytes)\n", chunk_name, length); +- +- /* write the length */ +- png_save_uint_32(buf, length); +- png_write_data(png_ptr, buf, (png_size_t)4); +- +- /* write the chunk name */ +- png_write_data(png_ptr, chunk_name, (png_size_t)4); +- /* reset the crc and run it over the chunk name */ +- png_reset_crc(png_ptr); +- png_calculate_crc(png_ptr, chunk_name, (png_size_t)4); +-} +- +-/* Write the data of a PNG chunk started with png_write_chunk_start(). +- * Note that multiple calls to this function are allowed, and that the +- * sum of the lengths from these calls *must* add up to the total_length +- * given to png_write_chunk_start(). +- */ +-void PNGAPI +-png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length) +-{ +- /* write the data, and run the CRC over it */ +- if (data != NULL && length > 0) +- { +- png_calculate_crc(png_ptr, data, length); +- png_write_data(png_ptr, data, length); +- } +-} +- +-/* Finish a chunk started with png_write_chunk_start(). */ +-void PNGAPI +-png_write_chunk_end(png_structp png_ptr) +-{ +- png_byte buf[4]; +- +- /* write the crc */ +- png_save_uint_32(buf, png_ptr->crc); +- +- png_write_data(png_ptr, buf, (png_size_t)4); +-} +- +-/* Simple function to write the signature. If we have already written +- * the magic bytes of the signature, or more likely, the PNG stream is +- * being embedded into another stream and doesn't need its own signature, +- * we should call png_set_sig_bytes() to tell libpng how many of the +- * bytes have already been written. +- */ +-void /* PRIVATE */ +-png_write_sig(png_structp png_ptr) +-{ +- png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; +- /* write the rest of the 8 byte signature */ +- png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes], +- (png_size_t)8 - png_ptr->sig_bytes); +- if(png_ptr->sig_bytes < 3) +- png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; +-} +- +-#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED) +-/* +- * This pair of functions encapsulates the operation of (a) compressing a +- * text string, and (b) issuing it later as a series of chunk data writes. +- * The compression_state structure is shared context for these functions +- * set up by the caller in order to make the whole mess thread-safe. +- */ +- +-typedef struct +-{ +- char *input; /* the uncompressed input data */ +- int input_len; /* its length */ +- int num_output_ptr; /* number of output pointers used */ +- int max_output_ptr; /* size of output_ptr */ +- png_charpp output_ptr; /* array of pointers to output */ +-} compression_state; +- +-/* compress given text into storage in the png_ptr structure */ +-static int /* PRIVATE */ +-png_text_compress(png_structp png_ptr, +- png_charp text, png_size_t text_len, int compression, +- compression_state *comp) +-{ +- int ret; +- +- comp->num_output_ptr = comp->max_output_ptr = 0; +- comp->output_ptr = NULL; +- comp->input = NULL; +- +- /* we may just want to pass the text right through */ +- if (compression == PNG_TEXT_COMPRESSION_NONE) +- { +- comp->input = text; +- comp->input_len = text_len; +- return((int)text_len); +- } +- +- if (compression >= PNG_TEXT_COMPRESSION_LAST) +- { +-#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) +- char msg[50]; +- sprintf(msg, "Unknown compression type %d", compression); +- png_warning(png_ptr, msg); +-#else +- png_warning(png_ptr, "Unknown compression type"); +-#endif +- } +- +- /* We can't write the chunk until we find out how much data we have, +- * which means we need to run the compressor first and save the +- * output. This shouldn't be a problem, as the vast majority of +- * comments should be reasonable, but we will set up an array of +- * malloc'd pointers to be sure. +- * +- * If we knew the application was well behaved, we could simplify this +- * greatly by assuming we can always malloc an output buffer large +- * enough to hold the compressed text ((1001 * text_len / 1000) + 12) +- * and malloc this directly. The only time this would be a bad idea is +- * if we can't malloc more than 64K and we have 64K of random input +- * data, or if the input string is incredibly large (although this +- * wouldn't cause a failure, just a slowdown due to swapping). +- */ +- +- /* set up the compression buffers */ +- png_ptr->zstream.avail_in = (uInt)text_len; +- png_ptr->zstream.next_in = (Bytef *)text; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf; +- +- /* this is the same compression loop as in png_write_row() */ +- do +- { +- /* compress the data */ +- ret = deflate(&png_ptr->zstream, Z_NO_FLUSH); +- if (ret != Z_OK) +- { +- /* error */ +- if (png_ptr->zstream.msg != NULL) +- png_error(png_ptr, png_ptr->zstream.msg); +- else +- png_error(png_ptr, "zlib error"); +- } +- /* check to see if we need more room */ +- if (!png_ptr->zstream.avail_out && png_ptr->zstream.avail_in) +- { +- /* make sure the output array has room */ +- if (comp->num_output_ptr >= comp->max_output_ptr) +- { +- int old_max; +- +- old_max = comp->max_output_ptr; +- comp->max_output_ptr = comp->num_output_ptr + 4; +- if (comp->output_ptr != NULL) +- { +- png_charpp old_ptr; +- +- old_ptr = comp->output_ptr; +- comp->output_ptr = (png_charpp)png_malloc(png_ptr, +- (png_uint_32)(comp->max_output_ptr * +- png_sizeof (png_charpp))); +- png_memcpy(comp->output_ptr, old_ptr, old_max +- * png_sizeof (png_charp)); +- png_free(png_ptr, old_ptr); +- } +- else +- comp->output_ptr = (png_charpp)png_malloc(png_ptr, +- (png_uint_32)(comp->max_output_ptr * +- png_sizeof (png_charp))); +- } +- +- /* save the data */ +- comp->output_ptr[comp->num_output_ptr] = (png_charp)png_malloc(png_ptr, +- (png_uint_32)png_ptr->zbuf_size); +- png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf, +- png_ptr->zbuf_size); +- comp->num_output_ptr++; +- +- /* and reset the buffer */ +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- png_ptr->zstream.next_out = png_ptr->zbuf; +- } +- /* continue until we don't have any more to compress */ +- } while (png_ptr->zstream.avail_in); +- +- /* finish the compression */ +- do +- { +- /* tell zlib we are finished */ +- ret = deflate(&png_ptr->zstream, Z_FINISH); +- +- if (ret == Z_OK) +- { +- /* check to see if we need more room */ +- if (!(png_ptr->zstream.avail_out)) +- { +- /* check to make sure our output array has room */ +- if (comp->num_output_ptr >= comp->max_output_ptr) +- { +- int old_max; +- +- old_max = comp->max_output_ptr; +- comp->max_output_ptr = comp->num_output_ptr + 4; +- if (comp->output_ptr != NULL) +- { +- png_charpp old_ptr; +- +- old_ptr = comp->output_ptr; +- /* This could be optimized to realloc() */ +- comp->output_ptr = (png_charpp)png_malloc(png_ptr, +- (png_uint_32)(comp->max_output_ptr * +- png_sizeof (png_charpp))); +- png_memcpy(comp->output_ptr, old_ptr, +- old_max * png_sizeof (png_charp)); +- png_free(png_ptr, old_ptr); +- } +- else +- comp->output_ptr = (png_charpp)png_malloc(png_ptr, +- (png_uint_32)(comp->max_output_ptr * +- png_sizeof (png_charp))); +- } +- +- /* save off the data */ +- comp->output_ptr[comp->num_output_ptr] = +- (png_charp)png_malloc(png_ptr, (png_uint_32)png_ptr->zbuf_size); +- png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf, +- png_ptr->zbuf_size); +- comp->num_output_ptr++; +- +- /* and reset the buffer pointers */ +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- png_ptr->zstream.next_out = png_ptr->zbuf; +- } +- } +- else if (ret != Z_STREAM_END) +- { +- /* we got an error */ +- if (png_ptr->zstream.msg != NULL) +- png_error(png_ptr, png_ptr->zstream.msg); +- else +- png_error(png_ptr, "zlib error"); +- } +- } while (ret != Z_STREAM_END); +- +- /* text length is number of buffers plus last buffer */ +- text_len = png_ptr->zbuf_size * comp->num_output_ptr; +- if (png_ptr->zstream.avail_out < png_ptr->zbuf_size) +- text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out; +- +- return((int)text_len); +-} +- +-/* ship the compressed text out via chunk writes */ +-static void /* PRIVATE */ +-png_write_compressed_data_out(png_structp png_ptr, compression_state *comp) +-{ +- int i; +- +- /* handle the no-compression case */ +- if (comp->input) +- { +- png_write_chunk_data(png_ptr, (png_bytep)comp->input, +- (png_size_t)comp->input_len); +- return; +- } +- +- /* write saved output buffers, if any */ +- for (i = 0; i < comp->num_output_ptr; i++) +- { +- png_write_chunk_data(png_ptr,(png_bytep)comp->output_ptr[i], +- png_ptr->zbuf_size); +- png_free(png_ptr, comp->output_ptr[i]); +- comp->output_ptr[i]=NULL; +- } +- if (comp->max_output_ptr != 0) +- png_free(png_ptr, comp->output_ptr); +- comp->output_ptr=NULL; +- /* write anything left in zbuf */ +- if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size) +- png_write_chunk_data(png_ptr, png_ptr->zbuf, +- png_ptr->zbuf_size - png_ptr->zstream.avail_out); +- +- /* reset zlib for another zTXt/iTXt or the image data */ +- deflateReset(&png_ptr->zstream); +- +-} +-#endif +- +-/* Write the IHDR chunk, and update the png_struct with the necessary +- * information. Note that the rest of this code depends upon this +- * information being correct. +- */ +-void /* PRIVATE */ +-png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, +- int bit_depth, int color_type, int compression_type, int filter_type, +- int interlace_type) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_IHDR; +-#endif +- png_byte buf[13]; /* buffer to store the IHDR info */ +- +- png_debug(1, "in png_write_IHDR\n"); +- /* Check that we have valid input data from the application info */ +- switch (color_type) +- { +- case PNG_COLOR_TYPE_GRAY: +- switch (bit_depth) +- { +- case 1: +- case 2: +- case 4: +- case 8: +- case 16: png_ptr->channels = 1; break; +- default: png_error(png_ptr,"Invalid bit depth for grayscale image"); +- } +- break; +- case PNG_COLOR_TYPE_RGB: +- if (bit_depth != 8 && bit_depth != 16) +- png_error(png_ptr, "Invalid bit depth for RGB image"); +- png_ptr->channels = 3; +- break; +- case PNG_COLOR_TYPE_PALETTE: +- switch (bit_depth) +- { +- case 1: +- case 2: +- case 4: +- case 8: png_ptr->channels = 1; break; +- default: png_error(png_ptr, "Invalid bit depth for paletted image"); +- } +- break; +- case PNG_COLOR_TYPE_GRAY_ALPHA: +- if (bit_depth != 8 && bit_depth != 16) +- png_error(png_ptr, "Invalid bit depth for grayscale+alpha image"); +- png_ptr->channels = 2; +- break; +- case PNG_COLOR_TYPE_RGB_ALPHA: +- if (bit_depth != 8 && bit_depth != 16) +- png_error(png_ptr, "Invalid bit depth for RGBA image"); +- png_ptr->channels = 4; +- break; +- default: +- png_error(png_ptr, "Invalid image color type specified"); +- } +- +- if (compression_type != PNG_COMPRESSION_TYPE_BASE) +- { +- png_warning(png_ptr, "Invalid compression type specified"); +- compression_type = PNG_COMPRESSION_TYPE_BASE; +- } +- +- /* Write filter_method 64 (intrapixel differencing) only if +- * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and +- * 2. Libpng did not write a PNG signature (this filter_method is only +- * used in PNG datastreams that are embedded in MNG datastreams) and +- * 3. The application called png_permit_mng_features with a mask that +- * included PNG_FLAG_MNG_FILTER_64 and +- * 4. The filter_method is 64 and +- * 5. The color_type is RGB or RGBA +- */ +- if ( +-#if defined(PNG_MNG_FEATURES_SUPPORTED) +- !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && +- ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) && +- (color_type == PNG_COLOR_TYPE_RGB || +- color_type == PNG_COLOR_TYPE_RGB_ALPHA) && +- (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) && +-#endif +- filter_type != PNG_FILTER_TYPE_BASE) +- { +- png_warning(png_ptr, "Invalid filter type specified"); +- filter_type = PNG_FILTER_TYPE_BASE; +- } +- +-#ifdef PNG_WRITE_INTERLACING_SUPPORTED +- if (interlace_type != PNG_INTERLACE_NONE && +- interlace_type != PNG_INTERLACE_ADAM7) +- { +- png_warning(png_ptr, "Invalid interlace type specified"); +- interlace_type = PNG_INTERLACE_ADAM7; +- } +-#else +- interlace_type=PNG_INTERLACE_NONE; +-#endif +- +- /* save off the relevent information */ +- png_ptr->bit_depth = (png_byte)bit_depth; +- png_ptr->color_type = (png_byte)color_type; +- png_ptr->interlaced = (png_byte)interlace_type; +-#if defined(PNG_MNG_FEATURES_SUPPORTED) +- png_ptr->filter_type = (png_byte)filter_type; +-#endif +- png_ptr->compression_type = (png_byte)compression_type; +- png_ptr->width = width; +- png_ptr->height = height; +- +- png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels); +- png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width); +- /* set the usr info, so any transformations can modify it */ +- png_ptr->usr_width = png_ptr->width; +- png_ptr->usr_bit_depth = png_ptr->bit_depth; +- png_ptr->usr_channels = png_ptr->channels; +- +- /* pack the header information into the buffer */ +- png_save_uint_32(buf, width); +- png_save_uint_32(buf + 4, height); +- buf[8] = (png_byte)bit_depth; +- buf[9] = (png_byte)color_type; +- buf[10] = (png_byte)compression_type; +- buf[11] = (png_byte)filter_type; +- buf[12] = (png_byte)interlace_type; +- +- /* write the chunk */ +- png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13); +- +- /* initialize zlib with PNG info */ +- png_ptr->zstream.zalloc = png_zalloc; +- png_ptr->zstream.zfree = png_zfree; +- png_ptr->zstream.opaque = (voidpf)png_ptr; +- if (!(png_ptr->do_filter)) +- { +- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE || +- png_ptr->bit_depth < 8) +- png_ptr->do_filter = PNG_FILTER_NONE; +- else +- png_ptr->do_filter = PNG_ALL_FILTERS; +- } +- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY)) +- { +- if (png_ptr->do_filter != PNG_FILTER_NONE) +- png_ptr->zlib_strategy = Z_FILTERED; +- else +- png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY; +- } +- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL)) +- png_ptr->zlib_level = Z_DEFAULT_COMPRESSION; +- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL)) +- png_ptr->zlib_mem_level = 8; +- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS)) +- png_ptr->zlib_window_bits = 15; +- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD)) +- png_ptr->zlib_method = 8; +- deflateInit2(&png_ptr->zstream, png_ptr->zlib_level, +- png_ptr->zlib_method, png_ptr->zlib_window_bits, +- png_ptr->zlib_mem_level, png_ptr->zlib_strategy); +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- +- png_ptr->mode = PNG_HAVE_IHDR; +-} +- +-/* write the palette. We are careful not to trust png_color to be in the +- * correct order for PNG, so people can redefine it to any convenient +- * structure. +- */ +-void /* PRIVATE */ +-png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_PLTE; +-#endif +- png_uint_32 i; +- png_colorp pal_ptr; +- png_byte buf[3]; +- +- png_debug(1, "in png_write_PLTE\n"); +- if (( +-#if defined(PNG_MNG_FEATURES_SUPPORTED) +- !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) && +-#endif +- num_pal == 0) || num_pal > 256) +- { +- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- { +- png_error(png_ptr, "Invalid number of colors in palette"); +- } +- else +- { +- png_warning(png_ptr, "Invalid number of colors in palette"); +- return; +- } +- } +- +- if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR)) +- { +- png_warning(png_ptr, +- "Ignoring request to write a PLTE chunk in grayscale PNG"); +- return; +- } +- +- png_ptr->num_palette = (png_uint_16)num_pal; +- png_debug1(3, "num_palette = %d\n", png_ptr->num_palette); +- +- png_write_chunk_start(png_ptr, (png_bytep)png_PLTE, num_pal * 3); +-#ifndef PNG_NO_POINTER_INDEXING +- for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++) +- { +- buf[0] = pal_ptr->red; +- buf[1] = pal_ptr->green; +- buf[2] = pal_ptr->blue; +- png_write_chunk_data(png_ptr, buf, (png_size_t)3); +- } +-#else +- /* This is a little slower but some buggy compilers need to do this instead */ +- pal_ptr=palette; +- for (i = 0; i < num_pal; i++) +- { +- buf[0] = pal_ptr[i].red; +- buf[1] = pal_ptr[i].green; +- buf[2] = pal_ptr[i].blue; +- png_write_chunk_data(png_ptr, buf, (png_size_t)3); +- } +-#endif +- png_write_chunk_end(png_ptr); +- png_ptr->mode |= PNG_HAVE_PLTE; +-} +- +-/* write an IDAT chunk */ +-void /* PRIVATE */ +-png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_IDAT; +-#endif +- png_debug(1, "in png_write_IDAT\n"); +- +- /* Optimize the CMF field in the zlib stream. */ +- /* This hack of the zlib stream is compliant to the stream specification. */ +- if (!(png_ptr->mode & PNG_HAVE_IDAT) && +- png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE) +- { +- unsigned int z_cmf = data[0]; /* zlib compression method and flags */ +- if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70) +- { +- /* Avoid memory underflows and multiplication overflows. */ +- /* The conditions below are practically always satisfied; +- however, they still must be checked. */ +- if (length >= 2 && +- png_ptr->height < 16384 && png_ptr->width < 16384) +- { +- png_uint_32 uncompressed_idat_size = png_ptr->height * +- ((png_ptr->width * +- png_ptr->channels * png_ptr->bit_depth + 15) >> 3); +- unsigned int z_cinfo = z_cmf >> 4; +- unsigned int half_z_window_size = 1 << (z_cinfo + 7); +- while (uncompressed_idat_size <= half_z_window_size && +- half_z_window_size >= 256) +- { +- z_cinfo--; +- half_z_window_size >>= 1; +- } +- z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4); +- if (data[0] != (png_byte)z_cmf) +- { +- data[0] = (png_byte)z_cmf; +- data[1] &= 0xe0; +- data[1] += (png_byte)(0x1f - ((z_cmf << 8) + data[1]) % 0x1f); +- } +- } +- } +- else +- png_error(png_ptr, +- "Invalid zlib compression method or flags in IDAT"); +- } +- +- png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length); +- png_ptr->mode |= PNG_HAVE_IDAT; +-} +- +-/* write an IEND chunk */ +-void /* PRIVATE */ +-png_write_IEND(png_structp png_ptr) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_IEND; +-#endif +- png_debug(1, "in png_write_IEND\n"); +- png_write_chunk(png_ptr, (png_bytep)png_IEND, png_bytep_NULL, +- (png_size_t)0); +- png_ptr->mode |= PNG_HAVE_IEND; +-} +- +-#if defined(PNG_WRITE_gAMA_SUPPORTED) +-/* write a gAMA chunk */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-void /* PRIVATE */ +-png_write_gAMA(png_structp png_ptr, double file_gamma) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_gAMA; +-#endif +- png_uint_32 igamma; +- png_byte buf[4]; +- +- png_debug(1, "in png_write_gAMA\n"); +- /* file_gamma is saved in 1/100,000ths */ +- igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5); +- png_save_uint_32(buf, igamma); +- png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4); +-} +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +-void /* PRIVATE */ +-png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_gAMA; +-#endif +- png_byte buf[4]; +- +- png_debug(1, "in png_write_gAMA\n"); +- /* file_gamma is saved in 1/100,000ths */ +- png_save_uint_32(buf, (png_uint_32)file_gamma); +- png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4); +-} +-#endif +-#endif +- +-#if defined(PNG_WRITE_sRGB_SUPPORTED) +-/* write a sRGB chunk */ +-void /* PRIVATE */ +-png_write_sRGB(png_structp png_ptr, int srgb_intent) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_sRGB; +-#endif +- png_byte buf[1]; +- +- png_debug(1, "in png_write_sRGB\n"); +- if(srgb_intent >= PNG_sRGB_INTENT_LAST) +- png_warning(png_ptr, +- "Invalid sRGB rendering intent specified"); +- buf[0]=(png_byte)srgb_intent; +- png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1); +-} +-#endif +- +-#if defined(PNG_WRITE_iCCP_SUPPORTED) +-/* write an iCCP chunk */ +-void /* PRIVATE */ +-png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type, +- png_charp profile, int profile_len) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_iCCP; +-#endif +- png_size_t name_len; +- png_charp new_name; +- compression_state comp; +- +- png_debug(1, "in png_write_iCCP\n"); +- if (name == NULL || (name_len = png_check_keyword(png_ptr, name, +- &new_name)) == 0) +- { +- png_warning(png_ptr, "Empty keyword in iCCP chunk"); +- return; +- } +- +- if (compression_type != PNG_COMPRESSION_TYPE_BASE) +- png_warning(png_ptr, "Unknown compression type in iCCP chunk"); +- +- if (profile == NULL) +- profile_len = 0; +- +- if (profile_len) +- profile_len = png_text_compress(png_ptr, profile, (png_size_t)profile_len, +- PNG_COMPRESSION_TYPE_BASE, &comp); +- +- /* make sure we include the NULL after the name and the compression type */ +- png_write_chunk_start(png_ptr, (png_bytep)png_iCCP, +- (png_uint_32)name_len+profile_len+2); +- new_name[name_len+1]=0x00; +- png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 2); +- +- if (profile_len) +- png_write_compressed_data_out(png_ptr, &comp); +- +- png_write_chunk_end(png_ptr); +- png_free(png_ptr, new_name); +-} +-#endif +- +-#if defined(PNG_WRITE_sPLT_SUPPORTED) +-/* write a sPLT chunk */ +-void /* PRIVATE */ +-png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_sPLT; +-#endif +- png_size_t name_len; +- png_charp new_name; +- png_byte entrybuf[10]; +- int entry_size = (spalette->depth == 8 ? 6 : 10); +- int palette_size = entry_size * spalette->nentries; +- png_sPLT_entryp ep; +-#ifdef PNG_NO_POINTER_INDEXING +- int i; +-#endif +- +- png_debug(1, "in png_write_sPLT\n"); +- if (spalette->name == NULL || (name_len = png_check_keyword(png_ptr, +- spalette->name, &new_name))==0) +- { +- png_warning(png_ptr, "Empty keyword in sPLT chunk"); +- return; +- } +- +- /* make sure we include the NULL after the name */ +- png_write_chunk_start(png_ptr, (png_bytep)png_sPLT, +- (png_uint_32)(name_len + 2 + palette_size)); +- png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 1); +- png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, 1); +- +- /* loop through each palette entry, writing appropriately */ +-#ifndef PNG_NO_POINTER_INDEXING +- for (ep = spalette->entries; epentries+spalette->nentries; ep++) +- { +- if (spalette->depth == 8) +- { +- entrybuf[0] = (png_byte)ep->red; +- entrybuf[1] = (png_byte)ep->green; +- entrybuf[2] = (png_byte)ep->blue; +- entrybuf[3] = (png_byte)ep->alpha; +- png_save_uint_16(entrybuf + 4, ep->frequency); +- } +- else +- { +- png_save_uint_16(entrybuf + 0, ep->red); +- png_save_uint_16(entrybuf + 2, ep->green); +- png_save_uint_16(entrybuf + 4, ep->blue); +- png_save_uint_16(entrybuf + 6, ep->alpha); +- png_save_uint_16(entrybuf + 8, ep->frequency); +- } +- png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size); +- } +-#else +- ep=spalette->entries; +- for (i=0; i>spalette->nentries; i++) +- { +- if (spalette->depth == 8) +- { +- entrybuf[0] = (png_byte)ep[i].red; +- entrybuf[1] = (png_byte)ep[i].green; +- entrybuf[2] = (png_byte)ep[i].blue; +- entrybuf[3] = (png_byte)ep[i].alpha; +- png_save_uint_16(entrybuf + 4, ep[i].frequency); +- } +- else +- { +- png_save_uint_16(entrybuf + 0, ep[i].red); +- png_save_uint_16(entrybuf + 2, ep[i].green); +- png_save_uint_16(entrybuf + 4, ep[i].blue); +- png_save_uint_16(entrybuf + 6, ep[i].alpha); +- png_save_uint_16(entrybuf + 8, ep[i].frequency); +- } +- png_write_chunk_data(png_ptr, entrybuf, entry_size); +- } +-#endif +- +- png_write_chunk_end(png_ptr); +- png_free(png_ptr, new_name); +-} +-#endif +- +-#if defined(PNG_WRITE_sBIT_SUPPORTED) +-/* write the sBIT chunk */ +-void /* PRIVATE */ +-png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_sBIT; +-#endif +- png_byte buf[4]; +- png_size_t size; +- +- png_debug(1, "in png_write_sBIT\n"); +- /* make sure we don't depend upon the order of PNG_COLOR_8 */ +- if (color_type & PNG_COLOR_MASK_COLOR) +- { +- png_byte maxbits; +- +- maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 : +- png_ptr->usr_bit_depth); +- if (sbit->red == 0 || sbit->red > maxbits || +- sbit->green == 0 || sbit->green > maxbits || +- sbit->blue == 0 || sbit->blue > maxbits) +- { +- png_warning(png_ptr, "Invalid sBIT depth specified"); +- return; +- } +- buf[0] = sbit->red; +- buf[1] = sbit->green; +- buf[2] = sbit->blue; +- size = 3; +- } +- else +- { +- if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth) +- { +- png_warning(png_ptr, "Invalid sBIT depth specified"); +- return; +- } +- buf[0] = sbit->gray; +- size = 1; +- } +- +- if (color_type & PNG_COLOR_MASK_ALPHA) +- { +- if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth) +- { +- png_warning(png_ptr, "Invalid sBIT depth specified"); +- return; +- } +- buf[size++] = sbit->alpha; +- } +- +- png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size); +-} +-#endif +- +-#if defined(PNG_WRITE_cHRM_SUPPORTED) +-/* write the cHRM chunk */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-void /* PRIVATE */ +-png_write_cHRM(png_structp png_ptr, double white_x, double white_y, +- double red_x, double red_y, double green_x, double green_y, +- double blue_x, double blue_y) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_cHRM; +-#endif +- png_byte buf[32]; +- png_uint_32 itemp; +- +- png_debug(1, "in png_write_cHRM\n"); +- /* each value is saved in 1/100,000ths */ +- if (white_x < 0 || white_x > 0.8 || white_y < 0 || white_y > 0.8 || +- white_x + white_y > 1.0) +- { +- png_warning(png_ptr, "Invalid cHRM white point specified"); +-#if !defined(PNG_NO_CONSOLE_IO) +- fprintf(stderr,"white_x=%f, white_y=%f\n",white_x, white_y); +-#endif +- return; +- } +- itemp = (png_uint_32)(white_x * 100000.0 + 0.5); +- png_save_uint_32(buf, itemp); +- itemp = (png_uint_32)(white_y * 100000.0 + 0.5); +- png_save_uint_32(buf + 4, itemp); +- +- if (red_x < 0 || red_x > 0.8 || red_y < 0 || red_y > 0.8 || +- red_x + red_y > 1.0) +- { +- png_warning(png_ptr, "Invalid cHRM red point specified"); +- return; +- } +- itemp = (png_uint_32)(red_x * 100000.0 + 0.5); +- png_save_uint_32(buf + 8, itemp); +- itemp = (png_uint_32)(red_y * 100000.0 + 0.5); +- png_save_uint_32(buf + 12, itemp); +- +- if (green_x < 0 || green_x > 0.8 || green_y < 0 || green_y > 0.8 || +- green_x + green_y > 1.0) +- { +- png_warning(png_ptr, "Invalid cHRM green point specified"); +- return; +- } +- itemp = (png_uint_32)(green_x * 100000.0 + 0.5); +- png_save_uint_32(buf + 16, itemp); +- itemp = (png_uint_32)(green_y * 100000.0 + 0.5); +- png_save_uint_32(buf + 20, itemp); +- +- if (blue_x < 0 || blue_x > 0.8 || blue_y < 0 || blue_y > 0.8 || +- blue_x + blue_y > 1.0) +- { +- png_warning(png_ptr, "Invalid cHRM blue point specified"); +- return; +- } +- itemp = (png_uint_32)(blue_x * 100000.0 + 0.5); +- png_save_uint_32(buf + 24, itemp); +- itemp = (png_uint_32)(blue_y * 100000.0 + 0.5); +- png_save_uint_32(buf + 28, itemp); +- +- png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32); +-} +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +-void /* PRIVATE */ +-png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x, +- png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y, +- png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x, +- png_fixed_point blue_y) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_cHRM; +-#endif +- png_byte buf[32]; +- +- png_debug(1, "in png_write_cHRM\n"); +- /* each value is saved in 1/100,000ths */ +- if (white_x > 80000L || white_y > 80000L || white_x + white_y > 100000L) +- { +- png_warning(png_ptr, "Invalid fixed cHRM white point specified"); +-#if !defined(PNG_NO_CONSOLE_IO) +- fprintf(stderr,"white_x=%ld, white_y=%ld\n",white_x, white_y); +-#endif +- return; +- } +- png_save_uint_32(buf, (png_uint_32)white_x); +- png_save_uint_32(buf + 4, (png_uint_32)white_y); +- +- if (red_x > 80000L || red_y > 80000L || red_x + red_y > 100000L) +- { +- png_warning(png_ptr, "Invalid cHRM fixed red point specified"); +- return; +- } +- png_save_uint_32(buf + 8, (png_uint_32)red_x); +- png_save_uint_32(buf + 12, (png_uint_32)red_y); +- +- if (green_x > 80000L || green_y > 80000L || green_x + green_y > 100000L) +- { +- png_warning(png_ptr, "Invalid fixed cHRM green point specified"); +- return; +- } +- png_save_uint_32(buf + 16, (png_uint_32)green_x); +- png_save_uint_32(buf + 20, (png_uint_32)green_y); +- +- if (blue_x > 80000L || blue_y > 80000L || blue_x + blue_y > 100000L) +- { +- png_warning(png_ptr, "Invalid fixed cHRM blue point specified"); +- return; +- } +- png_save_uint_32(buf + 24, (png_uint_32)blue_x); +- png_save_uint_32(buf + 28, (png_uint_32)blue_y); +- +- png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32); +-} +-#endif +-#endif +- +-#if defined(PNG_WRITE_tRNS_SUPPORTED) +-/* write the tRNS chunk */ +-void /* PRIVATE */ +-png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran, +- int num_trans, int color_type) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_tRNS; +-#endif +- png_byte buf[6]; +- +- png_debug(1, "in png_write_tRNS\n"); +- if (color_type == PNG_COLOR_TYPE_PALETTE) +- { +- if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette) +- { +- png_warning(png_ptr,"Invalid number of transparent colors specified"); +- return; +- } +- /* write the chunk out as it is */ +- png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans, (png_size_t)num_trans); +- } +- else if (color_type == PNG_COLOR_TYPE_GRAY) +- { +- /* one 16 bit value */ +- if(tran->gray >= (1 << png_ptr->bit_depth)) +- { +- png_warning(png_ptr, +- "Ignoring attempt to write tRNS chunk out-of-range for bit_depth"); +- return; +- } +- png_save_uint_16(buf, tran->gray); +- png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2); +- } +- else if (color_type == PNG_COLOR_TYPE_RGB) +- { +- /* three 16 bit values */ +- png_save_uint_16(buf, tran->red); +- png_save_uint_16(buf + 2, tran->green); +- png_save_uint_16(buf + 4, tran->blue); +- if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) +- { +- png_warning(png_ptr, +- "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8"); +- return; +- } +- png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6); +- } +- else +- { +- png_warning(png_ptr, "Can't write tRNS with an alpha channel"); +- } +-} +-#endif +- +-#if defined(PNG_WRITE_bKGD_SUPPORTED) +-/* write the background chunk */ +-void /* PRIVATE */ +-png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_bKGD; +-#endif +- png_byte buf[6]; +- +- png_debug(1, "in png_write_bKGD\n"); +- if (color_type == PNG_COLOR_TYPE_PALETTE) +- { +- if ( +-#if defined(PNG_MNG_FEATURES_SUPPORTED) +- (png_ptr->num_palette || +- (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) && +-#endif +- back->index > png_ptr->num_palette) +- { +- png_warning(png_ptr, "Invalid background palette index"); +- return; +- } +- buf[0] = back->index; +- png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1); +- } +- else if (color_type & PNG_COLOR_MASK_COLOR) +- { +- png_save_uint_16(buf, back->red); +- png_save_uint_16(buf + 2, back->green); +- png_save_uint_16(buf + 4, back->blue); +- if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) +- { +- png_warning(png_ptr, +- "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8"); +- return; +- } +- png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6); +- } +- else +- { +- if(back->gray >= (1 << png_ptr->bit_depth)) +- { +- png_warning(png_ptr, +- "Ignoring attempt to write bKGD chunk out-of-range for bit_depth"); +- return; +- } +- png_save_uint_16(buf, back->gray); +- png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2); +- } +-} +-#endif +- +-#if defined(PNG_WRITE_hIST_SUPPORTED) +-/* write the histogram */ +-void /* PRIVATE */ +-png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_hIST; +-#endif +- int i; +- png_byte buf[3]; +- +- png_debug(1, "in png_write_hIST\n"); +- if (num_hist > (int)png_ptr->num_palette) +- { +- png_debug2(3, "num_hist = %d, num_palette = %d\n", num_hist, +- png_ptr->num_palette); +- png_warning(png_ptr, "Invalid number of histogram entries specified"); +- return; +- } +- +- png_write_chunk_start(png_ptr, (png_bytep)png_hIST, (png_uint_32)(num_hist * 2)); +- for (i = 0; i < num_hist; i++) +- { +- png_save_uint_16(buf, hist[i]); +- png_write_chunk_data(png_ptr, buf, (png_size_t)2); +- } +- png_write_chunk_end(png_ptr); +-} +-#endif +- +-#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ +- defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) +-/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification, +- * and if invalid, correct the keyword rather than discarding the entire +- * chunk. The PNG 1.0 specification requires keywords 1-79 characters in +- * length, forbids leading or trailing whitespace, multiple internal spaces, +- * and the non-break space (0x80) from ISO 8859-1. Returns keyword length. +- * +- * The new_key is allocated to hold the corrected keyword and must be freed +- * by the calling routine. This avoids problems with trying to write to +- * static keywords without having to have duplicate copies of the strings. +- */ +-png_size_t /* PRIVATE */ +-png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key) +-{ +- png_size_t key_len; +- png_charp kp, dp; +- int kflag; +- int kwarn=0; +- +- png_debug(1, "in png_check_keyword\n"); +- *new_key = NULL; +- +- if (key == NULL || (key_len = png_strlen(key)) == 0) +- { +- png_warning(png_ptr, "zero length keyword"); +- return ((png_size_t)0); +- } +- +- png_debug1(2, "Keyword to be checked is '%s'\n", key); +- +- *new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2)); +- if (*new_key == NULL) +- { +- png_warning(png_ptr, "Out of memory while procesing keyword"); +- return ((png_size_t)0); +- } +- +- /* Replace non-printing characters with a blank and print a warning */ +- for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++) +- { +- if (*kp < 0x20 || (*kp > 0x7E && (png_byte)*kp < 0xA1)) +- { +-#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) +- char msg[40]; +- +- sprintf(msg, "invalid keyword character 0x%02X", *kp); +- png_warning(png_ptr, msg); +-#else +- png_warning(png_ptr, "invalid character in keyword"); +-#endif +- *dp = ' '; +- } +- else +- { +- *dp = *kp; +- } +- } +- *dp = '\0'; +- +- /* Remove any trailing white space. */ +- kp = *new_key + key_len - 1; +- if (*kp == ' ') +- { +- png_warning(png_ptr, "trailing spaces removed from keyword"); +- +- while (*kp == ' ') +- { +- *(kp--) = '\0'; +- key_len--; +- } +- } +- +- /* Remove any leading white space. */ +- kp = *new_key; +- if (*kp == ' ') +- { +- png_warning(png_ptr, "leading spaces removed from keyword"); +- +- while (*kp == ' ') +- { +- kp++; +- key_len--; +- } +- } +- +- png_debug1(2, "Checking for multiple internal spaces in '%s'\n", kp); +- +- /* Remove multiple internal spaces. */ +- for (kflag = 0, dp = *new_key; *kp != '\0'; kp++) +- { +- if (*kp == ' ' && kflag == 0) +- { +- *(dp++) = *kp; +- kflag = 1; +- } +- else if (*kp == ' ') +- { +- key_len--; +- kwarn=1; +- } +- else +- { +- *(dp++) = *kp; +- kflag = 0; +- } +- } +- *dp = '\0'; +- if(kwarn) +- png_warning(png_ptr, "extra interior spaces removed from keyword"); +- +- if (key_len == 0) +- { +- png_free(png_ptr, *new_key); +- *new_key=NULL; +- png_warning(png_ptr, "Zero length keyword"); +- } +- +- if (key_len > 79) +- { +- png_warning(png_ptr, "keyword length must be 1 - 79 characters"); +- new_key[79] = '\0'; +- key_len = 79; +- } +- +- return (key_len); +-} +-#endif +- +-#if defined(PNG_WRITE_tEXt_SUPPORTED) +-/* write a tEXt chunk */ +-void /* PRIVATE */ +-png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text, +- png_size_t text_len) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_tEXt; +-#endif +- png_size_t key_len; +- png_charp new_key; +- +- png_debug(1, "in png_write_tEXt\n"); +- if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0) +- { +- png_warning(png_ptr, "Empty keyword in tEXt chunk"); +- return; +- } +- +- if (text == NULL || *text == '\0') +- text_len = 0; +- else +- text_len = png_strlen(text); +- +- /* make sure we include the 0 after the key */ +- png_write_chunk_start(png_ptr, (png_bytep)png_tEXt, (png_uint_32)key_len+text_len+1); +- /* +- * We leave it to the application to meet PNG-1.0 requirements on the +- * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of +- * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them. +- * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. +- */ +- png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1); +- if (text_len) +- png_write_chunk_data(png_ptr, (png_bytep)text, text_len); +- +- png_write_chunk_end(png_ptr); +- png_free(png_ptr, new_key); +-} +-#endif +- +-#if defined(PNG_WRITE_zTXt_SUPPORTED) +-/* write a compressed text chunk */ +-void /* PRIVATE */ +-png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text, +- png_size_t text_len, int compression) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_zTXt; +-#endif +- png_size_t key_len; +- char buf[1]; +- png_charp new_key; +- compression_state comp; +- +- png_debug(1, "in png_write_zTXt\n"); +- +- if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0) +- { +- png_warning(png_ptr, "Empty keyword in zTXt chunk"); +- return; +- } +- +- if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE) +- { +- png_write_tEXt(png_ptr, new_key, text, (png_size_t)0); +- png_free(png_ptr, new_key); +- return; +- } +- +- text_len = png_strlen(text); +- +- png_free(png_ptr, new_key); +- +- /* compute the compressed data; do it now for the length */ +- text_len = png_text_compress(png_ptr, text, text_len, compression, +- &comp); +- +- /* write start of chunk */ +- png_write_chunk_start(png_ptr, (png_bytep)png_zTXt, (png_uint_32) +- (key_len+text_len+2)); +- /* write key */ +- png_write_chunk_data(png_ptr, (png_bytep)key, key_len + 1); +- buf[0] = (png_byte)compression; +- /* write compression */ +- png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1); +- /* write the compressed data */ +- png_write_compressed_data_out(png_ptr, &comp); +- +- /* close the chunk */ +- png_write_chunk_end(png_ptr); +-} +-#endif +- +-#if defined(PNG_WRITE_iTXt_SUPPORTED) +-/* write an iTXt chunk */ +-void /* PRIVATE */ +-png_write_iTXt(png_structp png_ptr, int compression, png_charp key, +- png_charp lang, png_charp lang_key, png_charp text) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_iTXt; +-#endif +- png_size_t lang_len, key_len, lang_key_len, text_len; +- png_charp new_lang, new_key; +- png_byte cbuf[2]; +- compression_state comp; +- +- png_debug(1, "in png_write_iTXt\n"); +- +- if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0) +- { +- png_warning(png_ptr, "Empty keyword in iTXt chunk"); +- return; +- } +- if (lang == NULL || (lang_len = png_check_keyword(png_ptr, lang, &new_lang))==0) +- { +- png_warning(png_ptr, "Empty language field in iTXt chunk"); +- new_lang = NULL; +- lang_len = 0; +- } +- +- if (lang_key == NULL) +- lang_key_len = 0; +- else +- lang_key_len = png_strlen(lang_key); +- +- if (text == NULL) +- text_len = 0; +- else +- text_len = png_strlen(text); +- +- /* compute the compressed data; do it now for the length */ +- text_len = png_text_compress(png_ptr, text, text_len, compression-2, +- &comp); +- +- +- /* make sure we include the compression flag, the compression byte, +- * and the NULs after the key, lang, and lang_key parts */ +- +- png_write_chunk_start(png_ptr, (png_bytep)png_iTXt, +- (png_uint_32)( +- 5 /* comp byte, comp flag, terminators for key, lang and lang_key */ +- + key_len +- + lang_len +- + lang_key_len +- + text_len)); +- +- /* +- * We leave it to the application to meet PNG-1.0 requirements on the +- * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of +- * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them. +- * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. +- */ +- png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1); +- +- /* set the compression flag */ +- if (compression == PNG_ITXT_COMPRESSION_NONE || \ +- compression == PNG_TEXT_COMPRESSION_NONE) +- cbuf[0] = 0; +- else /* compression == PNG_ITXT_COMPRESSION_zTXt */ +- cbuf[0] = 1; +- /* set the compression method */ +- cbuf[1] = 0; +- png_write_chunk_data(png_ptr, cbuf, 2); +- +- cbuf[0] = 0; +- png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf), lang_len + 1); +- png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf), lang_key_len + 1); +- png_write_compressed_data_out(png_ptr, &comp); +- +- png_write_chunk_end(png_ptr); +- png_free(png_ptr, new_key); +- if (new_lang) +- png_free(png_ptr, new_lang); +-} +-#endif +- +-#if defined(PNG_WRITE_oFFs_SUPPORTED) +-/* write the oFFs chunk */ +-void /* PRIVATE */ +-png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset, +- int unit_type) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_oFFs; +-#endif +- png_byte buf[9]; +- +- png_debug(1, "in png_write_oFFs\n"); +- if (unit_type >= PNG_OFFSET_LAST) +- png_warning(png_ptr, "Unrecognized unit type for oFFs chunk"); +- +- png_save_int_32(buf, x_offset); +- png_save_int_32(buf + 4, y_offset); +- buf[8] = (png_byte)unit_type; +- +- png_write_chunk(png_ptr, (png_bytep)png_oFFs, buf, (png_size_t)9); +-} +-#endif +- +-#if defined(PNG_WRITE_pCAL_SUPPORTED) +-/* write the pCAL chunk (described in the PNG extensions document) */ +-void /* PRIVATE */ +-png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0, +- png_int_32 X1, int type, int nparams, png_charp units, png_charpp params) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_pCAL; +-#endif +- png_size_t purpose_len, units_len, total_len; +- png_uint_32p params_len; +- png_byte buf[10]; +- png_charp new_purpose; +- int i; +- +- png_debug1(1, "in png_write_pCAL (%d parameters)\n", nparams); +- if (type >= PNG_EQUATION_LAST) +- png_warning(png_ptr, "Unrecognized equation type for pCAL chunk"); +- +- purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1; +- png_debug1(3, "pCAL purpose length = %d\n", (int)purpose_len); +- units_len = png_strlen(units) + (nparams == 0 ? 0 : 1); +- png_debug1(3, "pCAL units length = %d\n", (int)units_len); +- total_len = purpose_len + units_len + 10; +- +- params_len = (png_uint_32p)png_malloc(png_ptr, (png_uint_32)(nparams +- *png_sizeof(png_uint_32))); +- +- /* Find the length of each parameter, making sure we don't count the +- null terminator for the last parameter. */ +- for (i = 0; i < nparams; i++) +- { +- params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1); +- png_debug2(3, "pCAL parameter %d length = %lu\n", i, params_len[i]); +- total_len += (png_size_t)params_len[i]; +- } +- +- png_debug1(3, "pCAL total length = %d\n", (int)total_len); +- png_write_chunk_start(png_ptr, (png_bytep)png_pCAL, (png_uint_32)total_len); +- png_write_chunk_data(png_ptr, (png_bytep)new_purpose, purpose_len); +- png_save_int_32(buf, X0); +- png_save_int_32(buf + 4, X1); +- buf[8] = (png_byte)type; +- buf[9] = (png_byte)nparams; +- png_write_chunk_data(png_ptr, buf, (png_size_t)10); +- png_write_chunk_data(png_ptr, (png_bytep)units, (png_size_t)units_len); +- +- png_free(png_ptr, new_purpose); +- +- for (i = 0; i < nparams; i++) +- { +- png_write_chunk_data(png_ptr, (png_bytep)params[i], +- (png_size_t)params_len[i]); +- } +- +- png_free(png_ptr, params_len); +- png_write_chunk_end(png_ptr); +-} +-#endif +- +-#if defined(PNG_WRITE_sCAL_SUPPORTED) +-/* write the sCAL chunk */ +-#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) +-void /* PRIVATE */ +-png_write_sCAL(png_structp png_ptr, int unit, double width,double height) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_sCAL; +-#endif +- png_size_t total_len; +- char wbuf[32], hbuf[32]; +- png_byte bunit = unit; +- +- png_debug(1, "in png_write_sCAL\n"); +- +-#if defined(_WIN32_WCE) +-/* sprintf() function is not supported on WindowsCE */ +- { +- wchar_t wc_buf[32]; +- swprintf(wc_buf, TEXT("%12.12e"), width); +- WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, wbuf, 32, NULL, NULL); +- swprintf(wc_buf, TEXT("%12.12e"), height); +- WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, hbuf, 32, NULL, NULL); +- } +-#else +- sprintf(wbuf, "%12.12e", width); +- sprintf(hbuf, "%12.12e", height); +-#endif +- total_len = 1 + png_strlen(wbuf)+1 + png_strlen(hbuf); +- +- png_debug1(3, "sCAL total length = %d\n", (int)total_len); +- png_write_chunk_start(png_ptr, (png_bytep)png_sCAL, (png_uint_32)total_len); +- png_write_chunk_data(png_ptr, (png_bytep)&bunit, 1); +- png_write_chunk_data(png_ptr, (png_bytep)wbuf, png_strlen(wbuf)+1); +- png_write_chunk_data(png_ptr, (png_bytep)hbuf, png_strlen(hbuf)); +- +- png_write_chunk_end(png_ptr); +-} +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +-void /* PRIVATE */ +-png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width, +- png_charp height) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_sCAL; +-#endif +- png_size_t total_len; +- char wbuf[32], hbuf[32]; +- png_byte bunit = unit; +- +- png_debug(1, "in png_write_sCAL_s\n"); +- +- png_strcpy(wbuf,(const char *)width); +- png_strcpy(hbuf,(const char *)height); +- total_len = 1 + png_strlen(wbuf)+1 + png_strlen(hbuf); +- +- png_debug1(3, "sCAL total length = %d\n", total_len); +- png_write_chunk_start(png_ptr, (png_bytep)png_sCAL, (png_uint_32)total_len); +- png_write_chunk_data(png_ptr, (png_bytep)&bunit, 1); +- png_write_chunk_data(png_ptr, (png_bytep)wbuf, png_strlen(wbuf)+1); +- png_write_chunk_data(png_ptr, (png_bytep)hbuf, png_strlen(hbuf)); +- +- png_write_chunk_end(png_ptr); +-} +-#endif +-#endif +-#endif +- +-#if defined(PNG_WRITE_pHYs_SUPPORTED) +-/* write the pHYs chunk */ +-void /* PRIVATE */ +-png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit, +- png_uint_32 y_pixels_per_unit, +- int unit_type) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_pHYs; +-#endif +- png_byte buf[9]; +- +- png_debug(1, "in png_write_pHYs\n"); +- if (unit_type >= PNG_RESOLUTION_LAST) +- png_warning(png_ptr, "Unrecognized unit type for pHYs chunk"); +- +- png_save_uint_32(buf, x_pixels_per_unit); +- png_save_uint_32(buf + 4, y_pixels_per_unit); +- buf[8] = (png_byte)unit_type; +- +- png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9); +-} +-#endif +- +-#if defined(PNG_WRITE_tIME_SUPPORTED) +-/* Write the tIME chunk. Use either png_convert_from_struct_tm() +- * or png_convert_from_time_t(), or fill in the structure yourself. +- */ +-void /* PRIVATE */ +-png_write_tIME(png_structp png_ptr, png_timep mod_time) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_tIME; +-#endif +- png_byte buf[7]; +- +- png_debug(1, "in png_write_tIME\n"); +- if (mod_time->month > 12 || mod_time->month < 1 || +- mod_time->day > 31 || mod_time->day < 1 || +- mod_time->hour > 23 || mod_time->second > 60) +- { +- png_warning(png_ptr, "Invalid time specified for tIME chunk"); +- return; +- } +- +- png_save_uint_16(buf, mod_time->year); +- buf[2] = mod_time->month; +- buf[3] = mod_time->day; +- buf[4] = mod_time->hour; +- buf[5] = mod_time->minute; +- buf[6] = mod_time->second; +- +- png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7); +-} +-#endif +- +-/* initializes the row writing capability of libpng */ +-void /* PRIVATE */ +-png_write_start_row(png_structp png_ptr) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ +- +- /* start of interlace block */ +- int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; +- +- /* offset to next interlace block */ +- int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; +- +- /* start of interlace block in the y direction */ +- int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; +- +- /* offset to next interlace block in the y direction */ +- int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; +-#endif +- +- png_size_t buf_size; +- +- png_debug(1, "in png_write_start_row\n"); +- buf_size = (png_size_t)(PNG_ROWBYTES( +- png_ptr->usr_channels*png_ptr->usr_bit_depth,png_ptr->width)+1); +- +- /* set up row buffer */ +- png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size); +- png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE; +- +- /* set up filtering buffer, if using this filter */ +- if (png_ptr->do_filter & PNG_FILTER_SUB) +- { +- png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, +- (png_ptr->rowbytes + 1)); +- png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB; +- } +- +- /* We only need to keep the previous row if we are using one of these. */ +- if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) +- { +- /* set up previous row buffer */ +- png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size); +- png_memset(png_ptr->prev_row, 0, buf_size); +- +- if (png_ptr->do_filter & PNG_FILTER_UP) +- { +- png_ptr->up_row = (png_bytep )png_malloc(png_ptr, +- (png_ptr->rowbytes + 1)); +- png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; +- } +- +- if (png_ptr->do_filter & PNG_FILTER_AVG) +- { +- png_ptr->avg_row = (png_bytep)png_malloc(png_ptr, +- (png_ptr->rowbytes + 1)); +- png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG; +- } +- +- if (png_ptr->do_filter & PNG_FILTER_PAETH) +- { +- png_ptr->paeth_row = (png_bytep )png_malloc(png_ptr, +- (png_ptr->rowbytes + 1)); +- png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; +- } +- } +- +-#ifdef PNG_WRITE_INTERLACING_SUPPORTED +- /* if interlaced, we need to set up width and height of pass */ +- if (png_ptr->interlaced) +- { +- if (!(png_ptr->transformations & PNG_INTERLACE)) +- { +- png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 - +- png_pass_ystart[0]) / png_pass_yinc[0]; +- png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 - +- png_pass_start[0]) / png_pass_inc[0]; +- } +- else +- { +- png_ptr->num_rows = png_ptr->height; +- png_ptr->usr_width = png_ptr->width; +- } +- } +- else +-#endif +- { +- png_ptr->num_rows = png_ptr->height; +- png_ptr->usr_width = png_ptr->width; +- } +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- png_ptr->zstream.next_out = png_ptr->zbuf; +-} +- +-/* Internal use only. Called when finished processing a row of data. */ +-void /* PRIVATE */ +-png_write_finish_row(png_structp png_ptr) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ +- +- /* start of interlace block */ +- int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; +- +- /* offset to next interlace block */ +- int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; +- +- /* start of interlace block in the y direction */ +- int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; +- +- /* offset to next interlace block in the y direction */ +- int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; +-#endif +- +- int ret; +- +- png_debug(1, "in png_write_finish_row\n"); +- /* next row */ +- png_ptr->row_number++; +- +- /* see if we are done */ +- if (png_ptr->row_number < png_ptr->num_rows) +- return; +- +-#ifdef PNG_WRITE_INTERLACING_SUPPORTED +- /* if interlaced, go to next pass */ +- if (png_ptr->interlaced) +- { +- png_ptr->row_number = 0; +- if (png_ptr->transformations & PNG_INTERLACE) +- { +- png_ptr->pass++; +- } +- else +- { +- /* loop until we find a non-zero width or height pass */ +- do +- { +- png_ptr->pass++; +- if (png_ptr->pass >= 7) +- break; +- png_ptr->usr_width = (png_ptr->width + +- png_pass_inc[png_ptr->pass] - 1 - +- png_pass_start[png_ptr->pass]) / +- png_pass_inc[png_ptr->pass]; +- png_ptr->num_rows = (png_ptr->height + +- png_pass_yinc[png_ptr->pass] - 1 - +- png_pass_ystart[png_ptr->pass]) / +- png_pass_yinc[png_ptr->pass]; +- if (png_ptr->transformations & PNG_INTERLACE) +- break; +- } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0); +- +- } +- +- /* reset the row above the image for the next pass */ +- if (png_ptr->pass < 7) +- { +- if (png_ptr->prev_row != NULL) +- png_memset(png_ptr->prev_row, 0, +- (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels* +- png_ptr->usr_bit_depth,png_ptr->width))+1); +- return; +- } +- } +-#endif +- +- /* if we get here, we've just written the last row, so we need +- to flush the compressor */ +- do +- { +- /* tell the compressor we are done */ +- ret = deflate(&png_ptr->zstream, Z_FINISH); +- /* check for an error */ +- if (ret == Z_OK) +- { +- /* check to see if we need more room */ +- if (!(png_ptr->zstream.avail_out)) +- { +- png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- } +- } +- else if (ret != Z_STREAM_END) +- { +- if (png_ptr->zstream.msg != NULL) +- png_error(png_ptr, png_ptr->zstream.msg); +- else +- png_error(png_ptr, "zlib error"); +- } +- } while (ret != Z_STREAM_END); +- +- /* write any extra space */ +- if (png_ptr->zstream.avail_out < png_ptr->zbuf_size) +- { +- png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size - +- png_ptr->zstream.avail_out); +- } +- +- deflateReset(&png_ptr->zstream); +-} +- +-#if defined(PNG_WRITE_INTERLACING_SUPPORTED) +-/* Pick out the correct pixels for the interlace pass. +- * The basic idea here is to go through the row with a source +- * pointer and a destination pointer (sp and dp), and copy the +- * correct pixels for the pass. As the row gets compacted, +- * sp will always be >= dp, so we should never overwrite anything. +- * See the default: case for the easiest code to understand. +- */ +-void /* PRIVATE */ +-png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ +- +- /* start of interlace block */ +- int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; +- +- /* offset to next interlace block */ +- int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; +-#endif +- +- png_debug(1, "in png_do_write_interlace\n"); +- /* we don't have to do anything on the last pass (6) */ +-#if defined(PNG_USELESS_TESTS_SUPPORTED) +- if (row != NULL && row_info != NULL && pass < 6) +-#else +- if (pass < 6) +-#endif +- { +- /* each pixel depth is handled separately */ +- switch (row_info->pixel_depth) +- { +- case 1: +- { +- png_bytep sp; +- png_bytep dp; +- int shift; +- int d; +- int value; +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- +- dp = row; +- d = 0; +- shift = 7; +- for (i = png_pass_start[pass]; i < row_width; +- i += png_pass_inc[pass]) +- { +- sp = row + (png_size_t)(i >> 3); +- value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01; +- d |= (value << shift); +- +- if (shift == 0) +- { +- shift = 7; +- *dp++ = (png_byte)d; +- d = 0; +- } +- else +- shift--; +- +- } +- if (shift != 7) +- *dp = (png_byte)d; +- break; +- } +- case 2: +- { +- png_bytep sp; +- png_bytep dp; +- int shift; +- int d; +- int value; +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- +- dp = row; +- shift = 6; +- d = 0; +- for (i = png_pass_start[pass]; i < row_width; +- i += png_pass_inc[pass]) +- { +- sp = row + (png_size_t)(i >> 2); +- value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03; +- d |= (value << shift); +- +- if (shift == 0) +- { +- shift = 6; +- *dp++ = (png_byte)d; +- d = 0; +- } +- else +- shift -= 2; +- } +- if (shift != 6) +- *dp = (png_byte)d; +- break; +- } +- case 4: +- { +- png_bytep sp; +- png_bytep dp; +- int shift; +- int d; +- int value; +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- +- dp = row; +- shift = 4; +- d = 0; +- for (i = png_pass_start[pass]; i < row_width; +- i += png_pass_inc[pass]) +- { +- sp = row + (png_size_t)(i >> 1); +- value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f; +- d |= (value << shift); +- +- if (shift == 0) +- { +- shift = 4; +- *dp++ = (png_byte)d; +- d = 0; +- } +- else +- shift -= 4; +- } +- if (shift != 4) +- *dp = (png_byte)d; +- break; +- } +- default: +- { +- png_bytep sp; +- png_bytep dp; +- png_uint_32 i; +- png_uint_32 row_width = row_info->width; +- png_size_t pixel_bytes; +- +- /* start at the beginning */ +- dp = row; +- /* find out how many bytes each pixel takes up */ +- pixel_bytes = (row_info->pixel_depth >> 3); +- /* loop through the row, only looking at the pixels that +- matter */ +- for (i = png_pass_start[pass]; i < row_width; +- i += png_pass_inc[pass]) +- { +- /* find out where the original pixel is */ +- sp = row + (png_size_t)i * pixel_bytes; +- /* move the pixel */ +- if (dp != sp) +- png_memcpy(dp, sp, pixel_bytes); +- /* next pixel */ +- dp += pixel_bytes; +- } +- break; +- } +- } +- /* set new row width */ +- row_info->width = (row_info->width + +- png_pass_inc[pass] - 1 - +- png_pass_start[pass]) / +- png_pass_inc[pass]; +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, +- row_info->width); +- } +-} +-#endif +- +-/* This filters the row, chooses which filter to use, if it has not already +- * been specified by the application, and then writes the row out with the +- * chosen filter. +- */ +-#define PNG_MAXSUM (~((png_uint_32)0) >> 1) +-#define PNG_HISHIFT 10 +-#define PNG_LOMASK ((png_uint_32)0xffffL) +-#define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT)) +-void /* PRIVATE */ +-png_write_find_filter(png_structp png_ptr, png_row_infop row_info) +-{ +- png_bytep prev_row, best_row, row_buf; +- png_uint_32 mins, bpp; +- png_byte filter_to_do = png_ptr->do_filter; +- png_uint_32 row_bytes = row_info->rowbytes; +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) +- int num_p_filters = (int)png_ptr->num_prev_filters; +-#endif +- +- png_debug(1, "in png_write_find_filter\n"); +- /* find out how many bytes offset each pixel is */ +- bpp = (row_info->pixel_depth + 7) >> 3; +- +- prev_row = png_ptr->prev_row; +- best_row = row_buf = png_ptr->row_buf; +- mins = PNG_MAXSUM; +- +- /* The prediction method we use is to find which method provides the +- * smallest value when summing the absolute values of the distances +- * from zero, using anything >= 128 as negative numbers. This is known +- * as the "minimum sum of absolute differences" heuristic. Other +- * heuristics are the "weighted minimum sum of absolute differences" +- * (experimental and can in theory improve compression), and the "zlib +- * predictive" method (not implemented yet), which does test compressions +- * of lines using different filter methods, and then chooses the +- * (series of) filter(s) that give minimum compressed data size (VERY +- * computationally expensive). +- * +- * GRR 980525: consider also +- * (1) minimum sum of absolute differences from running average (i.e., +- * keep running sum of non-absolute differences & count of bytes) +- * [track dispersion, too? restart average if dispersion too large?] +- * (1b) minimum sum of absolute differences from sliding average, probably +- * with window size <= deflate window (usually 32K) +- * (2) minimum sum of squared differences from zero or running average +- * (i.e., ~ root-mean-square approach) +- */ +- +- +- /* We don't need to test the 'no filter' case if this is the only filter +- * that has been chosen, as it doesn't actually do anything to the data. +- */ +- if ((filter_to_do & PNG_FILTER_NONE) && +- filter_to_do != PNG_FILTER_NONE) +- { +- png_bytep rp; +- png_uint_32 sum = 0; +- png_uint_32 i; +- int v; +- +- for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++) +- { +- v = *rp; +- sum += (v < 128) ? v : 256 - v; +- } +- +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- png_uint_32 sumhi, sumlo; +- int j; +- sumlo = sum & PNG_LOMASK; +- sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */ +- +- /* Reduce the sum if we match any of the previous rows */ +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE) +- { +- sumlo = (sumlo * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- sumhi = (sumhi * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } +- +- /* Factor in the cost of this filter (this is here for completeness, +- * but it makes no sense to have a "cost" for the NONE filter, as +- * it has the minimum possible computational cost - none). +- */ +- sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >> +- PNG_COST_SHIFT; +- sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >> +- PNG_COST_SHIFT; +- +- if (sumhi > PNG_HIMASK) +- sum = PNG_MAXSUM; +- else +- sum = (sumhi << PNG_HISHIFT) + sumlo; +- } +-#endif +- mins = sum; +- } +- +- /* sub filter */ +- if (filter_to_do == PNG_FILTER_SUB) +- /* it's the only filter so no testing is needed */ +- { +- png_bytep rp, lp, dp; +- png_uint_32 i; +- for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp; +- i++, rp++, dp++) +- { +- *dp = *rp; +- } +- for (lp = row_buf + 1; i < row_bytes; +- i++, rp++, lp++, dp++) +- { +- *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); +- } +- best_row = png_ptr->sub_row; +- } +- +- else if (filter_to_do & PNG_FILTER_SUB) +- { +- png_bytep rp, dp, lp; +- png_uint_32 sum = 0, lmins = mins; +- png_uint_32 i; +- int v; +- +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) +- /* We temporarily increase the "minimum sum" by the factor we +- * would reduce the sum of this filter, so that we can do the +- * early exit comparison without scaling the sum each time. +- */ +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- int j; +- png_uint_32 lmhi, lmlo; +- lmlo = lmins & PNG_LOMASK; +- lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; +- +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB) +- { +- lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } +- +- lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> +- PNG_COST_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> +- PNG_COST_SHIFT; +- +- if (lmhi > PNG_HIMASK) +- lmins = PNG_MAXSUM; +- else +- lmins = (lmhi << PNG_HISHIFT) + lmlo; +- } +-#endif +- +- for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp; +- i++, rp++, dp++) +- { +- v = *dp = *rp; +- +- sum += (v < 128) ? v : 256 - v; +- } +- for (lp = row_buf + 1; i < row_bytes; +- i++, rp++, lp++, dp++) +- { +- v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); +- +- sum += (v < 128) ? v : 256 - v; +- +- if (sum > lmins) /* We are already worse, don't continue. */ +- break; +- } +- +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- int j; +- png_uint_32 sumhi, sumlo; +- sumlo = sum & PNG_LOMASK; +- sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; +- +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB) +- { +- sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } +- +- sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> +- PNG_COST_SHIFT; +- sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> +- PNG_COST_SHIFT; +- +- if (sumhi > PNG_HIMASK) +- sum = PNG_MAXSUM; +- else +- sum = (sumhi << PNG_HISHIFT) + sumlo; +- } +-#endif +- +- if (sum < mins) +- { +- mins = sum; +- best_row = png_ptr->sub_row; +- } +- } +- +- /* up filter */ +- if (filter_to_do == PNG_FILTER_UP) +- { +- png_bytep rp, dp, pp; +- png_uint_32 i; +- +- for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1, +- pp = prev_row + 1; i < row_bytes; +- i++, rp++, pp++, dp++) +- { +- *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff); +- } +- best_row = png_ptr->up_row; +- } +- +- else if (filter_to_do & PNG_FILTER_UP) +- { +- png_bytep rp, dp, pp; +- png_uint_32 sum = 0, lmins = mins; +- png_uint_32 i; +- int v; +- +- +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- int j; +- png_uint_32 lmhi, lmlo; +- lmlo = lmins & PNG_LOMASK; +- lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; +- +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP) +- { +- lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } +- +- lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >> +- PNG_COST_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >> +- PNG_COST_SHIFT; +- +- if (lmhi > PNG_HIMASK) +- lmins = PNG_MAXSUM; +- else +- lmins = (lmhi << PNG_HISHIFT) + lmlo; +- } +-#endif +- +- for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1, +- pp = prev_row + 1; i < row_bytes; i++) +- { +- v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); +- +- sum += (v < 128) ? v : 256 - v; +- +- if (sum > lmins) /* We are already worse, don't continue. */ +- break; +- } +- +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- int j; +- png_uint_32 sumhi, sumlo; +- sumlo = sum & PNG_LOMASK; +- sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; +- +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP) +- { +- sumlo = (sumlo * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- sumhi = (sumhi * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } +- +- sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >> +- PNG_COST_SHIFT; +- sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >> +- PNG_COST_SHIFT; +- +- if (sumhi > PNG_HIMASK) +- sum = PNG_MAXSUM; +- else +- sum = (sumhi << PNG_HISHIFT) + sumlo; +- } +-#endif +- +- if (sum < mins) +- { +- mins = sum; +- best_row = png_ptr->up_row; +- } +- } +- +- /* avg filter */ +- if (filter_to_do == PNG_FILTER_AVG) +- { +- png_bytep rp, dp, pp, lp; +- png_uint_32 i; +- for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1, +- pp = prev_row + 1; i < bpp; i++) +- { +- *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); +- } +- for (lp = row_buf + 1; i < row_bytes; i++) +- { +- *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) +- & 0xff); +- } +- best_row = png_ptr->avg_row; +- } +- +- else if (filter_to_do & PNG_FILTER_AVG) +- { +- png_bytep rp, dp, pp, lp; +- png_uint_32 sum = 0, lmins = mins; +- png_uint_32 i; +- int v; +- +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- int j; +- png_uint_32 lmhi, lmlo; +- lmlo = lmins & PNG_LOMASK; +- lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; +- +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG) +- { +- lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } +- +- lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >> +- PNG_COST_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >> +- PNG_COST_SHIFT; +- +- if (lmhi > PNG_HIMASK) +- lmins = PNG_MAXSUM; +- else +- lmins = (lmhi << PNG_HISHIFT) + lmlo; +- } +-#endif +- +- for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1, +- pp = prev_row + 1; i < bpp; i++) +- { +- v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); +- +- sum += (v < 128) ? v : 256 - v; +- } +- for (lp = row_buf + 1; i < row_bytes; i++) +- { +- v = *dp++ = +- (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff); +- +- sum += (v < 128) ? v : 256 - v; +- +- if (sum > lmins) /* We are already worse, don't continue. */ +- break; +- } +- +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- int j; +- png_uint_32 sumhi, sumlo; +- sumlo = sum & PNG_LOMASK; +- sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; +- +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE) +- { +- sumlo = (sumlo * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- sumhi = (sumhi * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } +- +- sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >> +- PNG_COST_SHIFT; +- sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >> +- PNG_COST_SHIFT; +- +- if (sumhi > PNG_HIMASK) +- sum = PNG_MAXSUM; +- else +- sum = (sumhi << PNG_HISHIFT) + sumlo; +- } +-#endif +- +- if (sum < mins) +- { +- mins = sum; +- best_row = png_ptr->avg_row; +- } +- } +- +- /* Paeth filter */ +- if (filter_to_do == PNG_FILTER_PAETH) +- { +- png_bytep rp, dp, pp, cp, lp; +- png_uint_32 i; +- for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1, +- pp = prev_row + 1; i < bpp; i++) +- { +- *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); +- } +- +- for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++) +- { +- int a, b, c, pa, pb, pc, p; +- +- b = *pp++; +- c = *cp++; +- a = *lp++; +- +- p = b - c; +- pc = a - c; +- +-#ifdef PNG_USE_ABS +- pa = abs(p); +- pb = abs(pc); +- pc = abs(p + pc); +-#else +- pa = p < 0 ? -p : p; +- pb = pc < 0 ? -pc : pc; +- pc = (p + pc) < 0 ? -(p + pc) : p + pc; +-#endif +- +- p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; +- +- *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); +- } +- best_row = png_ptr->paeth_row; +- } +- +- else if (filter_to_do & PNG_FILTER_PAETH) +- { +- png_bytep rp, dp, pp, cp, lp; +- png_uint_32 sum = 0, lmins = mins; +- png_uint_32 i; +- int v; +- +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- int j; +- png_uint_32 lmhi, lmlo; +- lmlo = lmins & PNG_LOMASK; +- lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; +- +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH) +- { +- lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } +- +- lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >> +- PNG_COST_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >> +- PNG_COST_SHIFT; +- +- if (lmhi > PNG_HIMASK) +- lmins = PNG_MAXSUM; +- else +- lmins = (lmhi << PNG_HISHIFT) + lmlo; +- } +-#endif +- +- for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1, +- pp = prev_row + 1; i < bpp; i++) +- { +- v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); +- +- sum += (v < 128) ? v : 256 - v; +- } +- +- for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++) +- { +- int a, b, c, pa, pb, pc, p; +- +- b = *pp++; +- c = *cp++; +- a = *lp++; +- +-#ifndef PNG_SLOW_PAETH +- p = b - c; +- pc = a - c; +-#ifdef PNG_USE_ABS +- pa = abs(p); +- pb = abs(pc); +- pc = abs(p + pc); +-#else +- pa = p < 0 ? -p : p; +- pb = pc < 0 ? -pc : pc; +- pc = (p + pc) < 0 ? -(p + pc) : p + pc; +-#endif +- p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; +-#else /* PNG_SLOW_PAETH */ +- p = a + b - c; +- pa = abs(p - a); +- pb = abs(p - b); +- pc = abs(p - c); +- if (pa <= pb && pa <= pc) +- p = a; +- else if (pb <= pc) +- p = b; +- else +- p = c; +-#endif /* PNG_SLOW_PAETH */ +- +- v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); +- +- sum += (v < 128) ? v : 256 - v; +- +- if (sum > lmins) /* We are already worse, don't continue. */ +- break; +- } +- +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- int j; +- png_uint_32 sumhi, sumlo; +- sumlo = sum & PNG_LOMASK; +- sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; +- +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH) +- { +- sumlo = (sumlo * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- sumhi = (sumhi * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } +- +- sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >> +- PNG_COST_SHIFT; +- sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >> +- PNG_COST_SHIFT; +- +- if (sumhi > PNG_HIMASK) +- sum = PNG_MAXSUM; +- else +- sum = (sumhi << PNG_HISHIFT) + sumlo; +- } +-#endif +- +- if (sum < mins) +- { +- best_row = png_ptr->paeth_row; +- } +- } +- +- /* Do the actual writing of the filtered row data from the chosen filter. */ +- +- png_write_filtered_row(png_ptr, best_row); +- +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) +- /* Save the type of filter we picked this time for future calculations */ +- if (png_ptr->num_prev_filters > 0) +- { +- int j; +- for (j = 1; j < num_p_filters; j++) +- { +- png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1]; +- } +- png_ptr->prev_filters[j] = best_row[0]; +- } +-#endif +-} +- +- +-/* Do the actual writing of a previously filtered row. */ +-void /* PRIVATE */ +-png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row) +-{ +- png_debug(1, "in png_write_filtered_row\n"); +- png_debug1(2, "filter = %d\n", filtered_row[0]); +- /* set up the zlib input buffer */ +- +- png_ptr->zstream.next_in = filtered_row; +- png_ptr->zstream.avail_in = (uInt)png_ptr->row_info.rowbytes + 1; +- /* repeat until we have compressed all the data */ +- do +- { +- int ret; /* return of zlib */ +- +- /* compress the data */ +- ret = deflate(&png_ptr->zstream, Z_NO_FLUSH); +- /* check for compression errors */ +- if (ret != Z_OK) +- { +- if (png_ptr->zstream.msg != NULL) +- png_error(png_ptr, png_ptr->zstream.msg); +- else +- png_error(png_ptr, "zlib error"); +- } +- +- /* see if it is time to write another IDAT */ +- if (!(png_ptr->zstream.avail_out)) +- { +- /* write the IDAT and reset the zlib output buffer */ +- png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- } +- /* repeat until all data has been compressed */ +- } while (png_ptr->zstream.avail_in); +- +- /* swap the current and previous rows */ +- if (png_ptr->prev_row != NULL) +- { +- png_bytep tptr; +- +- tptr = png_ptr->prev_row; +- png_ptr->prev_row = png_ptr->row_buf; +- png_ptr->row_buf = tptr; +- } +- +- /* finish row - updates counters and flushes zlib if last row */ +- png_write_finish_row(png_ptr); +- +-#if defined(PNG_WRITE_FLUSH_SUPPORTED) +- png_ptr->flush_rows++; +- +- if (png_ptr->flush_dist > 0 && +- png_ptr->flush_rows >= png_ptr->flush_dist) +- { +- png_write_flush(png_ptr); +- } +-#endif +-} +-#endif /* PNG_WRITE_SUPPORTED */ +diff --git a/thirdparty/minizip/CMakeLists.txt b/thirdparty/minizip/CMakeLists.txt +deleted file mode 100644 +index 5f4d0af..0000000 +--- a/thirdparty/minizip/CMakeLists.txt ++++ /dev/null +@@ -1,20 +0,0 @@ +-project(minizip) +- +-# Create the list of source files +-aux_source_directory( . source_files ) +- +-# Define _UNICODE (use wide-char encoding) +-add_definitions(-D_UNICODE -D_CRT_SECURE_NO_DEPRECATE /wd4127 /wd4131 /wd4100 /wd4189 /wd4244) +- +-# Add include dir +-include_directories( ${CMAKE_SOURCE_DIR}/thirdparty/zlib ) +- +-fix_default_compiler_settings_() +- +-# Add library build target +-add_library(minizip STATIC ${source_files}) +- +-# Add linker input libraries +-target_link_libraries(minizip zlib) +- +-set_target_properties(minizip PROPERTIES DEBUG_POSTFIX d ) +\ No newline at end of file +diff --git a/thirdparty/minizip/MiniZip64_Changes.txt b/thirdparty/minizip/MiniZip64_Changes.txt +deleted file mode 100644 +index 13a1bd9..0000000 +--- a/thirdparty/minizip/MiniZip64_Changes.txt ++++ /dev/null +@@ -1,6 +0,0 @@ +- +-MiniZip 1.1 was derrived from MiniZip at version 1.01f +- +-Change in 1.0 (Okt 2009) +- - **TODO - Add history** +- +diff --git a/thirdparty/minizip/MiniZip64_info.txt b/thirdparty/minizip/MiniZip64_info.txt +deleted file mode 100644 +index 57d7152..0000000 +--- a/thirdparty/minizip/MiniZip64_info.txt ++++ /dev/null +@@ -1,74 +0,0 @@ +-MiniZip - Copyright (c) 1998-2010 - by Gilles Vollant - version 1.1 64 bits from Mathias Svensson +- +-Introduction +---------------------- +-MiniZip 1.1 is built from MiniZip 1.0 by Gilles Vollant ( http://www.winimage.com/zLibDll/minizip.html ) +- +-When adding ZIP64 support into minizip it would result into risk of breaking compatibility with minizip 1.0. +-All possible work was done for compatibility. +- +- +-Background +---------------------- +-When adding ZIP64 support Mathias Svensson found that Even Rouault have added ZIP64 +-support for unzip.c into minizip for a open source project called gdal ( http://www.gdal.org/ ) +- +-That was used as a starting point. And after that ZIP64 support was added to zip.c +-some refactoring and code cleanup was also done. +- +- +-Changed from MiniZip 1.0 to MiniZip 1.1 +---------------------------------------- +-* Added ZIP64 support for unzip ( by Even Rouault ) +-* Added ZIP64 support for zip ( by Mathias Svensson ) +-* Reverted some changed that Even Rouault did. +-* Bunch of patches received from Gulles Vollant that he received for MiniZip from various users. +-* Added unzip patch for BZIP Compression method (patch create by Daniel Borca) +-* Added BZIP Compress method for zip +-* Did some refactoring and code cleanup +- +- +-Credits +- +- Gilles Vollant - Original MiniZip author +- Even Rouault - ZIP64 unzip Support +- Daniel Borca - BZip Compression method support in unzip +- Mathias Svensson - ZIP64 zip support +- Mathias Svensson - BZip Compression method support in zip +- +- Resources +- +- ZipLayout http://result42.com/projects/ZipFileLayout +- Command line tool for Windows that shows the layout and information of the headers in a zip archive. +- Used when debugging and validating the creation of zip files using MiniZip64 +- +- +- ZIP App Note http://www.pkware.com/documents/casestudies/APPNOTE.TXT +- Zip File specification +- +- +-Notes. +- * To be able to use BZip compression method in zip64.c or unzip64.c the BZIP2 lib is needed and HAVE_BZIP2 need to be defined. +- +-License +----------------------------------------------------------- +- Condition of use and distribution are the same than zlib : +- +- This software is provided 'as-is', without any express or implied +- warranty. In no event will the authors be held liable for any damages +- arising from the use of this software. +- +- Permission is granted to anyone to use this software for any purpose, +- including commercial applications, and to alter it and redistribute it +- freely, subject to the following restrictions: +- +- 1. The origin of this software must not be misrepresented; you must not +- claim that you wrote the original software. If you use this software +- in a product, an acknowledgment in the product documentation would be +- appreciated but is not required. +- 2. Altered source versions must be plainly marked as such, and must not be +- misrepresented as being the original software. +- 3. This notice may not be removed or altered from any source distribution. +- +----------------------------------------------------------- +- +diff --git a/thirdparty/minizip/crypt.h b/thirdparty/minizip/crypt.h +deleted file mode 100644 +index a01d08d..0000000 +--- a/thirdparty/minizip/crypt.h ++++ /dev/null +@@ -1,131 +0,0 @@ +-/* crypt.h -- base code for crypt/uncrypt ZIPfile +- +- +- Version 1.01e, February 12th, 2005 +- +- Copyright (C) 1998-2005 Gilles Vollant +- +- This code is a modified version of crypting code in Infozip distribution +- +- 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). +- +- If you don't need crypting in your application, just define symbols +- NOCRYPT and NOUNCRYPT. +- +- This code support the "Traditional PKWARE Encryption". +- +- The new AES encryption added on Zip format by Winzip (see the page +- http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong +- Encryption is not supported. +-*/ +- +-#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) +- +-/*********************************************************************** +- * Return the next byte in the pseudo-random sequence +- */ +-static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab) +-{ +- unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an +- * unpredictable manner on 16-bit systems; not a problem +- * with any known compiler so far, though */ +- +- temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2; +- return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); +-} +- +-/*********************************************************************** +- * Update the encryption keys with the next byte of plain text +- */ +-static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c) +-{ +- (*(pkeys+0)) = CRC32((*(pkeys+0)), c); +- (*(pkeys+1)) += (*(pkeys+0)) & 0xff; +- (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1; +- { +- register int keyshift = (int)((*(pkeys+1)) >> 24); +- (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift); +- } +- return c; +-} +- +- +-/*********************************************************************** +- * Initialize the encryption keys and the random header according to +- * the given password. +- */ +-static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab) +-{ +- *(pkeys+0) = 305419896L; +- *(pkeys+1) = 591751049L; +- *(pkeys+2) = 878082192L; +- while (*passwd != '\0') { +- update_keys(pkeys,pcrc_32_tab,(int)*passwd); +- passwd++; +- } +-} +- +-#define zdecode(pkeys,pcrc_32_tab,c) \ +- (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab))) +- +-#define zencode(pkeys,pcrc_32_tab,c,t) \ +- (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c)) +- +-#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED +- +-#define RAND_HEAD_LEN 12 +- /* "last resort" source for second part of crypt seed pattern */ +-# ifndef ZCR_SEED2 +-# define ZCR_SEED2 3141592654UL /* use PI as default pattern */ +-# endif +- +-static int crypthead(const char* passwd, /* password string */ +- unsigned char* buf, /* where to write header */ +- int bufSize, +- unsigned long* pkeys, +- const unsigned long* pcrc_32_tab, +- unsigned long crcForCrypting) +-{ +- int n; /* index in random header */ +- int t; /* temporary */ +- int c; /* random byte */ +- unsigned char header[RAND_HEAD_LEN-2]; /* random header */ +- static unsigned calls = 0; /* ensure different random header each time */ +- +- if (bufSize> 7) & 0xff; +- header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t); +- } +- /* Encrypt random header (last two bytes is high word of crc) */ +- init_keys(passwd, pkeys, pcrc_32_tab); +- for (n = 0; n < RAND_HEAD_LEN-2; n++) +- { +- buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t); +- } +- buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t); +- buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t); +- return n; +-} +- +-#endif +diff --git a/thirdparty/minizip/ioapi.c b/thirdparty/minizip/ioapi.c +deleted file mode 100644 +index 7f25460..0000000 +--- a/thirdparty/minizip/ioapi.c ++++ /dev/null +@@ -1,236 +0,0 @@ +-/* 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)) +- #define _CRT_SECURE_NO_WARNINGS +-#endif +- +-#include "ioapi.h" +-#include "tchar.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) == ((uLong)-1)) +- 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; +- wchar_t* mode_fopen = NULL; +- if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) +- mode_fopen = _T("rb"); +- else +- if (mode & ZLIB_FILEFUNC_MODE_EXISTING) +- mode_fopen = _T("r+b"); +- else +- if (mode & ZLIB_FILEFUNC_MODE_CREATE) +- mode_fopen = L"wb"; +- +- if ((filename!=NULL) && (mode_fopen != NULL)) +- file = _wfopen((wchar_t*)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 = ftello64((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(fseeko64((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/thirdparty/minizip/ioapi.h b/thirdparty/minizip/ioapi.h +deleted file mode 100644 +index be98b97..0000000 +--- a/thirdparty/minizip/ioapi.h ++++ /dev/null +@@ -1,200 +0,0 @@ +-/* 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)) +- +- // 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 +-#include +-#include "zlib.h" +- +-#if defined(USE_FILE32API) +-#define fopen64 _tfopen +-#define ftello64 ftell +-#define fseeko64 fseek +-#else +-#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 +- #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 +- +- +-#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/thirdparty/minizip/iowin32.c b/thirdparty/minizip/iowin32.c +deleted file mode 100644 +index 6a2a883..0000000 +--- a/thirdparty/minizip/iowin32.c ++++ /dev/null +@@ -1,389 +0,0 @@ +-/* 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 +- +-#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 +- +-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); +- +- if ((filename!=NULL) && (dwDesiredAccess != 0)) +- hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); +- +- 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); +- +- if ((filename!=NULL) && (dwDesiredAccess != 0)) +- hFile = CreateFileA((LPCSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); +- +- 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); +- +- if ((filename!=NULL) && (dwDesiredAccess != 0)) +- hFile = CreateFileW((LPCWSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); +- +- 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); +- +- if ((filename!=NULL) && (dwDesiredAccess != 0)) +- hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); +- +- 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; +-} +- +-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) +- { +- DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT); +- if (dwSet == INVALID_SET_FILE_POINTER) +- { +- DWORD dwErr = GetLastError(); +- ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; +- ret = -1; +- } +- else +- ret=(long)dwSet; +- } +- 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 li; +- li.QuadPart = 0; +- li.u.LowPart = SetFilePointer(hFile, li.u.LowPart, &li.u.HighPart, FILE_CURRENT); +- if ( (li.LowPart == 0xFFFFFFFF) && (GetLastError() != NO_ERROR)) +- { +- DWORD dwErr = GetLastError(); +- ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; +- ret = (ZPOS64_T)-1; +- } +- else +- ret=li.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) +- { +- DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod); +- if (dwSet == INVALID_SET_FILE_POINTER) +- { +- 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* li = (LARGE_INTEGER*)&offset; +- DWORD dwSet = SetFilePointer(hFile, li->u.LowPart, &li->u.HighPart, dwMoveMethod); +- if (dwSet == INVALID_SET_FILE_POINTER) +- { +- 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/thirdparty/minizip/iowin32.h b/thirdparty/minizip/iowin32.h +deleted file mode 100644 +index 0ca0969..0000000 +--- a/thirdparty/minizip/iowin32.h ++++ /dev/null +@@ -1,28 +0,0 @@ +-/* 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 +- +- +-#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/thirdparty/minizip/minizip_vs2010.vcxproj b/thirdparty/minizip/minizip_vs2010.vcxproj +deleted file mode 100644 +index 6173484..0000000 +--- a/thirdparty/minizip/minizip_vs2010.vcxproj ++++ /dev/null +@@ -1,238 +0,0 @@ +- +- +- +- +- Debug +- Win32 +- +- +- Debug +- x64 +- +- +- Release LIB +- Win32 +- +- +- Release LIB +- x64 +- +- +- Release +- Win32 +- +- +- Release +- x64 +- +- +- +- {C610F50E-1013-46F0-AE20-4E918654B40F} +- minizip +- Win32Proj +- minizip +- +- +- +- StaticLibrary +- Unicode +- true +- +- +- StaticLibrary +- Unicode +- true +- +- +- StaticLibrary +- Unicode +- true +- +- +- StaticLibrary +- Unicode +- true +- +- +- StaticLibrary +- Unicode +- +- +- StaticLibrary +- Unicode +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- <_ProjectFileVersion>10.0.30319.1 +- $(SolutionDir)thirdparty\lib\ +- $(SolutionDir)thirdparty\lib\$(Platform)\ +- $(Configuration)\ +- $(SolutionDir)\thirdparty\lib\ +- $(SolutionDir)\thirdparty\lib\$(Platform)\ +- $(Configuration)\ +- $(SolutionDir)\thirdparty\lib\ +- $(SolutionDir)\thirdparty\lib\$(Platform)\ +- $(Configuration)\ +- $(Configuration)\ +- AllRules.ruleset +- AllRules.ruleset +- +- +- +- +- AllRules.ruleset +- AllRules.ruleset +- +- +- +- +- AllRules.ruleset +- AllRules.ruleset +- +- +- +- +- minizipd +- minizipd +- minizip +- minizip +- minizip +- minizip +- +- +- +- Disabled +- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) +- WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions) +- EnableFastChecks +- MultiThreadedDebugDLL +- +- +- Level3 +- EditAndContinue +- 4133;4996;%(DisableSpecificWarnings) +- true +- +- +- +- +- +- Disabled +- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) +- _WIN64;_DEBUG;_LIB;%(PreprocessorDefinitions) +- EnableFastChecks +- MultiThreadedDebugDLL +- +- +- Level3 +- ProgramDatabase +- 4133;4996;%(DisableSpecificWarnings) +- true +- +- +- +- +- +- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) +- WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) +- MultiThreadedDLL +- +- +- Level3 +- ProgramDatabase +- 4133;4996;%(DisableSpecificWarnings) +- MinSpace +- Size +- true +- +- +- +- +- +- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) +- WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) +- MultiThreadedDLL +- +- +- Level3 +- ProgramDatabase +- 4133;4996;%(DisableSpecificWarnings) +- MinSpace +- Size +- true +- +- +- +- +- +- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) +- WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) +- MultiThreaded +- +- +- Level3 +- ProgramDatabase +- 4133;4996;%(DisableSpecificWarnings) +- MinSpace +- Size +- true +- +- +- +- +- +- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) +- WIN64;NDEBUG;_LIB;%(PreprocessorDefinitions) +- MultiThreaded +- +- +- Level3 +- ProgramDatabase +- 4133;4996;%(DisableSpecificWarnings) +- true +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +\ No newline at end of file +diff --git a/thirdparty/minizip/mztools.c b/thirdparty/minizip/mztools.c +deleted file mode 100644 +index f9092e6..0000000 +--- a/thirdparty/minizip/mztools.c ++++ /dev/null +@@ -1,281 +0,0 @@ +-/* +- Additional tools for Minizip +- Code: Xavier Roche '2004 +- License: Same as ZLIB (www.gzip.org) +-*/ +- +-/* Code */ +-#include +-#include +-#include +-#include "zlib.h" +-#include "unzip.h" +- +-#define READ_8(adr) ((unsigned char)*(adr)) +-#define READ_16(adr) ( READ_8(adr) | (READ_8(adr+1) << 8) ) +-#define READ_32(adr) ( READ_16(adr) | (READ_16((adr)+2) << 16) ) +- +-#define WRITE_8(buff, n) do { \ +- *((unsigned char*)(buff)) = (unsigned char) ((n) & 0xff); \ +-} while(0) +-#define WRITE_16(buff, n) do { \ +- WRITE_8((unsigned char*)(buff), n); \ +- WRITE_8(((unsigned char*)(buff)) + 1, (n) >> 8); \ +-} while(0) +-#define WRITE_32(buff, n) do { \ +- WRITE_16((unsigned char*)(buff), (n) & 0xffff); \ +- WRITE_16((unsigned char*)(buff) + 2, (n) >> 16); \ +-} while(0) +- +-extern int ZEXPORT unzRepair(file, fileOut, fileOutTmp, nRecovered, bytesRecovered) +-const char* file; +-const char* fileOut; +-const char* fileOutTmp; +-uLong* nRecovered; +-uLong* bytesRecovered; +-{ +- int err = Z_OK; +- FILE* fpZip = fopen(file, "rb"); +- FILE* fpOut = fopen(fileOut, "wb"); +- FILE* fpOutCD = fopen(fileOutTmp, "wb"); +- if (fpZip != NULL && fpOut != NULL) { +- int entries = 0; +- uLong totalBytes = 0; +- char header[30]; +- char filename[256]; +- char extra[1024]; +- int offset = 0; +- int offsetCD = 0; +- while ( fread(header, 1, 30, fpZip) == 30 ) { +- int currentOffset = offset; +- +- /* File entry */ +- if (READ_32(header) == 0x04034b50) { +- unsigned int version = READ_16(header + 4); +- unsigned int gpflag = READ_16(header + 6); +- unsigned int method = READ_16(header + 8); +- unsigned int filetime = READ_16(header + 10); +- unsigned int filedate = READ_16(header + 12); +- unsigned int crc = READ_32(header + 14); /* crc */ +- unsigned int cpsize = READ_32(header + 18); /* compressed size */ +- unsigned int uncpsize = READ_32(header + 22); /* uncompressed sz */ +- unsigned int fnsize = READ_16(header + 26); /* file name length */ +- unsigned int extsize = READ_16(header + 28); /* extra field length */ +- filename[0] = extra[0] = '\0'; +- +- /* Header */ +- if (fwrite(header, 1, 30, fpOut) == 30) { +- offset += 30; +- } else { +- err = Z_ERRNO; +- break; +- } +- +- /* Filename */ +- if (fnsize > 0) { +- if (fread(filename, 1, fnsize, fpZip) == fnsize) { +- if (fwrite(filename, 1, fnsize, fpOut) == fnsize) { +- offset += fnsize; +- } else { +- err = Z_ERRNO; +- break; +- } +- } else { +- err = Z_ERRNO; +- break; +- } +- } else { +- err = Z_STREAM_ERROR; +- break; +- } +- +- /* Extra field */ +- if (extsize > 0) { +- if (fread(extra, 1, extsize, fpZip) == extsize) { +- if (fwrite(extra, 1, extsize, fpOut) == extsize) { +- offset += extsize; +- } else { +- err = Z_ERRNO; +- break; +- } +- } else { +- err = Z_ERRNO; +- break; +- } +- } +- +- /* Data */ +- { +- int dataSize = cpsize; +- if (dataSize == 0) { +- dataSize = uncpsize; +- } +- if (dataSize > 0) { +- char* data = malloc(dataSize); +- if (data != NULL) { +- if ((int)fread(data, 1, dataSize, fpZip) == dataSize) { +- if ((int)fwrite(data, 1, dataSize, fpOut) == dataSize) { +- offset += dataSize; +- totalBytes += dataSize; +- } else { +- err = Z_ERRNO; +- } +- } else { +- err = Z_ERRNO; +- } +- free(data); +- if (err != Z_OK) { +- break; +- } +- } else { +- err = Z_MEM_ERROR; +- break; +- } +- } +- } +- +- /* Central directory entry */ +- { +- char header[46]; +- char* comment = ""; +- int comsize = (int) strlen(comment); +- WRITE_32(header, 0x02014b50); +- WRITE_16(header + 4, version); +- WRITE_16(header + 6, version); +- WRITE_16(header + 8, gpflag); +- WRITE_16(header + 10, method); +- WRITE_16(header + 12, filetime); +- WRITE_16(header + 14, filedate); +- WRITE_32(header + 16, crc); +- WRITE_32(header + 20, cpsize); +- WRITE_32(header + 24, uncpsize); +- WRITE_16(header + 28, fnsize); +- WRITE_16(header + 30, extsize); +- WRITE_16(header + 32, comsize); +- WRITE_16(header + 34, 0); /* disk # */ +- WRITE_16(header + 36, 0); /* int attrb */ +- WRITE_32(header + 38, 0); /* ext attrb */ +- WRITE_32(header + 42, currentOffset); +- /* Header */ +- if (fwrite(header, 1, 46, fpOutCD) == 46) { +- offsetCD += 46; +- +- /* Filename */ +- if (fnsize > 0) { +- if (fwrite(filename, 1, fnsize, fpOutCD) == fnsize) { +- offsetCD += fnsize; +- } else { +- err = Z_ERRNO; +- break; +- } +- } else { +- err = Z_STREAM_ERROR; +- break; +- } +- +- /* Extra field */ +- if (extsize > 0) { +- if (fwrite(extra, 1, extsize, fpOutCD) == extsize) { +- offsetCD += extsize; +- } else { +- err = Z_ERRNO; +- break; +- } +- } +- +- /* Comment field */ +- if (comsize > 0) { +- if ((int)fwrite(comment, 1, comsize, fpOutCD) == comsize) { +- offsetCD += comsize; +- } else { +- err = Z_ERRNO; +- break; +- } +- } +- +- +- } else { +- err = Z_ERRNO; +- break; +- } +- } +- +- /* Success */ +- entries++; +- +- } else { +- break; +- } +- } +- +- /* Final central directory */ +- { +- int entriesZip = entries; +- char header[22]; +- char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools"; +- int comsize = (int) strlen(comment); +- if (entriesZip > 0xffff) { +- entriesZip = 0xffff; +- } +- WRITE_32(header, 0x06054b50); +- WRITE_16(header + 4, 0); /* disk # */ +- WRITE_16(header + 6, 0); /* disk # */ +- WRITE_16(header + 8, entriesZip); /* hack */ +- WRITE_16(header + 10, entriesZip); /* hack */ +- WRITE_32(header + 12, offsetCD); /* size of CD */ +- WRITE_32(header + 16, offset); /* offset to CD */ +- WRITE_16(header + 20, comsize); /* comment */ +- +- /* Header */ +- if (fwrite(header, 1, 22, fpOutCD) == 22) { +- +- /* Comment field */ +- if (comsize > 0) { +- if ((int)fwrite(comment, 1, comsize, fpOutCD) != comsize) { +- err = Z_ERRNO; +- } +- } +- +- } else { +- err = Z_ERRNO; +- } +- } +- +- /* Final merge (file + central directory) */ +- fclose(fpOutCD); +- if (err == Z_OK) { +- fpOutCD = fopen(fileOutTmp, "rb"); +- if (fpOutCD != NULL) { +- int nRead; +- char buffer[8192]; +- while ( (nRead = (int)fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) { +- if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) { +- err = Z_ERRNO; +- break; +- } +- } +- fclose(fpOutCD); +- } +- } +- +- /* Close */ +- fclose(fpZip); +- fclose(fpOut); +- +- /* Wipe temporary file */ +- (void)remove(fileOutTmp); +- +- /* Number of recovered entries */ +- if (err == Z_OK) { +- if (nRecovered != NULL) { +- *nRecovered = entries; +- } +- if (bytesRecovered != NULL) { +- *bytesRecovered = totalBytes; +- } +- } +- } else { +- err = Z_STREAM_ERROR; +- } +- return err; +-} +diff --git a/thirdparty/minizip/mztools.h b/thirdparty/minizip/mztools.h +deleted file mode 100644 +index 88b3459..0000000 +--- a/thirdparty/minizip/mztools.h ++++ /dev/null +@@ -1,31 +0,0 @@ +-/* +- Additional tools for Minizip +- Code: Xavier Roche '2004 +- License: Same as ZLIB (www.gzip.org) +-*/ +- +-#ifndef _zip_tools_H +-#define _zip_tools_H +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-#ifndef _ZLIB_H +-#include "zlib.h" +-#endif +- +-#include "unzip.h" +- +-/* Repair a ZIP file (missing central directory) +- file: file to recover +- fileOut: output file after recovery +- fileOutTmp: temporary file name used for recovery +-*/ +-extern int ZEXPORT unzRepair(const char* file, +- const char* fileOut, +- const char* fileOutTmp, +- uLong* nRecovered, +- uLong* bytesRecovered); +- +-#endif +diff --git a/thirdparty/minizip/unzip.c b/thirdparty/minizip/unzip.c +deleted file mode 100644 +index 38a5c06..0000000 +--- a/thirdparty/minizip/unzip.c ++++ /dev/null +@@ -1,2125 +0,0 @@ +-/* 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 +-#include +-#include +- +-#ifndef NOUNCRYPT +- #define NOUNCRYPT +-#endif +- +-#include "zlib.h" +-#include "unzip.h" +- +-#ifdef STDC +-# include +-# include +-# include +-#endif +-#ifdef NO_ERRNO_H +- extern int errno; +-#else +-# include +-#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 unsigned long* 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 (c1c2) +- 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 (uBackReaduMaxBack) +- 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 (uBackReaduMaxBack) +- 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_pospfile_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_filename0) && (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_extraz_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 == (ZPOS64_T)(unsigned long)-1) +- { +- if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK) +- err=UNZ_ERRNO; +- } +- +- if(file_info.compressed_size == (ZPOS64_T)(unsigned long)-1) +- { +- if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK) +- err=UNZ_ERRNO; +- } +- +- if(file_info_internal.offset_curfile == (ZPOS64_T)(unsigned long)-1) +- { +- /* 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 == (unsigned long)-1) +- { +- /* 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_commentz_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 unzipStringFileNameCompare +- +- 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; +- case 2 : *level = 9; break; +- } +- } +- +- if ((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; +- +- pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc; +- pfile_in_zip_read_info->crc32=0; +- pfile_in_zip_read_info->total_out_64=0; +- pfile_in_zip_read_info->compression_method = s->cur_file_info.compression_method; +- pfile_in_zip_read_info->filestream=s->filestream; +- pfile_in_zip_read_info->z_filefunc=s->z_filefunc; +- pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile; +- +- pfile_in_zip_read_info->stream.total_out = 0; +- +- if ((s->cur_file_info.compression_method==Z_BZIP2ED) && (!raw)) +- { +-#ifdef HAVE_BZIP2 +- pfile_in_zip_read_info->bstream.bzalloc = (void *(*) (void *, int, int))0; +- pfile_in_zip_read_info->bstream.bzfree = (free_func)0; +- pfile_in_zip_read_info->bstream.opaque = (voidpf)0; +- pfile_in_zip_read_info->bstream.state = (voidpf)0; +- +- pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; +- pfile_in_zip_read_info->stream.zfree = (free_func)0; +- pfile_in_zip_read_info->stream.opaque = (voidpf)0; +- pfile_in_zip_read_info->stream.next_in = (voidpf)0; +- pfile_in_zip_read_info->stream.avail_in = 0; +- +- err=BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0); +- if (err == Z_OK) +- pfile_in_zip_read_info->stream_initialised=Z_BZIP2ED; +- else +- { +- TRYFREE(pfile_in_zip_read_info); +- return err; +- } +-#else +- pfile_in_zip_read_info->raw=1; +-#endif +- } +- else if ((s->cur_file_info.compression_method==Z_DEFLATED) && (!raw)) +- { +- pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; +- pfile_in_zip_read_info->stream.zfree = (free_func)0; +- pfile_in_zip_read_info->stream.opaque = (voidpf)0; +- pfile_in_zip_read_info->stream.next_in = 0; +- pfile_in_zip_read_info->stream.avail_in = 0; +- +- err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS); +- if (err == Z_OK) +- pfile_in_zip_read_info->stream_initialised=Z_DEFLATED; +- else +- { +- TRYFREE(pfile_in_zip_read_info); +- return err; +- } +- /* windowBits is passed < 0 to tell that there is no zlib header. +- * Note that in this case inflate *requires* an extra "dummy" byte +- * after the compressed stream in order to complete decompression and +- * return Z_STREAM_END. +- * In unzip, i don't wait absolutely Z_STREAM_END because I known the +- * size of both compressed and uncompressed data +- */ +- } +- pfile_in_zip_read_info->rest_read_compressed = +- s->cur_file_info.compressed_size ; +- pfile_in_zip_read_info->rest_read_uncompressed = +- s->cur_file_info.uncompressed_size ; +- +- +- pfile_in_zip_read_info->pos_in_zipfile = +- s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + +- iSizeVar; +- +- pfile_in_zip_read_info->stream.avail_in = (uInt)0; +- +- s->pfile_in_zip_read = pfile_in_zip_read_info; +- s->encrypted = 0; +- +-# ifndef NOUNCRYPT +- if (password != NULL) +- { +- int i; +- s->pcrc_32_tab = get_crc_table(); +- init_keys(password,s->keys,s->pcrc_32_tab); +- if (ZSEEK64(s->z_filefunc, s->filestream, +- s->pfile_in_zip_read->pos_in_zipfile + +- s->pfile_in_zip_read->byte_before_the_zipfile, +- SEEK_SET)!=0) +- return UNZ_INTERNALERROR; +- if(ZREAD64(s->z_filefunc, s->filestream,source, 12)<12) +- return UNZ_INTERNALERROR; +- +- for (i = 0; i<12; i++) +- zdecode(s->keys,s->pcrc_32_tab,source[i]); +- +- s->pfile_in_zip_read->pos_in_zipfile+=12; +- s->encrypted=1; +- } +-# endif +- +- +- return UNZ_OK; +-} +- +-extern int ZEXPORT unzOpenCurrentFile (unzFile file) +-{ +- return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL); +-} +- +-extern int ZEXPORT unzOpenCurrentFilePassword (unzFile file, const char* password) +-{ +- return unzOpenCurrentFile3(file, NULL, NULL, 0, password); +-} +- +-extern int ZEXPORT unzOpenCurrentFile2 (unzFile file, int* method, int* level, int raw) +-{ +- return unzOpenCurrentFile3(file, method, level, raw, NULL); +-} +- +-/** Addition for GDAL : START */ +- +-extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64( unzFile file) +-{ +- unz64_s* s; +- file_in_zip64_read_info_s* pfile_in_zip_read_info; +- s=(unz64_s*)file; +- if (file==NULL) +- return 0; //UNZ_PARAMERROR; +- pfile_in_zip_read_info=s->pfile_in_zip_read; +- if (pfile_in_zip_read_info==NULL) +- return 0; //UNZ_PARAMERROR; +- return pfile_in_zip_read_info->pos_in_zipfile + +- pfile_in_zip_read_info->byte_before_the_zipfile; +-} +- +-/** Addition for GDAL : END */ +- +-/* +- Read bytes from the current file. +- buf contain buffer where data must be copied +- len the size of buf. +- +- return the number of byte copied if somes bytes are copied +- return 0 if the end of file was reached +- return <0 with error code if there is an error +- (UNZ_ERRNO for IO error, or zLib error for uncompress error) +-*/ +-extern int ZEXPORT unzReadCurrentFile (unzFile file, voidp buf, unsigned len) +-{ +- int err=UNZ_OK; +- uInt iRead = 0; +- unz64_s* s; +- file_in_zip64_read_info_s* pfile_in_zip_read_info; +- if (file==NULL) +- return UNZ_PARAMERROR; +- s=(unz64_s*)file; +- pfile_in_zip_read_info=s->pfile_in_zip_read; +- +- if (pfile_in_zip_read_info==NULL) +- return UNZ_PARAMERROR; +- +- +- if ((pfile_in_zip_read_info->read_buffer == NULL)) +- return UNZ_END_OF_LIST_OF_FILE; +- if (len==0) +- return 0; +- +- pfile_in_zip_read_info->stream.next_out = (Bytef*)buf; +- +- pfile_in_zip_read_info->stream.avail_out = (uInt)len; +- +- if ((len>pfile_in_zip_read_info->rest_read_uncompressed) && +- (!(pfile_in_zip_read_info->raw))) +- pfile_in_zip_read_info->stream.avail_out = +- (uInt)pfile_in_zip_read_info->rest_read_uncompressed; +- +- if ((len>pfile_in_zip_read_info->rest_read_compressed+ +- pfile_in_zip_read_info->stream.avail_in) && +- (pfile_in_zip_read_info->raw)) +- pfile_in_zip_read_info->stream.avail_out = +- (uInt)pfile_in_zip_read_info->rest_read_compressed+ +- pfile_in_zip_read_info->stream.avail_in; +- +- while (pfile_in_zip_read_info->stream.avail_out>0) +- { +- if ((pfile_in_zip_read_info->stream.avail_in==0) && +- (pfile_in_zip_read_info->rest_read_compressed>0)) +- { +- uInt uReadThis = UNZ_BUFSIZE; +- if (pfile_in_zip_read_info->rest_read_compressedrest_read_compressed; +- if (uReadThis == 0) +- return UNZ_EOF; +- if (ZSEEK64(pfile_in_zip_read_info->z_filefunc, +- pfile_in_zip_read_info->filestream, +- pfile_in_zip_read_info->pos_in_zipfile + +- pfile_in_zip_read_info->byte_before_the_zipfile, +- ZLIB_FILEFUNC_SEEK_SET)!=0) +- return UNZ_ERRNO; +- if (ZREAD64(pfile_in_zip_read_info->z_filefunc, +- pfile_in_zip_read_info->filestream, +- pfile_in_zip_read_info->read_buffer, +- uReadThis)!=uReadThis) +- return UNZ_ERRNO; +- +- +-# ifndef NOUNCRYPT +- if(s->encrypted) +- { +- uInt i; +- for(i=0;iread_buffer[i] = +- zdecode(s->keys,s->pcrc_32_tab, +- pfile_in_zip_read_info->read_buffer[i]); +- } +-# endif +- +- +- pfile_in_zip_read_info->pos_in_zipfile += uReadThis; +- +- pfile_in_zip_read_info->rest_read_compressed-=uReadThis; +- +- pfile_in_zip_read_info->stream.next_in = +- (Bytef*)pfile_in_zip_read_info->read_buffer; +- pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis; +- } +- +- if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw)) +- { +- uInt uDoCopy,i ; +- +- if ((pfile_in_zip_read_info->stream.avail_in == 0) && +- (pfile_in_zip_read_info->rest_read_compressed == 0)) +- return (iRead==0) ? UNZ_EOF : iRead; +- +- if (pfile_in_zip_read_info->stream.avail_out < +- pfile_in_zip_read_info->stream.avail_in) +- uDoCopy = pfile_in_zip_read_info->stream.avail_out ; +- else +- uDoCopy = pfile_in_zip_read_info->stream.avail_in ; +- +- for (i=0;istream.next_out+i) = +- *(pfile_in_zip_read_info->stream.next_in+i); +- +- pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uDoCopy; +- +- pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, +- pfile_in_zip_read_info->stream.next_out, +- uDoCopy); +- pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy; +- pfile_in_zip_read_info->stream.avail_in -= uDoCopy; +- pfile_in_zip_read_info->stream.avail_out -= uDoCopy; +- pfile_in_zip_read_info->stream.next_out += uDoCopy; +- pfile_in_zip_read_info->stream.next_in += uDoCopy; +- pfile_in_zip_read_info->stream.total_out += uDoCopy; +- iRead += uDoCopy; +- } +- else if (pfile_in_zip_read_info->compression_method==Z_BZIP2ED) +- { +-#ifdef HAVE_BZIP2 +- uLong uTotalOutBefore,uTotalOutAfter; +- const Bytef *bufBefore; +- uLong uOutThis; +- +- pfile_in_zip_read_info->bstream.next_in = (char*)pfile_in_zip_read_info->stream.next_in; +- pfile_in_zip_read_info->bstream.avail_in = pfile_in_zip_read_info->stream.avail_in; +- pfile_in_zip_read_info->bstream.total_in_lo32 = pfile_in_zip_read_info->stream.total_in; +- pfile_in_zip_read_info->bstream.total_in_hi32 = 0; +- pfile_in_zip_read_info->bstream.next_out = (char*)pfile_in_zip_read_info->stream.next_out; +- pfile_in_zip_read_info->bstream.avail_out = pfile_in_zip_read_info->stream.avail_out; +- pfile_in_zip_read_info->bstream.total_out_lo32 = pfile_in_zip_read_info->stream.total_out; +- pfile_in_zip_read_info->bstream.total_out_hi32 = 0; +- +- uTotalOutBefore = pfile_in_zip_read_info->bstream.total_out_lo32; +- bufBefore = (const Bytef *)pfile_in_zip_read_info->bstream.next_out; +- +- err=BZ2_bzDecompress(&pfile_in_zip_read_info->bstream); +- +- uTotalOutAfter = pfile_in_zip_read_info->bstream.total_out_lo32; +- uOutThis = uTotalOutAfter-uTotalOutBefore; +- +- pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis; +- +- pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,bufBefore, (uInt)(uOutThis)); +- pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis; +- iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); +- +- pfile_in_zip_read_info->stream.next_in = (Bytef*)pfile_in_zip_read_info->bstream.next_in; +- pfile_in_zip_read_info->stream.avail_in = pfile_in_zip_read_info->bstream.avail_in; +- pfile_in_zip_read_info->stream.total_in = pfile_in_zip_read_info->bstream.total_in_lo32; +- pfile_in_zip_read_info->stream.next_out = (Bytef*)pfile_in_zip_read_info->bstream.next_out; +- pfile_in_zip_read_info->stream.avail_out = pfile_in_zip_read_info->bstream.avail_out; +- pfile_in_zip_read_info->stream.total_out = pfile_in_zip_read_info->bstream.total_out_lo32; +- +- if (err==BZ_STREAM_END) +- return (iRead==0) ? UNZ_EOF : iRead; +- if (err!=BZ_OK) +- break; +-#endif +- } // end Z_BZIP2ED +- else +- { +- ZPOS64_T uTotalOutBefore,uTotalOutAfter; +- const Bytef *bufBefore; +- ZPOS64_T uOutThis; +- int flush=Z_SYNC_FLUSH; +- +- uTotalOutBefore = pfile_in_zip_read_info->stream.total_out; +- bufBefore = pfile_in_zip_read_info->stream.next_out; +- +- /* +- if ((pfile_in_zip_read_info->rest_read_uncompressed == +- pfile_in_zip_read_info->stream.avail_out) && +- (pfile_in_zip_read_info->rest_read_compressed == 0)) +- flush = Z_FINISH; +- */ +- err=inflate(&pfile_in_zip_read_info->stream,flush); +- +- if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL)) +- err = Z_DATA_ERROR; +- +- uTotalOutAfter = pfile_in_zip_read_info->stream.total_out; +- uOutThis = uTotalOutAfter-uTotalOutBefore; +- +- pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis; +- +- pfile_in_zip_read_info->crc32 = +- crc32(pfile_in_zip_read_info->crc32,bufBefore, +- (uInt)(uOutThis)); +- +- pfile_in_zip_read_info->rest_read_uncompressed -= +- uOutThis; +- +- iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); +- +- if (err==Z_STREAM_END) +- return (iRead==0) ? UNZ_EOF : iRead; +- if (err!=Z_OK) +- break; +- } +- } +- +- if (err==Z_OK) +- return iRead; +- return err; +-} +- +- +-/* +- Give the current position in uncompressed data +-*/ +-extern z_off_t ZEXPORT unztell (unzFile file) +-{ +- unz64_s* s; +- file_in_zip64_read_info_s* pfile_in_zip_read_info; +- if (file==NULL) +- return UNZ_PARAMERROR; +- s=(unz64_s*)file; +- pfile_in_zip_read_info=s->pfile_in_zip_read; +- +- if (pfile_in_zip_read_info==NULL) +- return UNZ_PARAMERROR; +- +- return (z_off_t)pfile_in_zip_read_info->stream.total_out; +-} +- +-extern ZPOS64_T ZEXPORT unztell64 (unzFile file) +-{ +- +- unz64_s* s; +- file_in_zip64_read_info_s* pfile_in_zip_read_info; +- if (file==NULL) +- return (ZPOS64_T)-1; +- s=(unz64_s*)file; +- pfile_in_zip_read_info=s->pfile_in_zip_read; +- +- if (pfile_in_zip_read_info==NULL) +- return (ZPOS64_T)-1; +- +- return pfile_in_zip_read_info->total_out_64; +-} +- +- +-/* +- return 1 if the end of file was reached, 0 elsewhere +-*/ +-extern int ZEXPORT unzeof (unzFile file) +-{ +- unz64_s* s; +- file_in_zip64_read_info_s* pfile_in_zip_read_info; +- if (file==NULL) +- return UNZ_PARAMERROR; +- s=(unz64_s*)file; +- pfile_in_zip_read_info=s->pfile_in_zip_read; +- +- if (pfile_in_zip_read_info==NULL) +- return UNZ_PARAMERROR; +- +- if (pfile_in_zip_read_info->rest_read_uncompressed == 0) +- return 1; +- else +- return 0; +-} +- +- +- +-/* +-Read extra field from the current file (opened by unzOpenCurrentFile) +-This is the local-header version of the extra field (sometimes, there is +-more info in the local-header version than in the central-header) +- +- if buf==NULL, it return the size of the local extra field that can be read +- +- if buf!=NULL, len is the size of the buffer, the extra header is copied in +- buf. +- the return value is the number of bytes copied in buf, or (if <0) +- the error code +-*/ +-extern int ZEXPORT unzGetLocalExtrafield (unzFile file, voidp buf, unsigned len) +-{ +- unz64_s* s; +- file_in_zip64_read_info_s* pfile_in_zip_read_info; +- uInt read_now; +- ZPOS64_T size_to_read; +- +- if (file==NULL) +- return UNZ_PARAMERROR; +- s=(unz64_s*)file; +- pfile_in_zip_read_info=s->pfile_in_zip_read; +- +- if (pfile_in_zip_read_info==NULL) +- return UNZ_PARAMERROR; +- +- size_to_read = (pfile_in_zip_read_info->size_local_extrafield - +- pfile_in_zip_read_info->pos_local_extrafield); +- +- if (buf==NULL) +- return (int)size_to_read; +- +- if (len>size_to_read) +- read_now = (uInt)size_to_read; +- else +- read_now = (uInt)len ; +- +- if (read_now==0) +- return 0; +- +- if (ZSEEK64(pfile_in_zip_read_info->z_filefunc, +- pfile_in_zip_read_info->filestream, +- pfile_in_zip_read_info->offset_local_extrafield + +- pfile_in_zip_read_info->pos_local_extrafield, +- ZLIB_FILEFUNC_SEEK_SET)!=0) +- return UNZ_ERRNO; +- +- if (ZREAD64(pfile_in_zip_read_info->z_filefunc, +- pfile_in_zip_read_info->filestream, +- buf,read_now)!=read_now) +- return UNZ_ERRNO; +- +- return (int)read_now; +-} +- +-/* +- Close the file in zip opened with unzipOpenCurrentFile +- Return UNZ_CRCERROR if all the file was read but the CRC is not good +-*/ +-extern int ZEXPORT unzCloseCurrentFile (unzFile file) +-{ +- int err=UNZ_OK; +- +- unz64_s* s; +- file_in_zip64_read_info_s* pfile_in_zip_read_info; +- if (file==NULL) +- return UNZ_PARAMERROR; +- s=(unz64_s*)file; +- pfile_in_zip_read_info=s->pfile_in_zip_read; +- +- if (pfile_in_zip_read_info==NULL) +- return UNZ_PARAMERROR; +- +- +- if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) && +- (!pfile_in_zip_read_info->raw)) +- { +- if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait) +- err=UNZ_CRCERROR; +- } +- +- +- TRYFREE(pfile_in_zip_read_info->read_buffer); +- pfile_in_zip_read_info->read_buffer = NULL; +- if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED) +- inflateEnd(&pfile_in_zip_read_info->stream); +-#ifdef HAVE_BZIP2 +- else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED) +- BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream); +-#endif +- +- +- pfile_in_zip_read_info->stream_initialised = 0; +- TRYFREE(pfile_in_zip_read_info); +- +- s->pfile_in_zip_read=NULL; +- +- return err; +-} +- +- +-/* +- Get the global comment string of the ZipFile, in the szComment buffer. +- uSizeBuf is the size of the szComment buffer. +- return the number of byte copied or an error code <0 +-*/ +-extern int ZEXPORT unzGetGlobalComment (unzFile file, char * szComment, uLong uSizeBuf) +-{ +- unz64_s* s; +- uLong uReadThis ; +- if (file==NULL) +- return (int)UNZ_PARAMERROR; +- s=(unz64_s*)file; +- +- uReadThis = uSizeBuf; +- if (uReadThis>s->gi.size_comment) +- uReadThis = s->gi.size_comment; +- +- if (ZSEEK64(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0) +- return UNZ_ERRNO; +- +- if (uReadThis>0) +- { +- *szComment='\0'; +- if (ZREAD64(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis) +- return UNZ_ERRNO; +- } +- +- if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment)) +- *(szComment+s->gi.size_comment)='\0'; +- return (int)uReadThis; +-} +- +-/* Additions by RX '2004 */ +-extern ZPOS64_T ZEXPORT unzGetOffset64(unzFile file) +-{ +- unz64_s* s; +- +- if (file==NULL) +- return 0; //UNZ_PARAMERROR; +- s=(unz64_s*)file; +- if (!s->current_file_ok) +- return 0; +- if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff) +- if (s->num_file==s->gi.number_entry) +- return 0; +- return s->pos_in_central_dir; +-} +- +-extern uLong ZEXPORT unzGetOffset (unzFile file) +-{ +- ZPOS64_T offset64; +- +- if (file==NULL) +- return 0; //UNZ_PARAMERROR; +- offset64 = unzGetOffset64(file); +- return (uLong)offset64; +-} +- +-extern int ZEXPORT unzSetOffset64(unzFile file, ZPOS64_T pos) +-{ +- unz64_s* s; +- int err; +- +- if (file==NULL) +- return UNZ_PARAMERROR; +- s=(unz64_s*)file; +- +- s->pos_in_central_dir = pos; +- s->num_file = s->gi.number_entry; /* hack */ +- 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; +-} +- +-extern int ZEXPORT unzSetOffset (unzFile file, uLong pos) +-{ +- return unzSetOffset64(file,pos); +-} +diff --git a/thirdparty/minizip/unzip.h b/thirdparty/minizip/unzip.h +deleted file mode 100644 +index 3183968..0000000 +--- a/thirdparty/minizip/unzip.h ++++ /dev/null +@@ -1,437 +0,0 @@ +-/* unzip.h -- 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 +- +- --------------------------------------------------------------------------------- +- +- Condition of use and distribution are the same than zlib : +- +- This software is provided 'as-is', without any express or implied +- warranty. In no event will the authors be held liable for any damages +- arising from the use of this software. +- +- Permission is granted to anyone to use this software for any purpose, +- including commercial applications, and to alter it and redistribute it +- freely, subject to the following restrictions: +- +- 1. The origin of this software must not be misrepresented; you must not +- claim that you wrote the original software. If you use this software +- in a product, an acknowledgment in the product documentation would be +- appreciated but is not required. +- 2. Altered source versions must be plainly marked as such, and must not be +- misrepresented as being the original software. +- 3. This notice may not be removed or altered from any source distribution. +- +- --------------------------------------------------------------------------------- +- +- Changes +- +- See header of unzip64.c +- +-*/ +- +-#ifndef _unz64_H +-#define _unz64_H +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-#ifndef _ZLIB_H +-#include "zlib.h" +-#endif +- +-#ifndef _ZLIBIOAPI_H +-#include "ioapi.h" +-#endif +- +-#ifdef HAVE_BZIP2 +-#include "bzlib.h" +-#endif +- +-#define Z_BZIP2ED 12 +- +-#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP) +-/* like the STRICT of WIN32, we define a pointer that cannot be converted +- from (void*) without cast */ +-typedef struct TagunzFile__ { int unused; } unzFile__; +-typedef unzFile__ *unzFile; +-#else +-typedef voidp unzFile; +-#endif +- +- +-#define UNZ_OK (0) +-#define UNZ_END_OF_LIST_OF_FILE (-100) +-#define UNZ_ERRNO (Z_ERRNO) +-#define UNZ_EOF (0) +-#define UNZ_PARAMERROR (-102) +-#define UNZ_BADZIPFILE (-103) +-#define UNZ_INTERNALERROR (-104) +-#define UNZ_CRCERROR (-105) +- +-/* tm_unz contain date/time info */ +-typedef struct tm_unz_s +-{ +- uInt tm_sec; /* seconds after the minute - [0,59] */ +- uInt tm_min; /* minutes after the hour - [0,59] */ +- uInt tm_hour; /* hours since midnight - [0,23] */ +- uInt tm_mday; /* day of the month - [1,31] */ +- uInt tm_mon; /* months since January - [0,11] */ +- uInt tm_year; /* years - [1980..2044] */ +-} tm_unz; +- +-/* unz_global_info structure contain global data about the ZIPfile +- These data comes from the end of central dir */ +-typedef struct unz_global_info64_s +-{ +- ZPOS64_T number_entry; /* total number of entries in +- the central dir on this disk */ +- uLong size_comment; /* size of the global comment of the zipfile */ +-} unz_global_info64; +- +-typedef struct unz_global_info_s +-{ +- uLong number_entry; /* total number of entries in +- the central dir on this disk */ +- uLong size_comment; /* size of the global comment of the zipfile */ +-} unz_global_info; +- +-/* unz_file_info contain information about a file in the zipfile */ +-typedef struct unz_file_info64_s +-{ +- uLong version; /* version made by 2 bytes */ +- uLong version_needed; /* version needed to extract 2 bytes */ +- uLong flag; /* general purpose bit flag 2 bytes */ +- uLong compression_method; /* compression method 2 bytes */ +- uLong dosDate; /* last mod file date in Dos fmt 4 bytes */ +- uLong crc; /* crc-32 4 bytes */ +- ZPOS64_T compressed_size; /* compressed size 8 bytes */ +- ZPOS64_T uncompressed_size; /* uncompressed size 8 bytes */ +- uLong size_filename; /* filename length 2 bytes */ +- uLong size_file_extra; /* extra field length 2 bytes */ +- uLong size_file_comment; /* file comment length 2 bytes */ +- +- uLong disk_num_start; /* disk number start 2 bytes */ +- uLong internal_fa; /* internal file attributes 2 bytes */ +- uLong external_fa; /* external file attributes 4 bytes */ +- +- tm_unz tmu_date; +-} unz_file_info64; +- +-typedef struct unz_file_info_s +-{ +- uLong version; /* version made by 2 bytes */ +- uLong version_needed; /* version needed to extract 2 bytes */ +- uLong flag; /* general purpose bit flag 2 bytes */ +- uLong compression_method; /* compression method 2 bytes */ +- uLong dosDate; /* last mod file date in Dos fmt 4 bytes */ +- uLong crc; /* crc-32 4 bytes */ +- uLong compressed_size; /* compressed size 4 bytes */ +- uLong uncompressed_size; /* uncompressed size 4 bytes */ +- uLong size_filename; /* filename length 2 bytes */ +- uLong size_file_extra; /* extra field length 2 bytes */ +- uLong size_file_comment; /* file comment length 2 bytes */ +- +- uLong disk_num_start; /* disk number start 2 bytes */ +- uLong internal_fa; /* internal file attributes 2 bytes */ +- uLong external_fa; /* external file attributes 4 bytes */ +- +- tm_unz tmu_date; +-} unz_file_info; +- +-extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1, +- const char* fileName2, +- int iCaseSensitivity)); +-/* +- 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 unzFile ZEXPORT unzOpen OF((const char *path)); +-extern unzFile ZEXPORT unzOpen64 OF((const void *path)); +-/* +- Open a Zip file. path contain the full pathname (by example, +- on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer +- "zlib/zlib113.zip". +- If the zipfile cannot be opened (file don'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. +- the "64" function take a const void* pointer, because the path is just the +- value passed to the open64_file_func callback. +- Under Windows, if UNICODE is defined, using fill_fopen64_filefunc, the path +- is a pointer to a wide unicode string (LPCTSTR is LPCWSTR), so const char* +- does not describe the reality +-*/ +- +- +-extern unzFile ZEXPORT unzOpen2 OF((const char *path, +- zlib_filefunc_def* pzlib_filefunc_def)); +-/* +- Open a Zip file, like unzOpen, but provide a set of file low level API +- for read/write the zip file (see ioapi.h) +-*/ +- +-extern unzFile ZEXPORT unzOpen2_64 OF((const void *path, +- zlib_filefunc64_def* pzlib_filefunc_def)); +-/* +- Open a Zip file, like unz64Open, but provide a set of file low level API +- for read/write the zip file (see ioapi.h) +-*/ +- +-extern int ZEXPORT unzClose OF((unzFile file)); +-/* +- Close a ZipFile opened with unzipOpen. +- If there is files inside the .Zip opened with unzOpenCurrentFile (see later), +- these files MUST be closed with unzipCloseCurrentFile before call unzipClose. +- return UNZ_OK if there is no problem. */ +- +-extern int ZEXPORT unzGetGlobalInfo OF((unzFile file, +- unz_global_info *pglobal_info)); +- +-extern int ZEXPORT unzGetGlobalInfo64 OF((unzFile file, +- unz_global_info64 *pglobal_info)); +-/* +- 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 unzGetGlobalComment OF((unzFile file, +- char *szComment, +- uLong uSizeBuf)); +-/* +- Get the global comment string of the ZipFile, in the szComment buffer. +- uSizeBuf is the size of the szComment buffer. +- return the number of byte copied or an error code <0 +-*/ +- +- +-/***************************************************************************/ +-/* Unzip package allow you browse the directory of the zipfile */ +- +-extern int ZEXPORT unzGoToFirstFile OF((unzFile file)); +-/* +- Set the current file of the zipfile to the first file. +- return UNZ_OK if there is no problem +-*/ +- +-extern int ZEXPORT unzGoToNextFile OF((unzFile file)); +-/* +- 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 unzLocateFile OF((unzFile file, +- const char *szFileName, +- int iCaseSensitivity)); +-/* +- 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 +-*/ +- +- +-/* ****************************************** */ +-/* Ryan supplied functions */ +-/* unz_file_info contain information about a file in the zipfile */ +-typedef struct unz_file_pos_s +-{ +- uLong pos_in_zip_directory; /* offset in zip file directory */ +- uLong num_of_file; /* # of file */ +-} unz_file_pos; +- +-extern int ZEXPORT unzGetFilePos( +- unzFile file, +- unz_file_pos* file_pos); +- +-extern int ZEXPORT unzGoToFilePos( +- unzFile file, +- unz_file_pos* file_pos); +- +-typedef struct unz64_file_pos_s +-{ +- ZPOS64_T pos_in_zip_directory; /* offset in zip file directory */ +- ZPOS64_T num_of_file; /* # of file */ +-} unz64_file_pos; +- +-extern int ZEXPORT unzGetFilePos64( +- unzFile file, +- unz64_file_pos* file_pos); +- +-extern int ZEXPORT unzGoToFilePos64( +- unzFile file, +- const unz64_file_pos* file_pos); +- +-/* ****************************************** */ +- +-extern int ZEXPORT unzGetCurrentFileInfo64 OF((unzFile file, +- unz_file_info64 *pfile_info, +- char *szFileName, +- uLong fileNameBufferSize, +- void *extraField, +- uLong extraFieldBufferSize, +- char *szComment, +- uLong commentBufferSize)); +- +-extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file, +- unz_file_info *pfile_info, +- char *szFileName, +- uLong fileNameBufferSize, +- void *extraField, +- uLong extraFieldBufferSize, +- char *szComment, +- uLong commentBufferSize)); +-/* +- Get Info about the current file +- if pfile_info!=NULL, the *pfile_info structure will contain somes info about +- the current file +- if szFileName!=NULL, the filemane string will be copied in szFileName +- (fileNameBufferSize is the size of the buffer) +- if extraField!=NULL, the extra field information will be copied in extraField +- (extraFieldBufferSize is the size of the buffer). +- This is the Central-header version of the extra field +- if szComment!=NULL, the comment string of the file will be copied in szComment +- (commentBufferSize is the size of the buffer) +-*/ +- +- +-/** Addition for GDAL : START */ +- +-extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64 OF((unzFile file)); +- +-/** Addition for GDAL : END */ +- +- +-/***************************************************************************/ +-/* for reading the content of the current zipfile, you can open it, read data +- from it, and close it (you can close it before reading all the file) +- */ +- +-extern int ZEXPORT unzOpenCurrentFile OF((unzFile file)); +-/* +- Open for reading data the current file in the zipfile. +- If there is no error, the return value is UNZ_OK. +-*/ +- +-extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file, +- const char* password)); +-/* +- Open for reading data the current file in the zipfile. +- password is a crypting password +- If there is no error, the return value is UNZ_OK. +-*/ +- +-extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file, +- int* method, +- int* level, +- int raw)); +-/* +- Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) +- if raw==1 +- *method will receive method of compression, *level will receive level of +- compression +- note : you can set level parameter as NULL (if you did not want known level, +- but you CANNOT set method parameter as NULL +-*/ +- +-extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file, +- int* method, +- int* level, +- int raw, +- const char* password)); +-/* +- Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) +- if raw==1 +- *method will receive method of compression, *level will receive level of +- compression +- note : you can set level parameter as NULL (if you did not want known level, +- but you CANNOT set method parameter as NULL +-*/ +- +- +-extern int ZEXPORT unzCloseCurrentFile OF((unzFile file)); +-/* +- Close the file in zip opened with unzOpenCurrentFile +- Return UNZ_CRCERROR if all the file was read but the CRC is not good +-*/ +- +-extern int ZEXPORT unzReadCurrentFile OF((unzFile file, +- voidp buf, +- unsigned len)); +-/* +- Read bytes from the current file (opened by unzOpenCurrentFile) +- buf contain buffer where data must be copied +- len the size of buf. +- +- return the number of byte copied if somes bytes are copied +- return 0 if the end of file was reached +- return <0 with error code if there is an error +- (UNZ_ERRNO for IO error, or zLib error for uncompress error) +-*/ +- +-extern z_off_t ZEXPORT unztell OF((unzFile file)); +- +-extern ZPOS64_T ZEXPORT unztell64 OF((unzFile file)); +-/* +- Give the current position in uncompressed data +-*/ +- +-extern int ZEXPORT unzeof OF((unzFile file)); +-/* +- return 1 if the end of file was reached, 0 elsewhere +-*/ +- +-extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file, +- voidp buf, +- unsigned len)); +-/* +- Read extra field from the current file (opened by unzOpenCurrentFile) +- This is the local-header version of the extra field (sometimes, there is +- more info in the local-header version than in the central-header) +- +- if buf==NULL, it return the size of the local extra field +- +- if buf!=NULL, len is the size of the buffer, the extra header is copied in +- buf. +- the return value is the number of bytes copied in buf, or (if <0) +- the error code +-*/ +- +-/***************************************************************************/ +- +-/* Get the current file offset */ +-extern ZPOS64_T ZEXPORT unzGetOffset64 (unzFile file); +-extern uLong ZEXPORT unzGetOffset (unzFile file); +- +-/* Set the current file offset */ +-extern int ZEXPORT unzSetOffset64 (unzFile file, ZPOS64_T pos); +-extern int ZEXPORT unzSetOffset (unzFile file, uLong pos); +- +- +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif /* _unz64_H */ +diff --git a/thirdparty/minizip/zip.c b/thirdparty/minizip/zip.c +deleted file mode 100644 +index 3c34fc8..0000000 +--- a/thirdparty/minizip/zip.c ++++ /dev/null +@@ -1,2004 +0,0 @@ +-/* zip.c -- IO on .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 for Zip64 support +- Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) +- +- For more info read MiniZip_info.txt +- +- Changes +- Oct-2009 - Mathias Svensson - Remove old C style function prototypes +- Oct-2009 - Mathias Svensson - Added Zip64 Support when creating new file archives +- Oct-2009 - Mathias Svensson - Did some code cleanup and refactoring to get better overview of some functions. +- Oct-2009 - Mathias Svensson - Added zipRemoveExtraInfoBlock to strip extra field data from its ZIP64 data +- It is used when recreting zip archive with RAW when deleting items from a zip. +- ZIP64 data is automaticly added to items that needs it, and existing ZIP64 data need to be removed. +- Oct-2009 - Mathias Svensson - Added support for BZIP2 as compression mode (bzip2 lib is required) +- Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer +- +-*/ +- +- +-#include +-#include +-#include +-#include +-#include "zlib.h" +-#include "zip.h" +- +-#ifdef STDC +-# include +-# include +-# include +-#endif +-#ifdef NO_ERRNO_H +- extern int errno; +-#else +-# include +-#endif +- +- +-#ifndef local +-# define local static +-#endif +-/* compile with -Dlocal if your debugger can't find static symbols */ +- +-#ifndef VERSIONMADEBY +-# define VERSIONMADEBY (0x0) /* platform depedent */ +-#endif +- +-#ifndef Z_BUFSIZE +-#define Z_BUFSIZE (64*1024) //(16384) +-#endif +- +-#ifndef Z_MAXFILENAMEINZIP +-#define Z_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) +-*/ +- +-/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ +- +- +-// NOT sure that this work on ALL platform +-#define MAKEULONG64(a, b) ((ZPOS64_T)(((unsigned long)(a)) | ((ZPOS64_T)((unsigned long)(b))) << 32)) +- +-#ifndef SEEK_CUR +-#define SEEK_CUR 1 +-#endif +- +-#ifndef SEEK_END +-#define SEEK_END 2 +-#endif +- +-#ifndef SEEK_SET +-#define SEEK_SET 0 +-#endif +- +-#ifndef DEF_MEM_LEVEL +-#if MAX_MEM_LEVEL >= 8 +-# define DEF_MEM_LEVEL 8 +-#else +-# define DEF_MEM_LEVEL MAX_MEM_LEVEL +-#endif +-#endif +-const char zip_copyright[] =" zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; +- +- +-#define SIZEDATA_INDATABLOCK (4096-(4*4)) +- +-#define LOCALHEADERMAGIC (0x04034b50) +-#define CENTRALHEADERMAGIC (0x02014b50) +-#define ENDHEADERMAGIC (0x06054b50) +-#define ZIP64ENDHEADERMAGIC (0x6064b50) +-#define ZIP64ENDLOCHEADERMAGIC (0x7064b50) +- +-#define FLAG_LOCALHEADER_OFFSET (0x06) +-#define CRC_LOCALHEADER_OFFSET (0x0e) +- +-#define SIZECENTRALHEADER (0x2e) /* 46 */ +- +-typedef struct linkedlist_datablock_internal_s +-{ +- struct linkedlist_datablock_internal_s* next_datablock; +- uLong avail_in_this_block; +- uLong filled_in_this_block; +- uLong unused; /* for future use and alignement */ +- unsigned char data[SIZEDATA_INDATABLOCK]; +-} linkedlist_datablock_internal; +- +-typedef struct linkedlist_data_s +-{ +- linkedlist_datablock_internal* first_block; +- linkedlist_datablock_internal* last_block; +-} linkedlist_data; +- +- +-typedef struct +-{ +- z_stream stream; /* zLib stream structure for inflate */ +-#ifdef HAVE_BZIP2 +- bz_stream bstream; /* bzLib stream structure for bziped */ +-#endif +- +- int stream_initialised; /* 1 is stream is initialised */ +- uInt pos_in_buffered_data; /* last written byte in buffered_data */ +- +- ZPOS64_T pos_local_header; /* offset of the local header of the file +- currenty writing */ +- char* central_header; /* central header data for the current file */ +- uLong size_centralExtra; +- uLong size_centralheader; /* size of the central header for cur file */ +- uLong size_centralExtraFree; /* Extra bytes allocated to the centralheader but that are not used */ +- uLong flag; /* flag of the file currently writing */ +- +- int method; /* compression method of file currenty wr.*/ +- int raw; /* 1 for directly writing raw data */ +- Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/ +- uLong dosDate; +- uLong crc32; +- int encrypt; +- int zip64; /* Add ZIP64 extened information in the extra field */ +- ZPOS64_T pos_zip64extrainfo; +- ZPOS64_T totalCompressedData; +- ZPOS64_T totalUncompressedData; +-#ifndef NOCRYPT +- unsigned long keys[3]; /* keys defining the pseudo-random sequence */ +- const unsigned long* pcrc_32_tab; +- int crypt_header_size; +-#endif +-} curfile64_info; +- +-typedef struct +-{ +- zlib_filefunc64_32_def z_filefunc; +- voidpf filestream; /* io structore of the zipfile */ +- linkedlist_data central_dir;/* datablock with central dir in construction*/ +- int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/ +- curfile64_info ci; /* info on the file curretly writing */ +- +- ZPOS64_T begin_pos; /* position of the beginning of the zipfile */ +- ZPOS64_T add_position_when_writting_offset; +- ZPOS64_T number_entry; +- +-#ifndef NO_ADDFILEINEXISTINGZIP +- char *globalcomment; +-#endif +- +-} zip64_internal; +- +- +-#ifndef NOCRYPT +-#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED +-#include "crypt.h" +-#endif +- +-local linkedlist_datablock_internal* allocate_new_datablock() +-{ +- linkedlist_datablock_internal* ldi; +- ldi = (linkedlist_datablock_internal*) +- ALLOC(sizeof(linkedlist_datablock_internal)); +- if (ldi!=NULL) +- { +- ldi->next_datablock = NULL ; +- ldi->filled_in_this_block = 0 ; +- ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ; +- } +- return ldi; +-} +- +-local void free_datablock(linkedlist_datablock_internal* ldi) +-{ +- while (ldi!=NULL) +- { +- linkedlist_datablock_internal* ldinext = ldi->next_datablock; +- TRYFREE(ldi); +- ldi = ldinext; +- } +-} +- +-local void init_linkedlist(linkedlist_data* ll) +-{ +- ll->first_block = ll->last_block = NULL; +-} +- +-local void free_linkedlist(linkedlist_data* ll) +-{ +- free_datablock(ll->first_block); +- ll->first_block = ll->last_block = NULL; +-} +- +- +-local int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len) +-{ +- linkedlist_datablock_internal* ldi; +- const unsigned char* from_copy; +- +- if (ll==NULL) +- return ZIP_INTERNALERROR; +- +- if (ll->last_block == NULL) +- { +- ll->first_block = ll->last_block = allocate_new_datablock(); +- if (ll->first_block == NULL) +- return ZIP_INTERNALERROR; +- } +- +- ldi = ll->last_block; +- from_copy = (unsigned char*)buf; +- +- while (len>0) +- { +- uInt copy_this; +- uInt i; +- unsigned char* to_copy; +- +- if (ldi->avail_in_this_block==0) +- { +- ldi->next_datablock = allocate_new_datablock(); +- if (ldi->next_datablock == NULL) +- return ZIP_INTERNALERROR; +- ldi = ldi->next_datablock ; +- ll->last_block = ldi; +- } +- +- if (ldi->avail_in_this_block < len) +- copy_this = (uInt)ldi->avail_in_this_block; +- else +- copy_this = (uInt)len; +- +- to_copy = &(ldi->data[ldi->filled_in_this_block]); +- +- for (i=0;ifilled_in_this_block += copy_this; +- ldi->avail_in_this_block -= copy_this; +- from_copy += copy_this ; +- len -= copy_this; +- } +- return ZIP_OK; +-} +- +- +- +-/****************************************************************************/ +- +-#ifndef NO_ADDFILEINEXISTINGZIP +-/* =========================================================================== +- Inputs a long in LSB order to the given file +- nbByte == 1, 2 ,4 or 8 (byte, short or long, ZPOS64_T) +-*/ +- +-local int zip64local_putValue OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte)); +-local int zip64local_putValue (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte) +-{ +- unsigned char buf[8]; +- int n; +- for (n = 0; n < nbByte; n++) +- { +- buf[n] = (unsigned char)(x & 0xff); +- x >>= 8; +- } +- if (x != 0) +- { /* data overflow - hack for ZIP64 (X Roche) */ +- for (n = 0; n < nbByte; n++) +- { +- buf[n] = 0xff; +- } +- } +- +- if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte) +- return ZIP_ERRNO; +- else +- return ZIP_OK; +-} +- +-local void zip64local_putValue_inmemory OF((void* dest, ZPOS64_T x, int nbByte)); +-local void zip64local_putValue_inmemory (void* dest, ZPOS64_T x, int nbByte) +-{ +- unsigned char* buf=(unsigned char*)dest; +- int n; +- for (n = 0; n < nbByte; n++) { +- buf[n] = (unsigned char)(x & 0xff); +- x >>= 8; +- } +- +- if (x != 0) +- { /* data overflow - hack for ZIP64 */ +- for (n = 0; n < nbByte; n++) +- { +- buf[n] = 0xff; +- } +- } +-} +- +-/****************************************************************************/ +- +- +-local uLong zip64local_TmzDateToDosDate(const tm_zip* ptm) +-{ +- uLong year = (uLong)ptm->tm_year; +- if (year>=1980) +- year-=1980; +- else if (year>=80) +- year-=80; +- return +- (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) | +- ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour)); +-} +- +- +-/****************************************************************************/ +- +-local int zip64local_getByte OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi)); +- +-local int zip64local_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 ZIP_OK; +- } +- else +- { +- if (ZERROR64(*pzlib_filefunc_def,filestream)) +- return ZIP_ERRNO; +- else +- return ZIP_EOF; +- } +-} +- +- +-/* =========================================================================== +- Reads a long in LSB order from the given gz_stream. Sets +-*/ +-local int zip64local_getShort OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX)); +- +-local int zip64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX) +-{ +- uLong x ; +- int i = 0; +- int err; +- +- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); +- x = (uLong)i; +- +- if (err==ZIP_OK) +- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); +- x += ((uLong)i)<<8; +- +- if (err==ZIP_OK) +- *pX = x; +- else +- *pX = 0; +- return err; +-} +- +-local int zip64local_getLong OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX)); +- +-local int zip64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX) +-{ +- uLong x ; +- int i = 0; +- int err; +- +- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); +- x = (uLong)i; +- +- if (err==ZIP_OK) +- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); +- x += ((uLong)i)<<8; +- +- if (err==ZIP_OK) +- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); +- x += ((uLong)i)<<16; +- +- if (err==ZIP_OK) +- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); +- x += ((uLong)i)<<24; +- +- if (err==ZIP_OK) +- *pX = x; +- else +- *pX = 0; +- return err; +-} +- +-local int zip64local_getLong64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX)); +- +- +-local int zip64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX) +-{ +- ZPOS64_T x; +- int i = 0; +- int err; +- +- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); +- x = (ZPOS64_T)i; +- +- if (err==ZIP_OK) +- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); +- x += ((ZPOS64_T)i)<<8; +- +- if (err==ZIP_OK) +- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); +- x += ((ZPOS64_T)i)<<16; +- +- if (err==ZIP_OK) +- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); +- x += ((ZPOS64_T)i)<<24; +- +- if (err==ZIP_OK) +- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); +- x += ((ZPOS64_T)i)<<32; +- +- if (err==ZIP_OK) +- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); +- x += ((ZPOS64_T)i)<<40; +- +- if (err==ZIP_OK) +- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); +- x += ((ZPOS64_T)i)<<48; +- +- if (err==ZIP_OK) +- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); +- x += ((ZPOS64_T)i)<<56; +- +- if (err==ZIP_OK) +- *pX = x; +- else +- *pX = 0; +- +- return err; +-} +- +-#ifndef BUFREADCOMMENT +-#define BUFREADCOMMENT (0x400) +-#endif +-/* +- Locate the Central directory of a zipfile (at the end, just before +- the global comment) +-*/ +-local ZPOS64_T zip64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)); +- +-local ZPOS64_T zip64local_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 (uBackReaduMaxBack) +- 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 End of Zip64 Central directory locator and from there find the CD of a zipfile (at the end, just before +-the global comment) +-*/ +-local ZPOS64_T zip64local_SearchCentralDir64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)); +- +-local ZPOS64_T zip64local_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 (uBackReaduMaxBack) +- 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;) +- { +- // Signature "0x07064b50" Zip64 end of central directory locater +- 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 (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) +- return 0; +- +- /* number of the disk with the start of the zip64 end of central directory */ +- if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) +- return 0; +- if (uL != 0) +- return 0; +- +- /* relative offset of the zip64 end of central directory record */ +- if (zip64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=ZIP_OK) +- return 0; +- +- /* total number of disks */ +- if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) +- return 0; +- if (uL != 1) +- return 0; +- +- /* Goto Zip64 end of central directory record */ +- if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0) +- return 0; +- +- /* the signature */ +- if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) +- return 0; +- +- if (uL != 0x06064b50) // signature of 'Zip64 end of central directory' +- return 0; +- +- return relativeOffset; +-} +- +-int LoadCentralDirectoryRecord(zip64_internal* pziinit) +-{ +- int err=ZIP_OK; +- ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ +- +- ZPOS64_T size_central_dir; /* size of the central directory */ +- ZPOS64_T offset_central_dir; /* offset of start of central directory */ +- 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; +- ZPOS64_T number_entry_CD; /* total number of entries in +- the central dir +- (same than number_entry on nospan) */ +- uLong VersionMadeBy; +- uLong VersionNeeded; +- uLong size_comment; +- +- int hasZIP64Record = 0; +- +- // check first if we find a ZIP64 record +- central_pos = zip64local_SearchCentralDir64(&pziinit->z_filefunc,pziinit->filestream); +- if(central_pos > 0) +- { +- hasZIP64Record = 1; +- } +- else if(central_pos == 0) +- { +- central_pos = zip64local_SearchCentralDir(&pziinit->z_filefunc,pziinit->filestream); +- } +- +-/* disable to allow appending to empty ZIP archive +- if (central_pos==0) +- err=ZIP_ERRNO; +-*/ +- +- if(hasZIP64Record) +- { +- ZPOS64_T sizeEndOfCentralDirectory; +- if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) +- err=ZIP_ERRNO; +- +- /* the signature, already checked */ +- if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK) +- err=ZIP_ERRNO; +- +- /* size of zip64 end of central directory record */ +- if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &sizeEndOfCentralDirectory)!=ZIP_OK) +- err=ZIP_ERRNO; +- +- /* version made by */ +- if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionMadeBy)!=ZIP_OK) +- err=ZIP_ERRNO; +- +- /* version needed to extract */ +- if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionNeeded)!=ZIP_OK) +- err=ZIP_ERRNO; +- +- /* number of this disk */ +- if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK) +- err=ZIP_ERRNO; +- +- /* number of the disk with the start of the central directory */ +- if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK) +- err=ZIP_ERRNO; +- +- /* total number of entries in the central directory on this disk */ +- if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &number_entry)!=ZIP_OK) +- err=ZIP_ERRNO; +- +- /* total number of entries in the central directory */ +- if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&number_entry_CD)!=ZIP_OK) +- err=ZIP_ERRNO; +- +- if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0)) +- err=ZIP_BADZIPFILE; +- +- /* size of the central directory */ +- if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&size_central_dir)!=ZIP_OK) +- err=ZIP_ERRNO; +- +- /* offset of start of central directory with respect to the +- starting disk number */ +- if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&offset_central_dir)!=ZIP_OK) +- err=ZIP_ERRNO; +- +- // TODO.. +- // read the comment from the standard central header. +- size_comment = 0; +- } +- else +- { +- // Read End of central Directory info +- if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) +- err=ZIP_ERRNO; +- +- /* the signature, already checked */ +- if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK) +- err=ZIP_ERRNO; +- +- /* number of this disk */ +- if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK) +- err=ZIP_ERRNO; +- +- /* number of the disk with the start of the central directory */ +- if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK) +- err=ZIP_ERRNO; +- +- /* total number of entries in the central dir on this disk */ +- number_entry = 0; +- if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) +- err=ZIP_ERRNO; +- else +- number_entry = uL; +- +- /* total number of entries in the central dir */ +- number_entry_CD = 0; +- if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) +- err=ZIP_ERRNO; +- else +- number_entry_CD = uL; +- +- if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0)) +- err=ZIP_BADZIPFILE; +- +- /* size of the central directory */ +- size_central_dir = 0; +- if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) +- err=ZIP_ERRNO; +- else +- size_central_dir = uL; +- +- /* offset of start of central directory with respect to the starting disk number */ +- offset_central_dir = 0; +- if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) +- err=ZIP_ERRNO; +- else +- offset_central_dir = uL; +- +- +- /* zipfile global comment length */ +- if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &size_comment)!=ZIP_OK) +- err=ZIP_ERRNO; +- } +- +- if ((central_posz_filefunc, pziinit->filestream); +- return ZIP_ERRNO; +- } +- +- if (size_comment>0) +- { +- pziinit->globalcomment = (char*)ALLOC(size_comment+1); +- if (pziinit->globalcomment) +- { +- size_comment = ZREAD64(pziinit->z_filefunc, pziinit->filestream, pziinit->globalcomment,size_comment); +- pziinit->globalcomment[size_comment]=0; +- } +- } +- +- byte_before_the_zipfile = central_pos - (offset_central_dir+size_central_dir); +- pziinit->add_position_when_writting_offset = byte_before_the_zipfile; +- +- { +- ZPOS64_T size_central_dir_to_read = size_central_dir; +- size_t buf_size = SIZEDATA_INDATABLOCK; +- void* buf_read = (void*)ALLOC(buf_size); +- if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0) +- err=ZIP_ERRNO; +- +- while ((size_central_dir_to_read>0) && (err==ZIP_OK)) +- { +- ZPOS64_T read_this = SIZEDATA_INDATABLOCK; +- if (read_this > size_central_dir_to_read) +- read_this = size_central_dir_to_read; +- +- if (ZREAD64(pziinit->z_filefunc, pziinit->filestream,buf_read,(uLong)read_this) != read_this) +- err=ZIP_ERRNO; +- +- if (err==ZIP_OK) +- err = add_data_in_datablock(&pziinit->central_dir,buf_read, (uLong)read_this); +- +- size_central_dir_to_read-=read_this; +- } +- TRYFREE(buf_read); +- } +- pziinit->begin_pos = byte_before_the_zipfile; +- pziinit->number_entry = number_entry_CD; +- +- if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET) != 0) +- err=ZIP_ERRNO; +- +- return err; +-} +- +- +-#endif /* !NO_ADDFILEINEXISTINGZIP*/ +- +- +-/************************************************************/ +-extern zipFile ZEXPORT zipOpen3 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_32_def* pzlib_filefunc64_32_def) +-{ +- zip64_internal ziinit; +- zip64_internal* zi; +- int err=ZIP_OK; +- +- ziinit.z_filefunc.zseek32_file = NULL; +- ziinit.z_filefunc.ztell32_file = NULL; +- if (pzlib_filefunc64_32_def==NULL) +- fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64); +- else +- ziinit.z_filefunc = *pzlib_filefunc64_32_def; +- +- ziinit.filestream = ZOPEN64(ziinit.z_filefunc, +- pathname, +- (append == APPEND_STATUS_CREATE) ? +- (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) : +- (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING)); +- +- if (ziinit.filestream == NULL) +- return NULL; +- +- if (append == APPEND_STATUS_CREATEAFTER) +- ZSEEK64(ziinit.z_filefunc,ziinit.filestream,0,SEEK_END); +- +- ziinit.begin_pos = ZTELL64(ziinit.z_filefunc,ziinit.filestream); +- ziinit.in_opened_file_inzip = 0; +- ziinit.ci.stream_initialised = 0; +- ziinit.number_entry = 0; +- ziinit.add_position_when_writting_offset = 0; +- init_linkedlist(&(ziinit.central_dir)); +- +- +- +- zi = (zip64_internal*)ALLOC(sizeof(zip64_internal)); +- if (zi==NULL) +- { +- ZCLOSE64(ziinit.z_filefunc,ziinit.filestream); +- return NULL; +- } +- +- /* now we add file in a zipfile */ +-# ifndef NO_ADDFILEINEXISTINGZIP +- ziinit.globalcomment = NULL; +- if (append == APPEND_STATUS_ADDINZIP) +- { +- // Read and Cache Central Directory Records +- err = LoadCentralDirectoryRecord(&ziinit); +- } +- +- if (globalcomment) +- { +- *globalcomment = ziinit.globalcomment; +- } +-# endif /* !NO_ADDFILEINEXISTINGZIP*/ +- +- if (err != ZIP_OK) +- { +-# ifndef NO_ADDFILEINEXISTINGZIP +- TRYFREE(ziinit.globalcomment); +-# endif /* !NO_ADDFILEINEXISTINGZIP*/ +- TRYFREE(zi); +- return NULL; +- } +- else +- { +- *zi = ziinit; +- return (zipFile)zi; +- } +-} +- +-extern zipFile ZEXPORT zipOpen2 (const char *pathname, int append, zipcharpc* globalcomment, 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 zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill); +- } +- else +- return zipOpen3(pathname, append, globalcomment, NULL); +-} +- +-extern zipFile ZEXPORT zipOpen2_64 (const void *pathname, int append, zipcharpc* globalcomment, 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 zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill); +- } +- else +- return zipOpen3(pathname, append, globalcomment, NULL); +-} +- +- +- +-extern zipFile ZEXPORT zipOpen (const char* pathname, int append) +-{ +- return zipOpen3((const void*)pathname,append,NULL,NULL); +-} +- +-extern zipFile ZEXPORT zipOpen64 (const void* pathname, int append) +-{ +- return zipOpen3(pathname,append,NULL,NULL); +-} +- +-int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt size_extrafield_local, const void* extrafield_local) +-{ +- /* write the local header */ +- int err; +- uInt size_filename = (uInt)strlen(filename); +- uInt size_extrafield = size_extrafield_local; +- +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC, 4); +- +- if (err==ZIP_OK) +- { +- if(zi->ci.zip64) +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);/* version needed to extract */ +- else +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */ +- } +- +- if (err==ZIP_OK) +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2); +- +- if (err==ZIP_OK) +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2); +- +- if (err==ZIP_OK) +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4); +- +- // CRC / Compressed size / Uncompressed size will be filled in later and rewritten later +- if (err==ZIP_OK) +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */ +- if (err==ZIP_OK) +- { +- if(zi->ci.zip64) +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* compressed size, unknown */ +- else +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */ +- } +- if (err==ZIP_OK) +- { +- if(zi->ci.zip64) +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* uncompressed size, unknown */ +- else +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */ +- } +- +- if (err==ZIP_OK) +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2); +- +- if(zi->ci.zip64) +- { +- size_extrafield += 20; +- } +- +- if (err==ZIP_OK) +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield,2); +- +- if ((err==ZIP_OK) && (size_filename > 0)) +- { +- if (ZWRITE64(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename) +- err = ZIP_ERRNO; +- } +- +- if ((err==ZIP_OK) && (size_extrafield_local > 0)) +- { +- if (ZWRITE64(zi->z_filefunc, zi->filestream, extrafield_local, size_extrafield_local) != size_extrafield_local) +- err = ZIP_ERRNO; +- } +- +- +- if ((err==ZIP_OK) && (zi->ci.zip64)) +- { +- // write the Zip64 extended info +- short HeaderID = 1; +- short DataSize = 16; +- ZPOS64_T CompressedSize = 0; +- ZPOS64_T UncompressedSize = 0; +- +- // Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file) +- zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream); +- +- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)HeaderID,2); +- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)DataSize,2); +- +- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8); +- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8); +- } +- +- return err; +-} +- +-/* +- NOTE. +- When writing RAW the ZIP64 extended information in extrafield_local and extrafield_global needs to be stripped +- before calling this function it can be done with zipRemoveExtraInfoBlock +- +- It is not done here because then we need to realloc a new buffer since parameters are 'const' and I want to minimize +- unnecessary allocations. +- */ +-extern int ZEXPORT zipOpenNewFileInZip4_64 (zipFile file, const char* filename, const zip_fileinfo* zipfi, +- const void* extrafield_local, uInt size_extrafield_local, +- const void* extrafield_global, uInt size_extrafield_global, +- const char* comment, int method, int level, int raw, +- int windowBits,int memLevel, int strategy, +- const char* password, uLong crcForCrypting, +- uLong versionMadeBy, uLong flagBase, int zip64) +-{ +- zip64_internal* zi; +- uInt size_filename; +- uInt size_comment; +- uInt i; +- int err = ZIP_OK; +- +-# ifdef NOCRYPT +- if (password != NULL) +- return ZIP_PARAMERROR; +-# endif +- +- if (file == NULL) +- return ZIP_PARAMERROR; +- +-#ifdef HAVE_BZIP2 +- if ((method!=0) && (method!=Z_DEFLATED) && (method!=Z_BZIP2ED)) +- return ZIP_PARAMERROR; +-#else +- if ((method!=0) && (method!=Z_DEFLATED)) +- return ZIP_PARAMERROR; +-#endif +- +- zi = (zip64_internal*)file; +- +- if (zi->in_opened_file_inzip == 1) +- { +- err = zipCloseFileInZip (file); +- if (err != ZIP_OK) +- return err; +- } +- +- if (filename==NULL) +- filename="-"; +- +- if (comment==NULL) +- size_comment = 0; +- else +- size_comment = (uInt)strlen(comment); +- +- size_filename = (uInt)strlen(filename); +- +- if (zipfi == NULL) +- zi->ci.dosDate = 0; +- else +- { +- if (zipfi->dosDate != 0) +- zi->ci.dosDate = zipfi->dosDate; +- else +- zi->ci.dosDate = zip64local_TmzDateToDosDate(&zipfi->tmz_date); +- } +- +- zi->ci.flag = flagBase; +- if ((level==8) || (level==9)) +- zi->ci.flag |= 2; +- if ((level==2)) +- zi->ci.flag |= 4; +- if ((level==1)) +- zi->ci.flag |= 6; +- if (password != NULL) +- zi->ci.flag |= 1; +- +- zi->ci.crc32 = 0; +- zi->ci.method = method; +- zi->ci.encrypt = 0; +- zi->ci.stream_initialised = 0; +- zi->ci.pos_in_buffered_data = 0; +- zi->ci.raw = raw; +- zi->ci.pos_local_header = ZTELL64(zi->z_filefunc,zi->filestream); +- +- zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global + size_comment; +- zi->ci.size_centralExtraFree = 32; // Extra space we have reserved in case we need to add ZIP64 extra info data +- +- zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader + zi->ci.size_centralExtraFree); +- +- zi->ci.size_centralExtra = size_extrafield_global; +- zip64local_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4); +- /* version info */ +- zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)versionMadeBy,2); +- zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2); +- zip64local_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2); +- zip64local_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2); +- zip64local_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4); +- zip64local_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/ +- zip64local_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/ +- zip64local_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/ +- zip64local_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2); +- zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2); +- zip64local_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2); +- zip64local_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/ +- +- if (zipfi==NULL) +- zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2); +- else +- zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2); +- +- if (zipfi==NULL) +- zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4); +- else +- zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4); +- +- if(zi->ci.pos_local_header >= 0xffffffff) +- zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)0xffffffff,4); +- else +- zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header - zi->add_position_when_writting_offset,4); +- +- for (i=0;ici.central_header+SIZECENTRALHEADER+i) = *(filename+i); +- +- for (i=0;ici.central_header+SIZECENTRALHEADER+size_filename+i) = +- *(((const char*)extrafield_global)+i); +- +- for (i=0;ici.central_header+SIZECENTRALHEADER+size_filename+ +- size_extrafield_global+i) = *(comment+i); +- if (zi->ci.central_header == NULL) +- return ZIP_INTERNALERROR; +- +- zi->ci.zip64 = zip64; +- zi->ci.totalCompressedData = 0; +- zi->ci.totalUncompressedData = 0; +- zi->ci.pos_zip64extrainfo = 0; +- +- err = Write_LocalFileHeader(zi, filename, size_extrafield_local, extrafield_local); +- +-#ifdef HAVE_BZIP2 +- zi->ci.bstream.avail_in = (uInt)0; +- zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE; +- zi->ci.bstream.next_out = (char*)zi->ci.buffered_data; +- zi->ci.bstream.total_in_hi32 = 0; +- zi->ci.bstream.total_in_lo32 = 0; +- zi->ci.bstream.total_out_hi32 = 0; +- zi->ci.bstream.total_out_lo32 = 0; +-#endif +- +- zi->ci.stream.avail_in = (uInt)0; +- zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; +- zi->ci.stream.next_out = zi->ci.buffered_data; +- zi->ci.stream.total_in = 0; +- zi->ci.stream.total_out = 0; +- zi->ci.stream.data_type = Z_BINARY; +- +-#ifdef HAVE_BZIP2 +- if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED || zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) +-#else +- if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) +-#endif +- { +- if(zi->ci.method == Z_DEFLATED) +- { +- zi->ci.stream.zalloc = (alloc_func)0; +- zi->ci.stream.zfree = (free_func)0; +- zi->ci.stream.opaque = (voidpf)0; +- +- if (windowBits>0) +- windowBits = -windowBits; +- +- err = deflateInit2(&zi->ci.stream, level, Z_DEFLATED, windowBits, memLevel, strategy); +- +- if (err==Z_OK) +- zi->ci.stream_initialised = Z_DEFLATED; +- } +- else if(zi->ci.method == Z_BZIP2ED) +- { +-#ifdef HAVE_BZIP2 +- // Init BZip stuff here +- zi->ci.bstream.bzalloc = 0; +- zi->ci.bstream.bzfree = 0; +- zi->ci.bstream.opaque = (voidpf)0; +- +- err = BZ2_bzCompressInit(&zi->ci.bstream, level, 0,35); +- if(err == BZ_OK) +- zi->ci.stream_initialised = Z_BZIP2ED; +-#endif +- } +- +- } +- +-# ifndef NOCRYPT +- zi->ci.crypt_header_size = 0; +- if ((err==Z_OK) && (password != NULL)) +- { +- unsigned char bufHead[RAND_HEAD_LEN]; +- unsigned int sizeHead; +- zi->ci.encrypt = 1; +- zi->ci.pcrc_32_tab = get_crc_table(); +- /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/ +- +- sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting); +- zi->ci.crypt_header_size = sizeHead; +- +- if (ZWRITE64(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead) +- err = ZIP_ERRNO; +- } +-# endif +- +- if (err==Z_OK) +- zi->in_opened_file_inzip = 1; +- return err; +-} +- +-extern int ZEXPORT zipOpenNewFileInZip4 (zipFile file, const char* filename, const zip_fileinfo* zipfi, +- const void* extrafield_local, uInt size_extrafield_local, +- const void* extrafield_global, uInt size_extrafield_global, +- const char* comment, int method, int level, int raw, +- int windowBits,int memLevel, int strategy, +- const char* password, uLong crcForCrypting, +- uLong versionMadeBy, uLong flagBase) +-{ +- return zipOpenNewFileInZip4_64 (file, filename, zipfi, +- extrafield_local, size_extrafield_local, +- extrafield_global, size_extrafield_global, +- comment, method, level, raw, +- windowBits, memLevel, strategy, +- password, crcForCrypting, versionMadeBy, flagBase, 0); +-} +- +-extern int ZEXPORT zipOpenNewFileInZip3 (zipFile file, const char* filename, const zip_fileinfo* zipfi, +- const void* extrafield_local, uInt size_extrafield_local, +- const void* extrafield_global, uInt size_extrafield_global, +- const char* comment, int method, int level, int raw, +- int windowBits,int memLevel, int strategy, +- const char* password, uLong crcForCrypting) +-{ +- return zipOpenNewFileInZip4_64 (file, filename, zipfi, +- extrafield_local, size_extrafield_local, +- extrafield_global, size_extrafield_global, +- comment, method, level, raw, +- windowBits, memLevel, strategy, +- password, crcForCrypting, VERSIONMADEBY, 0, 0); +-} +- +-extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char* filename, const zip_fileinfo* zipfi, +- const void* extrafield_local, uInt size_extrafield_local, +- const void* extrafield_global, uInt size_extrafield_global, +- const char* comment, int method, int level, int raw, +- int windowBits,int memLevel, int strategy, +- const char* password, uLong crcForCrypting, int zip64) +-{ +- return zipOpenNewFileInZip4_64 (file, filename, zipfi, +- extrafield_local, size_extrafield_local, +- extrafield_global, size_extrafield_global, +- comment, method, level, raw, +- windowBits, memLevel, strategy, +- password, crcForCrypting, VERSIONMADEBY, 0, zip64); +-} +- +-extern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char* filename, const zip_fileinfo* zipfi, +- const void* extrafield_local, uInt size_extrafield_local, +- const void* extrafield_global, uInt size_extrafield_global, +- const char* comment, int method, int level, int raw) +-{ +- return zipOpenNewFileInZip4_64 (file, filename, zipfi, +- extrafield_local, size_extrafield_local, +- extrafield_global, size_extrafield_global, +- comment, method, level, raw, +- -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, +- NULL, 0, VERSIONMADEBY, 0, 0); +-} +- +-extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char* filename, const zip_fileinfo* zipfi, +- const void* extrafield_local, uInt size_extrafield_local, +- const void* extrafield_global, uInt size_extrafield_global, +- const char* comment, int method, int level, int raw, int zip64) +-{ +- return zipOpenNewFileInZip4_64 (file, filename, zipfi, +- extrafield_local, size_extrafield_local, +- extrafield_global, size_extrafield_global, +- comment, method, level, raw, +- -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, +- NULL, 0, VERSIONMADEBY, 0, zip64); +-} +- +-extern int ZEXPORT zipOpenNewFileInZip64 (zipFile file, const char* filename, const zip_fileinfo* zipfi, +- const void* extrafield_local, uInt size_extrafield_local, +- const void*extrafield_global, uInt size_extrafield_global, +- const char* comment, int method, int level, int zip64) +-{ +- return zipOpenNewFileInZip4_64 (file, filename, zipfi, +- extrafield_local, size_extrafield_local, +- extrafield_global, size_extrafield_global, +- comment, method, level, 0, +- -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, +- NULL, 0, VERSIONMADEBY, 0, zip64); +-} +- +-extern int ZEXPORT zipOpenNewFileInZip (zipFile file, const char* filename, const zip_fileinfo* zipfi, +- const void* extrafield_local, uInt size_extrafield_local, +- const void*extrafield_global, uInt size_extrafield_global, +- const char* comment, int method, int level) +-{ +- return zipOpenNewFileInZip4_64 (file, filename, zipfi, +- extrafield_local, size_extrafield_local, +- extrafield_global, size_extrafield_global, +- comment, method, level, 0, +- -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, +- NULL, 0, VERSIONMADEBY, 0, 0); +-} +- +-local int zip64FlushWriteBuffer(zip64_internal* zi) +-{ +- int err=ZIP_OK; +- +- if (zi->ci.encrypt != 0) +- { +-#ifndef NOCRYPT +- uInt i; +- int t; +- for (i=0;ici.pos_in_buffered_data;i++) +- zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, zi->ci.buffered_data[i],t); +-#endif +- } +- +- if (ZWRITE64(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) != zi->ci.pos_in_buffered_data) +- err = ZIP_ERRNO; +- +- zi->ci.totalCompressedData += zi->ci.pos_in_buffered_data; +- +-#ifdef HAVE_BZIP2 +- if(zi->ci.method == Z_BZIP2ED) +- { +- zi->ci.totalUncompressedData += zi->ci.bstream.total_in_lo32; +- zi->ci.bstream.total_in_lo32 = 0; +- zi->ci.bstream.total_in_hi32 = 0; +- } +- else +-#endif +- { +- zi->ci.totalUncompressedData += zi->ci.stream.total_in; +- zi->ci.stream.total_in = 0; +- } +- +- +- zi->ci.pos_in_buffered_data = 0; +- +- return err; +-} +- +-extern int ZEXPORT zipWriteInFileInZip (zipFile file,const void* buf,unsigned int len) +-{ +- zip64_internal* zi; +- int err=ZIP_OK; +- +- if (file == NULL) +- return ZIP_PARAMERROR; +- zi = (zip64_internal*)file; +- +- if (zi->in_opened_file_inzip == 0) +- return ZIP_PARAMERROR; +- +- zi->ci.crc32 = crc32(zi->ci.crc32,buf,(uInt)len); +- +-#ifdef HAVE_BZIP2 +- if(zi->ci.method == Z_BZIP2ED && (!zi->ci.raw)) +- { +- zi->ci.bstream.next_in = (void*)buf; +- zi->ci.bstream.avail_in = len; +- err = BZ_RUN_OK; +- +- while ((err==BZ_RUN_OK) && (zi->ci.bstream.avail_in>0)) +- { +- if (zi->ci.bstream.avail_out == 0) +- { +- if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) +- err = ZIP_ERRNO; +- zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE; +- zi->ci.bstream.next_out = (char*)zi->ci.buffered_data; +- } +- +- +- if(err != BZ_RUN_OK) +- break; +- +- if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) +- { +- uLong uTotalOutBefore_lo = zi->ci.bstream.total_out_lo32; +-// uLong uTotalOutBefore_hi = zi->ci.bstream.total_out_hi32; +- err=BZ2_bzCompress(&zi->ci.bstream, BZ_RUN); +- +- zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore_lo) ; +- } +- } +- +- if(err == BZ_RUN_OK) +- err = ZIP_OK; +- } +- else +-#endif +- { +- zi->ci.stream.next_in = (Bytef*)buf; +- zi->ci.stream.avail_in = len; +- +- while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0)) +- { +- if (zi->ci.stream.avail_out == 0) +- { +- if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) +- err = ZIP_ERRNO; +- zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; +- zi->ci.stream.next_out = zi->ci.buffered_data; +- } +- +- +- if(err != ZIP_OK) +- break; +- +- if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) +- { +- uLong uTotalOutBefore = zi->ci.stream.total_out; +- err=deflate(&zi->ci.stream, Z_NO_FLUSH); +- if(uTotalOutBefore > zi->ci.stream.total_out) +- { +- int bBreak = 0; +- bBreak++; +- } +- +- zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; +- } +- else +- { +- uInt copy_this,i; +- if (zi->ci.stream.avail_in < zi->ci.stream.avail_out) +- copy_this = zi->ci.stream.avail_in; +- else +- copy_this = zi->ci.stream.avail_out; +- +- for (i = 0; i < copy_this; i++) +- *(((char*)zi->ci.stream.next_out)+i) = +- *(((const char*)zi->ci.stream.next_in)+i); +- { +- zi->ci.stream.avail_in -= copy_this; +- zi->ci.stream.avail_out-= copy_this; +- zi->ci.stream.next_in+= copy_this; +- zi->ci.stream.next_out+= copy_this; +- zi->ci.stream.total_in+= copy_this; +- zi->ci.stream.total_out+= copy_this; +- zi->ci.pos_in_buffered_data += copy_this; +- } +- } +- }// while(...) +- } +- +- return err; +-} +- +-extern int ZEXPORT zipCloseFileInZipRaw (zipFile file, uLong uncompressed_size, uLong crc32) +-{ +- return zipCloseFileInZipRaw64 (file, uncompressed_size, crc32); +-} +- +-extern int ZEXPORT zipCloseFileInZipRaw64 (zipFile file, ZPOS64_T uncompressed_size, uLong crc32) +-{ +- zip64_internal* zi; +- ZPOS64_T compressed_size; +- uLong invalidValue = 0xffffffff; +- short datasize = 0; +- int err=ZIP_OK; +- +- if (file == NULL) +- return ZIP_PARAMERROR; +- zi = (zip64_internal*)file; +- +- if (zi->in_opened_file_inzip == 0) +- return ZIP_PARAMERROR; +- zi->ci.stream.avail_in = 0; +- +- if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) +- { +- while (err==ZIP_OK) +- { +- uLong uTotalOutBefore; +- if (zi->ci.stream.avail_out == 0) +- { +- if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) +- err = ZIP_ERRNO; +- zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; +- zi->ci.stream.next_out = zi->ci.buffered_data; +- } +- uTotalOutBefore = zi->ci.stream.total_out; +- err=deflate(&zi->ci.stream, Z_FINISH); +- zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; +- } +- } +- else if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) +- { +-#ifdef HAVE_BZIP2 +- err = BZ_FINISH_OK; +- while (err==BZ_FINISH_OK) +- { +- uLong uTotalOutBefore; +- if (zi->ci.bstream.avail_out == 0) +- { +- if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) +- err = ZIP_ERRNO; +- zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE; +- zi->ci.bstream.next_out = (char*)zi->ci.buffered_data; +- } +- uTotalOutBefore = zi->ci.bstream.total_out_lo32; +- err=BZ2_bzCompress(&zi->ci.bstream, BZ_FINISH); +- if(err == BZ_STREAM_END) +- err = Z_STREAM_END; +- +- zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore); +- } +- +- if(err == BZ_FINISH_OK) +- err = ZIP_OK; +-#endif +- } +- +- if (err==Z_STREAM_END) +- err=ZIP_OK; /* this is normal */ +- +- if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK)) +- { +- if (zip64FlushWriteBuffer(zi)==ZIP_ERRNO) +- err = ZIP_ERRNO; +- } +- +- if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) +- { +- int tmp_err = deflateEnd(&zi->ci.stream); +- if (err == ZIP_OK) +- err = tmp_err; +- zi->ci.stream_initialised = 0; +- } +-#ifdef HAVE_BZIP2 +- else if((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) +- { +- int tmperr = BZ2_bzCompressEnd(&zi->ci.bstream); +- if (err==ZIP_OK) +- err = tmperr; +- zi->ci.stream_initialised = 0; +- } +-#endif +- +- if (!zi->ci.raw) +- { +- crc32 = (uLong)zi->ci.crc32; +- uncompressed_size = zi->ci.totalUncompressedData; +- } +- compressed_size = zi->ci.totalCompressedData; +- +-# ifndef NOCRYPT +- compressed_size += zi->ci.crypt_header_size; +-# endif +- +- // update Current Item crc and sizes, +- if(compressed_size >= 0xffffffff || uncompressed_size >= 0xffffffff || zi->ci.pos_local_header >= 0xffffffff) +- { +- /*version Made by*/ +- zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)45,2); +- /*version needed*/ +- zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)45,2); +- +- } +- +- zip64local_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/ +- +- +- if(compressed_size >= 0xffffffff) +- zip64local_putValue_inmemory(zi->ci.central_header+20, invalidValue,4); /*compr size*/ +- else +- zip64local_putValue_inmemory(zi->ci.central_header+20, compressed_size,4); /*compr size*/ +- +- /// set internal file attributes field +- if (zi->ci.stream.data_type == Z_ASCII) +- zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2); +- +- if(uncompressed_size >= 0xffffffff) +- zip64local_putValue_inmemory(zi->ci.central_header+24, invalidValue,4); /*uncompr size*/ +- else +- zip64local_putValue_inmemory(zi->ci.central_header+24, uncompressed_size,4); /*uncompr size*/ +- +- // Add ZIP64 extra info field for uncompressed size +- if(uncompressed_size >= 0xffffffff) +- datasize += 8; +- +- // Add ZIP64 extra info field for compressed size +- if(compressed_size >= 0xffffffff) +- datasize += 8; +- +- // Add ZIP64 extra info field for relative offset to local file header of current file +- if(zi->ci.pos_local_header >= 0xffffffff) +- datasize += 8; +- +- if(datasize > 0) +- { +- char* p = NULL; +- +- if((uLong)(datasize + 4) > zi->ci.size_centralExtraFree) +- { +- // we can not write more data to the buffer that we have room for. +- return ZIP_BADZIPFILE; +- } +- +- p = zi->ci.central_header + zi->ci.size_centralheader; +- +- // Add Extra Information Header for 'ZIP64 information' +- zip64local_putValue_inmemory(p, 0x0001, 2); // HeaderID +- p += 2; +- zip64local_putValue_inmemory(p, datasize, 2); // DataSize +- p += 2; +- +- if(uncompressed_size >= 0xffffffff) +- { +- zip64local_putValue_inmemory(p, uncompressed_size, 8); +- p += 8; +- } +- +- if(compressed_size >= 0xffffffff) +- { +- zip64local_putValue_inmemory(p, compressed_size, 8); +- p += 8; +- } +- +- if(zi->ci.pos_local_header >= 0xffffffff) +- { +- zip64local_putValue_inmemory(p, zi->ci.pos_local_header, 8); +- p += 8; +- } +- +- // Update how much extra free space we got in the memory buffer +- // and increase the centralheader size so the new ZIP64 fields are included +- // ( 4 below is the size of HeaderID and DataSize field ) +- zi->ci.size_centralExtraFree -= datasize + 4; +- zi->ci.size_centralheader += datasize + 4; +- +- // Update the extra info size field +- zi->ci.size_centralExtra += datasize + 4; +- zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)zi->ci.size_centralExtra,2); +- } +- +- if (err==ZIP_OK) +- err = add_data_in_datablock(&zi->central_dir, zi->ci.central_header, (uLong)zi->ci.size_centralheader); +- +- free(zi->ci.central_header); +- +- if (err==ZIP_OK) +- { +- // Update the LocalFileHeader with the new values. +- +- ZPOS64_T cur_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream); +- +- if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0) +- err = ZIP_ERRNO; +- +- if (err==ZIP_OK) +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */ +- +- if(uncompressed_size >= 0xffffffff) +- { +- if(zi->ci.pos_zip64extrainfo > 0) +- { +- // Update the size in the ZIP64 extended field. +- if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_zip64extrainfo + 4,ZLIB_FILEFUNC_SEEK_SET)!=0) +- err = ZIP_ERRNO; +- +- if (err==ZIP_OK) /* compressed size, unknown */ +- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, uncompressed_size, 8); +- +- if (err==ZIP_OK) /* uncompressed size, unknown */ +- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, compressed_size, 8); +- } +- } +- else +- { +- if (err==ZIP_OK) /* compressed size, unknown */ +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4); +- +- if (err==ZIP_OK) /* uncompressed size, unknown */ +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4); +- } +- +- if (ZSEEK64(zi->z_filefunc,zi->filestream, cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0) +- err = ZIP_ERRNO; +- } +- +- zi->number_entry ++; +- zi->in_opened_file_inzip = 0; +- +- return err; +-} +- +-extern int ZEXPORT zipCloseFileInZip (zipFile file) +-{ +- return zipCloseFileInZipRaw (file,0,0); +-} +- +-int Write_Zip64EndOfCentralDirectoryLocator(zip64_internal* zi, ZPOS64_T zip64eocd_pos_inzip) +-{ +- int err = ZIP_OK; +- ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writting_offset; +- +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDLOCHEADERMAGIC,4); +- +- /*num disks*/ +- if (err==ZIP_OK) /* number of the disk with the start of the central directory */ +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); +- +- /*relative offset*/ +- if (err==ZIP_OK) /* Relative offset to the Zip64EndOfCentralDirectory */ +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream, pos,8); +- +- /*total disks*/ /* Do not support spawning of disk so always say 1 here*/ +- if (err==ZIP_OK) /* number of the disk with the start of the central directory */ +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)1,4); +- +- return err; +-} +- +-int Write_Zip64EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip) +-{ +- int err = ZIP_OK; +- +- uLong Zip64DataSize = 44; +- +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDHEADERMAGIC,4); +- +- if (err==ZIP_OK) /* size of this 'zip64 end of central directory' */ +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)Zip64DataSize,8); // why ZPOS64_T of this ? +- +- if (err==ZIP_OK) /* version made by */ +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2); +- +- if (err==ZIP_OK) /* version needed */ +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2); +- +- if (err==ZIP_OK) /* number of this disk */ +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); +- +- if (err==ZIP_OK) /* number of the disk with the start of the central directory */ +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); +- +- if (err==ZIP_OK) /* total number of entries in the central dir on this disk */ +- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8); +- +- if (err==ZIP_OK) /* total number of entries in the central dir */ +- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8); +- +- if (err==ZIP_OK) /* size of the central directory */ +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)size_centraldir,8); +- +- if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */ +- { +- ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset; +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (ZPOS64_T)pos,8); +- } +- return err; +-} +-int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip) +-{ +- int err = ZIP_OK; +- +- /*signature*/ +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4); +- +- if (err==ZIP_OK) /* number of this disk */ +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); +- +- if (err==ZIP_OK) /* number of the disk with the start of the central directory */ +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); +- +- if (err==ZIP_OK) /* total number of entries in the central dir on this disk */ +- { +- { +- if(zi->number_entry >= 0xFFFF) +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record +- else +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); +- } +- } +- +- if (err==ZIP_OK) /* total number of entries in the central dir */ +- { +- if(zi->number_entry >= 0xFFFF) +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record +- else +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); +- } +- +- if (err==ZIP_OK) /* size of the central directory */ +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4); +- +- if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */ +- { +- ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset; +- if(pos >= 0xffffffff) +- { +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)0xffffffff,4); +- } +- else +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4); +- } +- +- return err; +-} +- +-int Write_GlobalComment(zip64_internal* zi, const char* global_comment) +-{ +- int err = ZIP_OK; +- uInt size_global_comment = 0; +- +- if(global_comment != NULL) +- size_global_comment = (uInt)strlen(global_comment); +- +- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2); +- +- if (err == ZIP_OK && size_global_comment > 0) +- { +- if (ZWRITE64(zi->z_filefunc,zi->filestream, global_comment, size_global_comment) != size_global_comment) +- err = ZIP_ERRNO; +- } +- return err; +-} +- +-extern int ZEXPORT zipClose (zipFile file, const char* global_comment) +-{ +- zip64_internal* zi; +- int err = 0; +- uLong size_centraldir = 0; +- ZPOS64_T centraldir_pos_inzip; +- ZPOS64_T pos; +- +- if (file == NULL) +- return ZIP_PARAMERROR; +- +- zi = (zip64_internal*)file; +- +- if (zi->in_opened_file_inzip == 1) +- { +- err = zipCloseFileInZip (file); +- } +- +-#ifndef NO_ADDFILEINEXISTINGZIP +- if (global_comment==NULL) +- global_comment = zi->globalcomment; +-#endif +- +- centraldir_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream); +- +- if (err==ZIP_OK) +- { +- linkedlist_datablock_internal* ldi = zi->central_dir.first_block; +- while (ldi!=NULL) +- { +- if ((err==ZIP_OK) && (ldi->filled_in_this_block>0)) +- { +- if (ZWRITE64(zi->z_filefunc,zi->filestream, ldi->data, ldi->filled_in_this_block) != ldi->filled_in_this_block) +- err = ZIP_ERRNO; +- } +- +- size_centraldir += ldi->filled_in_this_block; +- ldi = ldi->next_datablock; +- } +- } +- free_linkedlist(&(zi->central_dir)); +- +- pos = centraldir_pos_inzip - zi->add_position_when_writting_offset; +- if(pos >= 0xffffffff) +- { +- ZPOS64_T Zip64EOCDpos = ZTELL64(zi->z_filefunc,zi->filestream); +- Write_Zip64EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip); +- +- Write_Zip64EndOfCentralDirectoryLocator(zi, Zip64EOCDpos); +- } +- +- if (err==ZIP_OK) +- err = Write_EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip); +- +- if(err == ZIP_OK) +- err = Write_GlobalComment(zi, global_comment); +- +- if (ZCLOSE64(zi->z_filefunc,zi->filestream) != 0) +- if (err == ZIP_OK) +- err = ZIP_ERRNO; +- +-#ifndef NO_ADDFILEINEXISTINGZIP +- TRYFREE(zi->globalcomment); +-#endif +- TRYFREE(zi); +- +- return err; +-} +- +-extern int ZEXPORT zipRemoveExtraInfoBlock (char* pData, int* dataLen, short sHeader) +-{ +- char* p = pData; +- int size = 0; +- char* pNewHeader; +- char* pTmp; +- short header; +- short dataSize; +- +- int retVal = ZIP_OK; +- +- if(pData == NULL || *dataLen < 4) +- return ZIP_PARAMERROR; +- +- pNewHeader = (char*)ALLOC(*dataLen); +- pTmp = pNewHeader; +- +- while(p < (pData + *dataLen)) +- { +- header = *(short*)p; +- dataSize = *(((short*)p)+1); +- +- if( header == sHeader ) // Header found. +- { +- p += dataSize + 4; // skip it. do not copy to temp buffer +- } +- else +- { +- // Extra Info block should not be removed, So copy it to the temp buffer. +- memcpy(pTmp, p, dataSize + 4); +- p += dataSize + 4; +- size += dataSize + 4; +- } +- +- } +- +- if(size < *dataLen) +- { +- // clean old extra info block. +- memset(pData,0, *dataLen); +- +- // copy the new extra info block over the old +- if(size > 0) +- memcpy(pData, pNewHeader, size); +- +- // set the new extra info size +- *dataLen = size; +- +- retVal = ZIP_OK; +- } +- else +- retVal = ZIP_ERRNO; +- +- TRYFREE(pNewHeader); +- +- return retVal; +-} +diff --git a/thirdparty/minizip/zip.h b/thirdparty/minizip/zip.h +deleted file mode 100644 +index 8aaebb6..0000000 +--- a/thirdparty/minizip/zip.h ++++ /dev/null +@@ -1,362 +0,0 @@ +-/* zip.h -- IO on .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 for Zip64 support +- Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) +- +- For more info read MiniZip_info.txt +- +- --------------------------------------------------------------------------- +- +- Condition of use and distribution are the same than zlib : +- +- This software is provided 'as-is', without any express or implied +- warranty. In no event will the authors be held liable for any damages +- arising from the use of this software. +- +- Permission is granted to anyone to use this software for any purpose, +- including commercial applications, and to alter it and redistribute it +- freely, subject to the following restrictions: +- +- 1. The origin of this software must not be misrepresented; you must not +- claim that you wrote the original software. If you use this software +- in a product, an acknowledgment in the product documentation would be +- appreciated but is not required. +- 2. Altered source versions must be plainly marked as such, and must not be +- misrepresented as being the original software. +- 3. This notice may not be removed or altered from any source distribution. +- +- --------------------------------------------------------------------------- +- +- Changes +- +- See header of zip.h +- +-*/ +- +-#ifndef _zip12_H +-#define _zip12_H +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-//#define HAVE_BZIP2 +- +-#ifndef _ZLIB_H +-#include "zlib.h" +-#endif +- +-#ifndef _ZLIBIOAPI_H +-#include "ioapi.h" +-#endif +- +-#ifdef HAVE_BZIP2 +-#include "bzlib.h" +-#endif +- +-#define Z_BZIP2ED 12 +- +-#if defined(STRICTZIP) || defined(STRICTZIPUNZIP) +-/* like the STRICT of WIN32, we define a pointer that cannot be converted +- from (void*) without cast */ +-typedef struct TagzipFile__ { int unused; } zipFile__; +-typedef zipFile__ *zipFile; +-#else +-typedef voidp zipFile; +-#endif +- +-#define ZIP_OK (0) +-#define ZIP_EOF (0) +-#define ZIP_ERRNO (Z_ERRNO) +-#define ZIP_PARAMERROR (-102) +-#define ZIP_BADZIPFILE (-103) +-#define ZIP_INTERNALERROR (-104) +- +-#ifndef DEF_MEM_LEVEL +-# if MAX_MEM_LEVEL >= 8 +-# define DEF_MEM_LEVEL 8 +-# else +-# define DEF_MEM_LEVEL MAX_MEM_LEVEL +-# endif +-#endif +-/* default memLevel */ +- +-/* tm_zip contain date/time info */ +-typedef struct tm_zip_s +-{ +- uInt tm_sec; /* seconds after the minute - [0,59] */ +- uInt tm_min; /* minutes after the hour - [0,59] */ +- uInt tm_hour; /* hours since midnight - [0,23] */ +- uInt tm_mday; /* day of the month - [1,31] */ +- uInt tm_mon; /* months since January - [0,11] */ +- uInt tm_year; /* years - [1980..2044] */ +-} tm_zip; +- +-typedef struct +-{ +- tm_zip tmz_date; /* date in understandable format */ +- uLong dosDate; /* if dos_date == 0, tmu_date is used */ +-/* uLong flag; */ /* general purpose bit flag 2 bytes */ +- +- uLong internal_fa; /* internal file attributes 2 bytes */ +- uLong external_fa; /* external file attributes 4 bytes */ +-} zip_fileinfo; +- +-typedef const char* zipcharpc; +- +- +-#define APPEND_STATUS_CREATE (0) +-#define APPEND_STATUS_CREATEAFTER (1) +-#define APPEND_STATUS_ADDINZIP (2) +- +-extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append)); +-extern zipFile ZEXPORT zipOpen64 OF((const void *pathname, int append)); +-/* +- Create a zipfile. +- pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on +- an Unix computer "zlib/zlib113.zip". +- if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip +- will be created at the end of the file. +- (useful if the file contain a self extractor code) +- if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will +- add files in existing zip (be sure you don't add file that doesn't exist) +- If the zipfile cannot be opened, the return value is NULL. +- Else, the return value is a zipFile Handle, usable with other function +- of this zip package. +-*/ +- +-/* Note : there is no delete function into a zipfile. +- If you want delete file into a zipfile, you must open a zipfile, and create another +- Of couse, you can use RAW reading and writing to copy the file you did not want delte +-*/ +- +-extern zipFile ZEXPORT zipOpen2 OF((const char *pathname, +- int append, +- zipcharpc* globalcomment, +- zlib_filefunc_def* pzlib_filefunc_def)); +- +-extern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname, +- int append, +- zipcharpc* globalcomment, +- zlib_filefunc64_def* pzlib_filefunc_def)); +- +-extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file, +- const char* filename, +- const zip_fileinfo* zipfi, +- const void* extrafield_local, +- uInt size_extrafield_local, +- const void* extrafield_global, +- uInt size_extrafield_global, +- const char* comment, +- int method, +- int level)); +- +-extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file, +- const char* filename, +- const zip_fileinfo* zipfi, +- const void* extrafield_local, +- uInt size_extrafield_local, +- const void* extrafield_global, +- uInt size_extrafield_global, +- const char* comment, +- int method, +- int level, +- int zip64)); +- +-/* +- Open a file in the ZIP for writing. +- filename : the filename in zip (if NULL, '-' without quote will be used +- *zipfi contain supplemental information +- if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local +- contains the extrafield data the the local header +- if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global +- contains the extrafield data the the local header +- if comment != NULL, comment contain the comment string +- method contain the compression method (0 for store, Z_DEFLATED for deflate) +- level contain the level of compression (can be Z_DEFAULT_COMPRESSION) +- zip64 is set to 1 if a zip64 extended information block should be added to the local file header. +- this MUST be '1' if the uncompressed size is >= 0xffffffff. +- +-*/ +- +- +-extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file, +- const char* filename, +- const zip_fileinfo* zipfi, +- const void* extrafield_local, +- uInt size_extrafield_local, +- const void* extrafield_global, +- uInt size_extrafield_global, +- const char* comment, +- int method, +- int level, +- int raw)); +- +- +-extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file, +- const char* filename, +- const zip_fileinfo* zipfi, +- const void* extrafield_local, +- uInt size_extrafield_local, +- const void* extrafield_global, +- uInt size_extrafield_global, +- const char* comment, +- int method, +- int level, +- int raw, +- int zip64)); +-/* +- Same than zipOpenNewFileInZip, except if raw=1, we write raw file +- */ +- +-extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file, +- const char* filename, +- const zip_fileinfo* zipfi, +- const void* extrafield_local, +- uInt size_extrafield_local, +- const void* extrafield_global, +- uInt size_extrafield_global, +- const char* comment, +- int method, +- int level, +- int raw, +- int windowBits, +- int memLevel, +- int strategy, +- const char* password, +- uLong crcForCrypting)); +- +-extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file, +- const char* filename, +- const zip_fileinfo* zipfi, +- const void* extrafield_local, +- uInt size_extrafield_local, +- const void* extrafield_global, +- uInt size_extrafield_global, +- const char* comment, +- int method, +- int level, +- int raw, +- int windowBits, +- int memLevel, +- int strategy, +- const char* password, +- uLong crcForCrypting, +- int zip64 +- )); +- +-/* +- Same than zipOpenNewFileInZip2, except +- windowBits,memLevel,,strategy : see parameter strategy in deflateInit2 +- password : crypting password (NULL for no crypting) +- crcForCrypting : crc of file to compress (needed for crypting) +- */ +- +-extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file, +- const char* filename, +- const zip_fileinfo* zipfi, +- const void* extrafield_local, +- uInt size_extrafield_local, +- const void* extrafield_global, +- uInt size_extrafield_global, +- const char* comment, +- int method, +- int level, +- int raw, +- int windowBits, +- int memLevel, +- int strategy, +- const char* password, +- uLong crcForCrypting, +- uLong versionMadeBy, +- uLong flagBase +- )); +- +- +-extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file, +- const char* filename, +- const zip_fileinfo* zipfi, +- const void* extrafield_local, +- uInt size_extrafield_local, +- const void* extrafield_global, +- uInt size_extrafield_global, +- const char* comment, +- int method, +- int level, +- int raw, +- int windowBits, +- int memLevel, +- int strategy, +- const char* password, +- uLong crcForCrypting, +- uLong versionMadeBy, +- uLong flagBase, +- int zip64 +- )); +-/* +- Same than zipOpenNewFileInZip4, except +- versionMadeBy : value for Version made by field +- flag : value for flag field (compression level info will be added) +- */ +- +- +-extern int ZEXPORT zipWriteInFileInZip OF((zipFile file, +- const void* buf, +- unsigned len)); +-/* +- Write data in the zipfile +-*/ +- +-extern int ZEXPORT zipCloseFileInZip OF((zipFile file)); +-/* +- Close the current file in the zipfile +-*/ +- +-extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file, +- uLong uncompressed_size, +- uLong crc32)); +- +-extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file, +- ZPOS64_T uncompressed_size, +- uLong crc32)); +- +-/* +- Close the current file in the zipfile, for file opened with +- parameter raw=1 in zipOpenNewFileInZip2 +- uncompressed_size and crc32 are value for the uncompressed size +-*/ +- +-extern int ZEXPORT zipClose OF((zipFile file, +- const char* global_comment)); +-/* +- Close the zipfile +-*/ +- +- +-extern int ZEXPORT zipRemoveExtraInfoBlock OF((char* pData, int* dataLen, short sHeader)); +-/* +- zipRemoveExtraInfoBlock - Added by Mathias Svensson +- +- Remove extra information block from a extra information data for the local file header or central directory header +- +- It is needed to remove ZIP64 extra information blocks when before data is written if using RAW mode. +- +- 0x0001 is the signature header for the ZIP64 extra information blocks +- +- usage. +- Remove ZIP64 Extra information from a central director extra field data +- zipRemoveExtraInfoBlock(pCenDirExtraFieldData, &nCenDirExtraFieldDataLen, 0x0001); +- +- Remove ZIP64 Extra information from a Local File Header extra field data +- zipRemoveExtraInfoBlock(pLocalHeaderExtraFieldData, &nLocalHeaderExtraFieldDataLen, 0x0001); +-*/ +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif /* _zip64_H */ +diff --git a/thirdparty/zlib/CMakeLists.txt b/thirdparty/zlib/CMakeLists.txt +deleted file mode 100644 +index a4eae3d..0000000 +--- a/thirdparty/zlib/CMakeLists.txt ++++ /dev/null +@@ -1,14 +0,0 @@ +-project(zlib) +- +-# Create the list of source files +-aux_source_directory( . source_files ) +- +-# Define _UNICODE (use wide-char encoding) +-add_definitions(-D_UNICODE -D_CRT_SECURE_NO_DEPRECATE /wd4996 /wd4131 /wd4244 /wd4127) +- +-fix_default_compiler_settings_() +- +-# Add library build target +-add_library(zlib STATIC ${source_files}) +- +-set_target_properties(zlib PROPERTIES DEBUG_POSTFIX d ) +\ No newline at end of file +diff --git a/thirdparty/zlib/ChangeLog b/thirdparty/zlib/ChangeLog +deleted file mode 100644 +index f310bb0..0000000 +--- a/thirdparty/zlib/ChangeLog ++++ /dev/null +@@ -1,1208 +0,0 @@ +- +- ChangeLog file for zlib +- +-Changes in 1.2.5 (19 Apr 2010) +-- Disable visibility attribute in win32/Makefile.gcc [Bar-Lev] +-- Default to libdir as sharedlibdir in configure [Nieder] +-- Update copyright dates on modified source files +-- Update trees.c to be able to generate modified trees.h +-- Exit configure for MinGW, suggesting win32/Makefile.gcc +- +-Changes in 1.2.4.5 (18 Apr 2010) +-- Set sharedlibdir in configure [Torok] +-- Set LDFLAGS in Makefile.in [Bar-Lev] +-- Avoid mkdir objs race condition in Makefile.in [Bowler] +-- Add ZLIB_INTERNAL in front of internal inter-module functions and arrays +-- Define ZLIB_INTERNAL to hide internal functions and arrays for GNU C +-- Don't use hidden attribute when it is a warning generator (e.g. Solaris) +- +-Changes in 1.2.4.4 (18 Apr 2010) +-- Fix CROSS_PREFIX executable testing, CHOST extract, mingw* [Torok] +-- Undefine _LARGEFILE64_SOURCE in zconf.h if it is zero, but not if empty +-- Try to use bash or ksh regardless of functionality of /bin/sh +-- Fix configure incompatibility with NetBSD sh +-- Remove attempt to run under bash or ksh since have better NetBSD fix +-- Fix win32/Makefile.gcc for MinGW [Bar-Lev] +-- Add diagnostic messages when using CROSS_PREFIX in configure +-- Added --sharedlibdir option to configure [Weigelt] +-- Use hidden visibility attribute when available [Frysinger] +- +-Changes in 1.2.4.3 (10 Apr 2010) +-- Only use CROSS_PREFIX in configure for ar and ranlib if they exist +-- Use CROSS_PREFIX for nm [Bar-Lev] +-- Assume _LARGEFILE64_SOURCE defined is equivalent to true +-- Avoid use of undefined symbols in #if with && and || +-- Make *64 prototypes in gzguts.h consistent with functions +-- Add -shared load option for MinGW in configure [Bowler] +-- Move z_off64_t to public interface, use instead of off64_t +-- Remove ! from shell test in configure (not portable to Solaris) +-- Change +0 macro tests to -0 for possibly increased portability +- +-Changes in 1.2.4.2 (9 Apr 2010) +-- Add consistent carriage returns to readme.txt's in masmx86 and masmx64 +-- Really provide prototypes for *64 functions when building without LFS +-- Only define unlink() in minigzip.c if unistd.h not included +-- Update README to point to contrib/vstudio project files +-- Move projects/vc6 to old/ and remove projects/ +-- Include stdlib.h in minigzip.c for setmode() definition under WinCE +-- Clean up assembler builds in win32/Makefile.msc [Rowe] +-- Include sys/types.h for Microsoft for off_t definition +-- Fix memory leak on error in gz_open() +-- Symbolize nm as $NM in configure [Weigelt] +-- Use TEST_LDSHARED instead of LDSHARED to link test programs [Weigelt] +-- Add +0 to _FILE_OFFSET_BITS and _LFS64_LARGEFILE in case not defined +-- Fix bug in gzeof() to take into account unused input data +-- Avoid initialization of structures with variables in puff.c +-- Updated win32/README-WIN32.txt [Rowe] +- +-Changes in 1.2.4.1 (28 Mar 2010) +-- Remove the use of [a-z] constructs for sed in configure [gentoo 310225] +-- Remove $(SHAREDLIB) from LIBS in Makefile.in [Creech] +-- Restore "for debugging" comment on sprintf() in gzlib.c +-- Remove fdopen for MVS from gzguts.h +-- Put new README-WIN32.txt in win32 [Rowe] +-- Add check for shell to configure and invoke another shell if needed +-- Fix big fat stinking bug in gzseek() on uncompressed files +-- Remove vestigial F_OPEN64 define in zutil.h +-- Set and check the value of _LARGEFILE_SOURCE and _LARGEFILE64_SOURCE +-- Avoid errors on non-LFS systems when applications define LFS macros +-- Set EXE to ".exe" in configure for MINGW [Kahle] +-- Match crc32() in crc32.c exactly to the prototype in zlib.h [Sherrill] +-- Add prefix for cross-compilation in win32/makefile.gcc [Bar-Lev] +-- Add DLL install in win32/makefile.gcc [Bar-Lev] +-- Allow Linux* or linux* from uname in configure [Bar-Lev] +-- Allow ldconfig to be redefined in configure and Makefile.in [Bar-Lev] +-- Add cross-compilation prefixes to configure [Bar-Lev] +-- Match type exactly in gz_load() invocation in gzread.c +-- Match type exactly of zcalloc() in zutil.c to zlib.h alloc_func +-- Provide prototypes for *64 functions when building zlib without LFS +-- Don't use -lc when linking shared library on MinGW +-- Remove errno.h check in configure and vestigial errno code in zutil.h +- +-Changes in 1.2.4 (14 Mar 2010) +-- Fix VER3 extraction in configure for no fourth subversion +-- Update zlib.3, add docs to Makefile.in to make .pdf out of it +-- Add zlib.3.pdf to distribution +-- Don't set error code in gzerror() if passed pointer is NULL +-- Apply destination directory fixes to CMakeLists.txt [Lowman] +-- Move #cmakedefine's to a new zconf.in.cmakein +-- Restore zconf.h for builds that don't use configure or cmake +-- Add distclean to dummy Makefile for convenience +-- Update and improve INDEX, README, and FAQ +-- Update CMakeLists.txt for the return of zconf.h [Lowman] +-- Update contrib/vstudio/vc9 and vc10 [Vollant] +-- Change libz.dll.a back to libzdll.a in win32/Makefile.gcc +-- Apply license and readme changes to contrib/asm686 [Raiter] +-- Check file name lengths and add -c option in minigzip.c [Li] +-- Update contrib/amd64 and contrib/masmx86/ [Vollant] +-- Avoid use of "eof" parameter in trees.c to not shadow library variable +-- Update make_vms.com for removal of zlibdefs.h [Zinser] +-- Update assembler code and vstudio projects in contrib [Vollant] +-- Remove outdated assembler code contrib/masm686 and contrib/asm586 +-- Remove old vc7 and vc8 from contrib/vstudio +-- Update win32/Makefile.msc, add ZLIB_VER_SUBREVISION [Rowe] +-- Fix memory leaks in gzclose_r() and gzclose_w(), file leak in gz_open() +-- Add contrib/gcc_gvmat64 for longest_match and inflate_fast [Vollant] +-- Remove *64 functions from win32/zlib.def (they're not 64-bit yet) +-- Fix bug in void-returning vsprintf() case in gzwrite.c +-- Fix name change from inflate.h in contrib/inflate86/inffas86.c +-- Check if temporary file exists before removing in make_vms.com [Zinser] +-- Fix make install and uninstall for --static option +-- Fix usage of _MSC_VER in gzguts.h and zutil.h [Truta] +-- Update readme.txt in contrib/masmx64 and masmx86 to assemble +- +-Changes in 1.2.3.9 (21 Feb 2010) +-- Expunge gzio.c +-- Move as400 build information to old +-- Fix updates in contrib/minizip and contrib/vstudio +-- Add const to vsnprintf test in configure to avoid warnings [Weigelt] +-- Delete zconf.h (made by configure) [Weigelt] +-- Change zconf.in.h to zconf.h.in per convention [Weigelt] +-- Check for NULL buf in gzgets() +-- Return empty string for gzgets() with len == 1 (like fgets()) +-- Fix description of gzgets() in zlib.h for end-of-file, NULL return +-- Update minizip to 1.1 [Vollant] +-- Avoid MSVC loss of data warnings in gzread.c, gzwrite.c +-- Note in zlib.h that gzerror() should be used to distinguish from EOF +-- Remove use of snprintf() from gzlib.c +-- Fix bug in gzseek() +-- Update contrib/vstudio, adding vc9 and vc10 [Kuno, Vollant] +-- Fix zconf.h generation in CMakeLists.txt [Lowman] +-- Improve comments in zconf.h where modified by configure +- +-Changes in 1.2.3.8 (13 Feb 2010) +-- Clean up text files (tabs, trailing whitespace, etc.) [Oberhumer] +-- Use z_off64_t in gz_zero() and gz_skip() to match state->skip +-- Avoid comparison problem when sizeof(int) == sizeof(z_off64_t) +-- Revert to Makefile.in from 1.2.3.6 (live with the clutter) +-- Fix missing error return in gzflush(), add zlib.h note +-- Add *64 functions to zlib.map [Levin] +-- Fix signed/unsigned comparison in gz_comp() +-- Use SFLAGS when testing shared linking in configure +-- Add --64 option to ./configure to use -m64 with gcc +-- Fix ./configure --help to correctly name options +-- Have make fail if a test fails [Levin] +-- Avoid buffer overrun in contrib/masmx64/gvmat64.asm [Simpson] +-- Remove assembler object files from contrib +- +-Changes in 1.2.3.7 (24 Jan 2010) +-- Always gzopen() with O_LARGEFILE if available +-- Fix gzdirect() to work immediately after gzopen() or gzdopen() +-- Make gzdirect() more precise when the state changes while reading +-- Improve zlib.h documentation in many places +-- Catch memory allocation failure in gz_open() +-- Complete close operation if seek forward in gzclose_w() fails +-- Return Z_ERRNO from gzclose_r() if close() fails +-- Return Z_STREAM_ERROR instead of EOF for gzclose() being passed NULL +-- Return zero for gzwrite() errors to match zlib.h description +-- Return -1 on gzputs() error to match zlib.h description +-- Add zconf.in.h to allow recovery from configure modification [Weigelt] +-- Fix static library permissions in Makefile.in [Weigelt] +-- Avoid warnings in configure tests that hide functionality [Weigelt] +-- Add *BSD and DragonFly to Linux case in configure [gentoo 123571] +-- Change libzdll.a to libz.dll.a in win32/Makefile.gcc [gentoo 288212] +-- Avoid access of uninitialized data for first inflateReset2 call [Gomes] +-- Keep object files in subdirectories to reduce the clutter somewhat +-- Remove default Makefile and zlibdefs.h, add dummy Makefile +-- Add new external functions to Z_PREFIX, remove duplicates, z_z_ -> z_ +-- Remove zlibdefs.h completely -- modify zconf.h instead +- +-Changes in 1.2.3.6 (17 Jan 2010) +-- Avoid void * arithmetic in gzread.c and gzwrite.c +-- Make compilers happier with const char * for gz_error message +-- Avoid unused parameter warning in inflate.c +-- Avoid signed-unsigned comparison warning in inflate.c +-- Indent #pragma's for traditional C +-- Fix usage of strwinerror() in glib.c, change to gz_strwinerror() +-- Correct email address in configure for system options +-- Update make_vms.com and add make_vms.com to contrib/minizip [Zinser] +-- Update zlib.map [Brown] +-- Fix Makefile.in for Solaris 10 make of example64 and minizip64 [Torok] +-- Apply various fixes to CMakeLists.txt [Lowman] +-- Add checks on len in gzread() and gzwrite() +-- Add error message for no more room for gzungetc() +-- Remove zlib version check in gzwrite() +-- Defer compression of gzprintf() result until need to +-- Use snprintf() in gzdopen() if available +-- Remove USE_MMAP configuration determination (only used by minigzip) +-- Remove examples/pigz.c (available separately) +-- Update examples/gun.c to 1.6 +- +-Changes in 1.2.3.5 (8 Jan 2010) +-- Add space after #if in zutil.h for some compilers +-- Fix relatively harmless bug in deflate_fast() [Exarevsky] +-- Fix same problem in deflate_slow() +-- Add $(SHAREDLIBV) to LIBS in Makefile.in [Brown] +-- Add deflate_rle() for faster Z_RLE strategy run-length encoding +-- Add deflate_huff() for faster Z_HUFFMAN_ONLY encoding +-- Change name of "write" variable in inffast.c to avoid library collisions +-- Fix premature EOF from gzread() in gzio.c [Brown] +-- Use zlib header window size if windowBits is 0 in inflateInit2() +-- Remove compressBound() call in deflate.c to avoid linking compress.o +-- Replace use of errno in gz* with functions, support WinCE [Alves] +-- Provide alternative to perror() in minigzip.c for WinCE [Alves] +-- Don't use _vsnprintf on later versions of MSVC [Lowman] +-- Add CMake build script and input file [Lowman] +-- Update contrib/minizip to 1.1 [Svensson, Vollant] +-- Moved nintendods directory from contrib to . +-- Replace gzio.c with a new set of routines with the same functionality +-- Add gzbuffer(), gzoffset(), gzclose_r(), gzclose_w() as part of above +-- Update contrib/minizip to 1.1b +-- Change gzeof() to return 0 on error instead of -1 to agree with zlib.h +- +-Changes in 1.2.3.4 (21 Dec 2009) +-- Use old school .SUFFIXES in Makefile.in for FreeBSD compatibility +-- Update comments in configure and Makefile.in for default --shared +-- Fix test -z's in configure [Marquess] +-- Build examplesh and minigzipsh when not testing +-- Change NULL's to Z_NULL's in deflate.c and in comments in zlib.h +-- Import LDFLAGS from the environment in configure +-- Fix configure to populate SFLAGS with discovered CFLAGS options +-- Adapt make_vms.com to the new Makefile.in [Zinser] +-- Add zlib2ansi script for C++ compilation [Marquess] +-- Add _FILE_OFFSET_BITS=64 test to make test (when applicable) +-- Add AMD64 assembler code for longest match to contrib [Teterin] +-- Include options from $SFLAGS when doing $LDSHARED +-- Simplify 64-bit file support by introducing z_off64_t type +-- Make shared object files in objs directory to work around old Sun cc +-- Use only three-part version number for Darwin shared compiles +-- Add rc option to ar in Makefile.in for when ./configure not run +-- Add -WI,-rpath,. to LDFLAGS for OSF 1 V4* +-- Set LD_LIBRARYN32_PATH for SGI IRIX shared compile +-- Protect against _FILE_OFFSET_BITS being defined when compiling zlib +-- Rename Makefile.in targets allstatic to static and allshared to shared +-- Fix static and shared Makefile.in targets to be independent +-- Correct error return bug in gz_open() by setting state [Brown] +-- Put spaces before ;;'s in configure for better sh compatibility +-- Add pigz.c (parallel implementation of gzip) to examples/ +-- Correct constant in crc32.c to UL [Leventhal] +-- Reject negative lengths in crc32_combine() +-- Add inflateReset2() function to work like inflateEnd()/inflateInit2() +-- Include sys/types.h for _LARGEFILE64_SOURCE [Brown] +-- Correct typo in doc/algorithm.txt [Janik] +-- Fix bug in adler32_combine() [Zhu] +-- Catch missing-end-of-block-code error in all inflates and in puff +- Assures that random input to inflate eventually results in an error +-- Added enough.c (calculation of ENOUGH for inftrees.h) to examples/ +-- Update ENOUGH and its usage to reflect discovered bounds +-- Fix gzerror() error report on empty input file [Brown] +-- Add ush casts in trees.c to avoid pedantic runtime errors +-- Fix typo in zlib.h uncompress() description [Reiss] +-- Correct inflate() comments with regard to automatic header detection +-- Remove deprecation comment on Z_PARTIAL_FLUSH (it stays) +-- Put new version of gzlog (2.0) in examples with interruption recovery +-- Add puff compile option to permit invalid distance-too-far streams +-- Add puff TEST command options, ability to read piped input +-- Prototype the *64 functions in zlib.h when _FILE_OFFSET_BITS == 64, but +- _LARGEFILE64_SOURCE not defined +-- Fix Z_FULL_FLUSH to truly erase the past by resetting s->strstart +-- Fix deflateSetDictionary() to use all 32K for output consistency +-- Remove extraneous #define MIN_LOOKAHEAD in deflate.c (in deflate.h) +-- Clear bytes after deflate lookahead to avoid use of uninitialized data +-- Change a limit in inftrees.c to be more transparent to Coverity Prevent +-- Update win32/zlib.def with exported symbols from zlib.h +-- Correct spelling error in zlib.h [Willem] +-- Allow Z_BLOCK for deflate() to force a new block +-- Allow negative bits in inflatePrime() to delete existing bit buffer +-- Add Z_TREES flush option to inflate() to return at end of trees +-- Add inflateMark() to return current state information for random access +-- Add Makefile for NintendoDS to contrib [Costa] +-- Add -w in configure compile tests to avoid spurious warnings [Beucler] +-- Fix typos in zlib.h comments for deflateSetDictionary() +-- Fix EOF detection in transparent gzread() [Maier] +- +-Changes in 1.2.3.3 (2 October 2006) +-- Make --shared the default for configure, add a --static option +-- Add compile option to permit invalid distance-too-far streams +-- Add inflateUndermine() function which is required to enable above +-- Remove use of "this" variable name for C++ compatibility [Marquess] +-- Add testing of shared library in make test, if shared library built +-- Use ftello() and fseeko() if available instead of ftell() and fseek() +-- Provide two versions of all functions that use the z_off_t type for +- binary compatibility -- a normal version and a 64-bit offset version, +- per the Large File Support Extension when _LARGEFILE64_SOURCE is +- defined; use the 64-bit versions by default when _FILE_OFFSET_BITS +- is defined to be 64 +-- Add a --uname= option to configure to perhaps help with cross-compiling +- +-Changes in 1.2.3.2 (3 September 2006) +-- Turn off silly Borland warnings [Hay] +-- Use off64_t and define _LARGEFILE64_SOURCE when present +-- Fix missing dependency on inffixed.h in Makefile.in +-- Rig configure --shared to build both shared and static [Teredesai, Truta] +-- Remove zconf.in.h and instead create a new zlibdefs.h file +-- Fix contrib/minizip/unzip.c non-encrypted after encrypted [Vollant] +-- Add treebuild.xml (see http://treebuild.metux.de/) [Weigelt] +- +-Changes in 1.2.3.1 (16 August 2006) +-- Add watcom directory with OpenWatcom make files [Daniel] +-- Remove #undef of FAR in zconf.in.h for MVS [Fedtke] +-- Update make_vms.com [Zinser] +-- Use -fPIC for shared build in configure [Teredesai, Nicholson] +-- Use only major version number for libz.so on IRIX and OSF1 [Reinholdtsen] +-- Use fdopen() (not _fdopen()) for Interix in zutil.h [BŠck] +-- Add some FAQ entries about the contrib directory +-- Update the MVS question in the FAQ +-- Avoid extraneous reads after EOF in gzio.c [Brown] +-- Correct spelling of "successfully" in gzio.c [Randers-Pehrson] +-- Add comments to zlib.h about gzerror() usage [Brown] +-- Set extra flags in gzip header in gzopen() like deflate() does +-- Make configure options more compatible with double-dash conventions +- [Weigelt] +-- Clean up compilation under Solaris SunStudio cc [Rowe, Reinholdtsen] +-- Fix uninstall target in Makefile.in [Truta] +-- Add pkgconfig support [Weigelt] +-- Use $(DESTDIR) macro in Makefile.in [Reinholdtsen, Weigelt] +-- Replace set_data_type() with a more accurate detect_data_type() in +- trees.c, according to the txtvsbin.txt document [Truta] +-- Swap the order of #include and #include "zlib.h" in +- gzio.c, example.c and minigzip.c [Truta] +-- Shut up annoying VS2005 warnings about standard C deprecation [Rowe, +- Truta] (where?) +-- Fix target "clean" from win32/Makefile.bor [Truta] +-- Create .pdb and .manifest files in win32/makefile.msc [Ziegler, Rowe] +-- Update zlib www home address in win32/DLL_FAQ.txt [Truta] +-- Update contrib/masmx86/inffas32.asm for VS2005 [Vollant, Van Wassenhove] +-- Enable browse info in the "Debug" and "ASM Debug" configurations in +- the Visual C++ 6 project, and set (non-ASM) "Debug" as default [Truta] +-- Add pkgconfig support [Weigelt] +-- Add ZLIB_VER_MAJOR, ZLIB_VER_MINOR and ZLIB_VER_REVISION in zlib.h, +- for use in win32/zlib1.rc [Polushin, Rowe, Truta] +-- Add a document that explains the new text detection scheme to +- doc/txtvsbin.txt [Truta] +-- Add rfc1950.txt, rfc1951.txt and rfc1952.txt to doc/ [Truta] +-- Move algorithm.txt into doc/ [Truta] +-- Synchronize FAQ with website +-- Fix compressBound(), was low for some pathological cases [Fearnley] +-- Take into account wrapper variations in deflateBound() +-- Set examples/zpipe.c input and output to binary mode for Windows +-- Update examples/zlib_how.html with new zpipe.c (also web site) +-- Fix some warnings in examples/gzlog.c and examples/zran.c (it seems +- that gcc became pickier in 4.0) +-- Add zlib.map for Linux: "All symbols from zlib-1.1.4 remain +- un-versioned, the patch adds versioning only for symbols introduced in +- zlib-1.2.0 or later. It also declares as local those symbols which are +- not designed to be exported." [Levin] +-- Update Z_PREFIX list in zconf.in.h, add --zprefix option to configure +-- Do not initialize global static by default in trees.c, add a response +- NO_INIT_GLOBAL_POINTERS to initialize them if needed [Marquess] +-- Don't use strerror() in gzio.c under WinCE [Yakimov] +-- Don't use errno.h in zutil.h under WinCE [Yakimov] +-- Move arguments for AR to its usage to allow replacing ar [Marot] +-- Add HAVE_VISIBILITY_PRAGMA in zconf.in.h for Mozilla [Randers-Pehrson] +-- Improve inflateInit() and inflateInit2() documentation +-- Fix structure size comment in inflate.h +-- Change configure help option from --h* to --help [Santos] +- +-Changes in 1.2.3 (18 July 2005) +-- Apply security vulnerability fixes to contrib/infback9 as well +-- Clean up some text files (carriage returns, trailing space) +-- Update testzlib, vstudio, masmx64, and masmx86 in contrib [Vollant] +- +-Changes in 1.2.2.4 (11 July 2005) +-- Add inflatePrime() function for starting inflation at bit boundary +-- Avoid some Visual C warnings in deflate.c +-- Avoid more silly Visual C warnings in inflate.c and inftrees.c for 64-bit +- compile +-- Fix some spelling errors in comments [Betts] +-- Correct inflateInit2() error return documentation in zlib.h +-- Add zran.c example of compressed data random access to examples +- directory, shows use of inflatePrime() +-- Fix cast for assignments to strm->state in inflate.c and infback.c +-- Fix zlibCompileFlags() in zutil.c to use 1L for long shifts [Oberhumer] +-- Move declarations of gf2 functions to right place in crc32.c [Oberhumer] +-- Add cast in trees.c t avoid a warning [Oberhumer] +-- Avoid some warnings in fitblk.c, gun.c, gzjoin.c in examples [Oberhumer] +-- Update make_vms.com [Zinser] +-- Initialize state->write in inflateReset() since copied in inflate_fast() +-- Be more strict on incomplete code sets in inflate_table() and increase +- ENOUGH and MAXD -- this repairs a possible security vulnerability for +- invalid inflate input. Thanks to Tavis Ormandy and Markus Oberhumer for +- discovering the vulnerability and providing test cases. +-- Add ia64 support to configure for HP-UX [Smith] +-- Add error return to gzread() for format or i/o error [Levin] +-- Use malloc.h for OS/2 [Necasek] +- +-Changes in 1.2.2.3 (27 May 2005) +-- Replace 1U constants in inflate.c and inftrees.c for 64-bit compile +-- Typecast fread() return values in gzio.c [Vollant] +-- Remove trailing space in minigzip.c outmode (VC++ can't deal with it) +-- Fix crc check bug in gzread() after gzungetc() [Heiner] +-- Add the deflateTune() function to adjust internal compression parameters +-- Add a fast gzip decompressor, gun.c, to examples (use of inflateBack) +-- Remove an incorrect assertion in examples/zpipe.c +-- Add C++ wrapper in infback9.h [Donais] +-- Fix bug in inflateCopy() when decoding fixed codes +-- Note in zlib.h how much deflateSetDictionary() actually uses +-- Remove USE_DICT_HEAD in deflate.c (would mess up inflate if used) +-- Add _WIN32_WCE to define WIN32 in zconf.in.h [Spencer] +-- Don't include stderr.h or errno.h for _WIN32_WCE in zutil.h [Spencer] +-- Add gzdirect() function to indicate transparent reads +-- Update contrib/minizip [Vollant] +-- Fix compilation of deflate.c when both ASMV and FASTEST [Oberhumer] +-- Add casts in crc32.c to avoid warnings [Oberhumer] +-- Add contrib/masmx64 [Vollant] +-- Update contrib/asm586, asm686, masmx86, testzlib, vstudio [Vollant] +- +-Changes in 1.2.2.2 (30 December 2004) +-- Replace structure assignments in deflate.c and inflate.c with zmemcpy to +- avoid implicit memcpy calls (portability for no-library compilation) +-- Increase sprintf() buffer size in gzdopen() to allow for large numbers +-- Add INFLATE_STRICT to check distances against zlib header +-- Improve WinCE errno handling and comments [Chang] +-- Remove comment about no gzip header processing in FAQ +-- Add Z_FIXED strategy option to deflateInit2() to force fixed trees +-- Add updated make_vms.com [Coghlan], update README +-- Create a new "examples" directory, move gzappend.c there, add zpipe.c, +- fitblk.c, gzlog.[ch], gzjoin.c, and zlib_how.html. +-- Add FAQ entry and comments in deflate.c on uninitialized memory access +-- Add Solaris 9 make options in configure [Gilbert] +-- Allow strerror() usage in gzio.c for STDC +-- Fix DecompressBuf in contrib/delphi/ZLib.pas [ManChesTer] +-- Update contrib/masmx86/inffas32.asm and gvmat32.asm [Vollant] +-- Use z_off_t for adler32_combine() and crc32_combine() lengths +-- Make adler32() much faster for small len +-- Use OS_CODE in deflate() default gzip header +- +-Changes in 1.2.2.1 (31 October 2004) +-- Allow inflateSetDictionary() call for raw inflate +-- Fix inflate header crc check bug for file names and comments +-- Add deflateSetHeader() and gz_header structure for custom gzip headers +-- Add inflateGetheader() to retrieve gzip headers +-- Add crc32_combine() and adler32_combine() functions +-- Add alloc_func, free_func, in_func, out_func to Z_PREFIX list +-- Use zstreamp consistently in zlib.h (inflate_back functions) +-- Remove GUNZIP condition from definition of inflate_mode in inflate.h +- and in contrib/inflate86/inffast.S [Truta, Anderson] +-- Add support for AMD64 in contrib/inflate86/inffas86.c [Anderson] +-- Update projects/README.projects and projects/visualc6 [Truta] +-- Update win32/DLL_FAQ.txt [Truta] +-- Avoid warning under NO_GZCOMPRESS in gzio.c; fix typo [Truta] +-- Deprecate Z_ASCII; use Z_TEXT instead [Truta] +-- Use a new algorithm for setting strm->data_type in trees.c [Truta] +-- Do not define an exit() prototype in zutil.c unless DEBUG defined +-- Remove prototype of exit() from zutil.c, example.c, minigzip.c [Truta] +-- Add comment in zlib.h for Z_NO_FLUSH parameter to deflate() +-- Fix Darwin build version identification [Peterson] +- +-Changes in 1.2.2 (3 October 2004) +-- Update zlib.h comments on gzip in-memory processing +-- Set adler to 1 in inflateReset() to support Java test suite [Walles] +-- Add contrib/dotzlib [Ravn] +-- Update win32/DLL_FAQ.txt [Truta] +-- Update contrib/minizip [Vollant] +-- Move contrib/visual-basic.txt to old/ [Truta] +-- Fix assembler builds in projects/visualc6/ [Truta] +- +-Changes in 1.2.1.2 (9 September 2004) +-- Update INDEX file +-- Fix trees.c to update strm->data_type (no one ever noticed!) +-- Fix bug in error case in inflate.c, infback.c, and infback9.c [Brown] +-- Add "volatile" to crc table flag declaration (for DYNAMIC_CRC_TABLE) +-- Add limited multitasking protection to DYNAMIC_CRC_TABLE +-- Add NO_vsnprintf for VMS in zutil.h [Mozilla] +-- Don't declare strerror() under VMS [Mozilla] +-- Add comment to DYNAMIC_CRC_TABLE to use get_crc_table() to initialize +-- Update contrib/ada [Anisimkov] +-- Update contrib/minizip [Vollant] +-- Fix configure to not hardcode directories for Darwin [Peterson] +-- Fix gzio.c to not return error on empty files [Brown] +-- Fix indentation; update version in contrib/delphi/ZLib.pas and +- contrib/pascal/zlibpas.pas [Truta] +-- Update mkasm.bat in contrib/masmx86 [Truta] +-- Update contrib/untgz [Truta] +-- Add projects/README.projects [Truta] +-- Add project for MS Visual C++ 6.0 in projects/visualc6 [Cadieux, Truta] +-- Update win32/DLL_FAQ.txt [Truta] +-- Update list of Z_PREFIX symbols in zconf.h [Randers-Pehrson, Truta] +-- Remove an unnecessary assignment to curr in inftrees.c [Truta] +-- Add OS/2 to exe builds in configure [Poltorak] +-- Remove err dummy parameter in zlib.h [Kientzle] +- +-Changes in 1.2.1.1 (9 January 2004) +-- Update email address in README +-- Several FAQ updates +-- Fix a big fat bug in inftrees.c that prevented decoding valid +- dynamic blocks with only literals and no distance codes -- +- Thanks to "Hot Emu" for the bug report and sample file +-- Add a note to puff.c on no distance codes case. +- +-Changes in 1.2.1 (17 November 2003) +-- Remove a tab in contrib/gzappend/gzappend.c +-- Update some interfaces in contrib for new zlib functions +-- Update zlib version number in some contrib entries +-- Add Windows CE definition for ptrdiff_t in zutil.h [Mai, Truta] +-- Support shared libraries on Hurd and KFreeBSD [Brown] +-- Fix error in NO_DIVIDE option of adler32.c +- +-Changes in 1.2.0.8 (4 November 2003) +-- Update version in contrib/delphi/ZLib.pas and contrib/pascal/zlibpas.pas +-- Add experimental NO_DIVIDE #define in adler32.c +- - Possibly faster on some processors (let me know if it is) +-- Correct Z_BLOCK to not return on first inflate call if no wrap +-- Fix strm->data_type on inflate() return to correctly indicate EOB +-- Add deflatePrime() function for appending in the middle of a byte +-- Add contrib/gzappend for an example of appending to a stream +-- Update win32/DLL_FAQ.txt [Truta] +-- Delete Turbo C comment in README [Truta] +-- Improve some indentation in zconf.h [Truta] +-- Fix infinite loop on bad input in configure script [Church] +-- Fix gzeof() for concatenated gzip files [Johnson] +-- Add example to contrib/visual-basic.txt [Michael B.] +-- Add -p to mkdir's in Makefile.in [vda] +-- Fix configure to properly detect presence or lack of printf functions +-- Add AS400 support [Monnerat] +-- Add a little Cygwin support [Wilson] +- +-Changes in 1.2.0.7 (21 September 2003) +-- Correct some debug formats in contrib/infback9 +-- Cast a type in a debug statement in trees.c +-- Change search and replace delimiter in configure from % to # [Beebe] +-- Update contrib/untgz to 0.2 with various fixes [Truta] +-- Add build support for Amiga [Nikl] +-- Remove some directories in old that have been updated to 1.2 +-- Add dylib building for Mac OS X in configure and Makefile.in +-- Remove old distribution stuff from Makefile +-- Update README to point to DLL_FAQ.txt, and add comment on Mac OS X +-- Update links in README +- +-Changes in 1.2.0.6 (13 September 2003) +-- Minor FAQ updates +-- Update contrib/minizip to 1.00 [Vollant] +-- Remove test of gz functions in example.c when GZ_COMPRESS defined [Truta] +-- Update POSTINC comment for 68060 [Nikl] +-- Add contrib/infback9 with deflate64 decoding (unsupported) +-- For MVS define NO_vsnprintf and undefine FAR [van Burik] +-- Add pragma for fdopen on MVS [van Burik] +- +-Changes in 1.2.0.5 (8 September 2003) +-- Add OF to inflateBackEnd() declaration in zlib.h +-- Remember start when using gzdopen in the middle of a file +-- Use internal off_t counters in gz* functions to properly handle seeks +-- Perform more rigorous check for distance-too-far in inffast.c +-- Add Z_BLOCK flush option to return from inflate at block boundary +-- Set strm->data_type on return from inflate +- - Indicate bits unused, if at block boundary, and if in last block +-- Replace size_t with ptrdiff_t in crc32.c, and check for correct size +-- Add condition so old NO_DEFLATE define still works for compatibility +-- FAQ update regarding the Windows DLL [Truta] +-- INDEX update: add qnx entry, remove aix entry [Truta] +-- Install zlib.3 into mandir [Wilson] +-- Move contrib/zlib_dll_FAQ.txt to win32/DLL_FAQ.txt; update [Truta] +-- Adapt the zlib interface to the new DLL convention guidelines [Truta] +-- Introduce ZLIB_WINAPI macro to allow the export of functions using +- the WINAPI calling convention, for Visual Basic [Vollant, Truta] +-- Update msdos and win32 scripts and makefiles [Truta] +-- Export symbols by name, not by ordinal, in win32/zlib.def [Truta] +-- Add contrib/ada [Anisimkov] +-- Move asm files from contrib/vstudio/vc70_32 to contrib/asm386 [Truta] +-- Rename contrib/asm386 to contrib/masmx86 [Truta, Vollant] +-- Add contrib/masm686 [Truta] +-- Fix offsets in contrib/inflate86 and contrib/masmx86/inffas32.asm +- [Truta, Vollant] +-- Update contrib/delphi; rename to contrib/pascal; add example [Truta] +-- Remove contrib/delphi2; add a new contrib/delphi [Truta] +-- Avoid inclusion of the nonstandard in contrib/iostream, +- and fix some method prototypes [Truta] +-- Fix the ZCR_SEED2 constant to avoid warnings in contrib/minizip +- [Truta] +-- Avoid the use of backslash (\) in contrib/minizip [Vollant] +-- Fix file time handling in contrib/untgz; update makefiles [Truta] +-- Update contrib/vstudio/vc70_32 to comply with the new DLL guidelines +- [Vollant] +-- Remove contrib/vstudio/vc15_16 [Vollant] +-- Rename contrib/vstudio/vc70_32 to contrib/vstudio/vc7 [Truta] +-- Update README.contrib [Truta] +-- Invert the assignment order of match_head and s->prev[...] in +- INSERT_STRING [Truta] +-- Compare TOO_FAR with 32767 instead of 32768, to avoid 16-bit warnings +- [Truta] +-- Compare function pointers with 0, not with NULL or Z_NULL [Truta] +-- Fix prototype of syncsearch in inflate.c [Truta] +-- Introduce ASMINF macro to be enabled when using an ASM implementation +- of inflate_fast [Truta] +-- Change NO_DEFLATE to NO_GZCOMPRESS [Truta] +-- Modify test_gzio in example.c to take a single file name as a +- parameter [Truta] +-- Exit the example.c program if gzopen fails [Truta] +-- Add type casts around strlen in example.c [Truta] +-- Remove casting to sizeof in minigzip.c; give a proper type +- to the variable compared with SUFFIX_LEN [Truta] +-- Update definitions of STDC and STDC99 in zconf.h [Truta] +-- Synchronize zconf.h with the new Windows DLL interface [Truta] +-- Use SYS16BIT instead of __32BIT__ to distinguish between +- 16- and 32-bit platforms [Truta] +-- Use far memory allocators in small 16-bit memory models for +- Turbo C [Truta] +-- Add info about the use of ASMV, ASMINF and ZLIB_WINAPI in +- zlibCompileFlags [Truta] +-- Cygwin has vsnprintf [Wilson] +-- In Windows16, OS_CODE is 0, as in MSDOS [Truta] +-- In Cygwin, OS_CODE is 3 (Unix), not 11 (Windows32) [Wilson] +- +-Changes in 1.2.0.4 (10 August 2003) +-- Minor FAQ updates +-- Be more strict when checking inflateInit2's windowBits parameter +-- Change NO_GUNZIP compile option to NO_GZIP to cover deflate as well +-- Add gzip wrapper option to deflateInit2 using windowBits +-- Add updated QNX rule in configure and qnx directory [Bonnefoy] +-- Make inflate distance-too-far checks more rigorous +-- Clean up FAR usage in inflate +-- Add casting to sizeof() in gzio.c and minigzip.c +- +-Changes in 1.2.0.3 (19 July 2003) +-- Fix silly error in gzungetc() implementation [Vollant] +-- Update contrib/minizip and contrib/vstudio [Vollant] +-- Fix printf format in example.c +-- Correct cdecl support in zconf.in.h [Anisimkov] +-- Minor FAQ updates +- +-Changes in 1.2.0.2 (13 July 2003) +-- Add ZLIB_VERNUM in zlib.h for numerical preprocessor comparisons +-- Attempt to avoid warnings in crc32.c for pointer-int conversion +-- Add AIX to configure, remove aix directory [Bakker] +-- Add some casts to minigzip.c +-- Improve checking after insecure sprintf() or vsprintf() calls +-- Remove #elif's from crc32.c +-- Change leave label to inf_leave in inflate.c and infback.c to avoid +- library conflicts +-- Remove inflate gzip decoding by default--only enable gzip decoding by +- special request for stricter backward compatibility +-- Add zlibCompileFlags() function to return compilation information +-- More typecasting in deflate.c to avoid warnings +-- Remove leading underscore from _Capital #defines [Truta] +-- Fix configure to link shared library when testing +-- Add some Windows CE target adjustments [Mai] +-- Remove #define ZLIB_DLL in zconf.h [Vollant] +-- Add zlib.3 [Rodgers] +-- Update RFC URL in deflate.c and algorithm.txt [Mai] +-- Add zlib_dll_FAQ.txt to contrib [Truta] +-- Add UL to some constants [Truta] +-- Update minizip and vstudio [Vollant] +-- Remove vestigial NEED_DUMMY_RETURN from zconf.in.h +-- Expand use of NO_DUMMY_DECL to avoid all dummy structures +-- Added iostream3 to contrib [Schwardt] +-- Replace rewind() with fseek() for WinCE [Truta] +-- Improve setting of zlib format compression level flags +- - Report 0 for huffman and rle strategies and for level == 0 or 1 +- - Report 2 only for level == 6 +-- Only deal with 64K limit when necessary at compile time [Truta] +-- Allow TOO_FAR check to be turned off at compile time [Truta] +-- Add gzclearerr() function [Souza] +-- Add gzungetc() function +- +-Changes in 1.2.0.1 (17 March 2003) +-- Add Z_RLE strategy for run-length encoding [Truta] +- - When Z_RLE requested, restrict matches to distance one +- - Update zlib.h, minigzip.c, gzopen(), gzdopen() for Z_RLE +-- Correct FASTEST compilation to allow level == 0 +-- Clean up what gets compiled for FASTEST +-- Incorporate changes to zconf.in.h [Vollant] +- - Refine detection of Turbo C need for dummy returns +- - Refine ZLIB_DLL compilation +- - Include additional header file on VMS for off_t typedef +-- Try to use _vsnprintf where it supplants vsprintf [Vollant] +-- Add some casts in inffast.c +-- Enchance comments in zlib.h on what happens if gzprintf() tries to +- write more than 4095 bytes before compression +-- Remove unused state from inflateBackEnd() +-- Remove exit(0) from minigzip.c, example.c +-- Get rid of all those darn tabs +-- Add "check" target to Makefile.in that does the same thing as "test" +-- Add "mostlyclean" and "maintainer-clean" targets to Makefile.in +-- Update contrib/inflate86 [Anderson] +-- Update contrib/testzlib, contrib/vstudio, contrib/minizip [Vollant] +-- Add msdos and win32 directories with makefiles [Truta] +-- More additions and improvements to the FAQ +- +-Changes in 1.2.0 (9 March 2003) +-- New and improved inflate code +- - About 20% faster +- - Does not allocate 32K window unless and until needed +- - Automatically detects and decompresses gzip streams +- - Raw inflate no longer needs an extra dummy byte at end +- - Added inflateBack functions using a callback interface--even faster +- than inflate, useful for file utilities (gzip, zip) +- - Added inflateCopy() function to record state for random access on +- externally generated deflate streams (e.g. in gzip files) +- - More readable code (I hope) +-- New and improved crc32() +- - About 50% faster, thanks to suggestions from Rodney Brown +-- Add deflateBound() and compressBound() functions +-- Fix memory leak in deflateInit2() +-- Permit setting dictionary for raw deflate (for parallel deflate) +-- Fix const declaration for gzwrite() +-- Check for some malloc() failures in gzio.c +-- Fix bug in gzopen() on single-byte file 0x1f +-- Fix bug in gzread() on concatenated file with 0x1f at end of buffer +- and next buffer doesn't start with 0x8b +-- Fix uncompress() to return Z_DATA_ERROR on truncated input +-- Free memory at end of example.c +-- Remove MAX #define in trees.c (conflicted with some libraries) +-- Fix static const's in deflate.c, gzio.c, and zutil.[ch] +-- Declare malloc() and free() in gzio.c if STDC not defined +-- Use malloc() instead of calloc() in zutil.c if int big enough +-- Define STDC for AIX +-- Add aix/ with approach for compiling shared library on AIX +-- Add HP-UX support for shared libraries in configure +-- Add OpenUNIX support for shared libraries in configure +-- Use $cc instead of gcc to build shared library +-- Make prefix directory if needed when installing +-- Correct Macintosh avoidance of typedef Byte in zconf.h +-- Correct Turbo C memory allocation when under Linux +-- Use libz.a instead of -lz in Makefile (assure use of compiled library) +-- Update configure to check for snprintf or vsnprintf functions and their +- return value, warn during make if using an insecure function +-- Fix configure problem with compile-time knowledge of HAVE_UNISTD_H that +- is lost when library is used--resolution is to build new zconf.h +-- Documentation improvements (in zlib.h): +- - Document raw deflate and inflate +- - Update RFCs URL +- - Point out that zlib and gzip formats are different +- - Note that Z_BUF_ERROR is not fatal +- - Document string limit for gzprintf() and possible buffer overflow +- - Note requirement on avail_out when flushing +- - Note permitted values of flush parameter of inflate() +-- Add some FAQs (and even answers) to the FAQ +-- Add contrib/inflate86/ for x86 faster inflate +-- Add contrib/blast/ for PKWare Data Compression Library decompression +-- Add contrib/puff/ simple inflate for deflate format description +- +-Changes in 1.1.4 (11 March 2002) +-- ZFREE was repeated on same allocation on some error conditions. +- This creates a security problem described in +- http://www.zlib.org/advisory-2002-03-11.txt +-- Returned incorrect error (Z_MEM_ERROR) on some invalid data +-- Avoid accesses before window for invalid distances with inflate window +- less than 32K. +-- force windowBits > 8 to avoid a bug in the encoder for a window size +- of 256 bytes. (A complete fix will be available in 1.1.5). +- +-Changes in 1.1.3 (9 July 1998) +-- fix "an inflate input buffer bug that shows up on rare but persistent +- occasions" (Mark) +-- fix gzread and gztell for concatenated .gz files (Didier Le Botlan) +-- fix gzseek(..., SEEK_SET) in write mode +-- fix crc check after a gzeek (Frank Faubert) +-- fix miniunzip when the last entry in a zip file is itself a zip file +- (J Lillge) +-- add contrib/asm586 and contrib/asm686 (Brian Raiter) +- See http://www.muppetlabs.com/~breadbox/software/assembly.html +-- add support for Delphi 3 in contrib/delphi (Bob Dellaca) +-- add support for C++Builder 3 and Delphi 3 in contrib/delphi2 (Davide Moretti) +-- do not exit prematurely in untgz if 0 at start of block (Magnus Holmgren) +-- use macro EXTERN instead of extern to support DLL for BeOS (Sander Stoks) +-- added a FAQ file +- +-- Support gzdopen on Mac with Metrowerks (Jason Linhart) +-- Do not redefine Byte on Mac (Brad Pettit & Jason Linhart) +-- define SEEK_END too if SEEK_SET is not defined (Albert Chin-A-Young) +-- avoid some warnings with Borland C (Tom Tanner) +-- fix a problem in contrib/minizip/zip.c for 16-bit MSDOS (Gilles Vollant) +-- emulate utime() for WIN32 in contrib/untgz (Gilles Vollant) +-- allow several arguments to configure (Tim Mooney, Frodo Looijaard) +-- use libdir and includedir in Makefile.in (Tim Mooney) +-- support shared libraries on OSF1 V4 (Tim Mooney) +-- remove so_locations in "make clean" (Tim Mooney) +-- fix maketree.c compilation error (Glenn, Mark) +-- Python interface to zlib now in Python 1.5 (Jeremy Hylton) +-- new Makefile.riscos (Rich Walker) +-- initialize static descriptors in trees.c for embedded targets (Nick Smith) +-- use "foo-gz" in example.c for RISCOS and VMS (Nick Smith) +-- add the OS/2 files in Makefile.in too (Andrew Zabolotny) +-- fix fdopen and halloc macros for Microsoft C 6.0 (Tom Lane) +-- fix maketree.c to allow clean compilation of inffixed.h (Mark) +-- fix parameter check in deflateCopy (Gunther Nikl) +-- cleanup trees.c, use compressed_len only in debug mode (Christian Spieler) +-- Many portability patches by Christian Spieler: +- . zutil.c, zutil.h: added "const" for zmem* +- . Make_vms.com: fixed some typos +- . Make_vms.com: msdos/Makefile.*: removed zutil.h from some dependency lists +- . msdos/Makefile.msc: remove "default rtl link library" info from obj files +- . msdos/Makefile.*: use model-dependent name for the built zlib library +- . msdos/Makefile.emx, nt/Makefile.emx, nt/Makefile.gcc: +- new makefiles, for emx (DOS/OS2), emx&rsxnt and mingw32 (Windows 9x / NT) +-- use define instead of typedef for Bytef also for MSC small/medium (Tom Lane) +-- replace __far with _far for better portability (Christian Spieler, Tom Lane) +-- fix test for errno.h in configure (Tim Newsham) +- +-Changes in 1.1.2 (19 March 98) +-- added contrib/minzip, mini zip and unzip based on zlib (Gilles Vollant) +- See http://www.winimage.com/zLibDll/unzip.html +-- preinitialize the inflate tables for fixed codes, to make the code +- completely thread safe (Mark) +-- some simplifications and slight speed-up to the inflate code (Mark) +-- fix gzeof on non-compressed files (Allan Schrum) +-- add -std1 option in configure for OSF1 to fix gzprintf (Martin Mokrejs) +-- use default value of 4K for Z_BUFSIZE for 16-bit MSDOS (Tim Wegner + Glenn) +-- added os2/Makefile.def and os2/zlib.def (Andrew Zabolotny) +-- add shared lib support for UNIX_SV4.2MP (MATSUURA Takanori) +-- do not wrap extern "C" around system includes (Tom Lane) +-- mention zlib binding for TCL in README (Andreas Kupries) +-- added amiga/Makefile.pup for Amiga powerUP SAS/C PPC (Andreas Kleinert) +-- allow "make install prefix=..." even after configure (Glenn Randers-Pehrson) +-- allow "configure --prefix $HOME" (Tim Mooney) +-- remove warnings in example.c and gzio.c (Glenn Randers-Pehrson) +-- move Makefile.sas to amiga/Makefile.sas +- +-Changes in 1.1.1 (27 Feb 98) +-- fix macros _tr_tally_* in deflate.h for debug mode (Glenn Randers-Pehrson) +-- remove block truncation heuristic which had very marginal effect for zlib +- (smaller lit_bufsize than in gzip 1.2.4) and degraded a little the +- compression ratio on some files. This also allows inlining _tr_tally for +- matches in deflate_slow. +-- added msdos/Makefile.w32 for WIN32 Microsoft Visual C++ (Bob Frazier) +- +-Changes in 1.1.0 (24 Feb 98) +-- do not return STREAM_END prematurely in inflate (John Bowler) +-- revert to the zlib 1.0.8 inflate to avoid the gcc 2.8.0 bug (Jeremy Buhler) +-- compile with -DFASTEST to get compression code optimized for speed only +-- in minigzip, try mmap'ing the input file first (Miguel Albrecht) +-- increase size of I/O buffers in minigzip.c and gzio.c (not a big gain +- on Sun but significant on HP) +- +-- add a pointer to experimental unzip library in README (Gilles Vollant) +-- initialize variable gcc in configure (Chris Herborth) +- +-Changes in 1.0.9 (17 Feb 1998) +-- added gzputs and gzgets functions +-- do not clear eof flag in gzseek (Mark Diekhans) +-- fix gzseek for files in transparent mode (Mark Diekhans) +-- do not assume that vsprintf returns the number of bytes written (Jens Krinke) +-- replace EXPORT with ZEXPORT to avoid conflict with other programs +-- added compress2 in zconf.h, zlib.def, zlib.dnt +-- new asm code from Gilles Vollant in contrib/asm386 +-- simplify the inflate code (Mark): +- . Replace ZALLOC's in huft_build() with single ZALLOC in inflate_blocks_new() +- . ZALLOC the length list in inflate_trees_fixed() instead of using stack +- . ZALLOC the value area for huft_build() instead of using stack +- . Simplify Z_FINISH check in inflate() +- +-- Avoid gcc 2.8.0 comparison bug a little differently than zlib 1.0.8 +-- in inftrees.c, avoid cc -O bug on HP (Farshid Elahi) +-- in zconf.h move the ZLIB_DLL stuff earlier to avoid problems with +- the declaration of FAR (Gilles VOllant) +-- install libz.so* with mode 755 (executable) instead of 644 (Marc Lehmann) +-- read_buf buf parameter of type Bytef* instead of charf* +-- zmemcpy parameters are of type Bytef*, not charf* (Joseph Strout) +-- do not redeclare unlink in minigzip.c for WIN32 (John Bowler) +-- fix check for presence of directories in "make install" (Ian Willis) +- +-Changes in 1.0.8 (27 Jan 1998) +-- fixed offsets in contrib/asm386/gvmat32.asm (Gilles Vollant) +-- fix gzgetc and gzputc for big endian systems (Markus Oberhumer) +-- added compress2() to allow setting the compression level +-- include sys/types.h to get off_t on some systems (Marc Lehmann & QingLong) +-- use constant arrays for the static trees in trees.c instead of computing +- them at run time (thanks to Ken Raeburn for this suggestion). To create +- trees.h, compile with GEN_TREES_H and run "make test". +-- check return code of example in "make test" and display result +-- pass minigzip command line options to file_compress +-- simplifying code of inflateSync to avoid gcc 2.8 bug +- +-- support CC="gcc -Wall" in configure -s (QingLong) +-- avoid a flush caused by ftell in gzopen for write mode (Ken Raeburn) +-- fix test for shared library support to avoid compiler warnings +-- zlib.lib -> zlib.dll in msdos/zlib.rc (Gilles Vollant) +-- check for TARGET_OS_MAC in addition to MACOS (Brad Pettit) +-- do not use fdopen for Metrowerks on Mac (Brad Pettit)) +-- add checks for gzputc and gzputc in example.c +-- avoid warnings in gzio.c and deflate.c (Andreas Kleinert) +-- use const for the CRC table (Ken Raeburn) +-- fixed "make uninstall" for shared libraries +-- use Tracev instead of Trace in infblock.c +-- in example.c use correct compressed length for test_sync +-- suppress +vnocompatwarnings in configure for HPUX (not always supported) +- +-Changes in 1.0.7 (20 Jan 1998) +-- fix gzseek which was broken in write mode +-- return error for gzseek to negative absolute position +-- fix configure for Linux (Chun-Chung Chen) +-- increase stack space for MSC (Tim Wegner) +-- get_crc_table and inflateSyncPoint are EXPORTed (Gilles Vollant) +-- define EXPORTVA for gzprintf (Gilles Vollant) +-- added man page zlib.3 (Rick Rodgers) +-- for contrib/untgz, fix makedir() and improve Makefile +- +-- check gzseek in write mode in example.c +-- allocate extra buffer for seeks only if gzseek is actually called +-- avoid signed/unsigned comparisons (Tim Wegner, Gilles Vollant) +-- add inflateSyncPoint in zconf.h +-- fix list of exported functions in nt/zlib.dnt and mdsos/zlib.def +- +-Changes in 1.0.6 (19 Jan 1998) +-- add functions gzprintf, gzputc, gzgetc, gztell, gzeof, gzseek, gzrewind and +- gzsetparams (thanks to Roland Giersig and Kevin Ruland for some of this code) +-- Fix a deflate bug occurring only with compression level 0 (thanks to +- Andy Buckler for finding this one). +-- In minigzip, pass transparently also the first byte for .Z files. +-- return Z_BUF_ERROR instead of Z_OK if output buffer full in uncompress() +-- check Z_FINISH in inflate (thanks to Marc Schluper) +-- Implement deflateCopy (thanks to Adam Costello) +-- make static libraries by default in configure, add --shared option. +-- move MSDOS or Windows specific files to directory msdos +-- suppress the notion of partial flush to simplify the interface +- (but the symbol Z_PARTIAL_FLUSH is kept for compatibility with 1.0.4) +-- suppress history buffer provided by application to simplify the interface +- (this feature was not implemented anyway in 1.0.4) +-- next_in and avail_in must be initialized before calling inflateInit or +- inflateInit2 +-- add EXPORT in all exported functions (for Windows DLL) +-- added Makefile.nt (thanks to Stephen Williams) +-- added the unsupported "contrib" directory: +- contrib/asm386/ by Gilles Vollant +- 386 asm code replacing longest_match(). +- contrib/iostream/ by Kevin Ruland +- A C++ I/O streams interface to the zlib gz* functions +- contrib/iostream2/ by Tyge Løvset +- Another C++ I/O streams interface +- contrib/untgz/ by "Pedro A. Aranda Guti\irrez" +- A very simple tar.gz file extractor using zlib +- contrib/visual-basic.txt by Carlos Rios +- How to use compress(), uncompress() and the gz* functions from VB. +-- pass params -f (filtered data), -h (huffman only), -1 to -9 (compression +- level) in minigzip (thanks to Tom Lane) +- +-- use const for rommable constants in deflate +-- added test for gzseek and gztell in example.c +-- add undocumented function inflateSyncPoint() (hack for Paul Mackerras) +-- add undocumented function zError to convert error code to string +- (for Tim Smithers) +-- Allow compilation of gzio with -DNO_DEFLATE to avoid the compression code. +-- Use default memcpy for Symantec MSDOS compiler. +-- Add EXPORT keyword for check_func (needed for Windows DLL) +-- add current directory to LD_LIBRARY_PATH for "make test" +-- create also a link for libz.so.1 +-- added support for FUJITSU UXP/DS (thanks to Toshiaki Nomura) +-- use $(SHAREDLIB) instead of libz.so in Makefile.in (for HPUX) +-- added -soname for Linux in configure (Chun-Chung Chen, +-- assign numbers to the exported functions in zlib.def (for Windows DLL) +-- add advice in zlib.h for best usage of deflateSetDictionary +-- work around compiler bug on Atari (cast Z_NULL in call of s->checkfn) +-- allow compilation with ANSI keywords only enabled for TurboC in large model +-- avoid "versionString"[0] (Borland bug) +-- add NEED_DUMMY_RETURN for Borland +-- use variable z_verbose for tracing in debug mode (L. Peter Deutsch). +-- allow compilation with CC +-- defined STDC for OS/2 (David Charlap) +-- limit external names to 8 chars for MVS (Thomas Lund) +-- in minigzip.c, use static buffers only for 16-bit systems +-- fix suffix check for "minigzip -d foo.gz" +-- do not return an error for the 2nd of two consecutive gzflush() (Felix Lee) +-- use _fdopen instead of fdopen for MSC >= 6.0 (Thomas Fanslau) +-- added makelcc.bat for lcc-win32 (Tom St Denis) +-- in Makefile.dj2, use copy and del instead of install and rm (Frank Donahoe) +-- Avoid expanded $Id$. Use "rcs -kb" or "cvs admin -kb" to avoid Id expansion. +-- check for unistd.h in configure (for off_t) +-- remove useless check parameter in inflate_blocks_free +-- avoid useless assignment of s->check to itself in inflate_blocks_new +-- do not flush twice in gzclose (thanks to Ken Raeburn) +-- rename FOPEN as F_OPEN to avoid clash with /usr/include/sys/file.h +-- use NO_ERRNO_H instead of enumeration of operating systems with errno.h +-- work around buggy fclose on pipes for HP/UX +-- support zlib DLL with BORLAND C++ 5.0 (thanks to Glenn Randers-Pehrson) +-- fix configure if CC is already equal to gcc +- +-Changes in 1.0.5 (3 Jan 98) +-- Fix inflate to terminate gracefully when fed corrupted or invalid data +-- Use const for rommable constants in inflate +-- Eliminate memory leaks on error conditions in inflate +-- Removed some vestigial code in inflate +-- Update web address in README +- +-Changes in 1.0.4 (24 Jul 96) +-- In very rare conditions, deflate(s, Z_FINISH) could fail to produce an EOF +- bit, so the decompressor could decompress all the correct data but went +- on to attempt decompressing extra garbage data. This affected minigzip too. +-- zlibVersion and gzerror return const char* (needed for DLL) +-- port to RISCOS (no fdopen, no multiple dots, no unlink, no fileno) +-- use z_error only for DEBUG (avoid problem with DLLs) +- +-Changes in 1.0.3 (2 Jul 96) +-- use z_streamp instead of z_stream *, which is now a far pointer in MSDOS +- small and medium models; this makes the library incompatible with previous +- versions for these models. (No effect in large model or on other systems.) +-- return OK instead of BUF_ERROR if previous deflate call returned with +- avail_out as zero but there is nothing to do +-- added memcmp for non STDC compilers +-- define NO_DUMMY_DECL for more Mac compilers (.h files merged incorrectly) +-- define __32BIT__ if __386__ or i386 is defined (pb. with Watcom and SCO) +-- better check for 16-bit mode MSC (avoids problem with Symantec) +- +-Changes in 1.0.2 (23 May 96) +-- added Windows DLL support +-- added a function zlibVersion (for the DLL support) +-- fixed declarations using Bytef in infutil.c (pb with MSDOS medium model) +-- Bytef is define's instead of typedef'd only for Borland C +-- avoid reading uninitialized memory in example.c +-- mention in README that the zlib format is now RFC1950 +-- updated Makefile.dj2 +-- added algorithm.doc +- +-Changes in 1.0.1 (20 May 96) [1.0 skipped to avoid confusion] +-- fix array overlay in deflate.c which sometimes caused bad compressed data +-- fix inflate bug with empty stored block +-- fix MSDOS medium model which was broken in 0.99 +-- fix deflateParams() which could generated bad compressed data. +-- Bytef is define'd instead of typedef'ed (work around Borland bug) +-- added an INDEX file +-- new makefiles for DJGPP (Makefile.dj2), 32-bit Borland (Makefile.b32), +- Watcom (Makefile.wat), Amiga SAS/C (Makefile.sas) +-- speed up adler32 for modern machines without auto-increment +-- added -ansi for IRIX in configure +-- static_init_done in trees.c is an int +-- define unlink as delete for VMS +-- fix configure for QNX +-- add configure branch for SCO and HPUX +-- avoid many warnings (unused variables, dead assignments, etc...) +-- no fdopen for BeOS +-- fix the Watcom fix for 32 bit mode (define FAR as empty) +-- removed redefinition of Byte for MKWERKS +-- work around an MWKERKS bug (incorrect merge of all .h files) +- +-Changes in 0.99 (27 Jan 96) +-- allow preset dictionary shared between compressor and decompressor +-- allow compression level 0 (no compression) +-- add deflateParams in zlib.h: allow dynamic change of compression level +- and compression strategy. +-- test large buffers and deflateParams in example.c +-- add optional "configure" to build zlib as a shared library +-- suppress Makefile.qnx, use configure instead +-- fixed deflate for 64-bit systems (detected on Cray) +-- fixed inflate_blocks for 64-bit systems (detected on Alpha) +-- declare Z_DEFLATED in zlib.h (possible parameter for deflateInit2) +-- always return Z_BUF_ERROR when deflate() has nothing to do +-- deflateInit and inflateInit are now macros to allow version checking +-- prefix all global functions and types with z_ with -DZ_PREFIX +-- make falloc completely reentrant (inftrees.c) +-- fixed very unlikely race condition in ct_static_init +-- free in reverse order of allocation to help memory manager +-- use zlib-1.0/* instead of zlib/* inside the tar.gz +-- make zlib warning-free with "gcc -O3 -Wall -Wwrite-strings -Wpointer-arith +- -Wconversion -Wstrict-prototypes -Wmissing-prototypes" +-- allow gzread on concatenated .gz files +-- deflateEnd now returns Z_DATA_ERROR if it was premature +-- deflate is finally (?) fully deterministic (no matches beyond end of input) +-- Document Z_SYNC_FLUSH +-- add uninstall in Makefile +-- Check for __cpluplus in zlib.h +-- Better test in ct_align for partial flush +-- avoid harmless warnings for Borland C++ +-- initialize hash_head in deflate.c +-- avoid warning on fdopen (gzio.c) for HP cc -Aa +-- include stdlib.h for STDC compilers +-- include errno.h for Cray +-- ignore error if ranlib doesn't exist +-- call ranlib twice for NeXTSTEP +-- use exec_prefix instead of prefix for libz.a +-- renamed ct_* as _tr_* to avoid conflict with applications +-- clear z->msg in inflateInit2 before any error return +-- initialize opaque in example.c, gzio.c, deflate.c and inflate.c +-- fixed typo in zconf.h (_GNUC__ => __GNUC__) +-- check for WIN32 in zconf.h and zutil.c (avoid farmalloc in 32-bit mode) +-- fix typo in Make_vms.com (f$trnlnm -> f$getsyi) +-- in fcalloc, normalize pointer if size > 65520 bytes +-- don't use special fcalloc for 32 bit Borland C++ +-- use STDC instead of __GO32__ to avoid redeclaring exit, calloc, etc... +-- use Z_BINARY instead of BINARY +-- document that gzclose after gzdopen will close the file +-- allow "a" as mode in gzopen. +-- fix error checking in gzread +-- allow skipping .gz extra-field on pipes +-- added reference to Perl interface in README +-- put the crc table in FAR data (I dislike more and more the medium model :) +-- added get_crc_table +-- added a dimension to all arrays (Borland C can't count). +-- workaround Borland C bug in declaration of inflate_codes_new & inflate_fast +-- guard against multiple inclusion of *.h (for precompiled header on Mac) +-- Watcom C pretends to be Microsoft C small model even in 32 bit mode. +-- don't use unsized arrays to avoid silly warnings by Visual C++: +- warning C4746: 'inflate_mask' : unsized array treated as '__far' +- (what's wrong with far data in far model?). +-- define enum out of inflate_blocks_state to allow compilation with C++ +- +-Changes in 0.95 (16 Aug 95) +-- fix MSDOS small and medium model (now easier to adapt to any compiler) +-- inlined send_bits +-- fix the final (:-) bug for deflate with flush (output was correct but +- not completely flushed in rare occasions). +-- default window size is same for compression and decompression +- (it's now sufficient to set MAX_WBITS in zconf.h). +-- voidp -> voidpf and voidnp -> voidp (for consistency with other +- typedefs and because voidnp was not near in large model). +- +-Changes in 0.94 (13 Aug 95) +-- support MSDOS medium model +-- fix deflate with flush (could sometimes generate bad output) +-- fix deflateReset (zlib header was incorrectly suppressed) +-- added support for VMS +-- allow a compression level in gzopen() +-- gzflush now calls fflush +-- For deflate with flush, flush even if no more input is provided. +-- rename libgz.a as libz.a +-- avoid complex expression in infcodes.c triggering Turbo C bug +-- work around a problem with gcc on Alpha (in INSERT_STRING) +-- don't use inline functions (problem with some gcc versions) +-- allow renaming of Byte, uInt, etc... with #define. +-- avoid warning about (unused) pointer before start of array in deflate.c +-- avoid various warnings in gzio.c, example.c, infblock.c, adler32.c, zutil.c +-- avoid reserved word 'new' in trees.c +- +-Changes in 0.93 (25 June 95) +-- temporarily disable inline functions +-- make deflate deterministic +-- give enough lookahead for PARTIAL_FLUSH +-- Set binary mode for stdin/stdout in minigzip.c for OS/2 +-- don't even use signed char in inflate (not portable enough) +-- fix inflate memory leak for segmented architectures +- +-Changes in 0.92 (3 May 95) +-- don't assume that char is signed (problem on SGI) +-- Clear bit buffer when starting a stored block +-- no memcpy on Pyramid +-- suppressed inftest.c +-- optimized fill_window, put longest_match inline for gcc +-- optimized inflate on stored blocks. +-- untabify all sources to simplify patches +- +-Changes in 0.91 (2 May 95) +-- Default MEM_LEVEL is 8 (not 9 for Unix) as documented in zlib.h +-- Document the memory requirements in zconf.h +-- added "make install" +-- fix sync search logic in inflateSync +-- deflate(Z_FULL_FLUSH) now works even if output buffer too short +-- after inflateSync, don't scare people with just "lo world" +-- added support for DJGPP +- +-Changes in 0.9 (1 May 95) +-- don't assume that zalloc clears the allocated memory (the TurboC bug +- was Mark's bug after all :) +-- let again gzread copy uncompressed data unchanged (was working in 0.71) +-- deflate(Z_FULL_FLUSH), inflateReset and inflateSync are now fully implemented +-- added a test of inflateSync in example.c +-- moved MAX_WBITS to zconf.h because users might want to change that. +-- document explicitly that zalloc(64K) on MSDOS must return a normalized +- pointer (zero offset) +-- added Makefiles for Microsoft C, Turbo C, Borland C++ +-- faster crc32() +- +-Changes in 0.8 (29 April 95) +-- added fast inflate (inffast.c) +-- deflate(Z_FINISH) now returns Z_STREAM_END when done. Warning: this +- is incompatible with previous versions of zlib which returned Z_OK. +-- work around a TurboC compiler bug (bad code for b << 0, see infutil.h) +- (actually that was not a compiler bug, see 0.81 above) +-- gzread no longer reads one extra byte in certain cases +-- In gzio destroy(), don't reference a freed structure +-- avoid many warnings for MSDOS +-- avoid the ERROR symbol which is used by MS Windows +- +-Changes in 0.71 (14 April 95) +-- Fixed more MSDOS compilation problems :( There is still a bug with +- TurboC large model. +- +-Changes in 0.7 (14 April 95) +-- Added full inflate support. +-- Simplified the crc32() interface. The pre- and post-conditioning +- (one's complement) is now done inside crc32(). WARNING: this is +- incompatible with previous versions; see zlib.h for the new usage. +- +-Changes in 0.61 (12 April 95) +-- workaround for a bug in TurboC. example and minigzip now work on MSDOS. +- +-Changes in 0.6 (11 April 95) +-- added minigzip.c +-- added gzdopen to reopen a file descriptor as gzFile +-- added transparent reading of non-gziped files in gzread. +-- fixed bug in gzread (don't read crc as data) +-- fixed bug in destroy (gzio.c) (don't return Z_STREAM_END for gzclose). +-- don't allocate big arrays in the stack (for MSDOS) +-- fix some MSDOS compilation problems +- +-Changes in 0.5: +-- do real compression in deflate.c. Z_PARTIAL_FLUSH is supported but +- not yet Z_FULL_FLUSH. +-- support decompression but only in a single step (forced Z_FINISH) +-- added opaque object for zalloc and zfree. +-- added deflateReset and inflateReset +-- added a variable zlib_version for consistency checking. +-- renamed the 'filter' parameter of deflateInit2 as 'strategy'. +- Added Z_FILTERED and Z_HUFFMAN_ONLY constants. +- +-Changes in 0.4: +-- avoid "zip" everywhere, use zlib instead of ziplib. +-- suppress Z_BLOCK_FLUSH, interpret Z_PARTIAL_FLUSH as block flush +- if compression method == 8. +-- added adler32 and crc32 +-- renamed deflateOptions as deflateInit2, call one or the other but not both +-- added the method parameter for deflateInit2. +-- added inflateInit2 +-- simplied considerably deflateInit and inflateInit by not supporting +- user-provided history buffer. This is supported only in deflateInit2 +- and inflateInit2. +- +-Changes in 0.3: +-- prefix all macro names with Z_ +-- use Z_FINISH instead of deflateEnd to finish compression. +-- added Z_HUFFMAN_ONLY +-- added gzerror() +diff --git a/thirdparty/zlib/FAQ b/thirdparty/zlib/FAQ +deleted file mode 100644 +index 1a22750..0000000 +--- a/thirdparty/zlib/FAQ ++++ /dev/null +@@ -1,366 +0,0 @@ +- +- Frequently Asked Questions about zlib +- +- +-If your question is not there, please check the zlib home page +-http://zlib.net/ which may have more recent information. +-The lastest zlib FAQ is at http://zlib.net/zlib_faq.html +- +- +- 1. Is zlib Y2K-compliant? +- +- Yes. zlib doesn't handle dates. +- +- 2. Where can I get a Windows DLL version? +- +- The zlib sources can be compiled without change to produce a DLL. See the +- file win32/DLL_FAQ.txt in the zlib distribution. Pointers to the +- precompiled DLL are found in the zlib web site at http://zlib.net/ . +- +- 3. Where can I get a Visual Basic interface to zlib? +- +- See +- * http://marknelson.us/1997/01/01/zlib-engine/ +- * win32/DLL_FAQ.txt in the zlib distribution +- +- 4. compress() returns Z_BUF_ERROR. +- +- Make sure that before the call of compress(), the length of the compressed +- buffer is equal to the available size of the compressed buffer and not +- zero. For Visual Basic, check that this parameter is passed by reference +- ("as any"), not by value ("as long"). +- +- 5. deflate() or inflate() returns Z_BUF_ERROR. +- +- Before making the call, make sure that avail_in and avail_out are not zero. +- When setting the parameter flush equal to Z_FINISH, also make sure that +- avail_out is big enough to allow processing all pending input. Note that a +- Z_BUF_ERROR is not fatal--another call to deflate() or inflate() can be +- made with more input or output space. A Z_BUF_ERROR may in fact be +- unavoidable depending on how the functions are used, since it is not +- possible to tell whether or not there is more output pending when +- strm.avail_out returns with zero. See http://zlib.net/zlib_how.html for a +- heavily annotated example. +- +- 6. Where's the zlib documentation (man pages, etc.)? +- +- It's in zlib.h . Examples of zlib usage are in the files example.c and +- minigzip.c, with more in examples/ . +- +- 7. Why don't you use GNU autoconf or libtool or ...? +- +- Because we would like to keep zlib as a very small and simple package. +- zlib is rather portable and doesn't need much configuration. +- +- 8. I found a bug in zlib. +- +- Most of the time, such problems are due to an incorrect usage of zlib. +- Please try to reproduce the problem with a small program and send the +- corresponding source to us at zlib@gzip.org . Do not send multi-megabyte +- data files without prior agreement. +- +- 9. Why do I get "undefined reference to gzputc"? +- +- If "make test" produces something like +- +- example.o(.text+0x154): undefined reference to `gzputc' +- +- check that you don't have old files libz.* in /usr/lib, /usr/local/lib or +- /usr/X11R6/lib. Remove any old versions, then do "make install". +- +-10. I need a Delphi interface to zlib. +- +- See the contrib/delphi directory in the zlib distribution. +- +-11. Can zlib handle .zip archives? +- +- Not by itself, no. See the directory contrib/minizip in the zlib +- distribution. +- +-12. Can zlib handle .Z files? +- +- No, sorry. You have to spawn an uncompress or gunzip subprocess, or adapt +- the code of uncompress on your own. +- +-13. How can I make a Unix shared library? +- +- make clean +- ./configure -s +- make +- +-14. How do I install a shared zlib library on Unix? +- +- After the above, then: +- +- make install +- +- However, many flavors of Unix come with a shared zlib already installed. +- Before going to the trouble of compiling a shared version of zlib and +- trying to install it, you may want to check if it's already there! If you +- can #include , it's there. The -lz option will probably link to +- it. You can check the version at the top of zlib.h or with the +- ZLIB_VERSION symbol defined in zlib.h . +- +-15. I have a question about OttoPDF. +- +- We are not the authors of OttoPDF. The real author is on the OttoPDF web +- site: Joel Hainley, jhainley@myndkryme.com. +- +-16. Can zlib decode Flate data in an Adobe PDF file? +- +- Yes. See http://www.pdflib.com/ . To modify PDF forms, see +- http://sourceforge.net/projects/acroformtool/ . +- +-17. Why am I getting this "register_frame_info not found" error on Solaris? +- +- After installing zlib 1.1.4 on Solaris 2.6, running applications using zlib +- generates an error such as: +- +- ld.so.1: rpm: fatal: relocation error: file /usr/local/lib/libz.so: +- symbol __register_frame_info: referenced symbol not found +- +- The symbol __register_frame_info is not part of zlib, it is generated by +- the C compiler (cc or gcc). You must recompile applications using zlib +- which have this problem. This problem is specific to Solaris. See +- http://www.sunfreeware.com for Solaris versions of zlib and applications +- using zlib. +- +-18. Why does gzip give an error on a file I make with compress/deflate? +- +- The compress and deflate functions produce data in the zlib format, which +- is different and incompatible with the gzip format. The gz* functions in +- zlib on the other hand use the gzip format. Both the zlib and gzip formats +- use the same compressed data format internally, but have different headers +- and trailers around the compressed data. +- +-19. Ok, so why are there two different formats? +- +- The gzip format was designed to retain the directory information about a +- single file, such as the name and last modification date. The zlib format +- on the other hand was designed for in-memory and communication channel +- applications, and has a much more compact header and trailer and uses a +- faster integrity check than gzip. +- +-20. Well that's nice, but how do I make a gzip file in memory? +- +- You can request that deflate write the gzip format instead of the zlib +- format using deflateInit2(). You can also request that inflate decode the +- gzip format using inflateInit2(). Read zlib.h for more details. +- +-21. Is zlib thread-safe? +- +- Yes. However any library routines that zlib uses and any application- +- provided memory allocation routines must also be thread-safe. zlib's gz* +- functions use stdio library routines, and most of zlib's functions use the +- library memory allocation routines by default. zlib's *Init* functions +- allow for the application to provide custom memory allocation routines. +- +- Of course, you should only operate on any given zlib or gzip stream from a +- single thread at a time. +- +-22. Can I use zlib in my commercial application? +- +- Yes. Please read the license in zlib.h. +- +-23. Is zlib under the GNU license? +- +- No. Please read the license in zlib.h. +- +-24. The license says that altered source versions must be "plainly marked". So +- what exactly do I need to do to meet that requirement? +- +- You need to change the ZLIB_VERSION and ZLIB_VERNUM #defines in zlib.h. In +- particular, the final version number needs to be changed to "f", and an +- identification string should be appended to ZLIB_VERSION. Version numbers +- x.x.x.f are reserved for modifications to zlib by others than the zlib +- maintainers. For example, if the version of the base zlib you are altering +- is "1.2.3.4", then in zlib.h you should change ZLIB_VERNUM to 0x123f, and +- ZLIB_VERSION to something like "1.2.3.f-zachary-mods-v3". You can also +- update the version strings in deflate.c and inftrees.c. +- +- For altered source distributions, you should also note the origin and +- nature of the changes in zlib.h, as well as in ChangeLog and README, along +- with the dates of the alterations. The origin should include at least your +- name (or your company's name), and an email address to contact for help or +- issues with the library. +- +- Note that distributing a compiled zlib library along with zlib.h and +- zconf.h is also a source distribution, and so you should change +- ZLIB_VERSION and ZLIB_VERNUM and note the origin and nature of the changes +- in zlib.h as you would for a full source distribution. +- +-25. Will zlib work on a big-endian or little-endian architecture, and can I +- exchange compressed data between them? +- +- Yes and yes. +- +-26. Will zlib work on a 64-bit machine? +- +- Yes. It has been tested on 64-bit machines, and has no dependence on any +- data types being limited to 32-bits in length. If you have any +- difficulties, please provide a complete problem report to zlib@gzip.org +- +-27. Will zlib decompress data from the PKWare Data Compression Library? +- +- No. The PKWare DCL uses a completely different compressed data format than +- does PKZIP and zlib. However, you can look in zlib's contrib/blast +- directory for a possible solution to your problem. +- +-28. Can I access data randomly in a compressed stream? +- +- No, not without some preparation. If when compressing you periodically use +- Z_FULL_FLUSH, carefully write all the pending data at those points, and +- keep an index of those locations, then you can start decompression at those +- points. You have to be careful to not use Z_FULL_FLUSH too often, since it +- can significantly degrade compression. Alternatively, you can scan a +- deflate stream once to generate an index, and then use that index for +- random access. See examples/zran.c . +- +-29. Does zlib work on MVS, OS/390, CICS, etc.? +- +- It has in the past, but we have not heard of any recent evidence. There +- were working ports of zlib 1.1.4 to MVS, but those links no longer work. +- If you know of recent, successful applications of zlib on these operating +- systems, please let us know. Thanks. +- +-30. Is there some simpler, easier to read version of inflate I can look at to +- understand the deflate format? +- +- First off, you should read RFC 1951. Second, yes. Look in zlib's +- contrib/puff directory. +- +-31. Does zlib infringe on any patents? +- +- As far as we know, no. In fact, that was originally the whole point behind +- zlib. Look here for some more information: +- +- http://www.gzip.org/#faq11 +- +-32. Can zlib work with greater than 4 GB of data? +- +- Yes. inflate() and deflate() will process any amount of data correctly. +- Each call of inflate() or deflate() is limited to input and output chunks +- of the maximum value that can be stored in the compiler's "unsigned int" +- type, but there is no limit to the number of chunks. Note however that the +- strm.total_in and strm_total_out counters may be limited to 4 GB. These +- counters are provided as a convenience and are not used internally by +- inflate() or deflate(). The application can easily set up its own counters +- updated after each call of inflate() or deflate() to count beyond 4 GB. +- compress() and uncompress() may be limited to 4 GB, since they operate in a +- single call. gzseek() and gztell() may be limited to 4 GB depending on how +- zlib is compiled. See the zlibCompileFlags() function in zlib.h. +- +- The word "may" appears several times above since there is a 4 GB limit only +- if the compiler's "long" type is 32 bits. If the compiler's "long" type is +- 64 bits, then the limit is 16 exabytes. +- +-33. Does zlib have any security vulnerabilities? +- +- The only one that we are aware of is potentially in gzprintf(). If zlib is +- compiled to use sprintf() or vsprintf(), then there is no protection +- against a buffer overflow of an 8K string space (or other value as set by +- gzbuffer()), other than the caller of gzprintf() assuring that the output +- will not exceed 8K. On the other hand, if zlib is compiled to use +- snprintf() or vsnprintf(), which should normally be the case, then there is +- no vulnerability. The ./configure script will display warnings if an +- insecure variation of sprintf() will be used by gzprintf(). Also the +- zlibCompileFlags() function will return information on what variant of +- sprintf() is used by gzprintf(). +- +- If you don't have snprintf() or vsnprintf() and would like one, you can +- find a portable implementation here: +- +- http://www.ijs.si/software/snprintf/ +- +- Note that you should be using the most recent version of zlib. Versions +- 1.1.3 and before were subject to a double-free vulnerability, and versions +- 1.2.1 and 1.2.2 were subject to an access exception when decompressing +- invalid compressed data. +- +-34. Is there a Java version of zlib? +- +- Probably what you want is to use zlib in Java. zlib is already included +- as part of the Java SDK in the java.util.zip package. If you really want +- a version of zlib written in the Java language, look on the zlib home +- page for links: http://zlib.net/ . +- +-35. I get this or that compiler or source-code scanner warning when I crank it +- up to maximally-pedantic. Can't you guys write proper code? +- +- Many years ago, we gave up attempting to avoid warnings on every compiler +- in the universe. It just got to be a waste of time, and some compilers +- were downright silly as well as contradicted each other. So now, we simply +- make sure that the code always works. +- +-36. Valgrind (or some similar memory access checker) says that deflate is +- performing a conditional jump that depends on an uninitialized value. +- Isn't that a bug? +- +- No. That is intentional for performance reasons, and the output of deflate +- is not affected. This only started showing up recently since zlib 1.2.x +- uses malloc() by default for allocations, whereas earlier versions used +- calloc(), which zeros out the allocated memory. Even though the code was +- correct, versions 1.2.4 and later was changed to not stimulate these +- checkers. +- +-37. Will zlib read the (insert any ancient or arcane format here) compressed +- data format? +- +- Probably not. Look in the comp.compression FAQ for pointers to various +- formats and associated software. +- +-38. How can I encrypt/decrypt zip files with zlib? +- +- zlib doesn't support encryption. The original PKZIP encryption is very +- weak and can be broken with freely available programs. To get strong +- encryption, use GnuPG, http://www.gnupg.org/ , which already includes zlib +- compression. For PKZIP compatible "encryption", look at +- http://www.info-zip.org/ +- +-39. What's the difference between the "gzip" and "deflate" HTTP 1.1 encodings? +- +- "gzip" is the gzip format, and "deflate" is the zlib format. They should +- probably have called the second one "zlib" instead to avoid confusion with +- the raw deflate compressed data format. While the HTTP 1.1 RFC 2616 +- correctly points to the zlib specification in RFC 1950 for the "deflate" +- transfer encoding, there have been reports of servers and browsers that +- incorrectly produce or expect raw deflate data per the deflate +- specficiation in RFC 1951, most notably Microsoft. So even though the +- "deflate" transfer encoding using the zlib format would be the more +- efficient approach (and in fact exactly what the zlib format was designed +- for), using the "gzip" transfer encoding is probably more reliable due to +- an unfortunate choice of name on the part of the HTTP 1.1 authors. +- +- Bottom line: use the gzip format for HTTP 1.1 encoding. +- +-40. Does zlib support the new "Deflate64" format introduced by PKWare? +- +- No. PKWare has apparently decided to keep that format proprietary, since +- they have not documented it as they have previous compression formats. In +- any case, the compression improvements are so modest compared to other more +- modern approaches, that it's not worth the effort to implement. +- +-41. I'm having a problem with the zip functions in zlib, can you help? +- +- There are no zip functions in zlib. You are probably using minizip by +- Giles Vollant, which is found in the contrib directory of zlib. It is not +- part of zlib. In fact none of the stuff in contrib is part of zlib. The +- files in there are not supported by the zlib authors. You need to contact +- the authors of the respective contribution for help. +- +-42. The match.asm code in contrib is under the GNU General Public License. +- Since it's part of zlib, doesn't that mean that all of zlib falls under the +- GNU GPL? +- +- No. The files in contrib are not part of zlib. They were contributed by +- other authors and are provided as a convenience to the user within the zlib +- distribution. Each item in contrib has its own license. +- +-43. Is zlib subject to export controls? What is its ECCN? +- +- zlib is not subject to export controls, and so is classified as EAR99. +- +-44. Can you please sign these lengthy legal documents and fax them back to us +- so that we can use your software in our product? +- +- No. Go away. Shoo. +diff --git a/thirdparty/zlib/README b/thirdparty/zlib/README +deleted file mode 100644 +index d4219bf..0000000 +--- a/thirdparty/zlib/README ++++ /dev/null +@@ -1,115 +0,0 @@ +-ZLIB DATA COMPRESSION LIBRARY +- +-zlib 1.2.5 is a general purpose data compression library. All the code is +-thread safe. The data format used by the zlib library is described by RFCs +-(Request for Comments) 1950 to 1952 in the files +-http://www.ietf.org/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate format) +-and rfc1952.txt (gzip format). +- +-All functions of the compression library are documented in the file zlib.h +-(volunteer to write man pages welcome, contact zlib@gzip.org). A usage example +-of the library is given in the file example.c which also tests that the library +-is working correctly. Another example is given in the file minigzip.c. The +-compression library itself is composed of all source files except example.c and +-minigzip.c. +- +-To compile all files and run the test program, follow the instructions given at +-the top of Makefile.in. In short "./configure; make test", and if that goes +-well, "make install" should work for most flavors of Unix. For Windows, use one +-of the special makefiles in win32/ or contrib/vstudio/ . For VMS, use +-make_vms.com. +- +-Questions about zlib should be sent to , or to Gilles Vollant +- for the Windows DLL version. The zlib home page is +-http://zlib.net/ . Before reporting a problem, please check this site to +-verify that you have the latest version of zlib; otherwise get the latest +-version and check whether the problem still exists or not. +- +-PLEASE read the zlib FAQ http://zlib.net/zlib_faq.html before asking for help. +- +-Mark Nelson wrote an article about zlib for the Jan. 1997 +-issue of Dr. Dobb's Journal; a copy of the article is available at +-http://marknelson.us/1997/01/01/zlib-engine/ . +- +-The changes made in version 1.2.5 are documented in the file ChangeLog. +- +-Unsupported third party contributions are provided in directory contrib/ . +- +-zlib is available in Java using the java.util.zip package, documented at +-http://java.sun.com/developer/technicalArticles/Programming/compression/ . +- +-A Perl interface to zlib written by Paul Marquess is available +-at CPAN (Comprehensive Perl Archive Network) sites, including +-http://search.cpan.org/~pmqs/IO-Compress-Zlib/ . +- +-A Python interface to zlib written by A.M. Kuchling is +-available in Python 1.5 and later versions, see +-http://www.python.org/doc/lib/module-zlib.html . +- +-zlib is built into tcl: http://wiki.tcl.tk/4610 . +- +-An experimental package to read and write files in .zip format, written on top +-of zlib by Gilles Vollant , is available in the +-contrib/minizip directory of zlib. +- +- +-Notes for some targets: +- +-- For Windows DLL versions, please see win32/DLL_FAQ.txt +- +-- For 64-bit Irix, deflate.c must be compiled without any optimization. With +- -O, one libpng test fails. The test works in 32 bit mode (with the -n32 +- compiler flag). The compiler bug has been reported to SGI. +- +-- zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1 it works +- when compiled with cc. +- +-- On Digital Unix 4.0D (formely OSF/1) on AlphaServer, the cc option -std1 is +- necessary to get gzprintf working correctly. This is done by configure. +- +-- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works with +- other compilers. Use "make test" to check your compiler. +- +-- gzdopen is not supported on RISCOS or BEOS. +- +-- For PalmOs, see http://palmzlib.sourceforge.net/ +- +- +-Acknowledgments: +- +- The deflate format used by zlib was defined by Phil Katz. The deflate and +- zlib specifications were written by L. Peter Deutsch. Thanks to all the +- people who reported problems and suggested various improvements in zlib; they +- are too numerous to cite here. +- +-Copyright notice: +- +- (C) 1995-2010 Jean-loup Gailly and Mark Adler +- +- This software is provided 'as-is', without any express or implied +- warranty. In no event will the authors be held liable for any damages +- arising from the use of this software. +- +- Permission is granted to anyone to use this software for any purpose, +- including commercial applications, and to alter it and redistribute it +- freely, subject to the following restrictions: +- +- 1. The origin of this software must not be misrepresented; you must not +- claim that you wrote the original software. If you use this software +- in a product, an acknowledgment in the product documentation would be +- appreciated but is not required. +- 2. Altered source versions must be plainly marked as such, and must not be +- misrepresented as being the original software. +- 3. This notice may not be removed or altered from any source distribution. +- +- Jean-loup Gailly Mark Adler +- jloup@gzip.org madler@alumni.caltech.edu +- +-If you use the zlib library in a product, we would appreciate *not* receiving +-lengthy legal documents to sign. The sources are provided for free but without +-warranty of any kind. The library has been entirely written by Jean-loup +-Gailly and Mark Adler; it does not include third-party code. +- +-If you redistribute modified sources, we would appreciate that you include in +-the file ChangeLog history information documenting your changes. Please read +-the FAQ for more information on the distribution of modified source versions. +diff --git a/thirdparty/zlib/adler32.c b/thirdparty/zlib/adler32.c +deleted file mode 100644 +index 65ad6a5..0000000 +--- a/thirdparty/zlib/adler32.c ++++ /dev/null +@@ -1,169 +0,0 @@ +-/* adler32.c -- compute the Adler-32 checksum of a data stream +- * Copyright (C) 1995-2007 Mark Adler +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* @(#) $Id$ */ +- +-#include "zutil.h" +- +-#define local static +- +-local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2); +- +-#define BASE 65521UL /* largest prime smaller than 65536 */ +-#define NMAX 5552 +-/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ +- +-#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} +-#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); +-#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); +-#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); +-#define DO16(buf) DO8(buf,0); DO8(buf,8); +- +-/* use NO_DIVIDE if your processor does not do division in hardware */ +-#ifdef NO_DIVIDE +-# define MOD(a) \ +- do { \ +- if (a >= (BASE << 16)) a -= (BASE << 16); \ +- if (a >= (BASE << 15)) a -= (BASE << 15); \ +- if (a >= (BASE << 14)) a -= (BASE << 14); \ +- if (a >= (BASE << 13)) a -= (BASE << 13); \ +- if (a >= (BASE << 12)) a -= (BASE << 12); \ +- if (a >= (BASE << 11)) a -= (BASE << 11); \ +- if (a >= (BASE << 10)) a -= (BASE << 10); \ +- if (a >= (BASE << 9)) a -= (BASE << 9); \ +- if (a >= (BASE << 8)) a -= (BASE << 8); \ +- if (a >= (BASE << 7)) a -= (BASE << 7); \ +- if (a >= (BASE << 6)) a -= (BASE << 6); \ +- if (a >= (BASE << 5)) a -= (BASE << 5); \ +- if (a >= (BASE << 4)) a -= (BASE << 4); \ +- if (a >= (BASE << 3)) a -= (BASE << 3); \ +- if (a >= (BASE << 2)) a -= (BASE << 2); \ +- if (a >= (BASE << 1)) a -= (BASE << 1); \ +- if (a >= BASE) a -= BASE; \ +- } while (0) +-# define MOD4(a) \ +- do { \ +- if (a >= (BASE << 4)) a -= (BASE << 4); \ +- if (a >= (BASE << 3)) a -= (BASE << 3); \ +- if (a >= (BASE << 2)) a -= (BASE << 2); \ +- if (a >= (BASE << 1)) a -= (BASE << 1); \ +- if (a >= BASE) a -= BASE; \ +- } while (0) +-#else +-# define MOD(a) a %= BASE +-# define MOD4(a) a %= BASE +-#endif +- +-/* ========================================================================= */ +-uLong ZEXPORT adler32(adler, buf, len) +- uLong adler; +- const Bytef *buf; +- uInt len; +-{ +- unsigned long sum2; +- unsigned n; +- +- /* split Adler-32 into component sums */ +- sum2 = (adler >> 16) & 0xffff; +- adler &= 0xffff; +- +- /* in case user likes doing a byte at a time, keep it fast */ +- if (len == 1) { +- adler += buf[0]; +- if (adler >= BASE) +- adler -= BASE; +- sum2 += adler; +- if (sum2 >= BASE) +- sum2 -= BASE; +- return adler | (sum2 << 16); +- } +- +- /* initial Adler-32 value (deferred check for len == 1 speed) */ +- if (buf == Z_NULL) +- return 1L; +- +- /* in case short lengths are provided, keep it somewhat fast */ +- if (len < 16) { +- while (len--) { +- adler += *buf++; +- sum2 += adler; +- } +- if (adler >= BASE) +- adler -= BASE; +- MOD4(sum2); /* only added so many BASE's */ +- return adler | (sum2 << 16); +- } +- +- /* do length NMAX blocks -- requires just one modulo operation */ +- while (len >= NMAX) { +- len -= NMAX; +- n = NMAX / 16; /* NMAX is divisible by 16 */ +- do { +- DO16(buf); /* 16 sums unrolled */ +- buf += 16; +- } while (--n); +- MOD(adler); +- MOD(sum2); +- } +- +- /* do remaining bytes (less than NMAX, still just one modulo) */ +- if (len) { /* avoid modulos if none remaining */ +- while (len >= 16) { +- len -= 16; +- DO16(buf); +- buf += 16; +- } +- while (len--) { +- adler += *buf++; +- sum2 += adler; +- } +- MOD(adler); +- MOD(sum2); +- } +- +- /* return recombined sums */ +- return adler | (sum2 << 16); +-} +- +-/* ========================================================================= */ +-local uLong adler32_combine_(adler1, adler2, len2) +- uLong adler1; +- uLong adler2; +- z_off64_t len2; +-{ +- unsigned long sum1; +- unsigned long sum2; +- unsigned rem; +- +- /* the derivation of this formula is left as an exercise for the reader */ +- rem = (unsigned)(len2 % BASE); +- sum1 = adler1 & 0xffff; +- sum2 = rem * sum1; +- MOD(sum2); +- sum1 += (adler2 & 0xffff) + BASE - 1; +- sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem; +- if (sum1 >= BASE) sum1 -= BASE; +- if (sum1 >= BASE) sum1 -= BASE; +- if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1); +- if (sum2 >= BASE) sum2 -= BASE; +- return sum1 | (sum2 << 16); +-} +- +-/* ========================================================================= */ +-uLong ZEXPORT adler32_combine(adler1, adler2, len2) +- uLong adler1; +- uLong adler2; +- z_off_t len2; +-{ +- return adler32_combine_(adler1, adler2, len2); +-} +- +-uLong ZEXPORT adler32_combine64(adler1, adler2, len2) +- uLong adler1; +- uLong adler2; +- z_off64_t len2; +-{ +- return adler32_combine_(adler1, adler2, len2); +-} +diff --git a/thirdparty/zlib/compress.c b/thirdparty/zlib/compress.c +deleted file mode 100644 +index ea4dfbe..0000000 +--- a/thirdparty/zlib/compress.c ++++ /dev/null +@@ -1,80 +0,0 @@ +-/* compress.c -- compress a memory buffer +- * Copyright (C) 1995-2005 Jean-loup Gailly. +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* @(#) $Id$ */ +- +-#define ZLIB_INTERNAL +-#include "zlib.h" +- +-/* =========================================================================== +- Compresses the source buffer into the destination buffer. The level +- parameter has the same meaning as in deflateInit. sourceLen is the byte +- length of the source buffer. Upon entry, destLen is the total size of the +- destination buffer, which must be at least 0.1% larger than sourceLen plus +- 12 bytes. Upon exit, destLen is the actual size of the compressed buffer. +- +- compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough +- memory, Z_BUF_ERROR if there was not enough room in the output buffer, +- Z_STREAM_ERROR if the level parameter is invalid. +-*/ +-int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) +- Bytef *dest; +- uLongf *destLen; +- const Bytef *source; +- uLong sourceLen; +- int level; +-{ +- z_stream stream; +- int err; +- +- stream.next_in = (Bytef*)source; +- stream.avail_in = (uInt)sourceLen; +-#ifdef MAXSEG_64K +- /* Check for source > 64K on 16-bit machine: */ +- if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; +-#endif +- stream.next_out = dest; +- stream.avail_out = (uInt)*destLen; +- if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; +- +- stream.zalloc = (alloc_func)0; +- stream.zfree = (free_func)0; +- stream.opaque = (voidpf)0; +- +- err = deflateInit(&stream, level); +- if (err != Z_OK) return err; +- +- err = deflate(&stream, Z_FINISH); +- if (err != Z_STREAM_END) { +- deflateEnd(&stream); +- return err == Z_OK ? Z_BUF_ERROR : err; +- } +- *destLen = stream.total_out; +- +- err = deflateEnd(&stream); +- return err; +-} +- +-/* =========================================================================== +- */ +-int ZEXPORT compress (dest, destLen, source, sourceLen) +- Bytef *dest; +- uLongf *destLen; +- const Bytef *source; +- uLong sourceLen; +-{ +- return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION); +-} +- +-/* =========================================================================== +- If the default memLevel or windowBits for deflateInit() is changed, then +- this function needs to be updated. +- */ +-uLong ZEXPORT compressBound (sourceLen) +- uLong sourceLen; +-{ +- return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + +- (sourceLen >> 25) + 13; +-} +diff --git a/thirdparty/zlib/crc32.c b/thirdparty/zlib/crc32.c +deleted file mode 100644 +index 91be372..0000000 +--- a/thirdparty/zlib/crc32.c ++++ /dev/null +@@ -1,442 +0,0 @@ +-/* crc32.c -- compute the CRC-32 of a data stream +- * Copyright (C) 1995-2006, 2010 Mark Adler +- * For conditions of distribution and use, see copyright notice in zlib.h +- * +- * Thanks to Rodney Brown for his contribution of faster +- * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing +- * tables for updating the shift register in one step with three exclusive-ors +- * instead of four steps with four exclusive-ors. This results in about a +- * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3. +- */ +- +-/* @(#) $Id$ */ +- +-/* +- Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore +- protection on the static variables used to control the first-use generation +- of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should +- first call get_crc_table() to initialize the tables before allowing more than +- one thread to use crc32(). +- */ +- +-#ifdef MAKECRCH +-# include +-# ifndef DYNAMIC_CRC_TABLE +-# define DYNAMIC_CRC_TABLE +-# endif /* !DYNAMIC_CRC_TABLE */ +-#endif /* MAKECRCH */ +- +-#include "zutil.h" /* for STDC and FAR definitions */ +- +-#define local static +- +-/* Find a four-byte integer type for crc32_little() and crc32_big(). */ +-#ifndef NOBYFOUR +-# ifdef STDC /* need ANSI C limits.h to determine sizes */ +-# include +-# define BYFOUR +-# if (UINT_MAX == 0xffffffffUL) +- typedef unsigned int u4; +-# else +-# if (ULONG_MAX == 0xffffffffUL) +- typedef unsigned long u4; +-# else +-# if (USHRT_MAX == 0xffffffffUL) +- typedef unsigned short u4; +-# else +-# undef BYFOUR /* can't find a four-byte integer type! */ +-# endif +-# endif +-# endif +-# endif /* STDC */ +-#endif /* !NOBYFOUR */ +- +-/* Definitions for doing the crc four data bytes at a time. */ +-#ifdef BYFOUR +-# define REV(w) ((((w)>>24)&0xff)+(((w)>>8)&0xff00)+ \ +- (((w)&0xff00)<<8)+(((w)&0xff)<<24)) +- local unsigned long crc32_little OF((unsigned long, +- const unsigned char FAR *, unsigned)); +- local unsigned long crc32_big OF((unsigned long, +- const unsigned char FAR *, unsigned)); +-# define TBLS 8 +-#else +-# define TBLS 1 +-#endif /* BYFOUR */ +- +-/* Local functions for crc concatenation */ +-local unsigned long gf2_matrix_times OF((unsigned long *mat, +- unsigned long vec)); +-local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat)); +-local uLong crc32_combine_(uLong crc1, uLong crc2, z_off64_t len2); +- +- +-#ifdef DYNAMIC_CRC_TABLE +- +-local volatile int crc_table_empty = 1; +-local unsigned long FAR crc_table[TBLS][256]; +-local void make_crc_table OF((void)); +-#ifdef MAKECRCH +- local void write_table OF((FILE *, const unsigned long FAR *)); +-#endif /* MAKECRCH */ +-/* +- Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: +- x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1. +- +- Polynomials over GF(2) are represented in binary, one bit per coefficient, +- with the lowest powers in the most significant bit. Then adding polynomials +- is just exclusive-or, and multiplying a polynomial by x is a right shift by +- one. If we call the above polynomial p, and represent a byte as the +- polynomial q, also with the lowest power in the most significant bit (so the +- byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, +- where a mod b means the remainder after dividing a by b. +- +- This calculation is done using the shift-register method of multiplying and +- taking the remainder. The register is initialized to zero, and for each +- incoming bit, x^32 is added mod p to the register if the bit is a one (where +- x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by +- x (which is shifting right by one and adding x^32 mod p if the bit shifted +- out is a one). We start with the highest power (least significant bit) of +- q and repeat for all eight bits of q. +- +- The first table is simply the CRC of all possible eight bit values. This is +- all the information needed to generate CRCs on data a byte at a time for all +- combinations of CRC register values and incoming bytes. The remaining tables +- allow for word-at-a-time CRC calculation for both big-endian and little- +- endian machines, where a word is four bytes. +-*/ +-local void make_crc_table() +-{ +- unsigned long c; +- int n, k; +- unsigned long poly; /* polynomial exclusive-or pattern */ +- /* terms of polynomial defining this crc (except x^32): */ +- static volatile int first = 1; /* flag to limit concurrent making */ +- static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; +- +- /* See if another task is already doing this (not thread-safe, but better +- than nothing -- significantly reduces duration of vulnerability in +- case the advice about DYNAMIC_CRC_TABLE is ignored) */ +- if (first) { +- first = 0; +- +- /* make exclusive-or pattern from polynomial (0xedb88320UL) */ +- poly = 0UL; +- for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++) +- poly |= 1UL << (31 - p[n]); +- +- /* generate a crc for every 8-bit value */ +- for (n = 0; n < 256; n++) { +- c = (unsigned long)n; +- for (k = 0; k < 8; k++) +- c = c & 1 ? poly ^ (c >> 1) : c >> 1; +- crc_table[0][n] = c; +- } +- +-#ifdef BYFOUR +- /* generate crc for each value followed by one, two, and three zeros, +- and then the byte reversal of those as well as the first table */ +- for (n = 0; n < 256; n++) { +- c = crc_table[0][n]; +- crc_table[4][n] = REV(c); +- for (k = 1; k < 4; k++) { +- c = crc_table[0][c & 0xff] ^ (c >> 8); +- crc_table[k][n] = c; +- crc_table[k + 4][n] = REV(c); +- } +- } +-#endif /* BYFOUR */ +- +- crc_table_empty = 0; +- } +- else { /* not first */ +- /* wait for the other guy to finish (not efficient, but rare) */ +- while (crc_table_empty) +- ; +- } +- +-#ifdef MAKECRCH +- /* write out CRC tables to crc32.h */ +- { +- FILE *out; +- +- out = fopen("crc32.h", "w"); +- if (out == NULL) return; +- fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n"); +- fprintf(out, " * Generated automatically by crc32.c\n */\n\n"); +- fprintf(out, "local const unsigned long FAR "); +- fprintf(out, "crc_table[TBLS][256] =\n{\n {\n"); +- write_table(out, crc_table[0]); +-# ifdef BYFOUR +- fprintf(out, "#ifdef BYFOUR\n"); +- for (k = 1; k < 8; k++) { +- fprintf(out, " },\n {\n"); +- write_table(out, crc_table[k]); +- } +- fprintf(out, "#endif\n"); +-# endif /* BYFOUR */ +- fprintf(out, " }\n};\n"); +- fclose(out); +- } +-#endif /* MAKECRCH */ +-} +- +-#ifdef MAKECRCH +-local void write_table(out, table) +- FILE *out; +- const unsigned long FAR *table; +-{ +- int n; +- +- for (n = 0; n < 256; n++) +- fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", table[n], +- n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); +-} +-#endif /* MAKECRCH */ +- +-#else /* !DYNAMIC_CRC_TABLE */ +-/* ======================================================================== +- * Tables of CRC-32s of all single-byte values, made by make_crc_table(). +- */ +-#include "crc32.h" +-#endif /* DYNAMIC_CRC_TABLE */ +- +-/* ========================================================================= +- * This function can be used by asm versions of crc32() +- */ +-const unsigned long FAR * ZEXPORT get_crc_table() +-{ +-#ifdef DYNAMIC_CRC_TABLE +- if (crc_table_empty) +- make_crc_table(); +-#endif /* DYNAMIC_CRC_TABLE */ +- return (const unsigned long FAR *)crc_table; +-} +- +-/* ========================================================================= */ +-#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8) +-#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 +- +-/* ========================================================================= */ +-unsigned long ZEXPORT crc32(crc, buf, len) +- unsigned long crc; +- const unsigned char FAR *buf; +- uInt len; +-{ +- if (buf == Z_NULL) return 0UL; +- +-#ifdef DYNAMIC_CRC_TABLE +- if (crc_table_empty) +- make_crc_table(); +-#endif /* DYNAMIC_CRC_TABLE */ +- +-#ifdef BYFOUR +- if (sizeof(void *) == sizeof(ptrdiff_t)) { +- u4 endian; +- +- endian = 1; +- if (*((unsigned char *)(&endian))) +- return crc32_little(crc, buf, len); +- else +- return crc32_big(crc, buf, len); +- } +-#endif /* BYFOUR */ +- crc = crc ^ 0xffffffffUL; +- while (len >= 8) { +- DO8; +- len -= 8; +- } +- if (len) do { +- DO1; +- } while (--len); +- return crc ^ 0xffffffffUL; +-} +- +-#ifdef BYFOUR +- +-/* ========================================================================= */ +-#define DOLIT4 c ^= *buf4++; \ +- c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \ +- crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24] +-#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4 +- +-/* ========================================================================= */ +-local unsigned long crc32_little(crc, buf, len) +- unsigned long crc; +- const unsigned char FAR *buf; +- unsigned len; +-{ +- register u4 c; +- register const u4 FAR *buf4; +- +- c = (u4)crc; +- c = ~c; +- while (len && ((ptrdiff_t)buf & 3)) { +- c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); +- len--; +- } +- +- buf4 = (const u4 FAR *)(const void FAR *)buf; +- while (len >= 32) { +- DOLIT32; +- len -= 32; +- } +- while (len >= 4) { +- DOLIT4; +- len -= 4; +- } +- buf = (const unsigned char FAR *)buf4; +- +- if (len) do { +- c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); +- } while (--len); +- c = ~c; +- return (unsigned long)c; +-} +- +-/* ========================================================================= */ +-#define DOBIG4 c ^= *++buf4; \ +- c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \ +- crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24] +-#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4 +- +-/* ========================================================================= */ +-local unsigned long crc32_big(crc, buf, len) +- unsigned long crc; +- const unsigned char FAR *buf; +- unsigned len; +-{ +- register u4 c; +- register const u4 FAR *buf4; +- +- c = REV((u4)crc); +- c = ~c; +- while (len && ((ptrdiff_t)buf & 3)) { +- c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); +- len--; +- } +- +- buf4 = (const u4 FAR *)(const void FAR *)buf; +- buf4--; +- while (len >= 32) { +- DOBIG32; +- len -= 32; +- } +- while (len >= 4) { +- DOBIG4; +- len -= 4; +- } +- buf4++; +- buf = (const unsigned char FAR *)buf4; +- +- if (len) do { +- c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); +- } while (--len); +- c = ~c; +- return (unsigned long)(REV(c)); +-} +- +-#endif /* BYFOUR */ +- +-#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */ +- +-/* ========================================================================= */ +-local unsigned long gf2_matrix_times(mat, vec) +- unsigned long *mat; +- unsigned long vec; +-{ +- unsigned long sum; +- +- sum = 0; +- while (vec) { +- if (vec & 1) +- sum ^= *mat; +- vec >>= 1; +- mat++; +- } +- return sum; +-} +- +-/* ========================================================================= */ +-local void gf2_matrix_square(square, mat) +- unsigned long *square; +- unsigned long *mat; +-{ +- int n; +- +- for (n = 0; n < GF2_DIM; n++) +- square[n] = gf2_matrix_times(mat, mat[n]); +-} +- +-/* ========================================================================= */ +-local uLong crc32_combine_(crc1, crc2, len2) +- uLong crc1; +- uLong crc2; +- z_off64_t len2; +-{ +- int n; +- unsigned long row; +- unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */ +- unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */ +- +- /* degenerate case (also disallow negative lengths) */ +- if (len2 <= 0) +- return crc1; +- +- /* put operator for one zero bit in odd */ +- odd[0] = 0xedb88320UL; /* CRC-32 polynomial */ +- row = 1; +- for (n = 1; n < GF2_DIM; n++) { +- odd[n] = row; +- row <<= 1; +- } +- +- /* put operator for two zero bits in even */ +- gf2_matrix_square(even, odd); +- +- /* put operator for four zero bits in odd */ +- gf2_matrix_square(odd, even); +- +- /* apply len2 zeros to crc1 (first square will put the operator for one +- zero byte, eight zero bits, in even) */ +- do { +- /* apply zeros operator for this bit of len2 */ +- gf2_matrix_square(even, odd); +- if (len2 & 1) +- crc1 = gf2_matrix_times(even, crc1); +- len2 >>= 1; +- +- /* if no more bits set, then done */ +- if (len2 == 0) +- break; +- +- /* another iteration of the loop with odd and even swapped */ +- gf2_matrix_square(odd, even); +- if (len2 & 1) +- crc1 = gf2_matrix_times(odd, crc1); +- len2 >>= 1; +- +- /* if no more bits set, then done */ +- } while (len2 != 0); +- +- /* return combined crc */ +- crc1 ^= crc2; +- return crc1; +-} +- +-/* ========================================================================= */ +-uLong ZEXPORT crc32_combine(crc1, crc2, len2) +- uLong crc1; +- uLong crc2; +- z_off_t len2; +-{ +- return crc32_combine_(crc1, crc2, len2); +-} +- +-uLong ZEXPORT crc32_combine64(crc1, crc2, len2) +- uLong crc1; +- uLong crc2; +- z_off64_t len2; +-{ +- return crc32_combine_(crc1, crc2, len2); +-} +diff --git a/thirdparty/zlib/crc32.h b/thirdparty/zlib/crc32.h +deleted file mode 100644 +index 8053b61..0000000 +--- a/thirdparty/zlib/crc32.h ++++ /dev/null +@@ -1,441 +0,0 @@ +-/* crc32.h -- tables for rapid CRC calculation +- * Generated automatically by crc32.c +- */ +- +-local const unsigned long FAR crc_table[TBLS][256] = +-{ +- { +- 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL, +- 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL, +- 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL, +- 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL, +- 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL, +- 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL, +- 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL, +- 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL, +- 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL, +- 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL, +- 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL, +- 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL, +- 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL, +- 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL, +- 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL, +- 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL, +- 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL, +- 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL, +- 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL, +- 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL, +- 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL, +- 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL, +- 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL, +- 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL, +- 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL, +- 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL, +- 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL, +- 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL, +- 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL, +- 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL, +- 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL, +- 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL, +- 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL, +- 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL, +- 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL, +- 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL, +- 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL, +- 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL, +- 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL, +- 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL, +- 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL, +- 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL, +- 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL, +- 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL, +- 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL, +- 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL, +- 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL, +- 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL, +- 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL, +- 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL, +- 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL, +- 0x2d02ef8dUL +-#ifdef BYFOUR +- }, +- { +- 0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL, +- 0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL, +- 0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL, +- 0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL, +- 0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL, +- 0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL, +- 0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL, +- 0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL, +- 0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL, +- 0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL, +- 0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL, +- 0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL, +- 0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL, +- 0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL, +- 0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL, +- 0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL, +- 0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL, +- 0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL, +- 0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL, +- 0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL, +- 0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL, +- 0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL, +- 0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL, +- 0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL, +- 0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL, +- 0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL, +- 0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL, +- 0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL, +- 0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL, +- 0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL, +- 0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL, +- 0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL, +- 0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL, +- 0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL, +- 0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL, +- 0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL, +- 0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL, +- 0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL, +- 0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL, +- 0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL, +- 0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL, +- 0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL, +- 0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL, +- 0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL, +- 0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL, +- 0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL, +- 0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL, +- 0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL, +- 0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL, +- 0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL, +- 0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL, +- 0x9324fd72UL +- }, +- { +- 0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL, +- 0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL, +- 0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL, +- 0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL, +- 0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL, +- 0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL, +- 0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL, +- 0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL, +- 0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL, +- 0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL, +- 0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL, +- 0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL, +- 0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL, +- 0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL, +- 0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL, +- 0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL, +- 0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL, +- 0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL, +- 0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL, +- 0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL, +- 0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL, +- 0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL, +- 0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL, +- 0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL, +- 0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL, +- 0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL, +- 0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL, +- 0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL, +- 0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL, +- 0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL, +- 0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL, +- 0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL, +- 0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL, +- 0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL, +- 0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL, +- 0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL, +- 0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL, +- 0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL, +- 0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL, +- 0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL, +- 0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL, +- 0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL, +- 0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL, +- 0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL, +- 0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL, +- 0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL, +- 0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL, +- 0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL, +- 0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL, +- 0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL, +- 0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL, +- 0xbe9834edUL +- }, +- { +- 0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL, +- 0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL, +- 0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL, +- 0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL, +- 0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL, +- 0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL, +- 0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL, +- 0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL, +- 0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL, +- 0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL, +- 0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL, +- 0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL, +- 0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL, +- 0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL, +- 0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL, +- 0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL, +- 0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL, +- 0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL, +- 0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL, +- 0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL, +- 0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL, +- 0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL, +- 0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL, +- 0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL, +- 0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL, +- 0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL, +- 0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL, +- 0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL, +- 0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL, +- 0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL, +- 0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL, +- 0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL, +- 0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL, +- 0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL, +- 0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL, +- 0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL, +- 0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL, +- 0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL, +- 0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL, +- 0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL, +- 0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL, +- 0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL, +- 0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL, +- 0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL, +- 0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL, +- 0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL, +- 0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL, +- 0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL, +- 0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL, +- 0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL, +- 0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL, +- 0xde0506f1UL +- }, +- { +- 0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL, +- 0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL, +- 0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL, +- 0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL, +- 0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL, +- 0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL, +- 0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL, +- 0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL, +- 0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL, +- 0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL, +- 0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL, +- 0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL, +- 0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL, +- 0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL, +- 0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL, +- 0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL, +- 0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL, +- 0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL, +- 0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL, +- 0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL, +- 0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL, +- 0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL, +- 0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL, +- 0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL, +- 0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL, +- 0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL, +- 0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL, +- 0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL, +- 0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL, +- 0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL, +- 0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL, +- 0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL, +- 0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL, +- 0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL, +- 0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL, +- 0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL, +- 0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL, +- 0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL, +- 0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL, +- 0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL, +- 0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL, +- 0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL, +- 0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL, +- 0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL, +- 0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL, +- 0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL, +- 0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL, +- 0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL, +- 0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL, +- 0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL, +- 0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL, +- 0x8def022dUL +- }, +- { +- 0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL, +- 0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL, +- 0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL, +- 0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL, +- 0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL, +- 0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL, +- 0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL, +- 0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL, +- 0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL, +- 0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL, +- 0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL, +- 0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL, +- 0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL, +- 0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL, +- 0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL, +- 0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL, +- 0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL, +- 0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL, +- 0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL, +- 0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL, +- 0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL, +- 0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL, +- 0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL, +- 0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL, +- 0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL, +- 0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL, +- 0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL, +- 0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL, +- 0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL, +- 0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL, +- 0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL, +- 0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL, +- 0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL, +- 0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL, +- 0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL, +- 0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL, +- 0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL, +- 0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL, +- 0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL, +- 0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL, +- 0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL, +- 0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL, +- 0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL, +- 0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL, +- 0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL, +- 0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL, +- 0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL, +- 0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL, +- 0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL, +- 0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL, +- 0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL, +- 0x72fd2493UL +- }, +- { +- 0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL, +- 0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL, +- 0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL, +- 0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL, +- 0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL, +- 0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL, +- 0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL, +- 0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL, +- 0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL, +- 0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL, +- 0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL, +- 0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL, +- 0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL, +- 0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL, +- 0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL, +- 0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL, +- 0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL, +- 0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL, +- 0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL, +- 0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL, +- 0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL, +- 0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL, +- 0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL, +- 0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL, +- 0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL, +- 0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL, +- 0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL, +- 0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL, +- 0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL, +- 0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL, +- 0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL, +- 0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL, +- 0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL, +- 0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL, +- 0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL, +- 0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL, +- 0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL, +- 0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL, +- 0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL, +- 0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL, +- 0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL, +- 0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL, +- 0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL, +- 0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL, +- 0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL, +- 0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL, +- 0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL, +- 0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL, +- 0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL, +- 0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL, +- 0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL, +- 0xed3498beUL +- }, +- { +- 0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL, +- 0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL, +- 0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL, +- 0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL, +- 0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL, +- 0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL, +- 0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL, +- 0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL, +- 0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL, +- 0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL, +- 0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL, +- 0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL, +- 0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL, +- 0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL, +- 0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL, +- 0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL, +- 0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL, +- 0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL, +- 0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL, +- 0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL, +- 0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL, +- 0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL, +- 0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL, +- 0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL, +- 0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL, +- 0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL, +- 0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL, +- 0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL, +- 0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL, +- 0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL, +- 0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL, +- 0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL, +- 0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL, +- 0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL, +- 0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL, +- 0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL, +- 0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL, +- 0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL, +- 0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL, +- 0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL, +- 0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL, +- 0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL, +- 0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL, +- 0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL, +- 0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL, +- 0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL, +- 0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL, +- 0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL, +- 0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL, +- 0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL, +- 0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL, +- 0xf10605deUL +-#endif +- } +-}; +diff --git a/thirdparty/zlib/deflate.c b/thirdparty/zlib/deflate.c +deleted file mode 100644 +index 5c4022f..0000000 +--- a/thirdparty/zlib/deflate.c ++++ /dev/null +@@ -1,1834 +0,0 @@ +-/* deflate.c -- compress data using the deflation algorithm +- * Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* +- * ALGORITHM +- * +- * The "deflation" process depends on being able to identify portions +- * of the input text which are identical to earlier input (within a +- * sliding window trailing behind the input currently being processed). +- * +- * The most straightforward technique turns out to be the fastest for +- * most input files: try all possible matches and select the longest. +- * The key feature of this algorithm is that insertions into the string +- * dictionary are very simple and thus fast, and deletions are avoided +- * completely. Insertions are performed at each input character, whereas +- * string matches are performed only when the previous match ends. So it +- * is preferable to spend more time in matches to allow very fast string +- * insertions and avoid deletions. The matching algorithm for small +- * strings is inspired from that of Rabin & Karp. A brute force approach +- * is used to find longer strings when a small match has been found. +- * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze +- * (by Leonid Broukhis). +- * A previous version of this file used a more sophisticated algorithm +- * (by Fiala and Greene) which is guaranteed to run in linear amortized +- * time, but has a larger average cost, uses more memory and is patented. +- * However the F&G algorithm may be faster for some highly redundant +- * files if the parameter max_chain_length (described below) is too large. +- * +- * ACKNOWLEDGEMENTS +- * +- * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and +- * I found it in 'freeze' written by Leonid Broukhis. +- * Thanks to many people for bug reports and testing. +- * +- * REFERENCES +- * +- * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification". +- * Available in http://www.ietf.org/rfc/rfc1951.txt +- * +- * A description of the Rabin and Karp algorithm is given in the book +- * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. +- * +- * Fiala,E.R., and Greene,D.H. +- * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 +- * +- */ +- +-/* @(#) $Id$ */ +- +-#include "deflate.h" +- +-const char deflate_copyright[] = +- " deflate 1.2.5 Copyright 1995-2010 Jean-loup Gailly and Mark Adler "; +-/* +- If you use the zlib library in a product, an acknowledgment is welcome +- in the documentation of your product. If for some reason you cannot +- include such an acknowledgment, I would appreciate that you keep this +- copyright string in the executable of your product. +- */ +- +-/* =========================================================================== +- * Function prototypes. +- */ +-typedef enum { +- need_more, /* block not completed, need more input or more output */ +- block_done, /* block flush performed */ +- finish_started, /* finish started, need only more output at next deflate */ +- finish_done /* finish done, accept no more input or output */ +-} block_state; +- +-typedef block_state (*compress_func) OF((deflate_state *s, int flush)); +-/* Compression function. Returns the block state after the call. */ +- +-local void fill_window OF((deflate_state *s)); +-local block_state deflate_stored OF((deflate_state *s, int flush)); +-local block_state deflate_fast OF((deflate_state *s, int flush)); +-#ifndef FASTEST +-local block_state deflate_slow OF((deflate_state *s, int flush)); +-#endif +-local block_state deflate_rle OF((deflate_state *s, int flush)); +-local block_state deflate_huff OF((deflate_state *s, int flush)); +-local void lm_init OF((deflate_state *s)); +-local void putShortMSB OF((deflate_state *s, uInt b)); +-local void flush_pending OF((z_streamp strm)); +-local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); +-#ifdef ASMV +- void match_init OF((void)); /* asm code initialization */ +- uInt longest_match OF((deflate_state *s, IPos cur_match)); +-#else +-local uInt longest_match OF((deflate_state *s, IPos cur_match)); +-#endif +- +-#ifdef DEBUG +-local void check_match OF((deflate_state *s, IPos start, IPos match, +- int length)); +-#endif +- +-/* =========================================================================== +- * Local data +- */ +- +-#define NIL 0 +-/* Tail of hash chains */ +- +-#ifndef TOO_FAR +-# define TOO_FAR 4096 +-#endif +-/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ +- +-/* Values for max_lazy_match, good_match and max_chain_length, depending on +- * the desired pack level (0..9). The values given below have been tuned to +- * exclude worst case performance for pathological files. Better values may be +- * found for specific files. +- */ +-typedef struct config_s { +- ush good_length; /* reduce lazy search above this match length */ +- ush max_lazy; /* do not perform lazy search above this match length */ +- ush nice_length; /* quit search above this match length */ +- ush max_chain; +- compress_func func; +-} config; +- +-#ifdef FASTEST +-local const config configuration_table[2] = { +-/* good lazy nice chain */ +-/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ +-/* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */ +-#else +-local const config configuration_table[10] = { +-/* good lazy nice chain */ +-/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ +-/* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */ +-/* 2 */ {4, 5, 16, 8, deflate_fast}, +-/* 3 */ {4, 6, 32, 32, deflate_fast}, +- +-/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */ +-/* 5 */ {8, 16, 32, 32, deflate_slow}, +-/* 6 */ {8, 16, 128, 128, deflate_slow}, +-/* 7 */ {8, 32, 128, 256, deflate_slow}, +-/* 8 */ {32, 128, 258, 1024, deflate_slow}, +-/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */ +-#endif +- +-/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 +- * For deflate_fast() (levels <= 3) good is ignored and lazy has a different +- * meaning. +- */ +- +-#define EQUAL 0 +-/* result of memcmp for equal strings */ +- +-#ifndef NO_DUMMY_DECL +-struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ +-#endif +- +-/* =========================================================================== +- * Update a hash value with the given input byte +- * IN assertion: all calls to to UPDATE_HASH are made with consecutive +- * input characters, so that a running hash key can be computed from the +- * previous key instead of complete recalculation each time. +- */ +-#define UPDATE_HASH(s,h,c) (h = (((h)<hash_shift) ^ (c)) & s->hash_mask) +- +- +-/* =========================================================================== +- * Insert string str in the dictionary and set match_head to the previous head +- * of the hash chain (the most recent string with same hash key). Return +- * the previous length of the hash chain. +- * If this file is compiled with -DFASTEST, the compression level is forced +- * to 1, and no hash chains are maintained. +- * IN assertion: all calls to to INSERT_STRING are made with consecutive +- * input characters and the first MIN_MATCH bytes of str are valid +- * (except for the last MIN_MATCH-1 bytes of the input file). +- */ +-#ifdef FASTEST +-#define INSERT_STRING(s, str, match_head) \ +- (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ +- match_head = s->head[s->ins_h], \ +- s->head[s->ins_h] = (Pos)(str)) +-#else +-#define INSERT_STRING(s, str, match_head) \ +- (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ +- match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \ +- s->head[s->ins_h] = (Pos)(str)) +-#endif +- +-/* =========================================================================== +- * Initialize the hash table (avoiding 64K overflow for 16 bit systems). +- * prev[] will be initialized on the fly. +- */ +-#define CLEAR_HASH(s) \ +- s->head[s->hash_size-1] = NIL; \ +- zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); +- +-/* ========================================================================= */ +-int ZEXPORT deflateInit_(strm, level, version, stream_size) +- z_streamp strm; +- int level; +- const char *version; +- int stream_size; +-{ +- return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, +- Z_DEFAULT_STRATEGY, version, stream_size); +- /* To do: ignore strm->next_in if we use it as window */ +-} +- +-/* ========================================================================= */ +-int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, +- version, stream_size) +- z_streamp strm; +- int level; +- int method; +- int windowBits; +- int memLevel; +- int strategy; +- const char *version; +- int stream_size; +-{ +- deflate_state *s; +- int wrap = 1; +- static const char my_version[] = ZLIB_VERSION; +- +- ushf *overlay; +- /* We overlay pending_buf and d_buf+l_buf. This works since the average +- * output size for (length,distance) codes is <= 24 bits. +- */ +- +- if (version == Z_NULL || version[0] != my_version[0] || +- stream_size != sizeof(z_stream)) { +- return Z_VERSION_ERROR; +- } +- if (strm == Z_NULL) return Z_STREAM_ERROR; +- +- strm->msg = Z_NULL; +- if (strm->zalloc == (alloc_func)0) { +- strm->zalloc = zcalloc; +- strm->opaque = (voidpf)0; +- } +- if (strm->zfree == (free_func)0) strm->zfree = zcfree; +- +-#ifdef FASTEST +- if (level != 0) level = 1; +-#else +- if (level == Z_DEFAULT_COMPRESSION) level = 6; +-#endif +- +- if (windowBits < 0) { /* suppress zlib wrapper */ +- wrap = 0; +- windowBits = -windowBits; +- } +-#ifdef GZIP +- else if (windowBits > 15) { +- wrap = 2; /* write gzip wrapper instead */ +- windowBits -= 16; +- } +-#endif +- if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || +- windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || +- strategy < 0 || strategy > Z_FIXED) { +- return Z_STREAM_ERROR; +- } +- if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */ +- s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state)); +- if (s == Z_NULL) return Z_MEM_ERROR; +- strm->state = (struct internal_state FAR *)s; +- s->strm = strm; +- +- s->wrap = wrap; +- s->gzhead = Z_NULL; +- s->w_bits = windowBits; +- s->w_size = 1 << s->w_bits; +- s->w_mask = s->w_size - 1; +- +- s->hash_bits = memLevel + 7; +- s->hash_size = 1 << s->hash_bits; +- s->hash_mask = s->hash_size - 1; +- s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); +- +- s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); +- s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); +- s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); +- +- s->high_water = 0; /* nothing written to s->window yet */ +- +- s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ +- +- overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); +- s->pending_buf = (uchf *) overlay; +- s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L); +- +- if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || +- s->pending_buf == Z_NULL) { +- s->status = FINISH_STATE; +- strm->msg = (char*)ERR_MSG(Z_MEM_ERROR); +- deflateEnd (strm); +- return Z_MEM_ERROR; +- } +- s->d_buf = overlay + s->lit_bufsize/sizeof(ush); +- s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; +- +- s->level = level; +- s->strategy = strategy; +- s->method = (Byte)method; +- +- return deflateReset(strm); +-} +- +-/* ========================================================================= */ +-int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) +- z_streamp strm; +- const Bytef *dictionary; +- uInt dictLength; +-{ +- deflate_state *s; +- uInt length = dictLength; +- uInt n; +- IPos hash_head = 0; +- +- if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL || +- strm->state->wrap == 2 || +- (strm->state->wrap == 1 && strm->state->status != INIT_STATE)) +- return Z_STREAM_ERROR; +- +- s = strm->state; +- if (s->wrap) +- strm->adler = adler32(strm->adler, dictionary, dictLength); +- +- if (length < MIN_MATCH) return Z_OK; +- if (length > s->w_size) { +- length = s->w_size; +- dictionary += dictLength - length; /* use the tail of the dictionary */ +- } +- zmemcpy(s->window, dictionary, length); +- s->strstart = length; +- s->block_start = (long)length; +- +- /* Insert all strings in the hash table (except for the last two bytes). +- * s->lookahead stays null, so s->ins_h will be recomputed at the next +- * call of fill_window. +- */ +- s->ins_h = s->window[0]; +- UPDATE_HASH(s, s->ins_h, s->window[1]); +- for (n = 0; n <= length - MIN_MATCH; n++) { +- INSERT_STRING(s, n, hash_head); +- } +- if (hash_head) hash_head = 0; /* to make compiler happy */ +- return Z_OK; +-} +- +-/* ========================================================================= */ +-int ZEXPORT deflateReset (strm) +- z_streamp strm; +-{ +- deflate_state *s; +- +- if (strm == Z_NULL || strm->state == Z_NULL || +- strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) { +- return Z_STREAM_ERROR; +- } +- +- strm->total_in = strm->total_out = 0; +- strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */ +- strm->data_type = Z_UNKNOWN; +- +- s = (deflate_state *)strm->state; +- s->pending = 0; +- s->pending_out = s->pending_buf; +- +- if (s->wrap < 0) { +- s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */ +- } +- s->status = s->wrap ? INIT_STATE : BUSY_STATE; +- strm->adler = +-#ifdef GZIP +- s->wrap == 2 ? crc32(0L, Z_NULL, 0) : +-#endif +- adler32(0L, Z_NULL, 0); +- s->last_flush = Z_NO_FLUSH; +- +- _tr_init(s); +- lm_init(s); +- +- return Z_OK; +-} +- +-/* ========================================================================= */ +-int ZEXPORT deflateSetHeader (strm, head) +- z_streamp strm; +- gz_headerp head; +-{ +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; +- if (strm->state->wrap != 2) return Z_STREAM_ERROR; +- strm->state->gzhead = head; +- return Z_OK; +-} +- +-/* ========================================================================= */ +-int ZEXPORT deflatePrime (strm, bits, value) +- z_streamp strm; +- int bits; +- int value; +-{ +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; +- strm->state->bi_valid = bits; +- strm->state->bi_buf = (ush)(value & ((1 << bits) - 1)); +- return Z_OK; +-} +- +-/* ========================================================================= */ +-int ZEXPORT deflateParams(strm, level, strategy) +- z_streamp strm; +- int level; +- int strategy; +-{ +- deflate_state *s; +- compress_func func; +- int err = Z_OK; +- +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; +- s = strm->state; +- +-#ifdef FASTEST +- if (level != 0) level = 1; +-#else +- if (level == Z_DEFAULT_COMPRESSION) level = 6; +-#endif +- if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { +- return Z_STREAM_ERROR; +- } +- func = configuration_table[s->level].func; +- +- if ((strategy != s->strategy || func != configuration_table[level].func) && +- strm->total_in != 0) { +- /* Flush the last buffer: */ +- err = deflate(strm, Z_BLOCK); +- } +- if (s->level != level) { +- s->level = level; +- s->max_lazy_match = configuration_table[level].max_lazy; +- s->good_match = configuration_table[level].good_length; +- s->nice_match = configuration_table[level].nice_length; +- s->max_chain_length = configuration_table[level].max_chain; +- } +- s->strategy = strategy; +- return err; +-} +- +-/* ========================================================================= */ +-int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain) +- z_streamp strm; +- int good_length; +- int max_lazy; +- int nice_length; +- int max_chain; +-{ +- deflate_state *s; +- +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; +- s = strm->state; +- s->good_match = good_length; +- s->max_lazy_match = max_lazy; +- s->nice_match = nice_length; +- s->max_chain_length = max_chain; +- return Z_OK; +-} +- +-/* ========================================================================= +- * For the default windowBits of 15 and memLevel of 8, this function returns +- * a close to exact, as well as small, upper bound on the compressed size. +- * They are coded as constants here for a reason--if the #define's are +- * changed, then this function needs to be changed as well. The return +- * value for 15 and 8 only works for those exact settings. +- * +- * For any setting other than those defaults for windowBits and memLevel, +- * the value returned is a conservative worst case for the maximum expansion +- * resulting from using fixed blocks instead of stored blocks, which deflate +- * can emit on compressed data for some combinations of the parameters. +- * +- * This function could be more sophisticated to provide closer upper bounds for +- * every combination of windowBits and memLevel. But even the conservative +- * upper bound of about 14% expansion does not seem onerous for output buffer +- * allocation. +- */ +-uLong ZEXPORT deflateBound(strm, sourceLen) +- z_streamp strm; +- uLong sourceLen; +-{ +- deflate_state *s; +- uLong complen, wraplen; +- Bytef *str; +- +- /* conservative upper bound for compressed data */ +- complen = sourceLen + +- ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5; +- +- /* if can't get parameters, return conservative bound plus zlib wrapper */ +- if (strm == Z_NULL || strm->state == Z_NULL) +- return complen + 6; +- +- /* compute wrapper length */ +- s = strm->state; +- switch (s->wrap) { +- case 0: /* raw deflate */ +- wraplen = 0; +- break; +- case 1: /* zlib wrapper */ +- wraplen = 6 + (s->strstart ? 4 : 0); +- break; +- case 2: /* gzip wrapper */ +- wraplen = 18; +- if (s->gzhead != Z_NULL) { /* user-supplied gzip header */ +- if (s->gzhead->extra != Z_NULL) +- wraplen += 2 + s->gzhead->extra_len; +- str = s->gzhead->name; +- if (str != Z_NULL) +- do { +- wraplen++; +- } while (*str++); +- str = s->gzhead->comment; +- if (str != Z_NULL) +- do { +- wraplen++; +- } while (*str++); +- if (s->gzhead->hcrc) +- wraplen += 2; +- } +- break; +- default: /* for compiler happiness */ +- wraplen = 6; +- } +- +- /* if not default parameters, return conservative bound */ +- if (s->w_bits != 15 || s->hash_bits != 8 + 7) +- return complen + wraplen; +- +- /* default settings: return tight bound for that case */ +- return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + +- (sourceLen >> 25) + 13 - 6 + wraplen; +-} +- +-/* ========================================================================= +- * Put a short in the pending buffer. The 16-bit value is put in MSB order. +- * IN assertion: the stream state is correct and there is enough room in +- * pending_buf. +- */ +-local void putShortMSB (s, b) +- deflate_state *s; +- uInt b; +-{ +- put_byte(s, (Byte)(b >> 8)); +- put_byte(s, (Byte)(b & 0xff)); +-} +- +-/* ========================================================================= +- * Flush as much pending output as possible. All deflate() output goes +- * through this function so some applications may wish to modify it +- * to avoid allocating a large strm->next_out buffer and copying into it. +- * (See also read_buf()). +- */ +-local void flush_pending(strm) +- z_streamp strm; +-{ +- unsigned len = strm->state->pending; +- +- if (len > strm->avail_out) len = strm->avail_out; +- if (len == 0) return; +- +- zmemcpy(strm->next_out, strm->state->pending_out, len); +- strm->next_out += len; +- strm->state->pending_out += len; +- strm->total_out += len; +- strm->avail_out -= len; +- strm->state->pending -= len; +- if (strm->state->pending == 0) { +- strm->state->pending_out = strm->state->pending_buf; +- } +-} +- +-/* ========================================================================= */ +-int ZEXPORT deflate (strm, flush) +- z_streamp strm; +- int flush; +-{ +- int old_flush; /* value of flush param for previous deflate call */ +- deflate_state *s; +- +- if (strm == Z_NULL || strm->state == Z_NULL || +- flush > Z_BLOCK || flush < 0) { +- return Z_STREAM_ERROR; +- } +- s = strm->state; +- +- if (strm->next_out == Z_NULL || +- (strm->next_in == Z_NULL && strm->avail_in != 0) || +- (s->status == FINISH_STATE && flush != Z_FINISH)) { +- ERR_RETURN(strm, Z_STREAM_ERROR); +- } +- if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); +- +- s->strm = strm; /* just in case */ +- old_flush = s->last_flush; +- s->last_flush = flush; +- +- /* Write the header */ +- if (s->status == INIT_STATE) { +-#ifdef GZIP +- if (s->wrap == 2) { +- strm->adler = crc32(0L, Z_NULL, 0); +- put_byte(s, 31); +- put_byte(s, 139); +- put_byte(s, 8); +- if (s->gzhead == Z_NULL) { +- put_byte(s, 0); +- put_byte(s, 0); +- put_byte(s, 0); +- put_byte(s, 0); +- put_byte(s, 0); +- put_byte(s, s->level == 9 ? 2 : +- (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? +- 4 : 0)); +- put_byte(s, OS_CODE); +- s->status = BUSY_STATE; +- } +- else { +- put_byte(s, (s->gzhead->text ? 1 : 0) + +- (s->gzhead->hcrc ? 2 : 0) + +- (s->gzhead->extra == Z_NULL ? 0 : 4) + +- (s->gzhead->name == Z_NULL ? 0 : 8) + +- (s->gzhead->comment == Z_NULL ? 0 : 16) +- ); +- put_byte(s, (Byte)(s->gzhead->time & 0xff)); +- put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff)); +- put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff)); +- put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff)); +- put_byte(s, s->level == 9 ? 2 : +- (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? +- 4 : 0)); +- put_byte(s, s->gzhead->os & 0xff); +- if (s->gzhead->extra != Z_NULL) { +- put_byte(s, s->gzhead->extra_len & 0xff); +- put_byte(s, (s->gzhead->extra_len >> 8) & 0xff); +- } +- if (s->gzhead->hcrc) +- strm->adler = crc32(strm->adler, s->pending_buf, +- s->pending); +- s->gzindex = 0; +- s->status = EXTRA_STATE; +- } +- } +- else +-#endif +- { +- uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; +- uInt level_flags; +- +- if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) +- level_flags = 0; +- else if (s->level < 6) +- level_flags = 1; +- else if (s->level == 6) +- level_flags = 2; +- else +- level_flags = 3; +- header |= (level_flags << 6); +- if (s->strstart != 0) header |= PRESET_DICT; +- header += 31 - (header % 31); +- +- s->status = BUSY_STATE; +- putShortMSB(s, header); +- +- /* Save the adler32 of the preset dictionary: */ +- if (s->strstart != 0) { +- putShortMSB(s, (uInt)(strm->adler >> 16)); +- putShortMSB(s, (uInt)(strm->adler & 0xffff)); +- } +- strm->adler = adler32(0L, Z_NULL, 0); +- } +- } +-#ifdef GZIP +- if (s->status == EXTRA_STATE) { +- if (s->gzhead->extra != Z_NULL) { +- uInt beg = s->pending; /* start of bytes to update crc */ +- +- while (s->gzindex < (s->gzhead->extra_len & 0xffff)) { +- if (s->pending == s->pending_buf_size) { +- if (s->gzhead->hcrc && s->pending > beg) +- strm->adler = crc32(strm->adler, s->pending_buf + beg, +- s->pending - beg); +- flush_pending(strm); +- beg = s->pending; +- if (s->pending == s->pending_buf_size) +- break; +- } +- put_byte(s, s->gzhead->extra[s->gzindex]); +- s->gzindex++; +- } +- if (s->gzhead->hcrc && s->pending > beg) +- strm->adler = crc32(strm->adler, s->pending_buf + beg, +- s->pending - beg); +- if (s->gzindex == s->gzhead->extra_len) { +- s->gzindex = 0; +- s->status = NAME_STATE; +- } +- } +- else +- s->status = NAME_STATE; +- } +- if (s->status == NAME_STATE) { +- if (s->gzhead->name != Z_NULL) { +- uInt beg = s->pending; /* start of bytes to update crc */ +- int val; +- +- do { +- if (s->pending == s->pending_buf_size) { +- if (s->gzhead->hcrc && s->pending > beg) +- strm->adler = crc32(strm->adler, s->pending_buf + beg, +- s->pending - beg); +- flush_pending(strm); +- beg = s->pending; +- if (s->pending == s->pending_buf_size) { +- val = 1; +- break; +- } +- } +- val = s->gzhead->name[s->gzindex++]; +- put_byte(s, val); +- } while (val != 0); +- if (s->gzhead->hcrc && s->pending > beg) +- strm->adler = crc32(strm->adler, s->pending_buf + beg, +- s->pending - beg); +- if (val == 0) { +- s->gzindex = 0; +- s->status = COMMENT_STATE; +- } +- } +- else +- s->status = COMMENT_STATE; +- } +- if (s->status == COMMENT_STATE) { +- if (s->gzhead->comment != Z_NULL) { +- uInt beg = s->pending; /* start of bytes to update crc */ +- int val; +- +- do { +- if (s->pending == s->pending_buf_size) { +- if (s->gzhead->hcrc && s->pending > beg) +- strm->adler = crc32(strm->adler, s->pending_buf + beg, +- s->pending - beg); +- flush_pending(strm); +- beg = s->pending; +- if (s->pending == s->pending_buf_size) { +- val = 1; +- break; +- } +- } +- val = s->gzhead->comment[s->gzindex++]; +- put_byte(s, val); +- } while (val != 0); +- if (s->gzhead->hcrc && s->pending > beg) +- strm->adler = crc32(strm->adler, s->pending_buf + beg, +- s->pending - beg); +- if (val == 0) +- s->status = HCRC_STATE; +- } +- else +- s->status = HCRC_STATE; +- } +- if (s->status == HCRC_STATE) { +- if (s->gzhead->hcrc) { +- if (s->pending + 2 > s->pending_buf_size) +- flush_pending(strm); +- if (s->pending + 2 <= s->pending_buf_size) { +- put_byte(s, (Byte)(strm->adler & 0xff)); +- put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); +- strm->adler = crc32(0L, Z_NULL, 0); +- s->status = BUSY_STATE; +- } +- } +- else +- s->status = BUSY_STATE; +- } +-#endif +- +- /* Flush as much pending output as possible */ +- if (s->pending != 0) { +- flush_pending(strm); +- if (strm->avail_out == 0) { +- /* Since avail_out is 0, deflate will be called again with +- * more output space, but possibly with both pending and +- * avail_in equal to zero. There won't be anything to do, +- * but this is not an error situation so make sure we +- * return OK instead of BUF_ERROR at next call of deflate: +- */ +- s->last_flush = -1; +- return Z_OK; +- } +- +- /* Make sure there is something to do and avoid duplicate consecutive +- * flushes. For repeated and useless calls with Z_FINISH, we keep +- * returning Z_STREAM_END instead of Z_BUF_ERROR. +- */ +- } else if (strm->avail_in == 0 && flush <= old_flush && +- flush != Z_FINISH) { +- ERR_RETURN(strm, Z_BUF_ERROR); +- } +- +- /* User must not provide more input after the first FINISH: */ +- if (s->status == FINISH_STATE && strm->avail_in != 0) { +- ERR_RETURN(strm, Z_BUF_ERROR); +- } +- +- /* Start a new block or continue the current one. +- */ +- if (strm->avail_in != 0 || s->lookahead != 0 || +- (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { +- block_state bstate; +- +- bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : +- (s->strategy == Z_RLE ? deflate_rle(s, flush) : +- (*(configuration_table[s->level].func))(s, flush)); +- +- if (bstate == finish_started || bstate == finish_done) { +- s->status = FINISH_STATE; +- } +- if (bstate == need_more || bstate == finish_started) { +- if (strm->avail_out == 0) { +- s->last_flush = -1; /* avoid BUF_ERROR next call, see above */ +- } +- return Z_OK; +- /* If flush != Z_NO_FLUSH && avail_out == 0, the next call +- * of deflate should use the same flush parameter to make sure +- * that the flush is complete. So we don't have to output an +- * empty block here, this will be done at next call. This also +- * ensures that for a very small output buffer, we emit at most +- * one empty block. +- */ +- } +- if (bstate == block_done) { +- if (flush == Z_PARTIAL_FLUSH) { +- _tr_align(s); +- } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */ +- _tr_stored_block(s, (char*)0, 0L, 0); +- /* For a full flush, this empty block will be recognized +- * as a special marker by inflate_sync(). +- */ +- if (flush == Z_FULL_FLUSH) { +- CLEAR_HASH(s); /* forget history */ +- if (s->lookahead == 0) { +- s->strstart = 0; +- s->block_start = 0L; +- } +- } +- } +- flush_pending(strm); +- if (strm->avail_out == 0) { +- s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ +- return Z_OK; +- } +- } +- } +- Assert(strm->avail_out > 0, "bug2"); +- +- if (flush != Z_FINISH) return Z_OK; +- if (s->wrap <= 0) return Z_STREAM_END; +- +- /* Write the trailer */ +-#ifdef GZIP +- if (s->wrap == 2) { +- put_byte(s, (Byte)(strm->adler & 0xff)); +- put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); +- put_byte(s, (Byte)((strm->adler >> 16) & 0xff)); +- put_byte(s, (Byte)((strm->adler >> 24) & 0xff)); +- put_byte(s, (Byte)(strm->total_in & 0xff)); +- put_byte(s, (Byte)((strm->total_in >> 8) & 0xff)); +- put_byte(s, (Byte)((strm->total_in >> 16) & 0xff)); +- put_byte(s, (Byte)((strm->total_in >> 24) & 0xff)); +- } +- else +-#endif +- { +- putShortMSB(s, (uInt)(strm->adler >> 16)); +- putShortMSB(s, (uInt)(strm->adler & 0xffff)); +- } +- flush_pending(strm); +- /* If avail_out is zero, the application will call deflate again +- * to flush the rest. +- */ +- if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */ +- return s->pending != 0 ? Z_OK : Z_STREAM_END; +-} +- +-/* ========================================================================= */ +-int ZEXPORT deflateEnd (strm) +- z_streamp strm; +-{ +- int status; +- +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; +- +- status = strm->state->status; +- if (status != INIT_STATE && +- status != EXTRA_STATE && +- status != NAME_STATE && +- status != COMMENT_STATE && +- status != HCRC_STATE && +- status != BUSY_STATE && +- status != FINISH_STATE) { +- return Z_STREAM_ERROR; +- } +- +- /* Deallocate in reverse order of allocations: */ +- TRY_FREE(strm, strm->state->pending_buf); +- TRY_FREE(strm, strm->state->head); +- TRY_FREE(strm, strm->state->prev); +- TRY_FREE(strm, strm->state->window); +- +- ZFREE(strm, strm->state); +- strm->state = Z_NULL; +- +- return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; +-} +- +-/* ========================================================================= +- * Copy the source state to the destination state. +- * To simplify the source, this is not supported for 16-bit MSDOS (which +- * doesn't have enough memory anyway to duplicate compression states). +- */ +-int ZEXPORT deflateCopy (dest, source) +- z_streamp dest; +- z_streamp source; +-{ +-#ifdef MAXSEG_64K +- return Z_STREAM_ERROR; +-#else +- deflate_state *ds; +- deflate_state *ss; +- ushf *overlay; +- +- +- if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { +- return Z_STREAM_ERROR; +- } +- +- ss = source->state; +- +- zmemcpy(dest, source, sizeof(z_stream)); +- +- ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state)); +- if (ds == Z_NULL) return Z_MEM_ERROR; +- dest->state = (struct internal_state FAR *) ds; +- zmemcpy(ds, ss, sizeof(deflate_state)); +- ds->strm = dest; +- +- ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); +- ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); +- ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); +- overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2); +- ds->pending_buf = (uchf *) overlay; +- +- if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || +- ds->pending_buf == Z_NULL) { +- deflateEnd (dest); +- return Z_MEM_ERROR; +- } +- /* following zmemcpy do not work for 16-bit MSDOS */ +- zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); +- zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos)); +- zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos)); +- zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); +- +- ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); +- ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush); +- ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize; +- +- ds->l_desc.dyn_tree = ds->dyn_ltree; +- ds->d_desc.dyn_tree = ds->dyn_dtree; +- ds->bl_desc.dyn_tree = ds->bl_tree; +- +- return Z_OK; +-#endif /* MAXSEG_64K */ +-} +- +-/* =========================================================================== +- * Read a new buffer from the current input stream, update the adler32 +- * and total number of bytes read. All deflate() input goes through +- * this function so some applications may wish to modify it to avoid +- * allocating a large strm->next_in buffer and copying from it. +- * (See also flush_pending()). +- */ +-local int read_buf(strm, buf, size) +- z_streamp strm; +- Bytef *buf; +- unsigned size; +-{ +- unsigned len = strm->avail_in; +- +- if (len > size) len = size; +- if (len == 0) return 0; +- +- strm->avail_in -= len; +- +- if (strm->state->wrap == 1) { +- strm->adler = adler32(strm->adler, strm->next_in, len); +- } +-#ifdef GZIP +- else if (strm->state->wrap == 2) { +- strm->adler = crc32(strm->adler, strm->next_in, len); +- } +-#endif +- zmemcpy(buf, strm->next_in, len); +- strm->next_in += len; +- strm->total_in += len; +- +- return (int)len; +-} +- +-/* =========================================================================== +- * Initialize the "longest match" routines for a new zlib stream +- */ +-local void lm_init (s) +- deflate_state *s; +-{ +- s->window_size = (ulg)2L*s->w_size; +- +- CLEAR_HASH(s); +- +- /* Set the default configuration parameters: +- */ +- s->max_lazy_match = configuration_table[s->level].max_lazy; +- s->good_match = configuration_table[s->level].good_length; +- s->nice_match = configuration_table[s->level].nice_length; +- s->max_chain_length = configuration_table[s->level].max_chain; +- +- s->strstart = 0; +- s->block_start = 0L; +- s->lookahead = 0; +- s->match_length = s->prev_length = MIN_MATCH-1; +- s->match_available = 0; +- s->ins_h = 0; +-#ifndef FASTEST +-#ifdef ASMV +- match_init(); /* initialize the asm code */ +-#endif +-#endif +-} +- +-#ifndef FASTEST +-/* =========================================================================== +- * Set match_start to the longest match starting at the given string and +- * return its length. Matches shorter or equal to prev_length are discarded, +- * in which case the result is equal to prev_length and match_start is +- * garbage. +- * IN assertions: cur_match is the head of the hash chain for the current +- * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 +- * OUT assertion: the match length is not greater than s->lookahead. +- */ +-#ifndef ASMV +-/* For 80x86 and 680x0, an optimized version will be provided in match.asm or +- * match.S. The code will be functionally equivalent. +- */ +-local uInt longest_match(s, cur_match) +- deflate_state *s; +- IPos cur_match; /* current match */ +-{ +- unsigned chain_length = s->max_chain_length;/* max hash chain length */ +- register Bytef *scan = s->window + s->strstart; /* current string */ +- register Bytef *match; /* matched string */ +- register int len; /* length of current match */ +- int best_len = s->prev_length; /* best match length so far */ +- int nice_match = s->nice_match; /* stop if match long enough */ +- IPos limit = s->strstart > (IPos)MAX_DIST(s) ? +- s->strstart - (IPos)MAX_DIST(s) : NIL; +- /* Stop when cur_match becomes <= limit. To simplify the code, +- * we prevent matches with the string of window index 0. +- */ +- Posf *prev = s->prev; +- uInt wmask = s->w_mask; +- +-#ifdef UNALIGNED_OK +- /* Compare two bytes at a time. Note: this is not always beneficial. +- * Try with and without -DUNALIGNED_OK to check. +- */ +- register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; +- register ush scan_start = *(ushf*)scan; +- register ush scan_end = *(ushf*)(scan+best_len-1); +-#else +- register Bytef *strend = s->window + s->strstart + MAX_MATCH; +- register Byte scan_end1 = scan[best_len-1]; +- register Byte scan_end = scan[best_len]; +-#endif +- +- /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. +- * It is easy to get rid of this optimization if necessary. +- */ +- Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); +- +- /* Do not waste too much time if we already have a good match: */ +- if (s->prev_length >= s->good_match) { +- chain_length >>= 2; +- } +- /* Do not look for matches beyond the end of the input. This is necessary +- * to make deflate deterministic. +- */ +- if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; +- +- Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); +- +- do { +- Assert(cur_match < s->strstart, "no future"); +- match = s->window + cur_match; +- +- /* Skip to next match if the match length cannot increase +- * or if the match length is less than 2. Note that the checks below +- * for insufficient lookahead only occur occasionally for performance +- * reasons. Therefore uninitialized memory will be accessed, and +- * conditional jumps will be made that depend on those values. +- * However the length of the match is limited to the lookahead, so +- * the output of deflate is not affected by the uninitialized values. +- */ +-#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) +- /* This code assumes sizeof(unsigned short) == 2. Do not use +- * UNALIGNED_OK if your compiler uses a different size. +- */ +- if (*(ushf*)(match+best_len-1) != scan_end || +- *(ushf*)match != scan_start) continue; +- +- /* It is not necessary to compare scan[2] and match[2] since they are +- * always equal when the other bytes match, given that the hash keys +- * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at +- * strstart+3, +5, ... up to strstart+257. We check for insufficient +- * lookahead only every 4th comparison; the 128th check will be made +- * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is +- * necessary to put more guard bytes at the end of the window, or +- * to check more often for insufficient lookahead. +- */ +- Assert(scan[2] == match[2], "scan[2]?"); +- scan++, match++; +- do { +- } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && +- *(ushf*)(scan+=2) == *(ushf*)(match+=2) && +- *(ushf*)(scan+=2) == *(ushf*)(match+=2) && +- *(ushf*)(scan+=2) == *(ushf*)(match+=2) && +- scan < strend); +- /* The funny "do {}" generates better code on most compilers */ +- +- /* Here, scan <= window+strstart+257 */ +- Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); +- if (*scan == *match) scan++; +- +- len = (MAX_MATCH - 1) - (int)(strend-scan); +- scan = strend - (MAX_MATCH-1); +- +-#else /* UNALIGNED_OK */ +- +- if (match[best_len] != scan_end || +- match[best_len-1] != scan_end1 || +- *match != *scan || +- *++match != scan[1]) continue; +- +- /* The check at best_len-1 can be removed because it will be made +- * again later. (This heuristic is not always a win.) +- * It is not necessary to compare scan[2] and match[2] since they +- * are always equal when the other bytes match, given that +- * the hash keys are equal and that HASH_BITS >= 8. +- */ +- scan += 2, match++; +- Assert(*scan == *match, "match[2]?"); +- +- /* We check for insufficient lookahead only every 8th comparison; +- * the 256th check will be made at strstart+258. +- */ +- do { +- } while (*++scan == *++match && *++scan == *++match && +- *++scan == *++match && *++scan == *++match && +- *++scan == *++match && *++scan == *++match && +- *++scan == *++match && *++scan == *++match && +- scan < strend); +- +- Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); +- +- len = MAX_MATCH - (int)(strend - scan); +- scan = strend - MAX_MATCH; +- +-#endif /* UNALIGNED_OK */ +- +- if (len > best_len) { +- s->match_start = cur_match; +- best_len = len; +- if (len >= nice_match) break; +-#ifdef UNALIGNED_OK +- scan_end = *(ushf*)(scan+best_len-1); +-#else +- scan_end1 = scan[best_len-1]; +- scan_end = scan[best_len]; +-#endif +- } +- } while ((cur_match = prev[cur_match & wmask]) > limit +- && --chain_length != 0); +- +- if ((uInt)best_len <= s->lookahead) return (uInt)best_len; +- return s->lookahead; +-} +-#endif /* ASMV */ +- +-#else /* FASTEST */ +- +-/* --------------------------------------------------------------------------- +- * Optimized version for FASTEST only +- */ +-local uInt longest_match(s, cur_match) +- deflate_state *s; +- IPos cur_match; /* current match */ +-{ +- register Bytef *scan = s->window + s->strstart; /* current string */ +- register Bytef *match; /* matched string */ +- register int len; /* length of current match */ +- register Bytef *strend = s->window + s->strstart + MAX_MATCH; +- +- /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. +- * It is easy to get rid of this optimization if necessary. +- */ +- Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); +- +- Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); +- +- Assert(cur_match < s->strstart, "no future"); +- +- match = s->window + cur_match; +- +- /* Return failure if the match length is less than 2: +- */ +- if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; +- +- /* The check at best_len-1 can be removed because it will be made +- * again later. (This heuristic is not always a win.) +- * It is not necessary to compare scan[2] and match[2] since they +- * are always equal when the other bytes match, given that +- * the hash keys are equal and that HASH_BITS >= 8. +- */ +- scan += 2, match += 2; +- Assert(*scan == *match, "match[2]?"); +- +- /* We check for insufficient lookahead only every 8th comparison; +- * the 256th check will be made at strstart+258. +- */ +- do { +- } while (*++scan == *++match && *++scan == *++match && +- *++scan == *++match && *++scan == *++match && +- *++scan == *++match && *++scan == *++match && +- *++scan == *++match && *++scan == *++match && +- scan < strend); +- +- Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); +- +- len = MAX_MATCH - (int)(strend - scan); +- +- if (len < MIN_MATCH) return MIN_MATCH - 1; +- +- s->match_start = cur_match; +- return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead; +-} +- +-#endif /* FASTEST */ +- +-#ifdef DEBUG +-/* =========================================================================== +- * Check that the match at match_start is indeed a match. +- */ +-local void check_match(s, start, match, length) +- deflate_state *s; +- IPos start, match; +- int length; +-{ +- /* check that the match is indeed a match */ +- if (zmemcmp(s->window + match, +- s->window + start, length) != EQUAL) { +- fprintf(stderr, " start %u, match %u, length %d\n", +- start, match, length); +- do { +- fprintf(stderr, "%c%c", s->window[match++], s->window[start++]); +- } while (--length != 0); +- z_error("invalid match"); +- } +- if (z_verbose > 1) { +- fprintf(stderr,"\\[%d,%d]", start-match, length); +- do { putc(s->window[start++], stderr); } while (--length != 0); +- } +-} +-#else +-# define check_match(s, start, match, length) +-#endif /* DEBUG */ +- +-/* =========================================================================== +- * Fill the window when the lookahead becomes insufficient. +- * Updates strstart and lookahead. +- * +- * IN assertion: lookahead < MIN_LOOKAHEAD +- * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD +- * At least one byte has been read, or avail_in == 0; reads are +- * performed for at least two bytes (required for the zip translate_eol +- * option -- not supported here). +- */ +-local void fill_window(s) +- deflate_state *s; +-{ +- register unsigned n, m; +- register Posf *p; +- unsigned more; /* Amount of free space at the end of the window. */ +- uInt wsize = s->w_size; +- +- do { +- more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); +- +- /* Deal with !@#$% 64K limit: */ +- if (sizeof(int) <= 2) { +- if (more == 0 && s->strstart == 0 && s->lookahead == 0) { +- more = wsize; +- +- } else if (more == (unsigned)(-1)) { +- /* Very unlikely, but possible on 16 bit machine if +- * strstart == 0 && lookahead == 1 (input done a byte at time) +- */ +- more--; +- } +- } +- +- /* If the window is almost full and there is insufficient lookahead, +- * move the upper half to the lower one to make room in the upper half. +- */ +- if (s->strstart >= wsize+MAX_DIST(s)) { +- +- zmemcpy(s->window, s->window+wsize, (unsigned)wsize); +- s->match_start -= wsize; +- s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ +- s->block_start -= (long) wsize; +- +- /* Slide the hash table (could be avoided with 32 bit values +- at the expense of memory usage). We slide even when level == 0 +- to keep the hash table consistent if we switch back to level > 0 +- later. (Using level 0 permanently is not an optimal usage of +- zlib, so we don't care about this pathological case.) +- */ +- n = s->hash_size; +- p = &s->head[n]; +- do { +- m = *--p; +- *p = (Pos)(m >= wsize ? m-wsize : NIL); +- } while (--n); +- +- n = wsize; +-#ifndef FASTEST +- p = &s->prev[n]; +- do { +- m = *--p; +- *p = (Pos)(m >= wsize ? m-wsize : NIL); +- /* If n is not on any hash chain, prev[n] is garbage but +- * its value will never be used. +- */ +- } while (--n); +-#endif +- more += wsize; +- } +- if (s->strm->avail_in == 0) return; +- +- /* If there was no sliding: +- * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && +- * more == window_size - lookahead - strstart +- * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) +- * => more >= window_size - 2*WSIZE + 2 +- * In the BIG_MEM or MMAP case (not yet supported), +- * window_size == input_size + MIN_LOOKAHEAD && +- * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. +- * Otherwise, window_size == 2*WSIZE so more >= 2. +- * If there was sliding, more >= WSIZE. So in all cases, more >= 2. +- */ +- Assert(more >= 2, "more < 2"); +- +- n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); +- s->lookahead += n; +- +- /* Initialize the hash value now that we have some input: */ +- if (s->lookahead >= MIN_MATCH) { +- s->ins_h = s->window[s->strstart]; +- UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); +-#if MIN_MATCH != 3 +- Call UPDATE_HASH() MIN_MATCH-3 more times +-#endif +- } +- /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, +- * but this is not important since only literal bytes will be emitted. +- */ +- +- } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); +- +- /* If the WIN_INIT bytes after the end of the current data have never been +- * written, then zero those bytes in order to avoid memory check reports of +- * the use of uninitialized (or uninitialised as Julian writes) bytes by +- * the longest match routines. Update the high water mark for the next +- * time through here. WIN_INIT is set to MAX_MATCH since the longest match +- * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. +- */ +- if (s->high_water < s->window_size) { +- ulg curr = s->strstart + (ulg)(s->lookahead); +- ulg init; +- +- if (s->high_water < curr) { +- /* Previous high water mark below current data -- zero WIN_INIT +- * bytes or up to end of window, whichever is less. +- */ +- init = s->window_size - curr; +- if (init > WIN_INIT) +- init = WIN_INIT; +- zmemzero(s->window + curr, (unsigned)init); +- s->high_water = curr + init; +- } +- else if (s->high_water < (ulg)curr + WIN_INIT) { +- /* High water mark at or above current data, but below current data +- * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up +- * to end of window, whichever is less. +- */ +- init = (ulg)curr + WIN_INIT - s->high_water; +- if (init > s->window_size - s->high_water) +- init = s->window_size - s->high_water; +- zmemzero(s->window + s->high_water, (unsigned)init); +- s->high_water += init; +- } +- } +-} +- +-/* =========================================================================== +- * Flush the current block, with given end-of-file flag. +- * IN assertion: strstart is set to the end of the current match. +- */ +-#define FLUSH_BLOCK_ONLY(s, last) { \ +- _tr_flush_block(s, (s->block_start >= 0L ? \ +- (charf *)&s->window[(unsigned)s->block_start] : \ +- (charf *)Z_NULL), \ +- (ulg)((long)s->strstart - s->block_start), \ +- (last)); \ +- s->block_start = s->strstart; \ +- flush_pending(s->strm); \ +- Tracev((stderr,"[FLUSH]")); \ +-} +- +-/* Same but force premature exit if necessary. */ +-#define FLUSH_BLOCK(s, last) { \ +- FLUSH_BLOCK_ONLY(s, last); \ +- if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \ +-} +- +-/* =========================================================================== +- * Copy without compression as much as possible from the input stream, return +- * the current block state. +- * This function does not insert new strings in the dictionary since +- * uncompressible data is probably not useful. This function is used +- * only for the level=0 compression option. +- * NOTE: this function should be optimized to avoid extra copying from +- * window to pending_buf. +- */ +-local block_state deflate_stored(s, flush) +- deflate_state *s; +- int flush; +-{ +- /* Stored blocks are limited to 0xffff bytes, pending_buf is limited +- * to pending_buf_size, and each stored block has a 5 byte header: +- */ +- ulg max_block_size = 0xffff; +- ulg max_start; +- +- if (max_block_size > s->pending_buf_size - 5) { +- max_block_size = s->pending_buf_size - 5; +- } +- +- /* Copy as much as possible from input to output: */ +- for (;;) { +- /* Fill the window as much as possible: */ +- if (s->lookahead <= 1) { +- +- Assert(s->strstart < s->w_size+MAX_DIST(s) || +- s->block_start >= (long)s->w_size, "slide too late"); +- +- fill_window(s); +- if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more; +- +- if (s->lookahead == 0) break; /* flush the current block */ +- } +- Assert(s->block_start >= 0L, "block gone"); +- +- s->strstart += s->lookahead; +- s->lookahead = 0; +- +- /* Emit a stored block if pending_buf will be full: */ +- max_start = s->block_start + max_block_size; +- if (s->strstart == 0 || (ulg)s->strstart >= max_start) { +- /* strstart == 0 is possible when wraparound on 16-bit machine */ +- s->lookahead = (uInt)(s->strstart - max_start); +- s->strstart = (uInt)max_start; +- FLUSH_BLOCK(s, 0); +- } +- /* Flush if we may have to slide, otherwise block_start may become +- * negative and the data will be gone: +- */ +- if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) { +- FLUSH_BLOCK(s, 0); +- } +- } +- FLUSH_BLOCK(s, flush == Z_FINISH); +- return flush == Z_FINISH ? finish_done : block_done; +-} +- +-/* =========================================================================== +- * Compress as much as possible from the input stream, return the current +- * block state. +- * This function does not perform lazy evaluation of matches and inserts +- * new strings in the dictionary only for unmatched strings or for short +- * matches. It is used only for the fast compression options. +- */ +-local block_state deflate_fast(s, flush) +- deflate_state *s; +- int flush; +-{ +- IPos hash_head; /* head of the hash chain */ +- int bflush; /* set if current block must be flushed */ +- +- for (;;) { +- /* Make sure that we always have enough lookahead, except +- * at the end of the input file. We need MAX_MATCH bytes +- * for the next match, plus MIN_MATCH bytes to insert the +- * string following the next match. +- */ +- if (s->lookahead < MIN_LOOKAHEAD) { +- fill_window(s); +- if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { +- return need_more; +- } +- if (s->lookahead == 0) break; /* flush the current block */ +- } +- +- /* Insert the string window[strstart .. strstart+2] in the +- * dictionary, and set hash_head to the head of the hash chain: +- */ +- hash_head = NIL; +- if (s->lookahead >= MIN_MATCH) { +- INSERT_STRING(s, s->strstart, hash_head); +- } +- +- /* Find the longest match, discarding those <= prev_length. +- * At this point we have always match_length < MIN_MATCH +- */ +- if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { +- /* To simplify the code, we prevent matches with the string +- * of window index 0 (in particular we have to avoid a match +- * of the string with itself at the start of the input file). +- */ +- s->match_length = longest_match (s, hash_head); +- /* longest_match() sets match_start */ +- } +- if (s->match_length >= MIN_MATCH) { +- check_match(s, s->strstart, s->match_start, s->match_length); +- +- _tr_tally_dist(s, s->strstart - s->match_start, +- s->match_length - MIN_MATCH, bflush); +- +- s->lookahead -= s->match_length; +- +- /* Insert new strings in the hash table only if the match length +- * is not too large. This saves time but degrades compression. +- */ +-#ifndef FASTEST +- if (s->match_length <= s->max_insert_length && +- s->lookahead >= MIN_MATCH) { +- s->match_length--; /* string at strstart already in table */ +- do { +- s->strstart++; +- INSERT_STRING(s, s->strstart, hash_head); +- /* strstart never exceeds WSIZE-MAX_MATCH, so there are +- * always MIN_MATCH bytes ahead. +- */ +- } while (--s->match_length != 0); +- s->strstart++; +- } else +-#endif +- { +- s->strstart += s->match_length; +- s->match_length = 0; +- s->ins_h = s->window[s->strstart]; +- UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); +-#if MIN_MATCH != 3 +- Call UPDATE_HASH() MIN_MATCH-3 more times +-#endif +- /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not +- * matter since it will be recomputed at next deflate call. +- */ +- } +- } else { +- /* No match, output a literal byte */ +- Tracevv((stderr,"%c", s->window[s->strstart])); +- _tr_tally_lit (s, s->window[s->strstart], bflush); +- s->lookahead--; +- s->strstart++; +- } +- if (bflush) FLUSH_BLOCK(s, 0); +- } +- FLUSH_BLOCK(s, flush == Z_FINISH); +- return flush == Z_FINISH ? finish_done : block_done; +-} +- +-#ifndef FASTEST +-/* =========================================================================== +- * Same as above, but achieves better compression. We use a lazy +- * evaluation for matches: a match is finally adopted only if there is +- * no better match at the next window position. +- */ +-local block_state deflate_slow(s, flush) +- deflate_state *s; +- int flush; +-{ +- IPos hash_head; /* head of hash chain */ +- int bflush; /* set if current block must be flushed */ +- +- /* Process the input block. */ +- for (;;) { +- /* Make sure that we always have enough lookahead, except +- * at the end of the input file. We need MAX_MATCH bytes +- * for the next match, plus MIN_MATCH bytes to insert the +- * string following the next match. +- */ +- if (s->lookahead < MIN_LOOKAHEAD) { +- fill_window(s); +- if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { +- return need_more; +- } +- if (s->lookahead == 0) break; /* flush the current block */ +- } +- +- /* Insert the string window[strstart .. strstart+2] in the +- * dictionary, and set hash_head to the head of the hash chain: +- */ +- hash_head = NIL; +- if (s->lookahead >= MIN_MATCH) { +- INSERT_STRING(s, s->strstart, hash_head); +- } +- +- /* Find the longest match, discarding those <= prev_length. +- */ +- s->prev_length = s->match_length, s->prev_match = s->match_start; +- s->match_length = MIN_MATCH-1; +- +- if (hash_head != NIL && s->prev_length < s->max_lazy_match && +- s->strstart - hash_head <= MAX_DIST(s)) { +- /* To simplify the code, we prevent matches with the string +- * of window index 0 (in particular we have to avoid a match +- * of the string with itself at the start of the input file). +- */ +- s->match_length = longest_match (s, hash_head); +- /* longest_match() sets match_start */ +- +- if (s->match_length <= 5 && (s->strategy == Z_FILTERED +-#if TOO_FAR <= 32767 +- || (s->match_length == MIN_MATCH && +- s->strstart - s->match_start > TOO_FAR) +-#endif +- )) { +- +- /* If prev_match is also MIN_MATCH, match_start is garbage +- * but we will ignore the current match anyway. +- */ +- s->match_length = MIN_MATCH-1; +- } +- } +- /* If there was a match at the previous step and the current +- * match is not better, output the previous match: +- */ +- if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { +- uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; +- /* Do not insert strings in hash table beyond this. */ +- +- check_match(s, s->strstart-1, s->prev_match, s->prev_length); +- +- _tr_tally_dist(s, s->strstart -1 - s->prev_match, +- s->prev_length - MIN_MATCH, bflush); +- +- /* Insert in hash table all strings up to the end of the match. +- * strstart-1 and strstart are already inserted. If there is not +- * enough lookahead, the last two strings are not inserted in +- * the hash table. +- */ +- s->lookahead -= s->prev_length-1; +- s->prev_length -= 2; +- do { +- if (++s->strstart <= max_insert) { +- INSERT_STRING(s, s->strstart, hash_head); +- } +- } while (--s->prev_length != 0); +- s->match_available = 0; +- s->match_length = MIN_MATCH-1; +- s->strstart++; +- +- if (bflush) FLUSH_BLOCK(s, 0); +- +- } else if (s->match_available) { +- /* If there was no match at the previous position, output a +- * single literal. If there was a match but the current match +- * is longer, truncate the previous match to a single literal. +- */ +- Tracevv((stderr,"%c", s->window[s->strstart-1])); +- _tr_tally_lit(s, s->window[s->strstart-1], bflush); +- if (bflush) { +- FLUSH_BLOCK_ONLY(s, 0); +- } +- s->strstart++; +- s->lookahead--; +- if (s->strm->avail_out == 0) return need_more; +- } else { +- /* There is no previous match to compare with, wait for +- * the next step to decide. +- */ +- s->match_available = 1; +- s->strstart++; +- s->lookahead--; +- } +- } +- Assert (flush != Z_NO_FLUSH, "no flush?"); +- if (s->match_available) { +- Tracevv((stderr,"%c", s->window[s->strstart-1])); +- _tr_tally_lit(s, s->window[s->strstart-1], bflush); +- s->match_available = 0; +- } +- FLUSH_BLOCK(s, flush == Z_FINISH); +- return flush == Z_FINISH ? finish_done : block_done; +-} +-#endif /* FASTEST */ +- +-/* =========================================================================== +- * For Z_RLE, simply look for runs of bytes, generate matches only of distance +- * one. Do not maintain a hash table. (It will be regenerated if this run of +- * deflate switches away from Z_RLE.) +- */ +-local block_state deflate_rle(s, flush) +- deflate_state *s; +- int flush; +-{ +- int bflush; /* set if current block must be flushed */ +- uInt prev; /* byte at distance one to match */ +- Bytef *scan, *strend; /* scan goes up to strend for length of run */ +- +- for (;;) { +- /* Make sure that we always have enough lookahead, except +- * at the end of the input file. We need MAX_MATCH bytes +- * for the longest encodable run. +- */ +- if (s->lookahead < MAX_MATCH) { +- fill_window(s); +- if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) { +- return need_more; +- } +- if (s->lookahead == 0) break; /* flush the current block */ +- } +- +- /* See how many times the previous byte repeats */ +- s->match_length = 0; +- if (s->lookahead >= MIN_MATCH && s->strstart > 0) { +- scan = s->window + s->strstart - 1; +- prev = *scan; +- if (prev == *++scan && prev == *++scan && prev == *++scan) { +- strend = s->window + s->strstart + MAX_MATCH; +- do { +- } while (prev == *++scan && prev == *++scan && +- prev == *++scan && prev == *++scan && +- prev == *++scan && prev == *++scan && +- prev == *++scan && prev == *++scan && +- scan < strend); +- s->match_length = MAX_MATCH - (int)(strend - scan); +- if (s->match_length > s->lookahead) +- s->match_length = s->lookahead; +- } +- } +- +- /* Emit match if have run of MIN_MATCH or longer, else emit literal */ +- if (s->match_length >= MIN_MATCH) { +- check_match(s, s->strstart, s->strstart - 1, s->match_length); +- +- _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush); +- +- s->lookahead -= s->match_length; +- s->strstart += s->match_length; +- s->match_length = 0; +- } else { +- /* No match, output a literal byte */ +- Tracevv((stderr,"%c", s->window[s->strstart])); +- _tr_tally_lit (s, s->window[s->strstart], bflush); +- s->lookahead--; +- s->strstart++; +- } +- if (bflush) FLUSH_BLOCK(s, 0); +- } +- FLUSH_BLOCK(s, flush == Z_FINISH); +- return flush == Z_FINISH ? finish_done : block_done; +-} +- +-/* =========================================================================== +- * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. +- * (It will be regenerated if this run of deflate switches away from Huffman.) +- */ +-local block_state deflate_huff(s, flush) +- deflate_state *s; +- int flush; +-{ +- int bflush; /* set if current block must be flushed */ +- +- for (;;) { +- /* Make sure that we have a literal to write. */ +- if (s->lookahead == 0) { +- fill_window(s); +- if (s->lookahead == 0) { +- if (flush == Z_NO_FLUSH) +- return need_more; +- break; /* flush the current block */ +- } +- } +- +- /* Output a literal byte */ +- s->match_length = 0; +- Tracevv((stderr,"%c", s->window[s->strstart])); +- _tr_tally_lit (s, s->window[s->strstart], bflush); +- s->lookahead--; +- s->strstart++; +- if (bflush) FLUSH_BLOCK(s, 0); +- } +- FLUSH_BLOCK(s, flush == Z_FINISH); +- return flush == Z_FINISH ? finish_done : block_done; +-} +diff --git a/thirdparty/zlib/deflate.h b/thirdparty/zlib/deflate.h +deleted file mode 100644 +index cbf0d1e..0000000 +--- a/thirdparty/zlib/deflate.h ++++ /dev/null +@@ -1,342 +0,0 @@ +-/* deflate.h -- internal compression state +- * Copyright (C) 1995-2010 Jean-loup Gailly +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* WARNING: this file should *not* be used by applications. It is +- part of the implementation of the compression library and is +- subject to change. Applications should only use zlib.h. +- */ +- +-/* @(#) $Id$ */ +- +-#ifndef DEFLATE_H +-#define DEFLATE_H +- +-#include "zutil.h" +- +-/* define NO_GZIP when compiling if you want to disable gzip header and +- trailer creation by deflate(). NO_GZIP would be used to avoid linking in +- the crc code when it is not needed. For shared libraries, gzip encoding +- should be left enabled. */ +-#ifndef NO_GZIP +-# define GZIP +-#endif +- +-/* =========================================================================== +- * Internal compression state. +- */ +- +-#define LENGTH_CODES 29 +-/* number of length codes, not counting the special END_BLOCK code */ +- +-#define LITERALS 256 +-/* number of literal bytes 0..255 */ +- +-#define L_CODES (LITERALS+1+LENGTH_CODES) +-/* number of Literal or Length codes, including the END_BLOCK code */ +- +-#define D_CODES 30 +-/* number of distance codes */ +- +-#define BL_CODES 19 +-/* number of codes used to transfer the bit lengths */ +- +-#define HEAP_SIZE (2*L_CODES+1) +-/* maximum heap size */ +- +-#define MAX_BITS 15 +-/* All codes must not exceed MAX_BITS bits */ +- +-#define INIT_STATE 42 +-#define EXTRA_STATE 69 +-#define NAME_STATE 73 +-#define COMMENT_STATE 91 +-#define HCRC_STATE 103 +-#define BUSY_STATE 113 +-#define FINISH_STATE 666 +-/* Stream status */ +- +- +-/* Data structure describing a single value and its code string. */ +-typedef struct ct_data_s { +- union { +- ush freq; /* frequency count */ +- ush code; /* bit string */ +- } fc; +- union { +- ush dad; /* father node in Huffman tree */ +- ush len; /* length of bit string */ +- } dl; +-} FAR ct_data; +- +-#define Freq fc.freq +-#define Code fc.code +-#define Dad dl.dad +-#define Len dl.len +- +-typedef struct static_tree_desc_s static_tree_desc; +- +-typedef struct tree_desc_s { +- ct_data *dyn_tree; /* the dynamic tree */ +- int max_code; /* largest code with non zero frequency */ +- static_tree_desc *stat_desc; /* the corresponding static tree */ +-} FAR tree_desc; +- +-typedef ush Pos; +-typedef Pos FAR Posf; +-typedef unsigned IPos; +- +-/* A Pos is an index in the character window. We use short instead of int to +- * save space in the various tables. IPos is used only for parameter passing. +- */ +- +-typedef struct internal_state { +- z_streamp strm; /* pointer back to this zlib stream */ +- int status; /* as the name implies */ +- Bytef *pending_buf; /* output still pending */ +- ulg pending_buf_size; /* size of pending_buf */ +- Bytef *pending_out; /* next pending byte to output to the stream */ +- uInt pending; /* nb of bytes in the pending buffer */ +- int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ +- gz_headerp gzhead; /* gzip header information to write */ +- uInt gzindex; /* where in extra, name, or comment */ +- Byte method; /* STORED (for zip only) or DEFLATED */ +- int last_flush; /* value of flush param for previous deflate call */ +- +- /* used by deflate.c: */ +- +- uInt w_size; /* LZ77 window size (32K by default) */ +- uInt w_bits; /* log2(w_size) (8..16) */ +- uInt w_mask; /* w_size - 1 */ +- +- Bytef *window; +- /* Sliding window. Input bytes are read into the second half of the window, +- * and move to the first half later to keep a dictionary of at least wSize +- * bytes. With this organization, matches are limited to a distance of +- * wSize-MAX_MATCH bytes, but this ensures that IO is always +- * performed with a length multiple of the block size. Also, it limits +- * the window size to 64K, which is quite useful on MSDOS. +- * To do: use the user input buffer as sliding window. +- */ +- +- ulg window_size; +- /* Actual size of window: 2*wSize, except when the user input buffer +- * is directly used as sliding window. +- */ +- +- Posf *prev; +- /* Link to older string with same hash index. To limit the size of this +- * array to 64K, this link is maintained only for the last 32K strings. +- * An index in this array is thus a window index modulo 32K. +- */ +- +- Posf *head; /* Heads of the hash chains or NIL. */ +- +- uInt ins_h; /* hash index of string to be inserted */ +- uInt hash_size; /* number of elements in hash table */ +- uInt hash_bits; /* log2(hash_size) */ +- uInt hash_mask; /* hash_size-1 */ +- +- uInt hash_shift; +- /* Number of bits by which ins_h must be shifted at each input +- * step. It must be such that after MIN_MATCH steps, the oldest +- * byte no longer takes part in the hash key, that is: +- * hash_shift * MIN_MATCH >= hash_bits +- */ +- +- long block_start; +- /* Window position at the beginning of the current output block. Gets +- * negative when the window is moved backwards. +- */ +- +- uInt match_length; /* length of best match */ +- IPos prev_match; /* previous match */ +- int match_available; /* set if previous match exists */ +- uInt strstart; /* start of string to insert */ +- uInt match_start; /* start of matching string */ +- uInt lookahead; /* number of valid bytes ahead in window */ +- +- uInt prev_length; +- /* Length of the best match at previous step. Matches not greater than this +- * are discarded. This is used in the lazy match evaluation. +- */ +- +- uInt max_chain_length; +- /* To speed up deflation, hash chains are never searched beyond this +- * length. A higher limit improves compression ratio but degrades the +- * speed. +- */ +- +- uInt max_lazy_match; +- /* Attempt to find a better match only when the current match is strictly +- * smaller than this value. This mechanism is used only for compression +- * levels >= 4. +- */ +-# define max_insert_length max_lazy_match +- /* Insert new strings in the hash table only if the match length is not +- * greater than this length. This saves time but degrades compression. +- * max_insert_length is used only for compression levels <= 3. +- */ +- +- int level; /* compression level (1..9) */ +- int strategy; /* favor or force Huffman coding*/ +- +- uInt good_match; +- /* Use a faster search when the previous match is longer than this */ +- +- int nice_match; /* Stop searching when current match exceeds this */ +- +- /* used by trees.c: */ +- /* Didn't use ct_data typedef below to supress compiler warning */ +- struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ +- struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ +- struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ +- +- struct tree_desc_s l_desc; /* desc. for literal tree */ +- struct tree_desc_s d_desc; /* desc. for distance tree */ +- struct tree_desc_s bl_desc; /* desc. for bit length tree */ +- +- ush bl_count[MAX_BITS+1]; +- /* number of codes at each bit length for an optimal tree */ +- +- int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ +- int heap_len; /* number of elements in the heap */ +- int heap_max; /* element of largest frequency */ +- /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. +- * The same heap array is used to build all trees. +- */ +- +- uch depth[2*L_CODES+1]; +- /* Depth of each subtree used as tie breaker for trees of equal frequency +- */ +- +- uchf *l_buf; /* buffer for literals or lengths */ +- +- uInt lit_bufsize; +- /* Size of match buffer for literals/lengths. There are 4 reasons for +- * limiting lit_bufsize to 64K: +- * - frequencies can be kept in 16 bit counters +- * - if compression is not successful for the first block, all input +- * data is still in the window so we can still emit a stored block even +- * when input comes from standard input. (This can also be done for +- * all blocks if lit_bufsize is not greater than 32K.) +- * - if compression is not successful for a file smaller than 64K, we can +- * even emit a stored file instead of a stored block (saving 5 bytes). +- * This is applicable only for zip (not gzip or zlib). +- * - creating new Huffman trees less frequently may not provide fast +- * adaptation to changes in the input data statistics. (Take for +- * example a binary file with poorly compressible code followed by +- * a highly compressible string table.) Smaller buffer sizes give +- * fast adaptation but have of course the overhead of transmitting +- * trees more frequently. +- * - I can't count above 4 +- */ +- +- uInt last_lit; /* running index in l_buf */ +- +- ushf *d_buf; +- /* Buffer for distances. To simplify the code, d_buf and l_buf have +- * the same number of elements. To use different lengths, an extra flag +- * array would be necessary. +- */ +- +- ulg opt_len; /* bit length of current block with optimal trees */ +- ulg static_len; /* bit length of current block with static trees */ +- uInt matches; /* number of string matches in current block */ +- int last_eob_len; /* bit length of EOB code for last block */ +- +-#ifdef DEBUG +- ulg compressed_len; /* total bit length of compressed file mod 2^32 */ +- ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ +-#endif +- +- ush bi_buf; +- /* Output buffer. bits are inserted starting at the bottom (least +- * significant bits). +- */ +- int bi_valid; +- /* Number of valid bits in bi_buf. All bits above the last valid bit +- * are always zero. +- */ +- +- ulg high_water; +- /* High water mark offset in window for initialized bytes -- bytes above +- * this are set to zero in order to avoid memory check warnings when +- * longest match routines access bytes past the input. This is then +- * updated to the new high water mark. +- */ +- +-} FAR deflate_state; +- +-/* Output a byte on the stream. +- * IN assertion: there is enough room in pending_buf. +- */ +-#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} +- +- +-#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) +-/* Minimum amount of lookahead, except at the end of the input file. +- * See deflate.c for comments about the MIN_MATCH+1. +- */ +- +-#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) +-/* In order to simplify the code, particularly on 16 bit machines, match +- * distances are limited to MAX_DIST instead of WSIZE. +- */ +- +-#define WIN_INIT MAX_MATCH +-/* Number of bytes after end of data in window to initialize in order to avoid +- memory checker errors from longest match routines */ +- +- /* in trees.c */ +-void ZLIB_INTERNAL _tr_init OF((deflate_state *s)); +-int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); +-void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf, +- ulg stored_len, int last)); +-void ZLIB_INTERNAL _tr_align OF((deflate_state *s)); +-void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, +- ulg stored_len, int last)); +- +-#define d_code(dist) \ +- ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) +-/* Mapping from a distance to a distance code. dist is the distance - 1 and +- * must not have side effects. _dist_code[256] and _dist_code[257] are never +- * used. +- */ +- +-#ifndef DEBUG +-/* Inline versions of _tr_tally for speed: */ +- +-#if defined(GEN_TREES_H) || !defined(STDC) +- extern uch ZLIB_INTERNAL _length_code[]; +- extern uch ZLIB_INTERNAL _dist_code[]; +-#else +- extern const uch ZLIB_INTERNAL _length_code[]; +- extern const uch ZLIB_INTERNAL _dist_code[]; +-#endif +- +-# define _tr_tally_lit(s, c, flush) \ +- { uch cc = (c); \ +- s->d_buf[s->last_lit] = 0; \ +- s->l_buf[s->last_lit++] = cc; \ +- s->dyn_ltree[cc].Freq++; \ +- flush = (s->last_lit == s->lit_bufsize-1); \ +- } +-# define _tr_tally_dist(s, distance, length, flush) \ +- { uch len = (length); \ +- ush dist = (distance); \ +- s->d_buf[s->last_lit] = dist; \ +- s->l_buf[s->last_lit++] = len; \ +- dist--; \ +- s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ +- s->dyn_dtree[d_code(dist)].Freq++; \ +- flush = (s->last_lit == s->lit_bufsize-1); \ +- } +-#else +-# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) +-# define _tr_tally_dist(s, distance, length, flush) \ +- flush = _tr_tally(s, distance, length) +-#endif +- +-#endif /* DEFLATE_H */ +diff --git a/thirdparty/zlib/gzclose.c b/thirdparty/zlib/gzclose.c +deleted file mode 100644 +index caeb99a..0000000 +--- a/thirdparty/zlib/gzclose.c ++++ /dev/null +@@ -1,25 +0,0 @@ +-/* gzclose.c -- zlib gzclose() function +- * Copyright (C) 2004, 2010 Mark Adler +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-#include "gzguts.h" +- +-/* gzclose() is in a separate file so that it is linked in only if it is used. +- That way the other gzclose functions can be used instead to avoid linking in +- unneeded compression or decompression routines. */ +-int ZEXPORT gzclose(file) +- gzFile file; +-{ +-#ifndef NO_GZCOMPRESS +- gz_statep state; +- +- if (file == NULL) +- return Z_STREAM_ERROR; +- state = (gz_statep)file; +- +- return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file); +-#else +- return gzclose_r(file); +-#endif +-} +diff --git a/thirdparty/zlib/gzguts.h b/thirdparty/zlib/gzguts.h +deleted file mode 100644 +index 0f8fb79..0000000 +--- a/thirdparty/zlib/gzguts.h ++++ /dev/null +@@ -1,132 +0,0 @@ +-/* gzguts.h -- zlib internal header definitions for gz* operations +- * Copyright (C) 2004, 2005, 2010 Mark Adler +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-#ifdef _LARGEFILE64_SOURCE +-# ifndef _LARGEFILE_SOURCE +-# define _LARGEFILE_SOURCE 1 +-# endif +-# ifdef _FILE_OFFSET_BITS +-# undef _FILE_OFFSET_BITS +-# endif +-#endif +- +-#if ((__GNUC__-0) * 10 + __GNUC_MINOR__-0 >= 33) && !defined(NO_VIZ) +-# define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) +-#else +-# define ZLIB_INTERNAL +-#endif +- +-#include +-#include "zlib.h" +-#ifdef STDC +-# include +-# include +-# include +-#endif +-#include +- +-#ifdef NO_DEFLATE /* for compatibility with old definition */ +-# define NO_GZCOMPRESS +-#endif +- +-#ifdef _MSC_VER +-# include +-# define vsnprintf _vsnprintf +-#endif +- +-#ifndef local +-# define local static +-#endif +-/* compile with -Dlocal if your debugger can't find static symbols */ +- +-/* gz* functions always use library allocation functions */ +-#ifndef STDC +- extern voidp malloc OF((uInt size)); +- extern void free OF((voidpf ptr)); +-#endif +- +-/* get errno and strerror definition */ +-#if defined UNDER_CE +-# include +-# define zstrerror() gz_strwinerror((DWORD)GetLastError()) +-#else +-# ifdef STDC +-# include +-# define zstrerror() strerror(errno) +-# else +-# define zstrerror() "stdio error (consult errno)" +-# endif +-#endif +- +-/* provide prototypes for these when building zlib without LFS */ +-#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 +- ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); +- ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); +- ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); +- ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); +-#endif +- +-/* default i/o buffer size -- double this for output when reading */ +-#define GZBUFSIZE 8192 +- +-/* gzip modes, also provide a little integrity check on the passed structure */ +-#define GZ_NONE 0 +-#define GZ_READ 7247 +-#define GZ_WRITE 31153 +-#define GZ_APPEND 1 /* mode set to GZ_WRITE after the file is opened */ +- +-/* values for gz_state how */ +-#define LOOK 0 /* look for a gzip header */ +-#define COPY 1 /* copy input directly */ +-#define GZIP 2 /* decompress a gzip stream */ +- +-/* internal gzip file state data structure */ +-typedef struct { +- /* used for both reading and writing */ +- int mode; /* see gzip modes above */ +- int fd; /* file descriptor */ +- char *path; /* path or fd for error messages */ +- z_off64_t pos; /* current position in uncompressed data */ +- unsigned size; /* buffer size, zero if not allocated yet */ +- unsigned want; /* requested buffer size, default is GZBUFSIZE */ +- unsigned char *in; /* input buffer */ +- unsigned char *out; /* output buffer (double-sized when reading) */ +- unsigned char *next; /* next output data to deliver or write */ +- /* just for reading */ +- unsigned have; /* amount of output data unused at next */ +- int eof; /* true if end of input file reached */ +- z_off64_t start; /* where the gzip data started, for rewinding */ +- z_off64_t raw; /* where the raw data started, for seeking */ +- int how; /* 0: get header, 1: copy, 2: decompress */ +- int direct; /* true if last read direct, false if gzip */ +- /* just for writing */ +- int level; /* compression level */ +- int strategy; /* compression strategy */ +- /* seek request */ +- z_off64_t skip; /* amount to skip (already rewound if backwards) */ +- int seek; /* true if seek request pending */ +- /* error information */ +- int err; /* error code */ +- char *msg; /* error message */ +- /* zlib inflate or deflate stream */ +- z_stream strm; /* stream structure in-place (not a pointer) */ +-} gz_state; +-typedef gz_state FAR *gz_statep; +- +-/* shared functions */ +-void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *)); +-#if defined UNDER_CE +-char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error)); +-#endif +- +-/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t +- value -- needed when comparing unsigned to z_off64_t, which is signed +- (possible z_off64_t types off_t, off64_t, and long are all signed) */ +-#ifdef INT_MAX +-# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX) +-#else +-unsigned ZLIB_INTERNAL gz_intmax OF((void)); +-# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax()) +-#endif +diff --git a/thirdparty/zlib/gzlib.c b/thirdparty/zlib/gzlib.c +deleted file mode 100644 +index 603e60e..0000000 +--- a/thirdparty/zlib/gzlib.c ++++ /dev/null +@@ -1,537 +0,0 @@ +-/* gzlib.c -- zlib functions common to reading and writing gzip files +- * Copyright (C) 2004, 2010 Mark Adler +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-#include "gzguts.h" +- +-#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 +-# define LSEEK lseek64 +-#else +-# define LSEEK lseek +-#endif +- +-/* Local functions */ +-local void gz_reset OF((gz_statep)); +-local gzFile gz_open OF((const char *, int, const char *)); +- +-#if defined UNDER_CE +- +-/* Map the Windows error number in ERROR to a locale-dependent error message +- string and return a pointer to it. Typically, the values for ERROR come +- from GetLastError. +- +- The string pointed to shall not be modified by the application, but may be +- overwritten by a subsequent call to gz_strwinerror +- +- The gz_strwinerror function does not change the current setting of +- GetLastError. */ +-char ZLIB_INTERNAL *gz_strwinerror (error) +- DWORD error; +-{ +- static char buf[1024]; +- +- wchar_t *msgbuf; +- DWORD lasterr = GetLastError(); +- DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM +- | FORMAT_MESSAGE_ALLOCATE_BUFFER, +- NULL, +- error, +- 0, /* Default language */ +- (LPVOID)&msgbuf, +- 0, +- NULL); +- if (chars != 0) { +- /* If there is an \r\n appended, zap it. */ +- if (chars >= 2 +- && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') { +- chars -= 2; +- msgbuf[chars] = 0; +- } +- +- if (chars > sizeof (buf) - 1) { +- chars = sizeof (buf) - 1; +- msgbuf[chars] = 0; +- } +- +- wcstombs(buf, msgbuf, chars + 1); +- LocalFree(msgbuf); +- } +- else { +- sprintf(buf, "unknown win32 error (%ld)", error); +- } +- +- SetLastError(lasterr); +- return buf; +-} +- +-#endif /* UNDER_CE */ +- +-/* Reset gzip file state */ +-local void gz_reset(state) +- gz_statep state; +-{ +- if (state->mode == GZ_READ) { /* for reading ... */ +- state->have = 0; /* no output data available */ +- state->eof = 0; /* not at end of file */ +- state->how = LOOK; /* look for gzip header */ +- state->direct = 1; /* default for empty file */ +- } +- state->seek = 0; /* no seek request pending */ +- gz_error(state, Z_OK, NULL); /* clear error */ +- state->pos = 0; /* no uncompressed data yet */ +- state->strm.avail_in = 0; /* no input data yet */ +-} +- +-/* Open a gzip file either by name or file descriptor. */ +-local gzFile gz_open(path, fd, mode) +- const char *path; +- int fd; +- const char *mode; +-{ +- gz_statep state; +- +- /* allocate gzFile structure to return */ +- state = malloc(sizeof(gz_state)); +- if (state == NULL) +- return NULL; +- state->size = 0; /* no buffers allocated yet */ +- state->want = GZBUFSIZE; /* requested buffer size */ +- state->msg = NULL; /* no error message yet */ +- +- /* interpret mode */ +- state->mode = GZ_NONE; +- state->level = Z_DEFAULT_COMPRESSION; +- state->strategy = Z_DEFAULT_STRATEGY; +- while (*mode) { +- if (*mode >= '0' && *mode <= '9') +- state->level = *mode - '0'; +- else +- switch (*mode) { +- case 'r': +- state->mode = GZ_READ; +- break; +-#ifndef NO_GZCOMPRESS +- case 'w': +- state->mode = GZ_WRITE; +- break; +- case 'a': +- state->mode = GZ_APPEND; +- break; +-#endif +- case '+': /* can't read and write at the same time */ +- free(state); +- return NULL; +- case 'b': /* ignore -- will request binary anyway */ +- break; +- case 'f': +- state->strategy = Z_FILTERED; +- break; +- case 'h': +- state->strategy = Z_HUFFMAN_ONLY; +- break; +- case 'R': +- state->strategy = Z_RLE; +- break; +- case 'F': +- state->strategy = Z_FIXED; +- default: /* could consider as an error, but just ignore */ +- ; +- } +- mode++; +- } +- +- /* must provide an "r", "w", or "a" */ +- if (state->mode == GZ_NONE) { +- free(state); +- return NULL; +- } +- +- /* save the path name for error messages */ +- state->path = malloc(strlen(path) + 1); +- if (state->path == NULL) { +- free(state); +- return NULL; +- } +- strcpy(state->path, path); +- +- /* open the file with the appropriate mode (or just use fd) */ +- state->fd = fd != -1 ? fd : +- open(path, +-#ifdef O_LARGEFILE +- O_LARGEFILE | +-#endif +-#ifdef O_BINARY +- O_BINARY | +-#endif +- (state->mode == GZ_READ ? +- O_RDONLY : +- (O_WRONLY | O_CREAT | ( +- state->mode == GZ_WRITE ? +- O_TRUNC : +- O_APPEND))), +- 0666); +- if (state->fd == -1) { +- free(state->path); +- free(state); +- return NULL; +- } +- if (state->mode == GZ_APPEND) +- state->mode = GZ_WRITE; /* simplify later checks */ +- +- /* save the current position for rewinding (only if reading) */ +- if (state->mode == GZ_READ) { +- state->start = LSEEK(state->fd, 0, SEEK_CUR); +- if (state->start == -1) state->start = 0; +- } +- +- /* initialize stream */ +- gz_reset(state); +- +- /* return stream */ +- return (gzFile)state; +-} +- +-/* -- see zlib.h -- */ +-gzFile ZEXPORT gzopen(path, mode) +- const char *path; +- const char *mode; +-{ +- return gz_open(path, -1, mode); +-} +- +-/* -- see zlib.h -- */ +-gzFile ZEXPORT gzopen64(path, mode) +- const char *path; +- const char *mode; +-{ +- return gz_open(path, -1, mode); +-} +- +-/* -- see zlib.h -- */ +-gzFile ZEXPORT gzdopen(fd, mode) +- int fd; +- const char *mode; +-{ +- char *path; /* identifier for error messages */ +- gzFile gz; +- +- if (fd == -1 || (path = malloc(7 + 3 * sizeof(int))) == NULL) +- return NULL; +- sprintf(path, "", fd); /* for debugging */ +- gz = gz_open(path, fd, mode); +- free(path); +- return gz; +-} +- +-/* -- see zlib.h -- */ +-int ZEXPORT gzbuffer(file, size) +- gzFile file; +- unsigned size; +-{ +- gz_statep state; +- +- /* get internal structure and check integrity */ +- if (file == NULL) +- return -1; +- state = (gz_statep)file; +- if (state->mode != GZ_READ && state->mode != GZ_WRITE) +- return -1; +- +- /* make sure we haven't already allocated memory */ +- if (state->size != 0) +- return -1; +- +- /* check and set requested size */ +- if (size == 0) +- return -1; +- state->want = size; +- return 0; +-} +- +-/* -- see zlib.h -- */ +-int ZEXPORT gzrewind(file) +- gzFile file; +-{ +- gz_statep state; +- +- /* get internal structure */ +- if (file == NULL) +- return -1; +- state = (gz_statep)file; +- +- /* check that we're reading and that there's no error */ +- if (state->mode != GZ_READ || state->err != Z_OK) +- return -1; +- +- /* back up and start over */ +- if (LSEEK(state->fd, state->start, SEEK_SET) == -1) +- return -1; +- gz_reset(state); +- return 0; +-} +- +-/* -- see zlib.h -- */ +-z_off64_t ZEXPORT gzseek64(file, offset, whence) +- gzFile file; +- z_off64_t offset; +- int whence; +-{ +- unsigned n; +- z_off64_t ret; +- gz_statep state; +- +- /* get internal structure and check integrity */ +- if (file == NULL) +- return -1; +- state = (gz_statep)file; +- if (state->mode != GZ_READ && state->mode != GZ_WRITE) +- return -1; +- +- /* check that there's no error */ +- if (state->err != Z_OK) +- return -1; +- +- /* can only seek from start or relative to current position */ +- if (whence != SEEK_SET && whence != SEEK_CUR) +- return -1; +- +- /* normalize offset to a SEEK_CUR specification */ +- if (whence == SEEK_SET) +- offset -= state->pos; +- else if (state->seek) +- offset += state->skip; +- state->seek = 0; +- +- /* if within raw area while reading, just go there */ +- if (state->mode == GZ_READ && state->how == COPY && +- state->pos + offset >= state->raw) { +- ret = LSEEK(state->fd, offset - state->have, SEEK_CUR); +- if (ret == -1) +- return -1; +- state->have = 0; +- state->eof = 0; +- state->seek = 0; +- gz_error(state, Z_OK, NULL); +- state->strm.avail_in = 0; +- state->pos += offset; +- return state->pos; +- } +- +- /* calculate skip amount, rewinding if needed for back seek when reading */ +- if (offset < 0) { +- if (state->mode != GZ_READ) /* writing -- can't go backwards */ +- return -1; +- offset += state->pos; +- if (offset < 0) /* before start of file! */ +- return -1; +- if (gzrewind(file) == -1) /* rewind, then skip to offset */ +- return -1; +- } +- +- /* if reading, skip what's in output buffer (one less gzgetc() check) */ +- if (state->mode == GZ_READ) { +- n = GT_OFF(state->have) || (z_off64_t)state->have > offset ? +- (unsigned)offset : state->have; +- state->have -= n; +- state->next += n; +- state->pos += n; +- offset -= n; +- } +- +- /* request skip (if not zero) */ +- if (offset) { +- state->seek = 1; +- state->skip = offset; +- } +- return state->pos + offset; +-} +- +-/* -- see zlib.h -- */ +-z_off_t ZEXPORT gzseek(file, offset, whence) +- gzFile file; +- z_off_t offset; +- int whence; +-{ +- z_off64_t ret; +- +- ret = gzseek64(file, (z_off64_t)offset, whence); +- return ret == (z_off_t)ret ? (z_off_t)ret : -1; +-} +- +-/* -- see zlib.h -- */ +-z_off64_t ZEXPORT gztell64(file) +- gzFile file; +-{ +- gz_statep state; +- +- /* get internal structure and check integrity */ +- if (file == NULL) +- return -1; +- state = (gz_statep)file; +- if (state->mode != GZ_READ && state->mode != GZ_WRITE) +- return -1; +- +- /* return position */ +- return state->pos + (state->seek ? state->skip : 0); +-} +- +-/* -- see zlib.h -- */ +-z_off_t ZEXPORT gztell(file) +- gzFile file; +-{ +- z_off64_t ret; +- +- ret = gztell64(file); +- return ret == (z_off_t)ret ? (z_off_t)ret : -1; +-} +- +-/* -- see zlib.h -- */ +-z_off64_t ZEXPORT gzoffset64(file) +- gzFile file; +-{ +- z_off64_t offset; +- gz_statep state; +- +- /* get internal structure and check integrity */ +- if (file == NULL) +- return -1; +- state = (gz_statep)file; +- if (state->mode != GZ_READ && state->mode != GZ_WRITE) +- return -1; +- +- /* compute and return effective offset in file */ +- offset = LSEEK(state->fd, 0, SEEK_CUR); +- if (offset == -1) +- return -1; +- if (state->mode == GZ_READ) /* reading */ +- offset -= state->strm.avail_in; /* don't count buffered input */ +- return offset; +-} +- +-/* -- see zlib.h -- */ +-z_off_t ZEXPORT gzoffset(file) +- gzFile file; +-{ +- z_off64_t ret; +- +- ret = gzoffset64(file); +- return ret == (z_off_t)ret ? (z_off_t)ret : -1; +-} +- +-/* -- see zlib.h -- */ +-int ZEXPORT gzeof(file) +- gzFile file; +-{ +- gz_statep state; +- +- /* get internal structure and check integrity */ +- if (file == NULL) +- return 0; +- state = (gz_statep)file; +- if (state->mode != GZ_READ && state->mode != GZ_WRITE) +- return 0; +- +- /* return end-of-file state */ +- return state->mode == GZ_READ ? +- (state->eof && state->strm.avail_in == 0 && state->have == 0) : 0; +-} +- +-/* -- see zlib.h -- */ +-const char * ZEXPORT gzerror(file, errnum) +- gzFile file; +- int *errnum; +-{ +- gz_statep state; +- +- /* get internal structure and check integrity */ +- if (file == NULL) +- return NULL; +- state = (gz_statep)file; +- if (state->mode != GZ_READ && state->mode != GZ_WRITE) +- return NULL; +- +- /* return error information */ +- if (errnum != NULL) +- *errnum = state->err; +- return state->msg == NULL ? "" : state->msg; +-} +- +-/* -- see zlib.h -- */ +-void ZEXPORT gzclearerr(file) +- gzFile file; +-{ +- gz_statep state; +- +- /* get internal structure and check integrity */ +- if (file == NULL) +- return; +- state = (gz_statep)file; +- if (state->mode != GZ_READ && state->mode != GZ_WRITE) +- return; +- +- /* clear error and end-of-file */ +- if (state->mode == GZ_READ) +- state->eof = 0; +- gz_error(state, Z_OK, NULL); +-} +- +-/* Create an error message in allocated memory and set state->err and +- state->msg accordingly. Free any previous error message already there. Do +- not try to free or allocate space if the error is Z_MEM_ERROR (out of +- memory). Simply save the error message as a static string. If there is an +- allocation failure constructing the error message, then convert the error to +- out of memory. */ +-void ZLIB_INTERNAL gz_error(state, err, msg) +- gz_statep state; +- int err; +- const char *msg; +-{ +- /* free previously allocated message and clear */ +- if (state->msg != NULL) { +- if (state->err != Z_MEM_ERROR) +- free(state->msg); +- state->msg = NULL; +- } +- +- /* set error code, and if no message, then done */ +- state->err = err; +- if (msg == NULL) +- return; +- +- /* for an out of memory error, save as static string */ +- if (err == Z_MEM_ERROR) { +- state->msg = (char *)msg; +- return; +- } +- +- /* construct error message with path */ +- if ((state->msg = malloc(strlen(state->path) + strlen(msg) + 3)) == NULL) { +- state->err = Z_MEM_ERROR; +- state->msg = (char *)"out of memory"; +- return; +- } +- strcpy(state->msg, state->path); +- strcat(state->msg, ": "); +- strcat(state->msg, msg); +- return; +-} +- +-#ifndef INT_MAX +-/* portably return maximum value for an int (when limits.h presumed not +- available) -- we need to do this to cover cases where 2's complement not +- used, since C standard permits 1's complement and sign-bit representations, +- otherwise we could just use ((unsigned)-1) >> 1 */ +-unsigned ZLIB_INTERNAL gz_intmax() +-{ +- unsigned p, q; +- +- p = 1; +- do { +- q = p; +- p <<= 1; +- p++; +- } while (p > q); +- return q >> 1; +-} +-#endif +diff --git a/thirdparty/zlib/gzread.c b/thirdparty/zlib/gzread.c +deleted file mode 100644 +index 548201a..0000000 +--- a/thirdparty/zlib/gzread.c ++++ /dev/null +@@ -1,653 +0,0 @@ +-/* gzread.c -- zlib functions for reading gzip files +- * Copyright (C) 2004, 2005, 2010 Mark Adler +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-#include "gzguts.h" +- +-/* Local functions */ +-local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *)); +-local int gz_avail OF((gz_statep)); +-local int gz_next4 OF((gz_statep, unsigned long *)); +-local int gz_head OF((gz_statep)); +-local int gz_decomp OF((gz_statep)); +-local int gz_make OF((gz_statep)); +-local int gz_skip OF((gz_statep, z_off64_t)); +- +-/* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from +- state->fd, and update state->eof, state->err, and state->msg as appropriate. +- This function needs to loop on read(), since read() is not guaranteed to +- read the number of bytes requested, depending on the type of descriptor. */ +-local int gz_load(state, buf, len, have) +- gz_statep state; +- unsigned char *buf; +- unsigned len; +- unsigned *have; +-{ +- int ret; +- +- *have = 0; +- do { +- ret = read(state->fd, buf + *have, len - *have); +- if (ret <= 0) +- break; +- *have += ret; +- } while (*have < len); +- if (ret < 0) { +- gz_error(state, Z_ERRNO, zstrerror()); +- return -1; +- } +- if (ret == 0) +- state->eof = 1; +- return 0; +-} +- +-/* Load up input buffer and set eof flag if last data loaded -- return -1 on +- error, 0 otherwise. Note that the eof flag is set when the end of the input +- file is reached, even though there may be unused data in the buffer. Once +- that data has been used, no more attempts will be made to read the file. +- gz_avail() assumes that strm->avail_in == 0. */ +-local int gz_avail(state) +- gz_statep state; +-{ +- z_streamp strm = &(state->strm); +- +- if (state->err != Z_OK) +- return -1; +- if (state->eof == 0) { +- if (gz_load(state, state->in, state->size, +- (unsigned *)&(strm->avail_in)) == -1) +- return -1; +- strm->next_in = state->in; +- } +- return 0; +-} +- +-/* Get next byte from input, or -1 if end or error. */ +-#define NEXT() ((strm->avail_in == 0 && gz_avail(state) == -1) ? -1 : \ +- (strm->avail_in == 0 ? -1 : \ +- (strm->avail_in--, *(strm->next_in)++))) +- +-/* Get a four-byte little-endian integer and return 0 on success and the value +- in *ret. Otherwise -1 is returned and *ret is not modified. */ +-local int gz_next4(state, ret) +- gz_statep state; +- unsigned long *ret; +-{ +- int ch; +- unsigned long val; +- z_streamp strm = &(state->strm); +- +- val = NEXT(); +- val += (unsigned)NEXT() << 8; +- val += (unsigned long)NEXT() << 16; +- ch = NEXT(); +- if (ch == -1) +- return -1; +- val += (unsigned long)ch << 24; +- *ret = val; +- return 0; +-} +- +-/* Look for gzip header, set up for inflate or copy. state->have must be zero. +- If this is the first time in, allocate required memory. state->how will be +- left unchanged if there is no more input data available, will be set to COPY +- if there is no gzip header and direct copying will be performed, or it will +- be set to GZIP for decompression, and the gzip header will be skipped so +- that the next available input data is the raw deflate stream. If direct +- copying, then leftover input data from the input buffer will be copied to +- the output buffer. In that case, all further file reads will be directly to +- either the output buffer or a user buffer. If decompressing, the inflate +- state and the check value will be initialized. gz_head() will return 0 on +- success or -1 on failure. Failures may include read errors or gzip header +- errors. */ +-local int gz_head(state) +- gz_statep state; +-{ +- z_streamp strm = &(state->strm); +- int flags; +- unsigned len; +- +- /* allocate read buffers and inflate memory */ +- if (state->size == 0) { +- /* allocate buffers */ +- state->in = malloc(state->want); +- state->out = malloc(state->want << 1); +- if (state->in == NULL || state->out == NULL) { +- if (state->out != NULL) +- free(state->out); +- if (state->in != NULL) +- free(state->in); +- gz_error(state, Z_MEM_ERROR, "out of memory"); +- return -1; +- } +- state->size = state->want; +- +- /* allocate inflate memory */ +- state->strm.zalloc = Z_NULL; +- state->strm.zfree = Z_NULL; +- state->strm.opaque = Z_NULL; +- state->strm.avail_in = 0; +- state->strm.next_in = Z_NULL; +- if (inflateInit2(&(state->strm), -15) != Z_OK) { /* raw inflate */ +- free(state->out); +- free(state->in); +- state->size = 0; +- gz_error(state, Z_MEM_ERROR, "out of memory"); +- return -1; +- } +- } +- +- /* get some data in the input buffer */ +- if (strm->avail_in == 0) { +- if (gz_avail(state) == -1) +- return -1; +- if (strm->avail_in == 0) +- return 0; +- } +- +- /* look for the gzip magic header bytes 31 and 139 */ +- if (strm->next_in[0] == 31) { +- strm->avail_in--; +- strm->next_in++; +- if (strm->avail_in == 0 && gz_avail(state) == -1) +- return -1; +- if (strm->avail_in && strm->next_in[0] == 139) { +- /* we have a gzip header, woo hoo! */ +- strm->avail_in--; +- strm->next_in++; +- +- /* skip rest of header */ +- if (NEXT() != 8) { /* compression method */ +- gz_error(state, Z_DATA_ERROR, "unknown compression method"); +- return -1; +- } +- flags = NEXT(); +- if (flags & 0xe0) { /* reserved flag bits */ +- gz_error(state, Z_DATA_ERROR, "unknown header flags set"); +- return -1; +- } +- NEXT(); /* modification time */ +- NEXT(); +- NEXT(); +- NEXT(); +- NEXT(); /* extra flags */ +- NEXT(); /* operating system */ +- if (flags & 4) { /* extra field */ +- len = (unsigned)NEXT(); +- len += (unsigned)NEXT() << 8; +- while (len--) +- if (NEXT() < 0) +- break; +- } +- if (flags & 8) /* file name */ +- while (NEXT() > 0) +- ; +- if (flags & 16) /* comment */ +- while (NEXT() > 0) +- ; +- if (flags & 2) { /* header crc */ +- NEXT(); +- NEXT(); +- } +- /* an unexpected end of file is not checked for here -- it will be +- noticed on the first request for uncompressed data */ +- +- /* set up for decompression */ +- inflateReset(strm); +- strm->adler = crc32(0L, Z_NULL, 0); +- state->how = GZIP; +- state->direct = 0; +- return 0; +- } +- else { +- /* not a gzip file -- save first byte (31) and fall to raw i/o */ +- state->out[0] = 31; +- state->have = 1; +- } +- } +- +- /* doing raw i/o, save start of raw data for seeking, copy any leftover +- input to output -- this assumes that the output buffer is larger than +- the input buffer, which also assures space for gzungetc() */ +- state->raw = state->pos; +- state->next = state->out; +- if (strm->avail_in) { +- memcpy(state->next + state->have, strm->next_in, strm->avail_in); +- state->have += strm->avail_in; +- strm->avail_in = 0; +- } +- state->how = COPY; +- state->direct = 1; +- return 0; +-} +- +-/* Decompress from input to the provided next_out and avail_out in the state. +- If the end of the compressed data is reached, then verify the gzip trailer +- check value and length (modulo 2^32). state->have and state->next are set +- to point to the just decompressed data, and the crc is updated. If the +- trailer is verified, state->how is reset to LOOK to look for the next gzip +- stream or raw data, once state->have is depleted. Returns 0 on success, -1 +- on failure. Failures may include invalid compressed data or a failed gzip +- trailer verification. */ +-local int gz_decomp(state) +- gz_statep state; +-{ +- int ret; +- unsigned had; +- unsigned long crc, len; +- z_streamp strm = &(state->strm); +- +- /* fill output buffer up to end of deflate stream */ +- had = strm->avail_out; +- do { +- /* get more input for inflate() */ +- if (strm->avail_in == 0 && gz_avail(state) == -1) +- return -1; +- if (strm->avail_in == 0) { +- gz_error(state, Z_DATA_ERROR, "unexpected end of file"); +- return -1; +- } +- +- /* decompress and handle errors */ +- ret = inflate(strm, Z_NO_FLUSH); +- if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) { +- gz_error(state, Z_STREAM_ERROR, +- "internal error: inflate stream corrupt"); +- return -1; +- } +- if (ret == Z_MEM_ERROR) { +- gz_error(state, Z_MEM_ERROR, "out of memory"); +- return -1; +- } +- if (ret == Z_DATA_ERROR) { /* deflate stream invalid */ +- gz_error(state, Z_DATA_ERROR, +- strm->msg == NULL ? "compressed data error" : strm->msg); +- return -1; +- } +- } while (strm->avail_out && ret != Z_STREAM_END); +- +- /* update available output and crc check value */ +- state->have = had - strm->avail_out; +- state->next = strm->next_out - state->have; +- strm->adler = crc32(strm->adler, state->next, state->have); +- +- /* check gzip trailer if at end of deflate stream */ +- if (ret == Z_STREAM_END) { +- if (gz_next4(state, &crc) == -1 || gz_next4(state, &len) == -1) { +- gz_error(state, Z_DATA_ERROR, "unexpected end of file"); +- return -1; +- } +- if (crc != strm->adler) { +- gz_error(state, Z_DATA_ERROR, "incorrect data check"); +- return -1; +- } +- if (len != (strm->total_out & 0xffffffffL)) { +- gz_error(state, Z_DATA_ERROR, "incorrect length check"); +- return -1; +- } +- state->how = LOOK; /* ready for next stream, once have is 0 (leave +- state->direct unchanged to remember how) */ +- } +- +- /* good decompression */ +- return 0; +-} +- +-/* Make data and put in the output buffer. Assumes that state->have == 0. +- Data is either copied from the input file or decompressed from the input +- file depending on state->how. If state->how is LOOK, then a gzip header is +- looked for (and skipped if found) to determine wither to copy or decompress. +- Returns -1 on error, otherwise 0. gz_make() will leave state->have as COPY +- or GZIP unless the end of the input file has been reached and all data has +- been processed. */ +-local int gz_make(state) +- gz_statep state; +-{ +- z_streamp strm = &(state->strm); +- +- if (state->how == LOOK) { /* look for gzip header */ +- if (gz_head(state) == -1) +- return -1; +- if (state->have) /* got some data from gz_head() */ +- return 0; +- } +- if (state->how == COPY) { /* straight copy */ +- if (gz_load(state, state->out, state->size << 1, &(state->have)) == -1) +- return -1; +- state->next = state->out; +- } +- else if (state->how == GZIP) { /* decompress */ +- strm->avail_out = state->size << 1; +- strm->next_out = state->out; +- if (gz_decomp(state) == -1) +- return -1; +- } +- return 0; +-} +- +-/* Skip len uncompressed bytes of output. Return -1 on error, 0 on success. */ +-local int gz_skip(state, len) +- gz_statep state; +- z_off64_t len; +-{ +- unsigned n; +- +- /* skip over len bytes or reach end-of-file, whichever comes first */ +- while (len) +- /* skip over whatever is in output buffer */ +- if (state->have) { +- n = GT_OFF(state->have) || (z_off64_t)state->have > len ? +- (unsigned)len : state->have; +- state->have -= n; +- state->next += n; +- state->pos += n; +- len -= n; +- } +- +- /* output buffer empty -- return if we're at the end of the input */ +- else if (state->eof && state->strm.avail_in == 0) +- break; +- +- /* need more data to skip -- load up output buffer */ +- else { +- /* get more output, looking for header if required */ +- if (gz_make(state) == -1) +- return -1; +- } +- return 0; +-} +- +-/* -- see zlib.h -- */ +-int ZEXPORT gzread(file, buf, len) +- gzFile file; +- voidp buf; +- unsigned len; +-{ +- unsigned got, n; +- gz_statep state; +- z_streamp strm; +- +- /* get internal structure */ +- if (file == NULL) +- return -1; +- state = (gz_statep)file; +- strm = &(state->strm); +- +- /* check that we're reading and that there's no error */ +- if (state->mode != GZ_READ || state->err != Z_OK) +- return -1; +- +- /* since an int is returned, make sure len fits in one, otherwise return +- with an error (this avoids the flaw in the interface) */ +- if ((int)len < 0) { +- gz_error(state, Z_BUF_ERROR, "requested length does not fit in int"); +- return -1; +- } +- +- /* if len is zero, avoid unnecessary operations */ +- if (len == 0) +- return 0; +- +- /* process a skip request */ +- if (state->seek) { +- state->seek = 0; +- if (gz_skip(state, state->skip) == -1) +- return -1; +- } +- +- /* get len bytes to buf, or less than len if at the end */ +- got = 0; +- do { +- /* first just try copying data from the output buffer */ +- if (state->have) { +- n = state->have > len ? len : state->have; +- memcpy(buf, state->next, n); +- state->next += n; +- state->have -= n; +- } +- +- /* output buffer empty -- return if we're at the end of the input */ +- else if (state->eof && strm->avail_in == 0) +- break; +- +- /* need output data -- for small len or new stream load up our output +- buffer */ +- else if (state->how == LOOK || len < (state->size << 1)) { +- /* get more output, looking for header if required */ +- if (gz_make(state) == -1) +- return -1; +- continue; /* no progress yet -- go back to memcpy() above */ +- /* the copy above assures that we will leave with space in the +- output buffer, allowing at least one gzungetc() to succeed */ +- } +- +- /* large len -- read directly into user buffer */ +- else if (state->how == COPY) { /* read directly */ +- if (gz_load(state, buf, len, &n) == -1) +- return -1; +- } +- +- /* large len -- decompress directly into user buffer */ +- else { /* state->how == GZIP */ +- strm->avail_out = len; +- strm->next_out = buf; +- if (gz_decomp(state) == -1) +- return -1; +- n = state->have; +- state->have = 0; +- } +- +- /* update progress */ +- len -= n; +- buf = (char *)buf + n; +- got += n; +- state->pos += n; +- } while (len); +- +- /* return number of bytes read into user buffer (will fit in int) */ +- return (int)got; +-} +- +-/* -- see zlib.h -- */ +-int ZEXPORT gzgetc(file) +- gzFile file; +-{ +- int ret; +- unsigned char buf[1]; +- gz_statep state; +- +- /* get internal structure */ +- if (file == NULL) +- return -1; +- state = (gz_statep)file; +- +- /* check that we're reading and that there's no error */ +- if (state->mode != GZ_READ || state->err != Z_OK) +- return -1; +- +- /* try output buffer (no need to check for skip request) */ +- if (state->have) { +- state->have--; +- state->pos++; +- return *(state->next)++; +- } +- +- /* nothing there -- try gzread() */ +- ret = gzread(file, buf, 1); +- return ret < 1 ? -1 : buf[0]; +-} +- +-/* -- see zlib.h -- */ +-int ZEXPORT gzungetc(c, file) +- int c; +- gzFile file; +-{ +- gz_statep state; +- +- /* get internal structure */ +- if (file == NULL) +- return -1; +- state = (gz_statep)file; +- +- /* check that we're reading and that there's no error */ +- if (state->mode != GZ_READ || state->err != Z_OK) +- return -1; +- +- /* process a skip request */ +- if (state->seek) { +- state->seek = 0; +- if (gz_skip(state, state->skip) == -1) +- return -1; +- } +- +- /* can't push EOF */ +- if (c < 0) +- return -1; +- +- /* if output buffer empty, put byte at end (allows more pushing) */ +- if (state->have == 0) { +- state->have = 1; +- state->next = state->out + (state->size << 1) - 1; +- state->next[0] = c; +- state->pos--; +- return c; +- } +- +- /* if no room, give up (must have already done a gzungetc()) */ +- if (state->have == (state->size << 1)) { +- gz_error(state, Z_BUF_ERROR, "out of room to push characters"); +- return -1; +- } +- +- /* slide output data if needed and insert byte before existing data */ +- if (state->next == state->out) { +- unsigned char *src = state->out + state->have; +- unsigned char *dest = state->out + (state->size << 1); +- while (src > state->out) +- *--dest = *--src; +- state->next = dest; +- } +- state->have++; +- state->next--; +- state->next[0] = c; +- state->pos--; +- return c; +-} +- +-/* -- see zlib.h -- */ +-char * ZEXPORT gzgets(file, buf, len) +- gzFile file; +- char *buf; +- int len; +-{ +- unsigned left, n; +- char *str; +- unsigned char *eol; +- gz_statep state; +- +- /* check parameters and get internal structure */ +- if (file == NULL || buf == NULL || len < 1) +- return NULL; +- state = (gz_statep)file; +- +- /* check that we're reading and that there's no error */ +- if (state->mode != GZ_READ || state->err != Z_OK) +- return NULL; +- +- /* process a skip request */ +- if (state->seek) { +- state->seek = 0; +- if (gz_skip(state, state->skip) == -1) +- return NULL; +- } +- +- /* copy output bytes up to new line or len - 1, whichever comes first -- +- append a terminating zero to the string (we don't check for a zero in +- the contents, let the user worry about that) */ +- str = buf; +- left = (unsigned)len - 1; +- if (left) do { +- /* assure that something is in the output buffer */ +- if (state->have == 0) { +- if (gz_make(state) == -1) +- return NULL; /* error */ +- if (state->have == 0) { /* end of file */ +- if (buf == str) /* got bupkus */ +- return NULL; +- break; /* got something -- return it */ +- } +- } +- +- /* look for end-of-line in current output buffer */ +- n = state->have > left ? left : state->have; +- eol = memchr(state->next, '\n', n); +- if (eol != NULL) +- n = (unsigned)(eol - state->next) + 1; +- +- /* copy through end-of-line, or remainder if not found */ +- memcpy(buf, state->next, n); +- state->have -= n; +- state->next += n; +- state->pos += n; +- left -= n; +- buf += n; +- } while (left && eol == NULL); +- +- /* found end-of-line or out of space -- terminate string and return it */ +- buf[0] = 0; +- return str; +-} +- +-/* -- see zlib.h -- */ +-int ZEXPORT gzdirect(file) +- gzFile file; +-{ +- gz_statep state; +- +- /* get internal structure */ +- if (file == NULL) +- return 0; +- state = (gz_statep)file; +- +- /* check that we're reading */ +- if (state->mode != GZ_READ) +- return 0; +- +- /* if the state is not known, but we can find out, then do so (this is +- mainly for right after a gzopen() or gzdopen()) */ +- if (state->how == LOOK && state->have == 0) +- (void)gz_head(state); +- +- /* return 1 if reading direct, 0 if decompressing a gzip stream */ +- return state->direct; +-} +- +-/* -- see zlib.h -- */ +-int ZEXPORT gzclose_r(file) +- gzFile file; +-{ +- int ret; +- gz_statep state; +- +- /* get internal structure */ +- if (file == NULL) +- return Z_STREAM_ERROR; +- state = (gz_statep)file; +- +- /* check that we're reading */ +- if (state->mode != GZ_READ) +- return Z_STREAM_ERROR; +- +- /* free memory and close file */ +- if (state->size) { +- inflateEnd(&(state->strm)); +- free(state->out); +- free(state->in); +- } +- gz_error(state, Z_OK, NULL); +- free(state->path); +- ret = close(state->fd); +- free(state); +- return ret ? Z_ERRNO : Z_OK; +-} +diff --git a/thirdparty/zlib/gzwrite.c b/thirdparty/zlib/gzwrite.c +deleted file mode 100644 +index e8defc6..0000000 +--- a/thirdparty/zlib/gzwrite.c ++++ /dev/null +@@ -1,531 +0,0 @@ +-/* gzwrite.c -- zlib functions for writing gzip files +- * Copyright (C) 2004, 2005, 2010 Mark Adler +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-#include "gzguts.h" +- +-/* Local functions */ +-local int gz_init OF((gz_statep)); +-local int gz_comp OF((gz_statep, int)); +-local int gz_zero OF((gz_statep, z_off64_t)); +- +-/* Initialize state for writing a gzip file. Mark initialization by setting +- state->size to non-zero. Return -1 on failure or 0 on success. */ +-local int gz_init(state) +- gz_statep state; +-{ +- int ret; +- z_streamp strm = &(state->strm); +- +- /* allocate input and output buffers */ +- state->in = malloc(state->want); +- state->out = malloc(state->want); +- if (state->in == NULL || state->out == NULL) { +- if (state->out != NULL) +- free(state->out); +- if (state->in != NULL) +- free(state->in); +- gz_error(state, Z_MEM_ERROR, "out of memory"); +- return -1; +- } +- +- /* allocate deflate memory, set up for gzip compression */ +- strm->zalloc = Z_NULL; +- strm->zfree = Z_NULL; +- strm->opaque = Z_NULL; +- ret = deflateInit2(strm, state->level, Z_DEFLATED, +- 15 + 16, 8, state->strategy); +- if (ret != Z_OK) { +- free(state->in); +- gz_error(state, Z_MEM_ERROR, "out of memory"); +- return -1; +- } +- +- /* mark state as initialized */ +- state->size = state->want; +- +- /* initialize write buffer */ +- strm->avail_out = state->size; +- strm->next_out = state->out; +- state->next = strm->next_out; +- return 0; +-} +- +-/* Compress whatever is at avail_in and next_in and write to the output file. +- Return -1 if there is an error writing to the output file, otherwise 0. +- flush is assumed to be a valid deflate() flush value. If flush is Z_FINISH, +- then the deflate() state is reset to start a new gzip stream. */ +-local int gz_comp(state, flush) +- gz_statep state; +- int flush; +-{ +- int ret, got; +- unsigned have; +- z_streamp strm = &(state->strm); +- +- /* allocate memory if this is the first time through */ +- if (state->size == 0 && gz_init(state) == -1) +- return -1; +- +- /* run deflate() on provided input until it produces no more output */ +- ret = Z_OK; +- do { +- /* write out current buffer contents if full, or if flushing, but if +- doing Z_FINISH then don't write until we get to Z_STREAM_END */ +- if (strm->avail_out == 0 || (flush != Z_NO_FLUSH && +- (flush != Z_FINISH || ret == Z_STREAM_END))) { +- have = (unsigned)(strm->next_out - state->next); +- if (have && ((got = write(state->fd, state->next, have)) < 0 || +- (unsigned)got != have)) { +- gz_error(state, Z_ERRNO, zstrerror()); +- return -1; +- } +- if (strm->avail_out == 0) { +- strm->avail_out = state->size; +- strm->next_out = state->out; +- } +- state->next = strm->next_out; +- } +- +- /* compress */ +- have = strm->avail_out; +- ret = deflate(strm, flush); +- if (ret == Z_STREAM_ERROR) { +- gz_error(state, Z_STREAM_ERROR, +- "internal error: deflate stream corrupt"); +- return -1; +- } +- have -= strm->avail_out; +- } while (have); +- +- /* if that completed a deflate stream, allow another to start */ +- if (flush == Z_FINISH) +- deflateReset(strm); +- +- /* all done, no errors */ +- return 0; +-} +- +-/* Compress len zeros to output. Return -1 on error, 0 on success. */ +-local int gz_zero(state, len) +- gz_statep state; +- z_off64_t len; +-{ +- int first; +- unsigned n; +- z_streamp strm = &(state->strm); +- +- /* consume whatever's left in the input buffer */ +- if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) +- return -1; +- +- /* compress len zeros (len guaranteed > 0) */ +- first = 1; +- while (len) { +- n = GT_OFF(state->size) || (z_off64_t)state->size > len ? +- (unsigned)len : state->size; +- if (first) { +- memset(state->in, 0, n); +- first = 0; +- } +- strm->avail_in = n; +- strm->next_in = state->in; +- state->pos += n; +- if (gz_comp(state, Z_NO_FLUSH) == -1) +- return -1; +- len -= n; +- } +- return 0; +-} +- +-/* -- see zlib.h -- */ +-int ZEXPORT gzwrite(file, buf, len) +- gzFile file; +- voidpc buf; +- unsigned len; +-{ +- unsigned put = len; +- unsigned n; +- gz_statep state; +- z_streamp strm; +- +- /* get internal structure */ +- if (file == NULL) +- return 0; +- state = (gz_statep)file; +- strm = &(state->strm); +- +- /* check that we're writing and that there's no error */ +- if (state->mode != GZ_WRITE || state->err != Z_OK) +- return 0; +- +- /* since an int is returned, make sure len fits in one, otherwise return +- with an error (this avoids the flaw in the interface) */ +- if ((int)len < 0) { +- gz_error(state, Z_BUF_ERROR, "requested length does not fit in int"); +- return 0; +- } +- +- /* if len is zero, avoid unnecessary operations */ +- if (len == 0) +- return 0; +- +- /* allocate memory if this is the first time through */ +- if (state->size == 0 && gz_init(state) == -1) +- return 0; +- +- /* check for seek request */ +- if (state->seek) { +- state->seek = 0; +- if (gz_zero(state, state->skip) == -1) +- return 0; +- } +- +- /* for small len, copy to input buffer, otherwise compress directly */ +- if (len < state->size) { +- /* copy to input buffer, compress when full */ +- do { +- if (strm->avail_in == 0) +- strm->next_in = state->in; +- n = state->size - strm->avail_in; +- if (n > len) +- n = len; +- memcpy(strm->next_in + strm->avail_in, buf, n); +- strm->avail_in += n; +- state->pos += n; +- buf = (char *)buf + n; +- len -= n; +- if (len && gz_comp(state, Z_NO_FLUSH) == -1) +- return 0; +- } while (len); +- } +- else { +- /* consume whatever's left in the input buffer */ +- if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) +- return 0; +- +- /* directly compress user buffer to file */ +- strm->avail_in = len; +- strm->next_in = (voidp)buf; +- state->pos += len; +- if (gz_comp(state, Z_NO_FLUSH) == -1) +- return 0; +- } +- +- /* input was all buffered or compressed (put will fit in int) */ +- return (int)put; +-} +- +-/* -- see zlib.h -- */ +-int ZEXPORT gzputc(file, c) +- gzFile file; +- int c; +-{ +- unsigned char buf[1]; +- gz_statep state; +- z_streamp strm; +- +- /* get internal structure */ +- if (file == NULL) +- return -1; +- state = (gz_statep)file; +- strm = &(state->strm); +- +- /* check that we're writing and that there's no error */ +- if (state->mode != GZ_WRITE || state->err != Z_OK) +- return -1; +- +- /* check for seek request */ +- if (state->seek) { +- state->seek = 0; +- if (gz_zero(state, state->skip) == -1) +- return -1; +- } +- +- /* try writing to input buffer for speed (state->size == 0 if buffer not +- initialized) */ +- if (strm->avail_in < state->size) { +- if (strm->avail_in == 0) +- strm->next_in = state->in; +- strm->next_in[strm->avail_in++] = c; +- state->pos++; +- return c; +- } +- +- /* no room in buffer or not initialized, use gz_write() */ +- buf[0] = c; +- if (gzwrite(file, buf, 1) != 1) +- return -1; +- return c; +-} +- +-/* -- see zlib.h -- */ +-int ZEXPORT gzputs(file, str) +- gzFile file; +- const char *str; +-{ +- int ret; +- unsigned len; +- +- /* write string */ +- len = (unsigned)strlen(str); +- ret = gzwrite(file, str, len); +- return ret == 0 && len != 0 ? -1 : ret; +-} +- +-#ifdef STDC +-#include +- +-/* -- see zlib.h -- */ +-int ZEXPORTVA gzprintf (gzFile file, const char *format, ...) +-{ +- int size, len; +- gz_statep state; +- z_streamp strm; +- va_list va; +- +- /* get internal structure */ +- if (file == NULL) +- return -1; +- state = (gz_statep)file; +- strm = &(state->strm); +- +- /* check that we're writing and that there's no error */ +- if (state->mode != GZ_WRITE || state->err != Z_OK) +- return 0; +- +- /* make sure we have some buffer space */ +- if (state->size == 0 && gz_init(state) == -1) +- return 0; +- +- /* check for seek request */ +- if (state->seek) { +- state->seek = 0; +- if (gz_zero(state, state->skip) == -1) +- return 0; +- } +- +- /* consume whatever's left in the input buffer */ +- if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) +- return 0; +- +- /* do the printf() into the input buffer, put length in len */ +- size = (int)(state->size); +- state->in[size - 1] = 0; +- va_start(va, format); +-#ifdef NO_vsnprintf +-# ifdef HAS_vsprintf_void +- (void)vsprintf(state->in, format, va); +- va_end(va); +- for (len = 0; len < size; len++) +- if (state->in[len] == 0) break; +-# else +- len = vsprintf(state->in, format, va); +- va_end(va); +-# endif +-#else +-# ifdef HAS_vsnprintf_void +- (void)vsnprintf(state->in, size, format, va); +- va_end(va); +- len = strlen(state->in); +-# else +- len = vsnprintf((char *)(state->in), size, format, va); +- va_end(va); +-# endif +-#endif +- +- /* check that printf() results fit in buffer */ +- if (len <= 0 || len >= (int)size || state->in[size - 1] != 0) +- return 0; +- +- /* update buffer and position, defer compression until needed */ +- strm->avail_in = (unsigned)len; +- strm->next_in = state->in; +- state->pos += len; +- return len; +-} +- +-#else /* !STDC */ +- +-/* -- see zlib.h -- */ +-int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, +- a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) +- gzFile file; +- const char *format; +- int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, +- a11, a12, a13, a14, a15, a16, a17, a18, a19, a20; +-{ +- int size, len; +- gz_statep state; +- z_streamp strm; +- +- /* get internal structure */ +- if (file == NULL) +- return -1; +- state = (gz_statep)file; +- strm = &(state->strm); +- +- /* check that we're writing and that there's no error */ +- if (state->mode != GZ_WRITE || state->err != Z_OK) +- return 0; +- +- /* make sure we have some buffer space */ +- if (state->size == 0 && gz_init(state) == -1) +- return 0; +- +- /* check for seek request */ +- if (state->seek) { +- state->seek = 0; +- if (gz_zero(state, state->skip) == -1) +- return 0; +- } +- +- /* consume whatever's left in the input buffer */ +- if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) +- return 0; +- +- /* do the printf() into the input buffer, put length in len */ +- size = (int)(state->size); +- state->in[size - 1] = 0; +-#ifdef NO_snprintf +-# ifdef HAS_sprintf_void +- sprintf(state->in, format, a1, a2, a3, a4, a5, a6, a7, a8, +- a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); +- for (len = 0; len < size; len++) +- if (state->in[len] == 0) break; +-# else +- len = sprintf(state->in, format, a1, a2, a3, a4, a5, a6, a7, a8, +- a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); +-# endif +-#else +-# ifdef HAS_snprintf_void +- snprintf(state->in, size, format, a1, a2, a3, a4, a5, a6, a7, a8, +- a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); +- len = strlen(state->in); +-# else +- len = snprintf(state->in, size, format, a1, a2, a3, a4, a5, a6, a7, a8, +- a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); +-# endif +-#endif +- +- /* check that printf() results fit in buffer */ +- if (len <= 0 || len >= (int)size || state->in[size - 1] != 0) +- return 0; +- +- /* update buffer and position, defer compression until needed */ +- strm->avail_in = (unsigned)len; +- strm->next_in = state->in; +- state->pos += len; +- return len; +-} +- +-#endif +- +-/* -- see zlib.h -- */ +-int ZEXPORT gzflush(file, flush) +- gzFile file; +- int flush; +-{ +- gz_statep state; +- +- /* get internal structure */ +- if (file == NULL) +- return -1; +- state = (gz_statep)file; +- +- /* check that we're writing and that there's no error */ +- if (state->mode != GZ_WRITE || state->err != Z_OK) +- return Z_STREAM_ERROR; +- +- /* check flush parameter */ +- if (flush < 0 || flush > Z_FINISH) +- return Z_STREAM_ERROR; +- +- /* check for seek request */ +- if (state->seek) { +- state->seek = 0; +- if (gz_zero(state, state->skip) == -1) +- return -1; +- } +- +- /* compress remaining data with requested flush */ +- gz_comp(state, flush); +- return state->err; +-} +- +-/* -- see zlib.h -- */ +-int ZEXPORT gzsetparams(file, level, strategy) +- gzFile file; +- int level; +- int strategy; +-{ +- gz_statep state; +- z_streamp strm; +- +- /* get internal structure */ +- if (file == NULL) +- return Z_STREAM_ERROR; +- state = (gz_statep)file; +- strm = &(state->strm); +- +- /* check that we're writing and that there's no error */ +- if (state->mode != GZ_WRITE || state->err != Z_OK) +- return Z_STREAM_ERROR; +- +- /* if no change is requested, then do nothing */ +- if (level == state->level && strategy == state->strategy) +- return Z_OK; +- +- /* check for seek request */ +- if (state->seek) { +- state->seek = 0; +- if (gz_zero(state, state->skip) == -1) +- return -1; +- } +- +- /* change compression parameters for subsequent input */ +- if (state->size) { +- /* flush previous input with previous parameters before changing */ +- if (strm->avail_in && gz_comp(state, Z_PARTIAL_FLUSH) == -1) +- return state->err; +- deflateParams(strm, level, strategy); +- } +- state->level = level; +- state->strategy = strategy; +- return Z_OK; +-} +- +-/* -- see zlib.h -- */ +-int ZEXPORT gzclose_w(file) +- gzFile file; +-{ +- int ret = 0; +- gz_statep state; +- +- /* get internal structure */ +- if (file == NULL) +- return Z_STREAM_ERROR; +- state = (gz_statep)file; +- +- /* check that we're writing */ +- if (state->mode != GZ_WRITE) +- return Z_STREAM_ERROR; +- +- /* check for seek request */ +- if (state->seek) { +- state->seek = 0; +- ret += gz_zero(state, state->skip); +- } +- +- /* flush, free memory, and close file */ +- ret += gz_comp(state, Z_FINISH); +- (void)deflateEnd(&(state->strm)); +- free(state->out); +- free(state->in); +- gz_error(state, Z_OK, NULL); +- free(state->path); +- ret += close(state->fd); +- free(state); +- return ret ? Z_ERRNO : Z_OK; +-} +diff --git a/thirdparty/zlib/infback.c b/thirdparty/zlib/infback.c +deleted file mode 100644 +index af3a8c9..0000000 +--- a/thirdparty/zlib/infback.c ++++ /dev/null +@@ -1,632 +0,0 @@ +-/* infback.c -- inflate using a call-back interface +- * Copyright (C) 1995-2009 Mark Adler +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* +- This code is largely copied from inflate.c. Normally either infback.o or +- inflate.o would be linked into an application--not both. The interface +- with inffast.c is retained so that optimized assembler-coded versions of +- inflate_fast() can be used with either inflate.c or infback.c. +- */ +- +-#include "zutil.h" +-#include "inftrees.h" +-#include "inflate.h" +-#include "inffast.h" +- +-/* function prototypes */ +-local void fixedtables OF((struct inflate_state FAR *state)); +- +-/* +- strm provides memory allocation functions in zalloc and zfree, or +- Z_NULL to use the library memory allocation functions. +- +- windowBits is in the range 8..15, and window is a user-supplied +- window and output buffer that is 2**windowBits bytes. +- */ +-int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size) +-z_streamp strm; +-int windowBits; +-unsigned char FAR *window; +-const char *version; +-int stream_size; +-{ +- struct inflate_state FAR *state; +- +- if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || +- stream_size != (int)(sizeof(z_stream))) +- return Z_VERSION_ERROR; +- if (strm == Z_NULL || window == Z_NULL || +- windowBits < 8 || windowBits > 15) +- return Z_STREAM_ERROR; +- strm->msg = Z_NULL; /* in case we return an error */ +- if (strm->zalloc == (alloc_func)0) { +- strm->zalloc = zcalloc; +- strm->opaque = (voidpf)0; +- } +- if (strm->zfree == (free_func)0) strm->zfree = zcfree; +- state = (struct inflate_state FAR *)ZALLOC(strm, 1, +- sizeof(struct inflate_state)); +- if (state == Z_NULL) return Z_MEM_ERROR; +- Tracev((stderr, "inflate: allocated\n")); +- strm->state = (struct internal_state FAR *)state; +- state->dmax = 32768U; +- state->wbits = windowBits; +- state->wsize = 1U << windowBits; +- state->window = window; +- state->wnext = 0; +- state->whave = 0; +- return Z_OK; +-} +- +-/* +- Return state with length and distance decoding tables and index sizes set to +- fixed code decoding. Normally this returns fixed tables from inffixed.h. +- If BUILDFIXED is defined, then instead this routine builds the tables the +- first time it's called, and returns those tables the first time and +- thereafter. This reduces the size of the code by about 2K bytes, in +- exchange for a little execution time. However, BUILDFIXED should not be +- used for threaded applications, since the rewriting of the tables and virgin +- may not be thread-safe. +- */ +-local void fixedtables(state) +-struct inflate_state FAR *state; +-{ +-#ifdef BUILDFIXED +- static int virgin = 1; +- static code *lenfix, *distfix; +- static code fixed[544]; +- +- /* build fixed huffman tables if first call (may not be thread safe) */ +- if (virgin) { +- unsigned sym, bits; +- static code *next; +- +- /* literal/length table */ +- sym = 0; +- while (sym < 144) state->lens[sym++] = 8; +- while (sym < 256) state->lens[sym++] = 9; +- while (sym < 280) state->lens[sym++] = 7; +- while (sym < 288) state->lens[sym++] = 8; +- next = fixed; +- lenfix = next; +- bits = 9; +- inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); +- +- /* distance table */ +- sym = 0; +- while (sym < 32) state->lens[sym++] = 5; +- distfix = next; +- bits = 5; +- inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); +- +- /* do this just once */ +- virgin = 0; +- } +-#else /* !BUILDFIXED */ +-# include "inffixed.h" +-#endif /* BUILDFIXED */ +- state->lencode = lenfix; +- state->lenbits = 9; +- state->distcode = distfix; +- state->distbits = 5; +-} +- +-/* Macros for inflateBack(): */ +- +-/* Load returned state from inflate_fast() */ +-#define LOAD() \ +- do { \ +- put = strm->next_out; \ +- left = strm->avail_out; \ +- next = strm->next_in; \ +- have = strm->avail_in; \ +- hold = state->hold; \ +- bits = state->bits; \ +- } while (0) +- +-/* Set state from registers for inflate_fast() */ +-#define RESTORE() \ +- do { \ +- strm->next_out = put; \ +- strm->avail_out = left; \ +- strm->next_in = next; \ +- strm->avail_in = have; \ +- state->hold = hold; \ +- state->bits = bits; \ +- } while (0) +- +-/* Clear the input bit accumulator */ +-#define INITBITS() \ +- do { \ +- hold = 0; \ +- bits = 0; \ +- } while (0) +- +-/* Assure that some input is available. If input is requested, but denied, +- then return a Z_BUF_ERROR from inflateBack(). */ +-#define PULL() \ +- do { \ +- if (have == 0) { \ +- have = in(in_desc, &next); \ +- if (have == 0) { \ +- next = Z_NULL; \ +- ret = Z_BUF_ERROR; \ +- goto inf_leave; \ +- } \ +- } \ +- } while (0) +- +-/* Get a byte of input into the bit accumulator, or return from inflateBack() +- with an error if there is no input available. */ +-#define PULLBYTE() \ +- do { \ +- PULL(); \ +- have--; \ +- hold += (unsigned long)(*next++) << bits; \ +- bits += 8; \ +- } while (0) +- +-/* Assure that there are at least n bits in the bit accumulator. If there is +- not enough available input to do that, then return from inflateBack() with +- an error. */ +-#define NEEDBITS(n) \ +- do { \ +- while (bits < (unsigned)(n)) \ +- PULLBYTE(); \ +- } while (0) +- +-/* Return the low n bits of the bit accumulator (n < 16) */ +-#define BITS(n) \ +- ((unsigned)hold & ((1U << (n)) - 1)) +- +-/* Remove n bits from the bit accumulator */ +-#define DROPBITS(n) \ +- do { \ +- hold >>= (n); \ +- bits -= (unsigned)(n); \ +- } while (0) +- +-/* Remove zero to seven bits as needed to go to a byte boundary */ +-#define BYTEBITS() \ +- do { \ +- hold >>= bits & 7; \ +- bits -= bits & 7; \ +- } while (0) +- +-/* Assure that some output space is available, by writing out the window +- if it's full. If the write fails, return from inflateBack() with a +- Z_BUF_ERROR. */ +-#define ROOM() \ +- do { \ +- if (left == 0) { \ +- put = state->window; \ +- left = state->wsize; \ +- state->whave = left; \ +- if (out(out_desc, put, left)) { \ +- ret = Z_BUF_ERROR; \ +- goto inf_leave; \ +- } \ +- } \ +- } while (0) +- +-/* +- strm provides the memory allocation functions and window buffer on input, +- and provides information on the unused input on return. For Z_DATA_ERROR +- returns, strm will also provide an error message. +- +- in() and out() are the call-back input and output functions. When +- inflateBack() needs more input, it calls in(). When inflateBack() has +- filled the window with output, or when it completes with data in the +- window, it calls out() to write out the data. The application must not +- change the provided input until in() is called again or inflateBack() +- returns. The application must not change the window/output buffer until +- inflateBack() returns. +- +- in() and out() are called with a descriptor parameter provided in the +- inflateBack() call. This parameter can be a structure that provides the +- information required to do the read or write, as well as accumulated +- information on the input and output such as totals and check values. +- +- in() should return zero on failure. out() should return non-zero on +- failure. If either in() or out() fails, than inflateBack() returns a +- Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it +- was in() or out() that caused in the error. Otherwise, inflateBack() +- returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format +- error, or Z_MEM_ERROR if it could not allocate memory for the state. +- inflateBack() can also return Z_STREAM_ERROR if the input parameters +- are not correct, i.e. strm is Z_NULL or the state was not initialized. +- */ +-int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc) +-z_streamp strm; +-in_func in; +-void FAR *in_desc; +-out_func out; +-void FAR *out_desc; +-{ +- struct inflate_state FAR *state; +- unsigned char FAR *next; /* next input */ +- unsigned char FAR *put; /* next output */ +- unsigned have, left; /* available input and output */ +- unsigned long hold; /* bit buffer */ +- unsigned bits; /* bits in bit buffer */ +- unsigned copy; /* number of stored or match bytes to copy */ +- unsigned char FAR *from; /* where to copy match bytes from */ +- code here; /* current decoding table entry */ +- code last; /* parent table entry */ +- unsigned len; /* length to copy for repeats, bits to drop */ +- int ret; /* return code */ +- static const unsigned short order[19] = /* permutation of code lengths */ +- {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; +- +- /* Check that the strm exists and that the state was initialized */ +- if (strm == Z_NULL || strm->state == Z_NULL) +- return Z_STREAM_ERROR; +- state = (struct inflate_state FAR *)strm->state; +- +- /* Reset the state */ +- strm->msg = Z_NULL; +- state->mode = TYPE; +- state->last = 0; +- state->whave = 0; +- next = strm->next_in; +- have = next != Z_NULL ? strm->avail_in : 0; +- hold = 0; +- bits = 0; +- put = state->window; +- left = state->wsize; +- +- /* Inflate until end of block marked as last */ +- for (;;) +- switch (state->mode) { +- case TYPE: +- /* determine and dispatch block type */ +- if (state->last) { +- BYTEBITS(); +- state->mode = DONE; +- break; +- } +- NEEDBITS(3); +- state->last = BITS(1); +- DROPBITS(1); +- switch (BITS(2)) { +- case 0: /* stored block */ +- Tracev((stderr, "inflate: stored block%s\n", +- state->last ? " (last)" : "")); +- state->mode = STORED; +- break; +- case 1: /* fixed block */ +- fixedtables(state); +- Tracev((stderr, "inflate: fixed codes block%s\n", +- state->last ? " (last)" : "")); +- state->mode = LEN; /* decode codes */ +- break; +- case 2: /* dynamic block */ +- Tracev((stderr, "inflate: dynamic codes block%s\n", +- state->last ? " (last)" : "")); +- state->mode = TABLE; +- break; +- case 3: +- strm->msg = (char *)"invalid block type"; +- state->mode = BAD; +- } +- DROPBITS(2); +- break; +- +- case STORED: +- /* get and verify stored block length */ +- BYTEBITS(); /* go to byte boundary */ +- NEEDBITS(32); +- if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { +- strm->msg = (char *)"invalid stored block lengths"; +- state->mode = BAD; +- break; +- } +- state->length = (unsigned)hold & 0xffff; +- Tracev((stderr, "inflate: stored length %u\n", +- state->length)); +- INITBITS(); +- +- /* copy stored block from input to output */ +- while (state->length != 0) { +- copy = state->length; +- PULL(); +- ROOM(); +- if (copy > have) copy = have; +- if (copy > left) copy = left; +- zmemcpy(put, next, copy); +- have -= copy; +- next += copy; +- left -= copy; +- put += copy; +- state->length -= copy; +- } +- Tracev((stderr, "inflate: stored end\n")); +- state->mode = TYPE; +- break; +- +- case TABLE: +- /* get dynamic table entries descriptor */ +- NEEDBITS(14); +- state->nlen = BITS(5) + 257; +- DROPBITS(5); +- state->ndist = BITS(5) + 1; +- DROPBITS(5); +- state->ncode = BITS(4) + 4; +- DROPBITS(4); +-#ifndef PKZIP_BUG_WORKAROUND +- if (state->nlen > 286 || state->ndist > 30) { +- strm->msg = (char *)"too many length or distance symbols"; +- state->mode = BAD; +- break; +- } +-#endif +- Tracev((stderr, "inflate: table sizes ok\n")); +- +- /* get code length code lengths (not a typo) */ +- state->have = 0; +- while (state->have < state->ncode) { +- NEEDBITS(3); +- state->lens[order[state->have++]] = (unsigned short)BITS(3); +- DROPBITS(3); +- } +- while (state->have < 19) +- state->lens[order[state->have++]] = 0; +- state->next = state->codes; +- state->lencode = (code const FAR *)(state->next); +- state->lenbits = 7; +- ret = inflate_table(CODES, state->lens, 19, &(state->next), +- &(state->lenbits), state->work); +- if (ret) { +- strm->msg = (char *)"invalid code lengths set"; +- state->mode = BAD; +- break; +- } +- Tracev((stderr, "inflate: code lengths ok\n")); +- +- /* get length and distance code code lengths */ +- state->have = 0; +- while (state->have < state->nlen + state->ndist) { +- for (;;) { +- here = state->lencode[BITS(state->lenbits)]; +- if ((unsigned)(here.bits) <= bits) break; +- PULLBYTE(); +- } +- if (here.val < 16) { +- NEEDBITS(here.bits); +- DROPBITS(here.bits); +- state->lens[state->have++] = here.val; +- } +- else { +- if (here.val == 16) { +- NEEDBITS(here.bits + 2); +- DROPBITS(here.bits); +- if (state->have == 0) { +- strm->msg = (char *)"invalid bit length repeat"; +- state->mode = BAD; +- break; +- } +- len = (unsigned)(state->lens[state->have - 1]); +- copy = 3 + BITS(2); +- DROPBITS(2); +- } +- else if (here.val == 17) { +- NEEDBITS(here.bits + 3); +- DROPBITS(here.bits); +- len = 0; +- copy = 3 + BITS(3); +- DROPBITS(3); +- } +- else { +- NEEDBITS(here.bits + 7); +- DROPBITS(here.bits); +- len = 0; +- copy = 11 + BITS(7); +- DROPBITS(7); +- } +- if (state->have + copy > state->nlen + state->ndist) { +- strm->msg = (char *)"invalid bit length repeat"; +- state->mode = BAD; +- break; +- } +- while (copy--) +- state->lens[state->have++] = (unsigned short)len; +- } +- } +- +- /* handle error breaks in while */ +- if (state->mode == BAD) break; +- +- /* check for end-of-block code (better have one) */ +- if (state->lens[256] == 0) { +- strm->msg = (char *)"invalid code -- missing end-of-block"; +- state->mode = BAD; +- break; +- } +- +- /* build code tables -- note: do not change the lenbits or distbits +- values here (9 and 6) without reading the comments in inftrees.h +- concerning the ENOUGH constants, which depend on those values */ +- state->next = state->codes; +- state->lencode = (code const FAR *)(state->next); +- state->lenbits = 9; +- ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), +- &(state->lenbits), state->work); +- if (ret) { +- strm->msg = (char *)"invalid literal/lengths set"; +- state->mode = BAD; +- break; +- } +- state->distcode = (code const FAR *)(state->next); +- state->distbits = 6; +- ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, +- &(state->next), &(state->distbits), state->work); +- if (ret) { +- strm->msg = (char *)"invalid distances set"; +- state->mode = BAD; +- break; +- } +- Tracev((stderr, "inflate: codes ok\n")); +- state->mode = LEN; +- +- case LEN: +- /* use inflate_fast() if we have enough input and output */ +- if (have >= 6 && left >= 258) { +- RESTORE(); +- if (state->whave < state->wsize) +- state->whave = state->wsize - left; +- inflate_fast(strm, state->wsize); +- LOAD(); +- break; +- } +- +- /* get a literal, length, or end-of-block code */ +- for (;;) { +- here = state->lencode[BITS(state->lenbits)]; +- if ((unsigned)(here.bits) <= bits) break; +- PULLBYTE(); +- } +- if (here.op && (here.op & 0xf0) == 0) { +- last = here; +- for (;;) { +- here = state->lencode[last.val + +- (BITS(last.bits + last.op) >> last.bits)]; +- if ((unsigned)(last.bits + here.bits) <= bits) break; +- PULLBYTE(); +- } +- DROPBITS(last.bits); +- } +- DROPBITS(here.bits); +- state->length = (unsigned)here.val; +- +- /* process literal */ +- if (here.op == 0) { +- Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? +- "inflate: literal '%c'\n" : +- "inflate: literal 0x%02x\n", here.val)); +- ROOM(); +- *put++ = (unsigned char)(state->length); +- left--; +- state->mode = LEN; +- break; +- } +- +- /* process end of block */ +- if (here.op & 32) { +- Tracevv((stderr, "inflate: end of block\n")); +- state->mode = TYPE; +- break; +- } +- +- /* invalid code */ +- if (here.op & 64) { +- strm->msg = (char *)"invalid literal/length code"; +- state->mode = BAD; +- break; +- } +- +- /* length code -- get extra bits, if any */ +- state->extra = (unsigned)(here.op) & 15; +- if (state->extra != 0) { +- NEEDBITS(state->extra); +- state->length += BITS(state->extra); +- DROPBITS(state->extra); +- } +- Tracevv((stderr, "inflate: length %u\n", state->length)); +- +- /* get distance code */ +- for (;;) { +- here = state->distcode[BITS(state->distbits)]; +- if ((unsigned)(here.bits) <= bits) break; +- PULLBYTE(); +- } +- if ((here.op & 0xf0) == 0) { +- last = here; +- for (;;) { +- here = state->distcode[last.val + +- (BITS(last.bits + last.op) >> last.bits)]; +- if ((unsigned)(last.bits + here.bits) <= bits) break; +- PULLBYTE(); +- } +- DROPBITS(last.bits); +- } +- DROPBITS(here.bits); +- if (here.op & 64) { +- strm->msg = (char *)"invalid distance code"; +- state->mode = BAD; +- break; +- } +- state->offset = (unsigned)here.val; +- +- /* get distance extra bits, if any */ +- state->extra = (unsigned)(here.op) & 15; +- if (state->extra != 0) { +- NEEDBITS(state->extra); +- state->offset += BITS(state->extra); +- DROPBITS(state->extra); +- } +- if (state->offset > state->wsize - (state->whave < state->wsize ? +- left : 0)) { +- strm->msg = (char *)"invalid distance too far back"; +- state->mode = BAD; +- break; +- } +- Tracevv((stderr, "inflate: distance %u\n", state->offset)); +- +- /* copy match from window to output */ +- do { +- ROOM(); +- copy = state->wsize - state->offset; +- if (copy < left) { +- from = put + copy; +- copy = left - copy; +- } +- else { +- from = put - state->offset; +- copy = left; +- } +- if (copy > state->length) copy = state->length; +- state->length -= copy; +- left -= copy; +- do { +- *put++ = *from++; +- } while (--copy); +- } while (state->length != 0); +- break; +- +- case DONE: +- /* inflate stream terminated properly -- write leftover output */ +- ret = Z_STREAM_END; +- if (left < state->wsize) { +- if (out(out_desc, state->window, state->wsize - left)) +- ret = Z_BUF_ERROR; +- } +- goto inf_leave; +- +- case BAD: +- ret = Z_DATA_ERROR; +- goto inf_leave; +- +- default: /* can't happen, but makes compilers happy */ +- ret = Z_STREAM_ERROR; +- goto inf_leave; +- } +- +- /* Return unused input */ +- inf_leave: +- strm->next_in = next; +- strm->avail_in = have; +- return ret; +-} +- +-int ZEXPORT inflateBackEnd(strm) +-z_streamp strm; +-{ +- if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) +- return Z_STREAM_ERROR; +- ZFREE(strm, strm->state); +- strm->state = Z_NULL; +- Tracev((stderr, "inflate: end\n")); +- return Z_OK; +-} +diff --git a/thirdparty/zlib/inffast.c b/thirdparty/zlib/inffast.c +deleted file mode 100644 +index 2f1d60b..0000000 +--- a/thirdparty/zlib/inffast.c ++++ /dev/null +@@ -1,340 +0,0 @@ +-/* inffast.c -- fast decoding +- * Copyright (C) 1995-2008, 2010 Mark Adler +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-#include "zutil.h" +-#include "inftrees.h" +-#include "inflate.h" +-#include "inffast.h" +- +-#ifndef ASMINF +- +-/* Allow machine dependent optimization for post-increment or pre-increment. +- Based on testing to date, +- Pre-increment preferred for: +- - PowerPC G3 (Adler) +- - MIPS R5000 (Randers-Pehrson) +- Post-increment preferred for: +- - none +- No measurable difference: +- - Pentium III (Anderson) +- - M68060 (Nikl) +- */ +-#ifdef POSTINC +-# define OFF 0 +-# define PUP(a) *(a)++ +-#else +-# define OFF 1 +-# define PUP(a) *++(a) +-#endif +- +-/* +- Decode literal, length, and distance codes and write out the resulting +- literal and match bytes until either not enough input or output is +- available, an end-of-block is encountered, or a data error is encountered. +- When large enough input and output buffers are supplied to inflate(), for +- example, a 16K input buffer and a 64K output buffer, more than 95% of the +- inflate execution time is spent in this routine. +- +- Entry assumptions: +- +- state->mode == LEN +- strm->avail_in >= 6 +- strm->avail_out >= 258 +- start >= strm->avail_out +- state->bits < 8 +- +- On return, state->mode is one of: +- +- LEN -- ran out of enough output space or enough available input +- TYPE -- reached end of block code, inflate() to interpret next block +- BAD -- error in block data +- +- Notes: +- +- - The maximum input bits used by a length/distance pair is 15 bits for the +- length code, 5 bits for the length extra, 15 bits for the distance code, +- and 13 bits for the distance extra. This totals 48 bits, or six bytes. +- Therefore if strm->avail_in >= 6, then there is enough input to avoid +- checking for available input while decoding. +- +- - The maximum bytes that a single length/distance pair can output is 258 +- bytes, which is the maximum length that can be coded. inflate_fast() +- requires strm->avail_out >= 258 for each loop to avoid checking for +- output space. +- */ +-void ZLIB_INTERNAL inflate_fast(strm, start) +-z_streamp strm; +-unsigned start; /* inflate()'s starting value for strm->avail_out */ +-{ +- struct inflate_state FAR *state; +- unsigned char FAR *in; /* local strm->next_in */ +- unsigned char FAR *last; /* while in < last, enough input available */ +- unsigned char FAR *out; /* local strm->next_out */ +- unsigned char FAR *beg; /* inflate()'s initial strm->next_out */ +- unsigned char FAR *end; /* while out < end, enough space available */ +-#ifdef INFLATE_STRICT +- unsigned dmax; /* maximum distance from zlib header */ +-#endif +- unsigned wsize; /* window size or zero if not using window */ +- unsigned whave; /* valid bytes in the window */ +- unsigned wnext; /* window write index */ +- unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */ +- unsigned long hold; /* local strm->hold */ +- unsigned bits; /* local strm->bits */ +- code const FAR *lcode; /* local strm->lencode */ +- code const FAR *dcode; /* local strm->distcode */ +- unsigned lmask; /* mask for first level of length codes */ +- unsigned dmask; /* mask for first level of distance codes */ +- code here; /* retrieved table entry */ +- unsigned op; /* code bits, operation, extra bits, or */ +- /* window position, window bytes to copy */ +- unsigned len; /* match length, unused bytes */ +- unsigned dist; /* match distance */ +- unsigned char FAR *from; /* where to copy match from */ +- +- /* copy state to local variables */ +- state = (struct inflate_state FAR *)strm->state; +- in = strm->next_in - OFF; +- last = in + (strm->avail_in - 5); +- out = strm->next_out - OFF; +- beg = out - (start - strm->avail_out); +- end = out + (strm->avail_out - 257); +-#ifdef INFLATE_STRICT +- dmax = state->dmax; +-#endif +- wsize = state->wsize; +- whave = state->whave; +- wnext = state->wnext; +- window = state->window; +- hold = state->hold; +- bits = state->bits; +- lcode = state->lencode; +- dcode = state->distcode; +- lmask = (1U << state->lenbits) - 1; +- dmask = (1U << state->distbits) - 1; +- +- /* decode literals and length/distances until end-of-block or not enough +- input data or output space */ +- do { +- if (bits < 15) { +- hold += (unsigned long)(PUP(in)) << bits; +- bits += 8; +- hold += (unsigned long)(PUP(in)) << bits; +- bits += 8; +- } +- here = lcode[hold & lmask]; +- dolen: +- op = (unsigned)(here.bits); +- hold >>= op; +- bits -= op; +- op = (unsigned)(here.op); +- if (op == 0) { /* literal */ +- Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? +- "inflate: literal '%c'\n" : +- "inflate: literal 0x%02x\n", here.val)); +- PUP(out) = (unsigned char)(here.val); +- } +- else if (op & 16) { /* length base */ +- len = (unsigned)(here.val); +- op &= 15; /* number of extra bits */ +- if (op) { +- if (bits < op) { +- hold += (unsigned long)(PUP(in)) << bits; +- bits += 8; +- } +- len += (unsigned)hold & ((1U << op) - 1); +- hold >>= op; +- bits -= op; +- } +- Tracevv((stderr, "inflate: length %u\n", len)); +- if (bits < 15) { +- hold += (unsigned long)(PUP(in)) << bits; +- bits += 8; +- hold += (unsigned long)(PUP(in)) << bits; +- bits += 8; +- } +- here = dcode[hold & dmask]; +- dodist: +- op = (unsigned)(here.bits); +- hold >>= op; +- bits -= op; +- op = (unsigned)(here.op); +- if (op & 16) { /* distance base */ +- dist = (unsigned)(here.val); +- op &= 15; /* number of extra bits */ +- if (bits < op) { +- hold += (unsigned long)(PUP(in)) << bits; +- bits += 8; +- if (bits < op) { +- hold += (unsigned long)(PUP(in)) << bits; +- bits += 8; +- } +- } +- dist += (unsigned)hold & ((1U << op) - 1); +-#ifdef INFLATE_STRICT +- if (dist > dmax) { +- strm->msg = (char *)"invalid distance too far back"; +- state->mode = BAD; +- break; +- } +-#endif +- hold >>= op; +- bits -= op; +- Tracevv((stderr, "inflate: distance %u\n", dist)); +- op = (unsigned)(out - beg); /* max distance in output */ +- if (dist > op) { /* see if copy from window */ +- op = dist - op; /* distance back in window */ +- if (op > whave) { +- if (state->sane) { +- strm->msg = +- (char *)"invalid distance too far back"; +- state->mode = BAD; +- break; +- } +-#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR +- if (len <= op - whave) { +- do { +- PUP(out) = 0; +- } while (--len); +- continue; +- } +- len -= op - whave; +- do { +- PUP(out) = 0; +- } while (--op > whave); +- if (op == 0) { +- from = out - dist; +- do { +- PUP(out) = PUP(from); +- } while (--len); +- continue; +- } +-#endif +- } +- from = window - OFF; +- if (wnext == 0) { /* very common case */ +- from += wsize - op; +- if (op < len) { /* some from window */ +- len -= op; +- do { +- PUP(out) = PUP(from); +- } while (--op); +- from = out - dist; /* rest from output */ +- } +- } +- else if (wnext < op) { /* wrap around window */ +- from += wsize + wnext - op; +- op -= wnext; +- if (op < len) { /* some from end of window */ +- len -= op; +- do { +- PUP(out) = PUP(from); +- } while (--op); +- from = window - OFF; +- if (wnext < len) { /* some from start of window */ +- op = wnext; +- len -= op; +- do { +- PUP(out) = PUP(from); +- } while (--op); +- from = out - dist; /* rest from output */ +- } +- } +- } +- else { /* contiguous in window */ +- from += wnext - op; +- if (op < len) { /* some from window */ +- len -= op; +- do { +- PUP(out) = PUP(from); +- } while (--op); +- from = out - dist; /* rest from output */ +- } +- } +- while (len > 2) { +- PUP(out) = PUP(from); +- PUP(out) = PUP(from); +- PUP(out) = PUP(from); +- len -= 3; +- } +- if (len) { +- PUP(out) = PUP(from); +- if (len > 1) +- PUP(out) = PUP(from); +- } +- } +- else { +- from = out - dist; /* copy direct from output */ +- do { /* minimum length is three */ +- PUP(out) = PUP(from); +- PUP(out) = PUP(from); +- PUP(out) = PUP(from); +- len -= 3; +- } while (len > 2); +- if (len) { +- PUP(out) = PUP(from); +- if (len > 1) +- PUP(out) = PUP(from); +- } +- } +- } +- else if ((op & 64) == 0) { /* 2nd level distance code */ +- here = dcode[here.val + (hold & ((1U << op) - 1))]; +- goto dodist; +- } +- else { +- strm->msg = (char *)"invalid distance code"; +- state->mode = BAD; +- break; +- } +- } +- else if ((op & 64) == 0) { /* 2nd level length code */ +- here = lcode[here.val + (hold & ((1U << op) - 1))]; +- goto dolen; +- } +- else if (op & 32) { /* end-of-block */ +- Tracevv((stderr, "inflate: end of block\n")); +- state->mode = TYPE; +- break; +- } +- else { +- strm->msg = (char *)"invalid literal/length code"; +- state->mode = BAD; +- break; +- } +- } while (in < last && out < end); +- +- /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ +- len = bits >> 3; +- in -= len; +- bits -= len << 3; +- hold &= (1U << bits) - 1; +- +- /* update state and return */ +- strm->next_in = in + OFF; +- strm->next_out = out + OFF; +- strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last)); +- strm->avail_out = (unsigned)(out < end ? +- 257 + (end - out) : 257 - (out - end)); +- state->hold = hold; +- state->bits = bits; +- return; +-} +- +-/* +- inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe): +- - Using bit fields for code structure +- - Different op definition to avoid & for extra bits (do & for table bits) +- - Three separate decoding do-loops for direct, window, and wnext == 0 +- - Special case for distance > 1 copies to do overlapped load and store copy +- - Explicit branch predictions (based on measured branch probabilities) +- - Deferring match copy and interspersed it with decoding subsequent codes +- - Swapping literal/length else +- - Swapping window/direct else +- - Larger unrolled copy loops (three is about right) +- - Moving len -= 3 statement into middle of loop +- */ +- +-#endif /* !ASMINF */ +diff --git a/thirdparty/zlib/inffast.h b/thirdparty/zlib/inffast.h +deleted file mode 100644 +index e5c1aa4..0000000 +--- a/thirdparty/zlib/inffast.h ++++ /dev/null +@@ -1,11 +0,0 @@ +-/* inffast.h -- header to use inffast.c +- * Copyright (C) 1995-2003, 2010 Mark Adler +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* WARNING: this file should *not* be used by applications. It is +- part of the implementation of the compression library and is +- subject to change. Applications should only use zlib.h. +- */ +- +-void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start)); +diff --git a/thirdparty/zlib/inffixed.h b/thirdparty/zlib/inffixed.h +deleted file mode 100644 +index 75ed4b5..0000000 +--- a/thirdparty/zlib/inffixed.h ++++ /dev/null +@@ -1,94 +0,0 @@ +- /* inffixed.h -- table for decoding fixed codes +- * Generated automatically by makefixed(). +- */ +- +- /* WARNING: this file should *not* be used by applications. It +- is part of the implementation of the compression library and +- is subject to change. Applications should only use zlib.h. +- */ +- +- static const code lenfix[512] = { +- {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, +- {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, +- {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, +- {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, +- {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, +- {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, +- {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, +- {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, +- {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, +- {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, +- {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, +- {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, +- {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, +- {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, +- {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, +- {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, +- {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, +- {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142}, +- {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, +- {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, +- {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, +- {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, +- {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, +- {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, +- {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, +- {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, +- {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, +- {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, +- {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, +- {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, +- {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, +- {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, +- {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55}, +- {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, +- {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, +- {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190}, +- {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16}, +- {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, +- {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, +- {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, +- {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, +- {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, +- {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, +- {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, +- {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, +- {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, +- {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, +- {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, +- {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, +- {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, +- {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51}, +- {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, +- {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, +- {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110}, +- {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0}, +- {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, +- {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, +- {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, +- {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, +- {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258}, +- {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, +- {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, +- {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, +- {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, +- {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, +- {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, +- {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, +- {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, +- {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, +- {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, +- {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, +- {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, +- {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, +- {0,9,255} +- }; +- +- static const code distfix[32] = { +- {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, +- {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, +- {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385}, +- {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, +- {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, +- {22,5,193},{64,5,0} +- }; +diff --git a/thirdparty/zlib/inflate.c b/thirdparty/zlib/inflate.c +deleted file mode 100644 +index a8431ab..0000000 +--- a/thirdparty/zlib/inflate.c ++++ /dev/null +@@ -1,1480 +0,0 @@ +-/* inflate.c -- zlib decompression +- * Copyright (C) 1995-2010 Mark Adler +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* +- * Change history: +- * +- * 1.2.beta0 24 Nov 2002 +- * - First version -- complete rewrite of inflate to simplify code, avoid +- * creation of window when not needed, minimize use of window when it is +- * needed, make inffast.c even faster, implement gzip decoding, and to +- * improve code readability and style over the previous zlib inflate code +- * +- * 1.2.beta1 25 Nov 2002 +- * - Use pointers for available input and output checking in inffast.c +- * - Remove input and output counters in inffast.c +- * - Change inffast.c entry and loop from avail_in >= 7 to >= 6 +- * - Remove unnecessary second byte pull from length extra in inffast.c +- * - Unroll direct copy to three copies per loop in inffast.c +- * +- * 1.2.beta2 4 Dec 2002 +- * - Change external routine names to reduce potential conflicts +- * - Correct filename to inffixed.h for fixed tables in inflate.c +- * - Make hbuf[] unsigned char to match parameter type in inflate.c +- * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset) +- * to avoid negation problem on Alphas (64 bit) in inflate.c +- * +- * 1.2.beta3 22 Dec 2002 +- * - Add comments on state->bits assertion in inffast.c +- * - Add comments on op field in inftrees.h +- * - Fix bug in reuse of allocated window after inflateReset() +- * - Remove bit fields--back to byte structure for speed +- * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths +- * - Change post-increments to pre-increments in inflate_fast(), PPC biased? +- * - Add compile time option, POSTINC, to use post-increments instead (Intel?) +- * - Make MATCH copy in inflate() much faster for when inflate_fast() not used +- * - Use local copies of stream next and avail values, as well as local bit +- * buffer and bit count in inflate()--for speed when inflate_fast() not used +- * +- * 1.2.beta4 1 Jan 2003 +- * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings +- * - Move a comment on output buffer sizes from inffast.c to inflate.c +- * - Add comments in inffast.c to introduce the inflate_fast() routine +- * - Rearrange window copies in inflate_fast() for speed and simplification +- * - Unroll last copy for window match in inflate_fast() +- * - Use local copies of window variables in inflate_fast() for speed +- * - Pull out common wnext == 0 case for speed in inflate_fast() +- * - Make op and len in inflate_fast() unsigned for consistency +- * - Add FAR to lcode and dcode declarations in inflate_fast() +- * - Simplified bad distance check in inflate_fast() +- * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new +- * source file infback.c to provide a call-back interface to inflate for +- * programs like gzip and unzip -- uses window as output buffer to avoid +- * window copying +- * +- * 1.2.beta5 1 Jan 2003 +- * - Improved inflateBack() interface to allow the caller to provide initial +- * input in strm. +- * - Fixed stored blocks bug in inflateBack() +- * +- * 1.2.beta6 4 Jan 2003 +- * - Added comments in inffast.c on effectiveness of POSTINC +- * - Typecasting all around to reduce compiler warnings +- * - Changed loops from while (1) or do {} while (1) to for (;;), again to +- * make compilers happy +- * - Changed type of window in inflateBackInit() to unsigned char * +- * +- * 1.2.beta7 27 Jan 2003 +- * - Changed many types to unsigned or unsigned short to avoid warnings +- * - Added inflateCopy() function +- * +- * 1.2.0 9 Mar 2003 +- * - Changed inflateBack() interface to provide separate opaque descriptors +- * for the in() and out() functions +- * - Changed inflateBack() argument and in_func typedef to swap the length +- * and buffer address return values for the input function +- * - Check next_in and next_out for Z_NULL on entry to inflate() +- * +- * The history for versions after 1.2.0 are in ChangeLog in zlib distribution. +- */ +- +-#include "zutil.h" +-#include "inftrees.h" +-#include "inflate.h" +-#include "inffast.h" +- +-#ifdef MAKEFIXED +-# ifndef BUILDFIXED +-# define BUILDFIXED +-# endif +-#endif +- +-/* function prototypes */ +-local void fixedtables OF((struct inflate_state FAR *state)); +-local int updatewindow OF((z_streamp strm, unsigned out)); +-#ifdef BUILDFIXED +- void makefixed OF((void)); +-#endif +-local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf, +- unsigned len)); +- +-int ZEXPORT inflateReset(strm) +-z_streamp strm; +-{ +- struct inflate_state FAR *state; +- +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; +- state = (struct inflate_state FAR *)strm->state; +- strm->total_in = strm->total_out = state->total = 0; +- strm->msg = Z_NULL; +- strm->adler = 1; /* to support ill-conceived Java test suite */ +- state->mode = HEAD; +- state->last = 0; +- state->havedict = 0; +- state->dmax = 32768U; +- state->head = Z_NULL; +- state->wsize = 0; +- state->whave = 0; +- state->wnext = 0; +- state->hold = 0; +- state->bits = 0; +- state->lencode = state->distcode = state->next = state->codes; +- state->sane = 1; +- state->back = -1; +- Tracev((stderr, "inflate: reset\n")); +- return Z_OK; +-} +- +-int ZEXPORT inflateReset2(strm, windowBits) +-z_streamp strm; +-int windowBits; +-{ +- int wrap; +- struct inflate_state FAR *state; +- +- /* get the state */ +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; +- state = (struct inflate_state FAR *)strm->state; +- +- /* extract wrap request from windowBits parameter */ +- if (windowBits < 0) { +- wrap = 0; +- windowBits = -windowBits; +- } +- else { +- wrap = (windowBits >> 4) + 1; +-#ifdef GUNZIP +- if (windowBits < 48) +- windowBits &= 15; +-#endif +- } +- +- /* set number of window bits, free window if different */ +- if (windowBits && (windowBits < 8 || windowBits > 15)) +- return Z_STREAM_ERROR; +- if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) { +- ZFREE(strm, state->window); +- state->window = Z_NULL; +- } +- +- /* update state and reset the rest of it */ +- state->wrap = wrap; +- state->wbits = (unsigned)windowBits; +- return inflateReset(strm); +-} +- +-int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size) +-z_streamp strm; +-int windowBits; +-const char *version; +-int stream_size; +-{ +- int ret; +- struct inflate_state FAR *state; +- +- if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || +- stream_size != (int)(sizeof(z_stream))) +- return Z_VERSION_ERROR; +- if (strm == Z_NULL) return Z_STREAM_ERROR; +- strm->msg = Z_NULL; /* in case we return an error */ +- if (strm->zalloc == (alloc_func)0) { +- strm->zalloc = zcalloc; +- strm->opaque = (voidpf)0; +- } +- if (strm->zfree == (free_func)0) strm->zfree = zcfree; +- state = (struct inflate_state FAR *) +- ZALLOC(strm, 1, sizeof(struct inflate_state)); +- if (state == Z_NULL) return Z_MEM_ERROR; +- Tracev((stderr, "inflate: allocated\n")); +- strm->state = (struct internal_state FAR *)state; +- state->window = Z_NULL; +- ret = inflateReset2(strm, windowBits); +- if (ret != Z_OK) { +- ZFREE(strm, state); +- strm->state = Z_NULL; +- } +- return ret; +-} +- +-int ZEXPORT inflateInit_(strm, version, stream_size) +-z_streamp strm; +-const char *version; +-int stream_size; +-{ +- return inflateInit2_(strm, DEF_WBITS, version, stream_size); +-} +- +-int ZEXPORT inflatePrime(strm, bits, value) +-z_streamp strm; +-int bits; +-int value; +-{ +- struct inflate_state FAR *state; +- +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; +- state = (struct inflate_state FAR *)strm->state; +- if (bits < 0) { +- state->hold = 0; +- state->bits = 0; +- return Z_OK; +- } +- if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR; +- value &= (1L << bits) - 1; +- state->hold += value << state->bits; +- state->bits += bits; +- return Z_OK; +-} +- +-/* +- Return state with length and distance decoding tables and index sizes set to +- fixed code decoding. Normally this returns fixed tables from inffixed.h. +- If BUILDFIXED is defined, then instead this routine builds the tables the +- first time it's called, and returns those tables the first time and +- thereafter. This reduces the size of the code by about 2K bytes, in +- exchange for a little execution time. However, BUILDFIXED should not be +- used for threaded applications, since the rewriting of the tables and virgin +- may not be thread-safe. +- */ +-local void fixedtables(state) +-struct inflate_state FAR *state; +-{ +-#ifdef BUILDFIXED +- static int virgin = 1; +- static code *lenfix, *distfix; +- static code fixed[544]; +- +- /* build fixed huffman tables if first call (may not be thread safe) */ +- if (virgin) { +- unsigned sym, bits; +- static code *next; +- +- /* literal/length table */ +- sym = 0; +- while (sym < 144) state->lens[sym++] = 8; +- while (sym < 256) state->lens[sym++] = 9; +- while (sym < 280) state->lens[sym++] = 7; +- while (sym < 288) state->lens[sym++] = 8; +- next = fixed; +- lenfix = next; +- bits = 9; +- inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); +- +- /* distance table */ +- sym = 0; +- while (sym < 32) state->lens[sym++] = 5; +- distfix = next; +- bits = 5; +- inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); +- +- /* do this just once */ +- virgin = 0; +- } +-#else /* !BUILDFIXED */ +-# include "inffixed.h" +-#endif /* BUILDFIXED */ +- state->lencode = lenfix; +- state->lenbits = 9; +- state->distcode = distfix; +- state->distbits = 5; +-} +- +-#ifdef MAKEFIXED +-#include +- +-/* +- Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also +- defines BUILDFIXED, so the tables are built on the fly. makefixed() writes +- those tables to stdout, which would be piped to inffixed.h. A small program +- can simply call makefixed to do this: +- +- void makefixed(void); +- +- int main(void) +- { +- makefixed(); +- return 0; +- } +- +- Then that can be linked with zlib built with MAKEFIXED defined and run: +- +- a.out > inffixed.h +- */ +-void makefixed() +-{ +- unsigned low, size; +- struct inflate_state state; +- +- fixedtables(&state); +- puts(" /* inffixed.h -- table for decoding fixed codes"); +- puts(" * Generated automatically by makefixed()."); +- puts(" */"); +- puts(""); +- puts(" /* WARNING: this file should *not* be used by applications."); +- puts(" It is part of the implementation of this library and is"); +- puts(" subject to change. Applications should only use zlib.h."); +- puts(" */"); +- puts(""); +- size = 1U << 9; +- printf(" static const code lenfix[%u] = {", size); +- low = 0; +- for (;;) { +- if ((low % 7) == 0) printf("\n "); +- printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits, +- state.lencode[low].val); +- if (++low == size) break; +- putchar(','); +- } +- puts("\n };"); +- size = 1U << 5; +- printf("\n static const code distfix[%u] = {", size); +- low = 0; +- for (;;) { +- if ((low % 6) == 0) printf("\n "); +- printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, +- state.distcode[low].val); +- if (++low == size) break; +- putchar(','); +- } +- puts("\n };"); +-} +-#endif /* MAKEFIXED */ +- +-/* +- Update the window with the last wsize (normally 32K) bytes written before +- returning. If window does not exist yet, create it. This is only called +- when a window is already in use, or when output has been written during this +- inflate call, but the end of the deflate stream has not been reached yet. +- It is also called to create a window for dictionary data when a dictionary +- is loaded. +- +- Providing output buffers larger than 32K to inflate() should provide a speed +- advantage, since only the last 32K of output is copied to the sliding window +- upon return from inflate(), and since all distances after the first 32K of +- output will fall in the output data, making match copies simpler and faster. +- The advantage may be dependent on the size of the processor's data caches. +- */ +-local int updatewindow(strm, out) +-z_streamp strm; +-unsigned out; +-{ +- struct inflate_state FAR *state; +- unsigned copy, dist; +- +- state = (struct inflate_state FAR *)strm->state; +- +- /* if it hasn't been done already, allocate space for the window */ +- if (state->window == Z_NULL) { +- state->window = (unsigned char FAR *) +- ZALLOC(strm, 1U << state->wbits, +- sizeof(unsigned char)); +- if (state->window == Z_NULL) return 1; +- } +- +- /* if window not in use yet, initialize */ +- if (state->wsize == 0) { +- state->wsize = 1U << state->wbits; +- state->wnext = 0; +- state->whave = 0; +- } +- +- /* copy state->wsize or less output bytes into the circular window */ +- copy = out - strm->avail_out; +- if (copy >= state->wsize) { +- zmemcpy(state->window, strm->next_out - state->wsize, state->wsize); +- state->wnext = 0; +- state->whave = state->wsize; +- } +- else { +- dist = state->wsize - state->wnext; +- if (dist > copy) dist = copy; +- zmemcpy(state->window + state->wnext, strm->next_out - copy, dist); +- copy -= dist; +- if (copy) { +- zmemcpy(state->window, strm->next_out - copy, copy); +- state->wnext = copy; +- state->whave = state->wsize; +- } +- else { +- state->wnext += dist; +- if (state->wnext == state->wsize) state->wnext = 0; +- if (state->whave < state->wsize) state->whave += dist; +- } +- } +- return 0; +-} +- +-/* Macros for inflate(): */ +- +-/* check function to use adler32() for zlib or crc32() for gzip */ +-#ifdef GUNZIP +-# define UPDATE(check, buf, len) \ +- (state->flags ? crc32(check, buf, len) : adler32(check, buf, len)) +-#else +-# define UPDATE(check, buf, len) adler32(check, buf, len) +-#endif +- +-/* check macros for header crc */ +-#ifdef GUNZIP +-# define CRC2(check, word) \ +- do { \ +- hbuf[0] = (unsigned char)(word); \ +- hbuf[1] = (unsigned char)((word) >> 8); \ +- check = crc32(check, hbuf, 2); \ +- } while (0) +- +-# define CRC4(check, word) \ +- do { \ +- hbuf[0] = (unsigned char)(word); \ +- hbuf[1] = (unsigned char)((word) >> 8); \ +- hbuf[2] = (unsigned char)((word) >> 16); \ +- hbuf[3] = (unsigned char)((word) >> 24); \ +- check = crc32(check, hbuf, 4); \ +- } while (0) +-#endif +- +-/* Load registers with state in inflate() for speed */ +-#define LOAD() \ +- do { \ +- put = strm->next_out; \ +- left = strm->avail_out; \ +- next = strm->next_in; \ +- have = strm->avail_in; \ +- hold = state->hold; \ +- bits = state->bits; \ +- } while (0) +- +-/* Restore state from registers in inflate() */ +-#define RESTORE() \ +- do { \ +- strm->next_out = put; \ +- strm->avail_out = left; \ +- strm->next_in = next; \ +- strm->avail_in = have; \ +- state->hold = hold; \ +- state->bits = bits; \ +- } while (0) +- +-/* Clear the input bit accumulator */ +-#define INITBITS() \ +- do { \ +- hold = 0; \ +- bits = 0; \ +- } while (0) +- +-/* Get a byte of input into the bit accumulator, or return from inflate() +- if there is no input available. */ +-#define PULLBYTE() \ +- do { \ +- if (have == 0) goto inf_leave; \ +- have--; \ +- hold += (unsigned long)(*next++) << bits; \ +- bits += 8; \ +- } while (0) +- +-/* Assure that there are at least n bits in the bit accumulator. If there is +- not enough available input to do that, then return from inflate(). */ +-#define NEEDBITS(n) \ +- do { \ +- while (bits < (unsigned)(n)) \ +- PULLBYTE(); \ +- } while (0) +- +-/* Return the low n bits of the bit accumulator (n < 16) */ +-#define BITS(n) \ +- ((unsigned)hold & ((1U << (n)) - 1)) +- +-/* Remove n bits from the bit accumulator */ +-#define DROPBITS(n) \ +- do { \ +- hold >>= (n); \ +- bits -= (unsigned)(n); \ +- } while (0) +- +-/* Remove zero to seven bits as needed to go to a byte boundary */ +-#define BYTEBITS() \ +- do { \ +- hold >>= bits & 7; \ +- bits -= bits & 7; \ +- } while (0) +- +-/* Reverse the bytes in a 32-bit value */ +-#define REVERSE(q) \ +- ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ +- (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) +- +-/* +- inflate() uses a state machine to process as much input data and generate as +- much output data as possible before returning. The state machine is +- structured roughly as follows: +- +- for (;;) switch (state) { +- ... +- case STATEn: +- if (not enough input data or output space to make progress) +- return; +- ... make progress ... +- state = STATEm; +- break; +- ... +- } +- +- so when inflate() is called again, the same case is attempted again, and +- if the appropriate resources are provided, the machine proceeds to the +- next state. The NEEDBITS() macro is usually the way the state evaluates +- whether it can proceed or should return. NEEDBITS() does the return if +- the requested bits are not available. The typical use of the BITS macros +- is: +- +- NEEDBITS(n); +- ... do something with BITS(n) ... +- DROPBITS(n); +- +- where NEEDBITS(n) either returns from inflate() if there isn't enough +- input left to load n bits into the accumulator, or it continues. BITS(n) +- gives the low n bits in the accumulator. When done, DROPBITS(n) drops +- the low n bits off the accumulator. INITBITS() clears the accumulator +- and sets the number of available bits to zero. BYTEBITS() discards just +- enough bits to put the accumulator on a byte boundary. After BYTEBITS() +- and a NEEDBITS(8), then BITS(8) would return the next byte in the stream. +- +- NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return +- if there is no input available. The decoding of variable length codes uses +- PULLBYTE() directly in order to pull just enough bytes to decode the next +- code, and no more. +- +- Some states loop until they get enough input, making sure that enough +- state information is maintained to continue the loop where it left off +- if NEEDBITS() returns in the loop. For example, want, need, and keep +- would all have to actually be part of the saved state in case NEEDBITS() +- returns: +- +- case STATEw: +- while (want < need) { +- NEEDBITS(n); +- keep[want++] = BITS(n); +- DROPBITS(n); +- } +- state = STATEx; +- case STATEx: +- +- As shown above, if the next state is also the next case, then the break +- is omitted. +- +- A state may also return if there is not enough output space available to +- complete that state. Those states are copying stored data, writing a +- literal byte, and copying a matching string. +- +- When returning, a "goto inf_leave" is used to update the total counters, +- update the check value, and determine whether any progress has been made +- during that inflate() call in order to return the proper return code. +- Progress is defined as a change in either strm->avail_in or strm->avail_out. +- When there is a window, goto inf_leave will update the window with the last +- output written. If a goto inf_leave occurs in the middle of decompression +- and there is no window currently, goto inf_leave will create one and copy +- output to the window for the next call of inflate(). +- +- In this implementation, the flush parameter of inflate() only affects the +- return code (per zlib.h). inflate() always writes as much as possible to +- strm->next_out, given the space available and the provided input--the effect +- documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers +- the allocation of and copying into a sliding window until necessary, which +- provides the effect documented in zlib.h for Z_FINISH when the entire input +- stream available. So the only thing the flush parameter actually does is: +- when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it +- will return Z_BUF_ERROR if it has not reached the end of the stream. +- */ +- +-int ZEXPORT inflate(strm, flush) +-z_streamp strm; +-int flush; +-{ +- struct inflate_state FAR *state; +- unsigned char FAR *next; /* next input */ +- unsigned char FAR *put; /* next output */ +- unsigned have, left; /* available input and output */ +- unsigned long hold; /* bit buffer */ +- unsigned bits; /* bits in bit buffer */ +- unsigned in, out; /* save starting available input and output */ +- unsigned copy; /* number of stored or match bytes to copy */ +- unsigned char FAR *from; /* where to copy match bytes from */ +- code here; /* current decoding table entry */ +- code last; /* parent table entry */ +- unsigned len; /* length to copy for repeats, bits to drop */ +- int ret; /* return code */ +-#ifdef GUNZIP +- unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ +-#endif +- static const unsigned short order[19] = /* permutation of code lengths */ +- {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; +- +- if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL || +- (strm->next_in == Z_NULL && strm->avail_in != 0)) +- return Z_STREAM_ERROR; +- +- state = (struct inflate_state FAR *)strm->state; +- if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */ +- LOAD(); +- in = have; +- out = left; +- ret = Z_OK; +- for (;;) +- switch (state->mode) { +- case HEAD: +- if (state->wrap == 0) { +- state->mode = TYPEDO; +- break; +- } +- NEEDBITS(16); +-#ifdef GUNZIP +- if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */ +- state->check = crc32(0L, Z_NULL, 0); +- CRC2(state->check, hold); +- INITBITS(); +- state->mode = FLAGS; +- break; +- } +- state->flags = 0; /* expect zlib header */ +- if (state->head != Z_NULL) +- state->head->done = -1; +- if (!(state->wrap & 1) || /* check if zlib header allowed */ +-#else +- if ( +-#endif +- ((BITS(8) << 8) + (hold >> 8)) % 31) { +- strm->msg = (char *)"incorrect header check"; +- state->mode = BAD; +- break; +- } +- if (BITS(4) != Z_DEFLATED) { +- strm->msg = (char *)"unknown compression method"; +- state->mode = BAD; +- break; +- } +- DROPBITS(4); +- len = BITS(4) + 8; +- if (state->wbits == 0) +- state->wbits = len; +- else if (len > state->wbits) { +- strm->msg = (char *)"invalid window size"; +- state->mode = BAD; +- break; +- } +- state->dmax = 1U << len; +- Tracev((stderr, "inflate: zlib header ok\n")); +- strm->adler = state->check = adler32(0L, Z_NULL, 0); +- state->mode = hold & 0x200 ? DICTID : TYPE; +- INITBITS(); +- break; +-#ifdef GUNZIP +- case FLAGS: +- NEEDBITS(16); +- state->flags = (int)(hold); +- if ((state->flags & 0xff) != Z_DEFLATED) { +- strm->msg = (char *)"unknown compression method"; +- state->mode = BAD; +- break; +- } +- if (state->flags & 0xe000) { +- strm->msg = (char *)"unknown header flags set"; +- state->mode = BAD; +- break; +- } +- if (state->head != Z_NULL) +- state->head->text = (int)((hold >> 8) & 1); +- if (state->flags & 0x0200) CRC2(state->check, hold); +- INITBITS(); +- state->mode = TIME; +- case TIME: +- NEEDBITS(32); +- if (state->head != Z_NULL) +- state->head->time = hold; +- if (state->flags & 0x0200) CRC4(state->check, hold); +- INITBITS(); +- state->mode = OS; +- case OS: +- NEEDBITS(16); +- if (state->head != Z_NULL) { +- state->head->xflags = (int)(hold & 0xff); +- state->head->os = (int)(hold >> 8); +- } +- if (state->flags & 0x0200) CRC2(state->check, hold); +- INITBITS(); +- state->mode = EXLEN; +- case EXLEN: +- if (state->flags & 0x0400) { +- NEEDBITS(16); +- state->length = (unsigned)(hold); +- if (state->head != Z_NULL) +- state->head->extra_len = (unsigned)hold; +- if (state->flags & 0x0200) CRC2(state->check, hold); +- INITBITS(); +- } +- else if (state->head != Z_NULL) +- state->head->extra = Z_NULL; +- state->mode = EXTRA; +- case EXTRA: +- if (state->flags & 0x0400) { +- copy = state->length; +- if (copy > have) copy = have; +- if (copy) { +- if (state->head != Z_NULL && +- state->head->extra != Z_NULL) { +- len = state->head->extra_len - state->length; +- zmemcpy(state->head->extra + len, next, +- len + copy > state->head->extra_max ? +- state->head->extra_max - len : copy); +- } +- if (state->flags & 0x0200) +- state->check = crc32(state->check, next, copy); +- have -= copy; +- next += copy; +- state->length -= copy; +- } +- if (state->length) goto inf_leave; +- } +- state->length = 0; +- state->mode = NAME; +- case NAME: +- if (state->flags & 0x0800) { +- if (have == 0) goto inf_leave; +- copy = 0; +- do { +- len = (unsigned)(next[copy++]); +- if (state->head != Z_NULL && +- state->head->name != Z_NULL && +- state->length < state->head->name_max) +- state->head->name[state->length++] = len; +- } while (len && copy < have); +- if (state->flags & 0x0200) +- state->check = crc32(state->check, next, copy); +- have -= copy; +- next += copy; +- if (len) goto inf_leave; +- } +- else if (state->head != Z_NULL) +- state->head->name = Z_NULL; +- state->length = 0; +- state->mode = COMMENT; +- case COMMENT: +- if (state->flags & 0x1000) { +- if (have == 0) goto inf_leave; +- copy = 0; +- do { +- len = (unsigned)(next[copy++]); +- if (state->head != Z_NULL && +- state->head->comment != Z_NULL && +- state->length < state->head->comm_max) +- state->head->comment[state->length++] = len; +- } while (len && copy < have); +- if (state->flags & 0x0200) +- state->check = crc32(state->check, next, copy); +- have -= copy; +- next += copy; +- if (len) goto inf_leave; +- } +- else if (state->head != Z_NULL) +- state->head->comment = Z_NULL; +- state->mode = HCRC; +- case HCRC: +- if (state->flags & 0x0200) { +- NEEDBITS(16); +- if (hold != (state->check & 0xffff)) { +- strm->msg = (char *)"header crc mismatch"; +- state->mode = BAD; +- break; +- } +- INITBITS(); +- } +- if (state->head != Z_NULL) { +- state->head->hcrc = (int)((state->flags >> 9) & 1); +- state->head->done = 1; +- } +- strm->adler = state->check = crc32(0L, Z_NULL, 0); +- state->mode = TYPE; +- break; +-#endif +- case DICTID: +- NEEDBITS(32); +- strm->adler = state->check = REVERSE(hold); +- INITBITS(); +- state->mode = DICT; +- case DICT: +- if (state->havedict == 0) { +- RESTORE(); +- return Z_NEED_DICT; +- } +- strm->adler = state->check = adler32(0L, Z_NULL, 0); +- state->mode = TYPE; +- case TYPE: +- if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; +- case TYPEDO: +- if (state->last) { +- BYTEBITS(); +- state->mode = CHECK; +- break; +- } +- NEEDBITS(3); +- state->last = BITS(1); +- DROPBITS(1); +- switch (BITS(2)) { +- case 0: /* stored block */ +- Tracev((stderr, "inflate: stored block%s\n", +- state->last ? " (last)" : "")); +- state->mode = STORED; +- break; +- case 1: /* fixed block */ +- fixedtables(state); +- Tracev((stderr, "inflate: fixed codes block%s\n", +- state->last ? " (last)" : "")); +- state->mode = LEN_; /* decode codes */ +- if (flush == Z_TREES) { +- DROPBITS(2); +- goto inf_leave; +- } +- break; +- case 2: /* dynamic block */ +- Tracev((stderr, "inflate: dynamic codes block%s\n", +- state->last ? " (last)" : "")); +- state->mode = TABLE; +- break; +- case 3: +- strm->msg = (char *)"invalid block type"; +- state->mode = BAD; +- } +- DROPBITS(2); +- break; +- case STORED: +- BYTEBITS(); /* go to byte boundary */ +- NEEDBITS(32); +- if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { +- strm->msg = (char *)"invalid stored block lengths"; +- state->mode = BAD; +- break; +- } +- state->length = (unsigned)hold & 0xffff; +- Tracev((stderr, "inflate: stored length %u\n", +- state->length)); +- INITBITS(); +- state->mode = COPY_; +- if (flush == Z_TREES) goto inf_leave; +- case COPY_: +- state->mode = COPY; +- case COPY: +- copy = state->length; +- if (copy) { +- if (copy > have) copy = have; +- if (copy > left) copy = left; +- if (copy == 0) goto inf_leave; +- zmemcpy(put, next, copy); +- have -= copy; +- next += copy; +- left -= copy; +- put += copy; +- state->length -= copy; +- break; +- } +- Tracev((stderr, "inflate: stored end\n")); +- state->mode = TYPE; +- break; +- case TABLE: +- NEEDBITS(14); +- state->nlen = BITS(5) + 257; +- DROPBITS(5); +- state->ndist = BITS(5) + 1; +- DROPBITS(5); +- state->ncode = BITS(4) + 4; +- DROPBITS(4); +-#ifndef PKZIP_BUG_WORKAROUND +- if (state->nlen > 286 || state->ndist > 30) { +- strm->msg = (char *)"too many length or distance symbols"; +- state->mode = BAD; +- break; +- } +-#endif +- Tracev((stderr, "inflate: table sizes ok\n")); +- state->have = 0; +- state->mode = LENLENS; +- case LENLENS: +- while (state->have < state->ncode) { +- NEEDBITS(3); +- state->lens[order[state->have++]] = (unsigned short)BITS(3); +- DROPBITS(3); +- } +- while (state->have < 19) +- state->lens[order[state->have++]] = 0; +- state->next = state->codes; +- state->lencode = (code const FAR *)(state->next); +- state->lenbits = 7; +- ret = inflate_table(CODES, state->lens, 19, &(state->next), +- &(state->lenbits), state->work); +- if (ret) { +- strm->msg = (char *)"invalid code lengths set"; +- state->mode = BAD; +- break; +- } +- Tracev((stderr, "inflate: code lengths ok\n")); +- state->have = 0; +- state->mode = CODELENS; +- case CODELENS: +- while (state->have < state->nlen + state->ndist) { +- for (;;) { +- here = state->lencode[BITS(state->lenbits)]; +- if ((unsigned)(here.bits) <= bits) break; +- PULLBYTE(); +- } +- if (here.val < 16) { +- NEEDBITS(here.bits); +- DROPBITS(here.bits); +- state->lens[state->have++] = here.val; +- } +- else { +- if (here.val == 16) { +- NEEDBITS(here.bits + 2); +- DROPBITS(here.bits); +- if (state->have == 0) { +- strm->msg = (char *)"invalid bit length repeat"; +- state->mode = BAD; +- break; +- } +- len = state->lens[state->have - 1]; +- copy = 3 + BITS(2); +- DROPBITS(2); +- } +- else if (here.val == 17) { +- NEEDBITS(here.bits + 3); +- DROPBITS(here.bits); +- len = 0; +- copy = 3 + BITS(3); +- DROPBITS(3); +- } +- else { +- NEEDBITS(here.bits + 7); +- DROPBITS(here.bits); +- len = 0; +- copy = 11 + BITS(7); +- DROPBITS(7); +- } +- if (state->have + copy > state->nlen + state->ndist) { +- strm->msg = (char *)"invalid bit length repeat"; +- state->mode = BAD; +- break; +- } +- while (copy--) +- state->lens[state->have++] = (unsigned short)len; +- } +- } +- +- /* handle error breaks in while */ +- if (state->mode == BAD) break; +- +- /* check for end-of-block code (better have one) */ +- if (state->lens[256] == 0) { +- strm->msg = (char *)"invalid code -- missing end-of-block"; +- state->mode = BAD; +- break; +- } +- +- /* build code tables -- note: do not change the lenbits or distbits +- values here (9 and 6) without reading the comments in inftrees.h +- concerning the ENOUGH constants, which depend on those values */ +- state->next = state->codes; +- state->lencode = (code const FAR *)(state->next); +- state->lenbits = 9; +- ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), +- &(state->lenbits), state->work); +- if (ret) { +- strm->msg = (char *)"invalid literal/lengths set"; +- state->mode = BAD; +- break; +- } +- state->distcode = (code const FAR *)(state->next); +- state->distbits = 6; +- ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, +- &(state->next), &(state->distbits), state->work); +- if (ret) { +- strm->msg = (char *)"invalid distances set"; +- state->mode = BAD; +- break; +- } +- Tracev((stderr, "inflate: codes ok\n")); +- state->mode = LEN_; +- if (flush == Z_TREES) goto inf_leave; +- case LEN_: +- state->mode = LEN; +- case LEN: +- if (have >= 6 && left >= 258) { +- RESTORE(); +- inflate_fast(strm, out); +- LOAD(); +- if (state->mode == TYPE) +- state->back = -1; +- break; +- } +- state->back = 0; +- for (;;) { +- here = state->lencode[BITS(state->lenbits)]; +- if ((unsigned)(here.bits) <= bits) break; +- PULLBYTE(); +- } +- if (here.op && (here.op & 0xf0) == 0) { +- last = here; +- for (;;) { +- here = state->lencode[last.val + +- (BITS(last.bits + last.op) >> last.bits)]; +- if ((unsigned)(last.bits + here.bits) <= bits) break; +- PULLBYTE(); +- } +- DROPBITS(last.bits); +- state->back += last.bits; +- } +- DROPBITS(here.bits); +- state->back += here.bits; +- state->length = (unsigned)here.val; +- if ((int)(here.op) == 0) { +- Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? +- "inflate: literal '%c'\n" : +- "inflate: literal 0x%02x\n", here.val)); +- state->mode = LIT; +- break; +- } +- if (here.op & 32) { +- Tracevv((stderr, "inflate: end of block\n")); +- state->back = -1; +- state->mode = TYPE; +- break; +- } +- if (here.op & 64) { +- strm->msg = (char *)"invalid literal/length code"; +- state->mode = BAD; +- break; +- } +- state->extra = (unsigned)(here.op) & 15; +- state->mode = LENEXT; +- case LENEXT: +- if (state->extra) { +- NEEDBITS(state->extra); +- state->length += BITS(state->extra); +- DROPBITS(state->extra); +- state->back += state->extra; +- } +- Tracevv((stderr, "inflate: length %u\n", state->length)); +- state->was = state->length; +- state->mode = DIST; +- case DIST: +- for (;;) { +- here = state->distcode[BITS(state->distbits)]; +- if ((unsigned)(here.bits) <= bits) break; +- PULLBYTE(); +- } +- if ((here.op & 0xf0) == 0) { +- last = here; +- for (;;) { +- here = state->distcode[last.val + +- (BITS(last.bits + last.op) >> last.bits)]; +- if ((unsigned)(last.bits + here.bits) <= bits) break; +- PULLBYTE(); +- } +- DROPBITS(last.bits); +- state->back += last.bits; +- } +- DROPBITS(here.bits); +- state->back += here.bits; +- if (here.op & 64) { +- strm->msg = (char *)"invalid distance code"; +- state->mode = BAD; +- break; +- } +- state->offset = (unsigned)here.val; +- state->extra = (unsigned)(here.op) & 15; +- state->mode = DISTEXT; +- case DISTEXT: +- if (state->extra) { +- NEEDBITS(state->extra); +- state->offset += BITS(state->extra); +- DROPBITS(state->extra); +- state->back += state->extra; +- } +-#ifdef INFLATE_STRICT +- if (state->offset > state->dmax) { +- strm->msg = (char *)"invalid distance too far back"; +- state->mode = BAD; +- break; +- } +-#endif +- Tracevv((stderr, "inflate: distance %u\n", state->offset)); +- state->mode = MATCH; +- case MATCH: +- if (left == 0) goto inf_leave; +- copy = out - left; +- if (state->offset > copy) { /* copy from window */ +- copy = state->offset - copy; +- if (copy > state->whave) { +- if (state->sane) { +- strm->msg = (char *)"invalid distance too far back"; +- state->mode = BAD; +- break; +- } +-#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR +- Trace((stderr, "inflate.c too far\n")); +- copy -= state->whave; +- if (copy > state->length) copy = state->length; +- if (copy > left) copy = left; +- left -= copy; +- state->length -= copy; +- do { +- *put++ = 0; +- } while (--copy); +- if (state->length == 0) state->mode = LEN; +- break; +-#endif +- } +- if (copy > state->wnext) { +- copy -= state->wnext; +- from = state->window + (state->wsize - copy); +- } +- else +- from = state->window + (state->wnext - copy); +- if (copy > state->length) copy = state->length; +- } +- else { /* copy from output */ +- from = put - state->offset; +- copy = state->length; +- } +- if (copy > left) copy = left; +- left -= copy; +- state->length -= copy; +- do { +- *put++ = *from++; +- } while (--copy); +- if (state->length == 0) state->mode = LEN; +- break; +- case LIT: +- if (left == 0) goto inf_leave; +- *put++ = (unsigned char)(state->length); +- left--; +- state->mode = LEN; +- break; +- case CHECK: +- if (state->wrap) { +- NEEDBITS(32); +- out -= left; +- strm->total_out += out; +- state->total += out; +- if (out) +- strm->adler = state->check = +- UPDATE(state->check, put - out, out); +- out = left; +- if (( +-#ifdef GUNZIP +- state->flags ? hold : +-#endif +- REVERSE(hold)) != state->check) { +- strm->msg = (char *)"incorrect data check"; +- state->mode = BAD; +- break; +- } +- INITBITS(); +- Tracev((stderr, "inflate: check matches trailer\n")); +- } +-#ifdef GUNZIP +- state->mode = LENGTH; +- case LENGTH: +- if (state->wrap && state->flags) { +- NEEDBITS(32); +- if (hold != (state->total & 0xffffffffUL)) { +- strm->msg = (char *)"incorrect length check"; +- state->mode = BAD; +- break; +- } +- INITBITS(); +- Tracev((stderr, "inflate: length matches trailer\n")); +- } +-#endif +- state->mode = DONE; +- case DONE: +- ret = Z_STREAM_END; +- goto inf_leave; +- case BAD: +- ret = Z_DATA_ERROR; +- goto inf_leave; +- case MEM: +- return Z_MEM_ERROR; +- case SYNC: +- default: +- return Z_STREAM_ERROR; +- } +- +- /* +- Return from inflate(), updating the total counts and the check value. +- If there was no progress during the inflate() call, return a buffer +- error. Call updatewindow() to create and/or update the window state. +- Note: a memory error from inflate() is non-recoverable. +- */ +- inf_leave: +- RESTORE(); +- if (state->wsize || (state->mode < CHECK && out != strm->avail_out)) +- if (updatewindow(strm, out)) { +- state->mode = MEM; +- return Z_MEM_ERROR; +- } +- in -= strm->avail_in; +- out -= strm->avail_out; +- strm->total_in += in; +- strm->total_out += out; +- state->total += out; +- if (state->wrap && out) +- strm->adler = state->check = +- UPDATE(state->check, strm->next_out - out, out); +- strm->data_type = state->bits + (state->last ? 64 : 0) + +- (state->mode == TYPE ? 128 : 0) + +- (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0); +- if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) +- ret = Z_BUF_ERROR; +- return ret; +-} +- +-int ZEXPORT inflateEnd(strm) +-z_streamp strm; +-{ +- struct inflate_state FAR *state; +- if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) +- return Z_STREAM_ERROR; +- state = (struct inflate_state FAR *)strm->state; +- if (state->window != Z_NULL) ZFREE(strm, state->window); +- ZFREE(strm, strm->state); +- strm->state = Z_NULL; +- Tracev((stderr, "inflate: end\n")); +- return Z_OK; +-} +- +-int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) +-z_streamp strm; +-const Bytef *dictionary; +-uInt dictLength; +-{ +- struct inflate_state FAR *state; +- unsigned long id; +- +- /* check state */ +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; +- state = (struct inflate_state FAR *)strm->state; +- if (state->wrap != 0 && state->mode != DICT) +- return Z_STREAM_ERROR; +- +- /* check for correct dictionary id */ +- if (state->mode == DICT) { +- id = adler32(0L, Z_NULL, 0); +- id = adler32(id, dictionary, dictLength); +- if (id != state->check) +- return Z_DATA_ERROR; +- } +- +- /* copy dictionary to window */ +- if (updatewindow(strm, strm->avail_out)) { +- state->mode = MEM; +- return Z_MEM_ERROR; +- } +- if (dictLength > state->wsize) { +- zmemcpy(state->window, dictionary + dictLength - state->wsize, +- state->wsize); +- state->whave = state->wsize; +- } +- else { +- zmemcpy(state->window + state->wsize - dictLength, dictionary, +- dictLength); +- state->whave = dictLength; +- } +- state->havedict = 1; +- Tracev((stderr, "inflate: dictionary set\n")); +- return Z_OK; +-} +- +-int ZEXPORT inflateGetHeader(strm, head) +-z_streamp strm; +-gz_headerp head; +-{ +- struct inflate_state FAR *state; +- +- /* check state */ +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; +- state = (struct inflate_state FAR *)strm->state; +- if ((state->wrap & 2) == 0) return Z_STREAM_ERROR; +- +- /* save header structure */ +- state->head = head; +- head->done = 0; +- return Z_OK; +-} +- +-/* +- Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found +- or when out of input. When called, *have is the number of pattern bytes +- found in order so far, in 0..3. On return *have is updated to the new +- state. If on return *have equals four, then the pattern was found and the +- return value is how many bytes were read including the last byte of the +- pattern. If *have is less than four, then the pattern has not been found +- yet and the return value is len. In the latter case, syncsearch() can be +- called again with more data and the *have state. *have is initialized to +- zero for the first call. +- */ +-local unsigned syncsearch(have, buf, len) +-unsigned FAR *have; +-unsigned char FAR *buf; +-unsigned len; +-{ +- unsigned got; +- unsigned next; +- +- got = *have; +- next = 0; +- while (next < len && got < 4) { +- if ((int)(buf[next]) == (got < 2 ? 0 : 0xff)) +- got++; +- else if (buf[next]) +- got = 0; +- else +- got = 4 - got; +- next++; +- } +- *have = got; +- return next; +-} +- +-int ZEXPORT inflateSync(strm) +-z_streamp strm; +-{ +- unsigned len; /* number of bytes to look at or looked at */ +- unsigned long in, out; /* temporary to save total_in and total_out */ +- unsigned char buf[4]; /* to restore bit buffer to byte string */ +- struct inflate_state FAR *state; +- +- /* check parameters */ +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; +- state = (struct inflate_state FAR *)strm->state; +- if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR; +- +- /* if first time, start search in bit buffer */ +- if (state->mode != SYNC) { +- state->mode = SYNC; +- state->hold <<= state->bits & 7; +- state->bits -= state->bits & 7; +- len = 0; +- while (state->bits >= 8) { +- buf[len++] = (unsigned char)(state->hold); +- state->hold >>= 8; +- state->bits -= 8; +- } +- state->have = 0; +- syncsearch(&(state->have), buf, len); +- } +- +- /* search available input */ +- len = syncsearch(&(state->have), strm->next_in, strm->avail_in); +- strm->avail_in -= len; +- strm->next_in += len; +- strm->total_in += len; +- +- /* return no joy or set up to restart inflate() on a new block */ +- if (state->have != 4) return Z_DATA_ERROR; +- in = strm->total_in; out = strm->total_out; +- inflateReset(strm); +- strm->total_in = in; strm->total_out = out; +- state->mode = TYPE; +- return Z_OK; +-} +- +-/* +- Returns true if inflate is currently at the end of a block generated by +- Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP +- implementation to provide an additional safety check. PPP uses +- Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored +- block. When decompressing, PPP checks that at the end of input packet, +- inflate is waiting for these length bytes. +- */ +-int ZEXPORT inflateSyncPoint(strm) +-z_streamp strm; +-{ +- struct inflate_state FAR *state; +- +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; +- state = (struct inflate_state FAR *)strm->state; +- return state->mode == STORED && state->bits == 0; +-} +- +-int ZEXPORT inflateCopy(dest, source) +-z_streamp dest; +-z_streamp source; +-{ +- struct inflate_state FAR *state; +- struct inflate_state FAR *copy; +- unsigned char FAR *window; +- unsigned wsize; +- +- /* check input */ +- if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL || +- source->zalloc == (alloc_func)0 || source->zfree == (free_func)0) +- return Z_STREAM_ERROR; +- state = (struct inflate_state FAR *)source->state; +- +- /* allocate space */ +- copy = (struct inflate_state FAR *) +- ZALLOC(source, 1, sizeof(struct inflate_state)); +- if (copy == Z_NULL) return Z_MEM_ERROR; +- window = Z_NULL; +- if (state->window != Z_NULL) { +- window = (unsigned char FAR *) +- ZALLOC(source, 1U << state->wbits, sizeof(unsigned char)); +- if (window == Z_NULL) { +- ZFREE(source, copy); +- return Z_MEM_ERROR; +- } +- } +- +- /* copy state */ +- zmemcpy(dest, source, sizeof(z_stream)); +- zmemcpy(copy, state, sizeof(struct inflate_state)); +- if (state->lencode >= state->codes && +- state->lencode <= state->codes + ENOUGH - 1) { +- copy->lencode = copy->codes + (state->lencode - state->codes); +- copy->distcode = copy->codes + (state->distcode - state->codes); +- } +- copy->next = copy->codes + (state->next - state->codes); +- if (window != Z_NULL) { +- wsize = 1U << state->wbits; +- zmemcpy(window, state->window, wsize); +- } +- copy->window = window; +- dest->state = (struct internal_state FAR *)copy; +- return Z_OK; +-} +- +-int ZEXPORT inflateUndermine(strm, subvert) +-z_streamp strm; +-int subvert; +-{ +- struct inflate_state FAR *state; +- +- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; +- state = (struct inflate_state FAR *)strm->state; +- state->sane = !subvert; +-#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR +- return Z_OK; +-#else +- state->sane = 1; +- return Z_DATA_ERROR; +-#endif +-} +- +-long ZEXPORT inflateMark(strm) +-z_streamp strm; +-{ +- struct inflate_state FAR *state; +- +- if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16; +- state = (struct inflate_state FAR *)strm->state; +- return ((long)(state->back) << 16) + +- (state->mode == COPY ? state->length : +- (state->mode == MATCH ? state->was - state->length : 0)); +-} +diff --git a/thirdparty/zlib/inflate.h b/thirdparty/zlib/inflate.h +deleted file mode 100644 +index 95f4986..0000000 +--- a/thirdparty/zlib/inflate.h ++++ /dev/null +@@ -1,122 +0,0 @@ +-/* inflate.h -- internal inflate state definition +- * Copyright (C) 1995-2009 Mark Adler +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* WARNING: this file should *not* be used by applications. It is +- part of the implementation of the compression library and is +- subject to change. Applications should only use zlib.h. +- */ +- +-/* define NO_GZIP when compiling if you want to disable gzip header and +- trailer decoding by inflate(). NO_GZIP would be used to avoid linking in +- the crc code when it is not needed. For shared libraries, gzip decoding +- should be left enabled. */ +-#ifndef NO_GZIP +-# define GUNZIP +-#endif +- +-/* Possible inflate modes between inflate() calls */ +-typedef enum { +- HEAD, /* i: waiting for magic header */ +- FLAGS, /* i: waiting for method and flags (gzip) */ +- TIME, /* i: waiting for modification time (gzip) */ +- OS, /* i: waiting for extra flags and operating system (gzip) */ +- EXLEN, /* i: waiting for extra length (gzip) */ +- EXTRA, /* i: waiting for extra bytes (gzip) */ +- NAME, /* i: waiting for end of file name (gzip) */ +- COMMENT, /* i: waiting for end of comment (gzip) */ +- HCRC, /* i: waiting for header crc (gzip) */ +- DICTID, /* i: waiting for dictionary check value */ +- DICT, /* waiting for inflateSetDictionary() call */ +- TYPE, /* i: waiting for type bits, including last-flag bit */ +- TYPEDO, /* i: same, but skip check to exit inflate on new block */ +- STORED, /* i: waiting for stored size (length and complement) */ +- COPY_, /* i/o: same as COPY below, but only first time in */ +- COPY, /* i/o: waiting for input or output to copy stored block */ +- TABLE, /* i: waiting for dynamic block table lengths */ +- LENLENS, /* i: waiting for code length code lengths */ +- CODELENS, /* i: waiting for length/lit and distance code lengths */ +- LEN_, /* i: same as LEN below, but only first time in */ +- LEN, /* i: waiting for length/lit/eob code */ +- LENEXT, /* i: waiting for length extra bits */ +- DIST, /* i: waiting for distance code */ +- DISTEXT, /* i: waiting for distance extra bits */ +- MATCH, /* o: waiting for output space to copy string */ +- LIT, /* o: waiting for output space to write literal */ +- CHECK, /* i: waiting for 32-bit check value */ +- LENGTH, /* i: waiting for 32-bit length (gzip) */ +- DONE, /* finished check, done -- remain here until reset */ +- BAD, /* got a data error -- remain here until reset */ +- MEM, /* got an inflate() memory error -- remain here until reset */ +- SYNC /* looking for synchronization bytes to restart inflate() */ +-} inflate_mode; +- +-/* +- State transitions between above modes - +- +- (most modes can go to BAD or MEM on error -- not shown for clarity) +- +- Process header: +- HEAD -> (gzip) or (zlib) or (raw) +- (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT -> +- HCRC -> TYPE +- (zlib) -> DICTID or TYPE +- DICTID -> DICT -> TYPE +- (raw) -> TYPEDO +- Read deflate blocks: +- TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK +- STORED -> COPY_ -> COPY -> TYPE +- TABLE -> LENLENS -> CODELENS -> LEN_ +- LEN_ -> LEN +- Read deflate codes in fixed or dynamic block: +- LEN -> LENEXT or LIT or TYPE +- LENEXT -> DIST -> DISTEXT -> MATCH -> LEN +- LIT -> LEN +- Process trailer: +- CHECK -> LENGTH -> DONE +- */ +- +-/* state maintained between inflate() calls. Approximately 10K bytes. */ +-struct inflate_state { +- inflate_mode mode; /* current inflate mode */ +- int last; /* true if processing last block */ +- int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ +- int havedict; /* true if dictionary provided */ +- int flags; /* gzip header method and flags (0 if zlib) */ +- unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */ +- unsigned long check; /* protected copy of check value */ +- unsigned long total; /* protected copy of output count */ +- gz_headerp head; /* where to save gzip header information */ +- /* sliding window */ +- unsigned wbits; /* log base 2 of requested window size */ +- unsigned wsize; /* window size or zero if not using window */ +- unsigned whave; /* valid bytes in the window */ +- unsigned wnext; /* window write index */ +- unsigned char FAR *window; /* allocated sliding window, if needed */ +- /* bit accumulator */ +- unsigned long hold; /* input bit accumulator */ +- unsigned bits; /* number of bits in "in" */ +- /* for string and stored block copying */ +- unsigned length; /* literal or length of data to copy */ +- unsigned offset; /* distance back to copy string from */ +- /* for table and code decoding */ +- unsigned extra; /* extra bits needed */ +- /* fixed and dynamic code tables */ +- code const FAR *lencode; /* starting table for length/literal codes */ +- code const FAR *distcode; /* starting table for distance codes */ +- unsigned lenbits; /* index bits for lencode */ +- unsigned distbits; /* index bits for distcode */ +- /* dynamic table building */ +- unsigned ncode; /* number of code length code lengths */ +- unsigned nlen; /* number of length code lengths */ +- unsigned ndist; /* number of distance code lengths */ +- unsigned have; /* number of code lengths in lens[] */ +- code FAR *next; /* next available space in codes[] */ +- unsigned short lens[320]; /* temporary storage for code lengths */ +- unsigned short work[288]; /* work area for code table building */ +- code codes[ENOUGH]; /* space for code tables */ +- int sane; /* if false, allow invalid distance too far */ +- int back; /* bits back of last unprocessed length/lit */ +- unsigned was; /* initial length of match */ +-}; +diff --git a/thirdparty/zlib/inftrees.c b/thirdparty/zlib/inftrees.c +deleted file mode 100644 +index 11e9c52..0000000 +--- a/thirdparty/zlib/inftrees.c ++++ /dev/null +@@ -1,330 +0,0 @@ +-/* inftrees.c -- generate Huffman trees for efficient decoding +- * Copyright (C) 1995-2010 Mark Adler +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-#include "zutil.h" +-#include "inftrees.h" +- +-#define MAXBITS 15 +- +-const char inflate_copyright[] = +- " inflate 1.2.5 Copyright 1995-2010 Mark Adler "; +-/* +- If you use the zlib library in a product, an acknowledgment is welcome +- in the documentation of your product. If for some reason you cannot +- include such an acknowledgment, I would appreciate that you keep this +- copyright string in the executable of your product. +- */ +- +-/* +- Build a set of tables to decode the provided canonical Huffman code. +- The code lengths are lens[0..codes-1]. The result starts at *table, +- whose indices are 0..2^bits-1. work is a writable array of at least +- lens shorts, which is used as a work area. type is the type of code +- to be generated, CODES, LENS, or DISTS. On return, zero is success, +- -1 is an invalid code, and +1 means that ENOUGH isn't enough. table +- on return points to the next available entry's address. bits is the +- requested root table index bits, and on return it is the actual root +- table index bits. It will differ if the request is greater than the +- longest code or if it is less than the shortest code. +- */ +-int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work) +-codetype type; +-unsigned short FAR *lens; +-unsigned codes; +-code FAR * FAR *table; +-unsigned FAR *bits; +-unsigned short FAR *work; +-{ +- unsigned len; /* a code's length in bits */ +- unsigned sym; /* index of code symbols */ +- unsigned min, max; /* minimum and maximum code lengths */ +- unsigned root; /* number of index bits for root table */ +- unsigned curr; /* number of index bits for current table */ +- unsigned drop; /* code bits to drop for sub-table */ +- int left; /* number of prefix codes available */ +- unsigned used; /* code entries in table used */ +- unsigned huff; /* Huffman code */ +- unsigned incr; /* for incrementing code, index */ +- unsigned fill; /* index for replicating entries */ +- unsigned low; /* low bits for current root entry */ +- unsigned mask; /* mask for low root bits */ +- code here; /* table entry for duplication */ +- code FAR *next; /* next available space in table */ +- const unsigned short FAR *base; /* base value table to use */ +- const unsigned short FAR *extra; /* extra bits table to use */ +- int end; /* use base and extra for symbol > end */ +- unsigned short count[MAXBITS+1]; /* number of codes of each length */ +- unsigned short offs[MAXBITS+1]; /* offsets in table for each length */ +- static const unsigned short lbase[31] = { /* Length codes 257..285 base */ +- 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, +- 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; +- static const unsigned short lext[31] = { /* Length codes 257..285 extra */ +- 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, +- 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 73, 195}; +- static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ +- 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, +- 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, +- 8193, 12289, 16385, 24577, 0, 0}; +- static const unsigned short dext[32] = { /* Distance codes 0..29 extra */ +- 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, +- 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, +- 28, 28, 29, 29, 64, 64}; +- +- /* +- Process a set of code lengths to create a canonical Huffman code. The +- code lengths are lens[0..codes-1]. Each length corresponds to the +- symbols 0..codes-1. The Huffman code is generated by first sorting the +- symbols by length from short to long, and retaining the symbol order +- for codes with equal lengths. Then the code starts with all zero bits +- for the first code of the shortest length, and the codes are integer +- increments for the same length, and zeros are appended as the length +- increases. For the deflate format, these bits are stored backwards +- from their more natural integer increment ordering, and so when the +- decoding tables are built in the large loop below, the integer codes +- are incremented backwards. +- +- This routine assumes, but does not check, that all of the entries in +- lens[] are in the range 0..MAXBITS. The caller must assure this. +- 1..MAXBITS is interpreted as that code length. zero means that that +- symbol does not occur in this code. +- +- The codes are sorted by computing a count of codes for each length, +- creating from that a table of starting indices for each length in the +- sorted table, and then entering the symbols in order in the sorted +- table. The sorted table is work[], with that space being provided by +- the caller. +- +- The length counts are used for other purposes as well, i.e. finding +- the minimum and maximum length codes, determining if there are any +- codes at all, checking for a valid set of lengths, and looking ahead +- at length counts to determine sub-table sizes when building the +- decoding tables. +- */ +- +- /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ +- for (len = 0; len <= MAXBITS; len++) +- count[len] = 0; +- for (sym = 0; sym < codes; sym++) +- count[lens[sym]]++; +- +- /* bound code lengths, force root to be within code lengths */ +- root = *bits; +- for (max = MAXBITS; max >= 1; max--) +- if (count[max] != 0) break; +- if (root > max) root = max; +- if (max == 0) { /* no symbols to code at all */ +- here.op = (unsigned char)64; /* invalid code marker */ +- here.bits = (unsigned char)1; +- here.val = (unsigned short)0; +- *(*table)++ = here; /* make a table to force an error */ +- *(*table)++ = here; +- *bits = 1; +- return 0; /* no symbols, but wait for decoding to report error */ +- } +- for (min = 1; min < max; min++) +- if (count[min] != 0) break; +- if (root < min) root = min; +- +- /* check for an over-subscribed or incomplete set of lengths */ +- left = 1; +- for (len = 1; len <= MAXBITS; len++) { +- left <<= 1; +- left -= count[len]; +- if (left < 0) return -1; /* over-subscribed */ +- } +- if (left > 0 && (type == CODES || max != 1)) +- return -1; /* incomplete set */ +- +- /* generate offsets into symbol table for each length for sorting */ +- offs[1] = 0; +- for (len = 1; len < MAXBITS; len++) +- offs[len + 1] = offs[len] + count[len]; +- +- /* sort symbols by length, by symbol order within each length */ +- for (sym = 0; sym < codes; sym++) +- if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym; +- +- /* +- Create and fill in decoding tables. In this loop, the table being +- filled is at next and has curr index bits. The code being used is huff +- with length len. That code is converted to an index by dropping drop +- bits off of the bottom. For codes where len is less than drop + curr, +- those top drop + curr - len bits are incremented through all values to +- fill the table with replicated entries. +- +- root is the number of index bits for the root table. When len exceeds +- root, sub-tables are created pointed to by the root entry with an index +- of the low root bits of huff. This is saved in low to check for when a +- new sub-table should be started. drop is zero when the root table is +- being filled, and drop is root when sub-tables are being filled. +- +- When a new sub-table is needed, it is necessary to look ahead in the +- code lengths to determine what size sub-table is needed. The length +- counts are used for this, and so count[] is decremented as codes are +- entered in the tables. +- +- used keeps track of how many table entries have been allocated from the +- provided *table space. It is checked for LENS and DIST tables against +- the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in +- the initial root table size constants. See the comments in inftrees.h +- for more information. +- +- sym increments through all symbols, and the loop terminates when +- all codes of length max, i.e. all codes, have been processed. This +- routine permits incomplete codes, so another loop after this one fills +- in the rest of the decoding tables with invalid code markers. +- */ +- +- /* set up for code type */ +- switch (type) { +- case CODES: +- base = extra = work; /* dummy value--not used */ +- end = 19; +- break; +- case LENS: +- base = lbase; +- base -= 257; +- extra = lext; +- extra -= 257; +- end = 256; +- break; +- default: /* DISTS */ +- base = dbase; +- extra = dext; +- end = -1; +- } +- +- /* initialize state for loop */ +- huff = 0; /* starting code */ +- sym = 0; /* starting code symbol */ +- len = min; /* starting code length */ +- next = *table; /* current table to fill in */ +- curr = root; /* current table index bits */ +- drop = 0; /* current bits to drop from code for index */ +- low = (unsigned)(-1); /* trigger new sub-table when len > root */ +- used = 1U << root; /* use root table entries */ +- mask = used - 1; /* mask for comparing low */ +- +- /* check available table space */ +- if ((type == LENS && used >= ENOUGH_LENS) || +- (type == DISTS && used >= ENOUGH_DISTS)) +- return 1; +- +- /* process all codes and make table entries */ +- for (;;) { +- /* create table entry */ +- here.bits = (unsigned char)(len - drop); +- if ((int)(work[sym]) < end) { +- here.op = (unsigned char)0; +- here.val = work[sym]; +- } +- else if ((int)(work[sym]) > end) { +- here.op = (unsigned char)(extra[work[sym]]); +- here.val = base[work[sym]]; +- } +- else { +- here.op = (unsigned char)(32 + 64); /* end of block */ +- here.val = 0; +- } +- +- /* replicate for those indices with low len bits equal to huff */ +- incr = 1U << (len - drop); +- fill = 1U << curr; +- min = fill; /* save offset to next table */ +- do { +- fill -= incr; +- next[(huff >> drop) + fill] = here; +- } while (fill != 0); +- +- /* backwards increment the len-bit code huff */ +- incr = 1U << (len - 1); +- while (huff & incr) +- incr >>= 1; +- if (incr != 0) { +- huff &= incr - 1; +- huff += incr; +- } +- else +- huff = 0; +- +- /* go to next symbol, update count, len */ +- sym++; +- if (--(count[len]) == 0) { +- if (len == max) break; +- len = lens[work[sym]]; +- } +- +- /* create new sub-table if needed */ +- if (len > root && (huff & mask) != low) { +- /* if first time, transition to sub-tables */ +- if (drop == 0) +- drop = root; +- +- /* increment past last table */ +- next += min; /* here min is 1 << curr */ +- +- /* determine length of next table */ +- curr = len - drop; +- left = (int)(1 << curr); +- while (curr + drop < max) { +- left -= count[curr + drop]; +- if (left <= 0) break; +- curr++; +- left <<= 1; +- } +- +- /* check for enough space */ +- used += 1U << curr; +- if ((type == LENS && used >= ENOUGH_LENS) || +- (type == DISTS && used >= ENOUGH_DISTS)) +- return 1; +- +- /* point entry in root table to sub-table */ +- low = huff & mask; +- (*table)[low].op = (unsigned char)curr; +- (*table)[low].bits = (unsigned char)root; +- (*table)[low].val = (unsigned short)(next - *table); +- } +- } +- +- /* +- Fill in rest of table for incomplete codes. This loop is similar to the +- loop above in incrementing huff for table indices. It is assumed that +- len is equal to curr + drop, so there is no loop needed to increment +- through high index bits. When the current sub-table is filled, the loop +- drops back to the root table to fill in any remaining entries there. +- */ +- here.op = (unsigned char)64; /* invalid code marker */ +- here.bits = (unsigned char)(len - drop); +- here.val = (unsigned short)0; +- while (huff != 0) { +- /* when done with sub-table, drop back to root table */ +- if (drop != 0 && (huff & mask) != low) { +- drop = 0; +- len = root; +- next = *table; +- here.bits = (unsigned char)len; +- } +- +- /* put invalid code marker in table */ +- next[huff >> drop] = here; +- +- /* backwards increment the len-bit code huff */ +- incr = 1U << (len - 1); +- while (huff & incr) +- incr >>= 1; +- if (incr != 0) { +- huff &= incr - 1; +- huff += incr; +- } +- else +- huff = 0; +- } +- +- /* set return parameters */ +- *table += used; +- *bits = root; +- return 0; +-} +diff --git a/thirdparty/zlib/inftrees.h b/thirdparty/zlib/inftrees.h +deleted file mode 100644 +index baa53a0..0000000 +--- a/thirdparty/zlib/inftrees.h ++++ /dev/null +@@ -1,62 +0,0 @@ +-/* inftrees.h -- header to use inftrees.c +- * Copyright (C) 1995-2005, 2010 Mark Adler +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* WARNING: this file should *not* be used by applications. It is +- part of the implementation of the compression library and is +- subject to change. Applications should only use zlib.h. +- */ +- +-/* Structure for decoding tables. Each entry provides either the +- information needed to do the operation requested by the code that +- indexed that table entry, or it provides a pointer to another +- table that indexes more bits of the code. op indicates whether +- the entry is a pointer to another table, a literal, a length or +- distance, an end-of-block, or an invalid code. For a table +- pointer, the low four bits of op is the number of index bits of +- that table. For a length or distance, the low four bits of op +- is the number of extra bits to get after the code. bits is +- the number of bits in this code or part of the code to drop off +- of the bit buffer. val is the actual byte to output in the case +- of a literal, the base length or distance, or the offset from +- the current table to the next table. Each entry is four bytes. */ +-typedef struct { +- unsigned char op; /* operation, extra bits, table bits */ +- unsigned char bits; /* bits in this part of the code */ +- unsigned short val; /* offset in table or code value */ +-} code; +- +-/* op values as set by inflate_table(): +- 00000000 - literal +- 0000tttt - table link, tttt != 0 is the number of table index bits +- 0001eeee - length or distance, eeee is the number of extra bits +- 01100000 - end of block +- 01000000 - invalid code +- */ +- +-/* Maximum size of the dynamic table. The maximum number of code structures is +- 1444, which is the sum of 852 for literal/length codes and 592 for distance +- codes. These values were found by exhaustive searches using the program +- examples/enough.c found in the zlib distribtution. The arguments to that +- program are the number of symbols, the initial root table size, and the +- maximum bit length of a code. "enough 286 9 15" for literal/length codes +- returns returns 852, and "enough 30 6 15" for distance codes returns 592. +- The initial root table size (9 or 6) is found in the fifth argument of the +- inflate_table() calls in inflate.c and infback.c. If the root table size is +- changed, then these maximum sizes would be need to be recalculated and +- updated. */ +-#define ENOUGH_LENS 852 +-#define ENOUGH_DISTS 592 +-#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS) +- +-/* Type of code to build for inflate_table() */ +-typedef enum { +- CODES, +- LENS, +- DISTS +-} codetype; +- +-int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens, +- unsigned codes, code FAR * FAR *table, +- unsigned FAR *bits, unsigned short FAR *work)); +diff --git a/thirdparty/zlib/minigzip.c b/thirdparty/zlib/minigzip.c +deleted file mode 100644 +index 9825ccc..0000000 +--- a/thirdparty/zlib/minigzip.c ++++ /dev/null +@@ -1,440 +0,0 @@ +-/* minigzip.c -- simulate gzip using the zlib compression library +- * Copyright (C) 1995-2006, 2010 Jean-loup Gailly. +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* +- * minigzip is a minimal implementation of the gzip utility. This is +- * only an example of using zlib and isn't meant to replace the +- * full-featured gzip. No attempt is made to deal with file systems +- * limiting names to 14 or 8+3 characters, etc... Error checking is +- * very limited. So use minigzip only for testing; use gzip for the +- * real thing. On MSDOS, use only on file names without extension +- * or in pipe mode. +- */ +- +-/* @(#) $Id$ */ +- +-#include "zlib.h" +-#include +- +-#ifdef STDC +-# include +-# include +-#endif +- +-#ifdef USE_MMAP +-# include +-# include +-# include +-#endif +- +-#if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__) +-# include +-# include +-# ifdef UNDER_CE +-# include +-# endif +-# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY) +-#else +-# define SET_BINARY_MODE(file) +-#endif +- +-#ifdef VMS +-# define unlink delete +-# define GZ_SUFFIX "-gz" +-#endif +-#ifdef RISCOS +-# define unlink remove +-# define GZ_SUFFIX "-gz" +-# define fileno(file) file->__file +-#endif +-#if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os +-# include /* for fileno */ +-#endif +- +-#if !defined(Z_HAVE_UNISTD_H) && !defined(_LARGEFILE64_SOURCE) +-#ifndef WIN32 /* unlink already in stdio.h for WIN32 */ +- extern int unlink OF((const char *)); +-#endif +-#endif +- +-#if defined(UNDER_CE) +-# include +-# define perror(s) pwinerror(s) +- +-/* Map the Windows error number in ERROR to a locale-dependent error +- message string and return a pointer to it. Typically, the values +- for ERROR come from GetLastError. +- +- The string pointed to shall not be modified by the application, +- but may be overwritten by a subsequent call to strwinerror +- +- The strwinerror function does not change the current setting +- of GetLastError. */ +- +-static char *strwinerror (error) +- DWORD error; +-{ +- static char buf[1024]; +- +- wchar_t *msgbuf; +- DWORD lasterr = GetLastError(); +- DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM +- | FORMAT_MESSAGE_ALLOCATE_BUFFER, +- NULL, +- error, +- 0, /* Default language */ +- (LPVOID)&msgbuf, +- 0, +- NULL); +- if (chars != 0) { +- /* If there is an \r\n appended, zap it. */ +- if (chars >= 2 +- && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') { +- chars -= 2; +- msgbuf[chars] = 0; +- } +- +- if (chars > sizeof (buf) - 1) { +- chars = sizeof (buf) - 1; +- msgbuf[chars] = 0; +- } +- +- wcstombs(buf, msgbuf, chars + 1); +- LocalFree(msgbuf); +- } +- else { +- sprintf(buf, "unknown win32 error (%ld)", error); +- } +- +- SetLastError(lasterr); +- return buf; +-} +- +-static void pwinerror (s) +- const char *s; +-{ +- if (s && *s) +- fprintf(stderr, "%s: %s\n", s, strwinerror(GetLastError ())); +- else +- fprintf(stderr, "%s\n", strwinerror(GetLastError ())); +-} +- +-#endif /* UNDER_CE */ +- +-#ifndef GZ_SUFFIX +-# define GZ_SUFFIX ".gz" +-#endif +-#define SUFFIX_LEN (sizeof(GZ_SUFFIX)-1) +- +-#define BUFLEN 16384 +-#define MAX_NAME_LEN 1024 +- +-#ifdef MAXSEG_64K +-# define local static +- /* Needed for systems with limitation on stack size. */ +-#else +-# define local +-#endif +- +-char *prog; +- +-void error OF((const char *msg)); +-void gz_compress OF((FILE *in, gzFile out)); +-#ifdef USE_MMAP +-int gz_compress_mmap OF((FILE *in, gzFile out)); +-#endif +-void gz_uncompress OF((gzFile in, FILE *out)); +-void file_compress OF((char *file, char *mode)); +-void file_uncompress OF((char *file)); +-int main OF((int argc, char *argv[])); +- +-/* =========================================================================== +- * Display error message and exit +- */ +-void error(msg) +- const char *msg; +-{ +- fprintf(stderr, "%s: %s\n", prog, msg); +- exit(1); +-} +- +-/* =========================================================================== +- * Compress input to output then close both files. +- */ +- +-void gz_compress(in, out) +- FILE *in; +- gzFile out; +-{ +- local char buf[BUFLEN]; +- int len; +- int err; +- +-#ifdef USE_MMAP +- /* Try first compressing with mmap. If mmap fails (minigzip used in a +- * pipe), use the normal fread loop. +- */ +- if (gz_compress_mmap(in, out) == Z_OK) return; +-#endif +- for (;;) { +- len = (int)fread(buf, 1, sizeof(buf), in); +- if (ferror(in)) { +- perror("fread"); +- exit(1); +- } +- if (len == 0) break; +- +- if (gzwrite(out, buf, (unsigned)len) != len) error(gzerror(out, &err)); +- } +- fclose(in); +- if (gzclose(out) != Z_OK) error("failed gzclose"); +-} +- +-#ifdef USE_MMAP /* MMAP version, Miguel Albrecht */ +- +-/* Try compressing the input file at once using mmap. Return Z_OK if +- * if success, Z_ERRNO otherwise. +- */ +-int gz_compress_mmap(in, out) +- FILE *in; +- gzFile out; +-{ +- int len; +- int err; +- int ifd = fileno(in); +- caddr_t buf; /* mmap'ed buffer for the entire input file */ +- off_t buf_len; /* length of the input file */ +- struct stat sb; +- +- /* Determine the size of the file, needed for mmap: */ +- if (fstat(ifd, &sb) < 0) return Z_ERRNO; +- buf_len = sb.st_size; +- if (buf_len <= 0) return Z_ERRNO; +- +- /* Now do the actual mmap: */ +- buf = mmap((caddr_t) 0, buf_len, PROT_READ, MAP_SHARED, ifd, (off_t)0); +- if (buf == (caddr_t)(-1)) return Z_ERRNO; +- +- /* Compress the whole file at once: */ +- len = gzwrite(out, (char *)buf, (unsigned)buf_len); +- +- if (len != (int)buf_len) error(gzerror(out, &err)); +- +- munmap(buf, buf_len); +- fclose(in); +- if (gzclose(out) != Z_OK) error("failed gzclose"); +- return Z_OK; +-} +-#endif /* USE_MMAP */ +- +-/* =========================================================================== +- * Uncompress input to output then close both files. +- */ +-void gz_uncompress(in, out) +- gzFile in; +- FILE *out; +-{ +- local char buf[BUFLEN]; +- int len; +- int err; +- +- for (;;) { +- len = gzread(in, buf, sizeof(buf)); +- if (len < 0) error (gzerror(in, &err)); +- if (len == 0) break; +- +- if ((int)fwrite(buf, 1, (unsigned)len, out) != len) { +- error("failed fwrite"); +- } +- } +- if (fclose(out)) error("failed fclose"); +- +- if (gzclose(in) != Z_OK) error("failed gzclose"); +-} +- +- +-/* =========================================================================== +- * Compress the given file: create a corresponding .gz file and remove the +- * original. +- */ +-void file_compress(file, mode) +- char *file; +- char *mode; +-{ +- local char outfile[MAX_NAME_LEN]; +- FILE *in; +- gzFile out; +- +- if (strlen(file) + strlen(GZ_SUFFIX) >= sizeof(outfile)) { +- fprintf(stderr, "%s: filename too long\n", prog); +- exit(1); +- } +- +- strcpy(outfile, file); +- strcat(outfile, GZ_SUFFIX); +- +- in = fopen(file, "rb"); +- if (in == NULL) { +- perror(file); +- exit(1); +- } +- out = gzopen(outfile, mode); +- if (out == NULL) { +- fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile); +- exit(1); +- } +- gz_compress(in, out); +- +- unlink(file); +-} +- +- +-/* =========================================================================== +- * Uncompress the given file and remove the original. +- */ +-void file_uncompress(file) +- char *file; +-{ +- local char buf[MAX_NAME_LEN]; +- char *infile, *outfile; +- FILE *out; +- gzFile in; +- size_t len = strlen(file); +- +- if (len + strlen(GZ_SUFFIX) >= sizeof(buf)) { +- fprintf(stderr, "%s: filename too long\n", prog); +- exit(1); +- } +- +- strcpy(buf, file); +- +- if (len > SUFFIX_LEN && strcmp(file+len-SUFFIX_LEN, GZ_SUFFIX) == 0) { +- infile = file; +- outfile = buf; +- outfile[len-3] = '\0'; +- } else { +- outfile = file; +- infile = buf; +- strcat(infile, GZ_SUFFIX); +- } +- in = gzopen(infile, "rb"); +- if (in == NULL) { +- fprintf(stderr, "%s: can't gzopen %s\n", prog, infile); +- exit(1); +- } +- out = fopen(outfile, "wb"); +- if (out == NULL) { +- perror(file); +- exit(1); +- } +- +- gz_uncompress(in, out); +- +- unlink(infile); +-} +- +- +-/* =========================================================================== +- * Usage: minigzip [-c] [-d] [-f] [-h] [-r] [-1 to -9] [files...] +- * -c : write to standard output +- * -d : decompress +- * -f : compress with Z_FILTERED +- * -h : compress with Z_HUFFMAN_ONLY +- * -r : compress with Z_RLE +- * -1 to -9 : compression level +- */ +- +-int main(argc, argv) +- int argc; +- char *argv[]; +-{ +- int copyout = 0; +- int uncompr = 0; +- gzFile file; +- char *bname, outmode[20]; +- +- strcpy(outmode, "wb6 "); +- +- prog = argv[0]; +- bname = strrchr(argv[0], '/'); +- if (bname) +- bname++; +- else +- bname = argv[0]; +- argc--, argv++; +- +- if (!strcmp(bname, "gunzip")) +- uncompr = 1; +- else if (!strcmp(bname, "zcat")) +- copyout = uncompr = 1; +- +- while (argc > 0) { +- if (strcmp(*argv, "-c") == 0) +- copyout = 1; +- else if (strcmp(*argv, "-d") == 0) +- uncompr = 1; +- else if (strcmp(*argv, "-f") == 0) +- outmode[3] = 'f'; +- else if (strcmp(*argv, "-h") == 0) +- outmode[3] = 'h'; +- else if (strcmp(*argv, "-r") == 0) +- outmode[3] = 'R'; +- else if ((*argv)[0] == '-' && (*argv)[1] >= '1' && (*argv)[1] <= '9' && +- (*argv)[2] == 0) +- outmode[2] = (*argv)[1]; +- else +- break; +- argc--, argv++; +- } +- if (outmode[3] == ' ') +- outmode[3] = 0; +- if (argc == 0) { +- SET_BINARY_MODE(stdin); +- SET_BINARY_MODE(stdout); +- if (uncompr) { +- file = gzdopen(fileno(stdin), "rb"); +- if (file == NULL) error("can't gzdopen stdin"); +- gz_uncompress(file, stdout); +- } else { +- file = gzdopen(fileno(stdout), outmode); +- if (file == NULL) error("can't gzdopen stdout"); +- gz_compress(stdin, file); +- } +- } else { +- if (copyout) { +- SET_BINARY_MODE(stdout); +- } +- do { +- if (uncompr) { +- if (copyout) { +- file = gzopen(*argv, "rb"); +- if (file == NULL) +- fprintf(stderr, "%s: can't gzopen %s\n", prog, *argv); +- else +- gz_uncompress(file, stdout); +- } else { +- file_uncompress(*argv); +- } +- } else { +- if (copyout) { +- FILE * in = fopen(*argv, "rb"); +- +- if (in == NULL) { +- perror(*argv); +- } else { +- file = gzdopen(fileno(stdout), outmode); +- if (file == NULL) error("can't gzdopen stdout"); +- +- gz_compress(in, file); +- } +- +- } else { +- file_compress(*argv, outmode); +- } +- } +- } while (argv++, --argc); +- } +- return 0; +-} +diff --git a/thirdparty/zlib/trees.c b/thirdparty/zlib/trees.c +deleted file mode 100644 +index 56e9bb1..0000000 +--- a/thirdparty/zlib/trees.c ++++ /dev/null +@@ -1,1244 +0,0 @@ +-/* trees.c -- output deflated data using Huffman coding +- * Copyright (C) 1995-2010 Jean-loup Gailly +- * detect_data_type() function provided freely by Cosmin Truta, 2006 +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* +- * ALGORITHM +- * +- * The "deflation" process uses several Huffman trees. The more +- * common source values are represented by shorter bit sequences. +- * +- * Each code tree is stored in a compressed form which is itself +- * a Huffman encoding of the lengths of all the code strings (in +- * ascending order by source values). The actual code strings are +- * reconstructed from the lengths in the inflate process, as described +- * in the deflate specification. +- * +- * REFERENCES +- * +- * Deutsch, L.P.,"'Deflate' Compressed Data Format Specification". +- * Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc +- * +- * Storer, James A. +- * Data Compression: Methods and Theory, pp. 49-50. +- * Computer Science Press, 1988. ISBN 0-7167-8156-5. +- * +- * Sedgewick, R. +- * Algorithms, p290. +- * Addison-Wesley, 1983. ISBN 0-201-06672-6. +- */ +- +-/* @(#) $Id$ */ +- +-/* #define GEN_TREES_H */ +- +-#include "deflate.h" +- +-#ifdef DEBUG +-# include +-#endif +- +-/* =========================================================================== +- * Constants +- */ +- +-#define MAX_BL_BITS 7 +-/* Bit length codes must not exceed MAX_BL_BITS bits */ +- +-#define END_BLOCK 256 +-/* end of block literal code */ +- +-#define REP_3_6 16 +-/* repeat previous bit length 3-6 times (2 bits of repeat count) */ +- +-#define REPZ_3_10 17 +-/* repeat a zero length 3-10 times (3 bits of repeat count) */ +- +-#define REPZ_11_138 18 +-/* repeat a zero length 11-138 times (7 bits of repeat count) */ +- +-local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */ +- = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0}; +- +-local const int extra_dbits[D_CODES] /* extra bits for each distance code */ +- = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; +- +-local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */ +- = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7}; +- +-local const uch bl_order[BL_CODES] +- = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15}; +-/* The lengths of the bit length codes are sent in order of decreasing +- * probability, to avoid transmitting the lengths for unused bit length codes. +- */ +- +-#define Buf_size (8 * 2*sizeof(char)) +-/* Number of bits used within bi_buf. (bi_buf might be implemented on +- * more than 16 bits on some systems.) +- */ +- +-/* =========================================================================== +- * Local data. These are initialized only once. +- */ +- +-#define DIST_CODE_LEN 512 /* see definition of array dist_code below */ +- +-#if defined(GEN_TREES_H) || !defined(STDC) +-/* non ANSI compilers may not accept trees.h */ +- +-local ct_data static_ltree[L_CODES+2]; +-/* The static literal tree. Since the bit lengths are imposed, there is no +- * need for the L_CODES extra codes used during heap construction. However +- * The codes 286 and 287 are needed to build a canonical tree (see _tr_init +- * below). +- */ +- +-local ct_data static_dtree[D_CODES]; +-/* The static distance tree. (Actually a trivial tree since all codes use +- * 5 bits.) +- */ +- +-uch _dist_code[DIST_CODE_LEN]; +-/* Distance codes. The first 256 values correspond to the distances +- * 3 .. 258, the last 256 values correspond to the top 8 bits of +- * the 15 bit distances. +- */ +- +-uch _length_code[MAX_MATCH-MIN_MATCH+1]; +-/* length code for each normalized match length (0 == MIN_MATCH) */ +- +-local int base_length[LENGTH_CODES]; +-/* First normalized length for each code (0 = MIN_MATCH) */ +- +-local int base_dist[D_CODES]; +-/* First normalized distance for each code (0 = distance of 1) */ +- +-#else +-# include "trees.h" +-#endif /* GEN_TREES_H */ +- +-struct static_tree_desc_s { +- const ct_data *static_tree; /* static tree or NULL */ +- const intf *extra_bits; /* extra bits for each code or NULL */ +- int extra_base; /* base index for extra_bits */ +- int elems; /* max number of elements in the tree */ +- int max_length; /* max bit length for the codes */ +-}; +- +-local static_tree_desc static_l_desc = +-{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS}; +- +-local static_tree_desc static_d_desc = +-{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS}; +- +-local static_tree_desc static_bl_desc = +-{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS}; +- +-/* =========================================================================== +- * Local (static) routines in this file. +- */ +- +-local void tr_static_init OF((void)); +-local void init_block OF((deflate_state *s)); +-local void pqdownheap OF((deflate_state *s, ct_data *tree, int k)); +-local void gen_bitlen OF((deflate_state *s, tree_desc *desc)); +-local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count)); +-local void build_tree OF((deflate_state *s, tree_desc *desc)); +-local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code)); +-local void send_tree OF((deflate_state *s, ct_data *tree, int max_code)); +-local int build_bl_tree OF((deflate_state *s)); +-local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, +- int blcodes)); +-local void compress_block OF((deflate_state *s, ct_data *ltree, +- ct_data *dtree)); +-local int detect_data_type OF((deflate_state *s)); +-local unsigned bi_reverse OF((unsigned value, int length)); +-local void bi_windup OF((deflate_state *s)); +-local void bi_flush OF((deflate_state *s)); +-local void copy_block OF((deflate_state *s, charf *buf, unsigned len, +- int header)); +- +-#ifdef GEN_TREES_H +-local void gen_trees_header OF((void)); +-#endif +- +-#ifndef DEBUG +-# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len) +- /* Send a code of the given tree. c and tree must not have side effects */ +- +-#else /* DEBUG */ +-# define send_code(s, c, tree) \ +- { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \ +- send_bits(s, tree[c].Code, tree[c].Len); } +-#endif +- +-/* =========================================================================== +- * Output a short LSB first on the stream. +- * IN assertion: there is enough room in pendingBuf. +- */ +-#define put_short(s, w) { \ +- put_byte(s, (uch)((w) & 0xff)); \ +- put_byte(s, (uch)((ush)(w) >> 8)); \ +-} +- +-/* =========================================================================== +- * Send a value on a given number of bits. +- * IN assertion: length <= 16 and value fits in length bits. +- */ +-#ifdef DEBUG +-local void send_bits OF((deflate_state *s, int value, int length)); +- +-local void send_bits(s, value, length) +- deflate_state *s; +- int value; /* value to send */ +- int length; /* number of bits */ +-{ +- Tracevv((stderr," l %2d v %4x ", length, value)); +- Assert(length > 0 && length <= 15, "invalid length"); +- s->bits_sent += (ulg)length; +- +- /* If not enough room in bi_buf, use (valid) bits from bi_buf and +- * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) +- * unused bits in value. +- */ +- if (s->bi_valid > (int)Buf_size - length) { +- s->bi_buf |= (ush)value << s->bi_valid; +- put_short(s, s->bi_buf); +- s->bi_buf = (ush)value >> (Buf_size - s->bi_valid); +- s->bi_valid += length - Buf_size; +- } else { +- s->bi_buf |= (ush)value << s->bi_valid; +- s->bi_valid += length; +- } +-} +-#else /* !DEBUG */ +- +-#define send_bits(s, value, length) \ +-{ int len = length;\ +- if (s->bi_valid > (int)Buf_size - len) {\ +- int val = value;\ +- s->bi_buf |= (ush)val << s->bi_valid;\ +- put_short(s, s->bi_buf);\ +- s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\ +- s->bi_valid += len - Buf_size;\ +- } else {\ +- s->bi_buf |= (ush)(value) << s->bi_valid;\ +- s->bi_valid += len;\ +- }\ +-} +-#endif /* DEBUG */ +- +- +-/* the arguments must not have side effects */ +- +-/* =========================================================================== +- * Initialize the various 'constant' tables. +- */ +-local void tr_static_init() +-{ +-#if defined(GEN_TREES_H) || !defined(STDC) +- static int static_init_done = 0; +- int n; /* iterates over tree elements */ +- int bits; /* bit counter */ +- int length; /* length value */ +- int code; /* code value */ +- int dist; /* distance index */ +- ush bl_count[MAX_BITS+1]; +- /* number of codes at each bit length for an optimal tree */ +- +- if (static_init_done) return; +- +- /* For some embedded targets, global variables are not initialized: */ +-#ifdef NO_INIT_GLOBAL_POINTERS +- static_l_desc.static_tree = static_ltree; +- static_l_desc.extra_bits = extra_lbits; +- static_d_desc.static_tree = static_dtree; +- static_d_desc.extra_bits = extra_dbits; +- static_bl_desc.extra_bits = extra_blbits; +-#endif +- +- /* Initialize the mapping length (0..255) -> length code (0..28) */ +- length = 0; +- for (code = 0; code < LENGTH_CODES-1; code++) { +- base_length[code] = length; +- for (n = 0; n < (1< dist code (0..29) */ +- dist = 0; +- for (code = 0 ; code < 16; code++) { +- base_dist[code] = dist; +- for (n = 0; n < (1<>= 7; /* from now on, all distances are divided by 128 */ +- for ( ; code < D_CODES; code++) { +- base_dist[code] = dist << 7; +- for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) { +- _dist_code[256 + dist++] = (uch)code; +- } +- } +- Assert (dist == 256, "tr_static_init: 256+dist != 512"); +- +- /* Construct the codes of the static literal tree */ +- for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0; +- n = 0; +- while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++; +- while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++; +- while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++; +- while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++; +- /* Codes 286 and 287 do not exist, but we must include them in the +- * tree construction to get a canonical Huffman tree (longest code +- * all ones) +- */ +- gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count); +- +- /* The static distance tree is trivial: */ +- for (n = 0; n < D_CODES; n++) { +- static_dtree[n].Len = 5; +- static_dtree[n].Code = bi_reverse((unsigned)n, 5); +- } +- static_init_done = 1; +- +-# ifdef GEN_TREES_H +- gen_trees_header(); +-# endif +-#endif /* defined(GEN_TREES_H) || !defined(STDC) */ +-} +- +-/* =========================================================================== +- * Genererate the file trees.h describing the static trees. +- */ +-#ifdef GEN_TREES_H +-# ifndef DEBUG +-# include +-# endif +- +-# define SEPARATOR(i, last, width) \ +- ((i) == (last)? "\n};\n\n" : \ +- ((i) % (width) == (width)-1 ? ",\n" : ", ")) +- +-void gen_trees_header() +-{ +- FILE *header = fopen("trees.h", "w"); +- int i; +- +- Assert (header != NULL, "Can't open trees.h"); +- fprintf(header, +- "/* header created automatically with -DGEN_TREES_H */\n\n"); +- +- fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n"); +- for (i = 0; i < L_CODES+2; i++) { +- fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code, +- static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5)); +- } +- +- fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n"); +- for (i = 0; i < D_CODES; i++) { +- fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code, +- static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5)); +- } +- +- fprintf(header, "const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n"); +- for (i = 0; i < DIST_CODE_LEN; i++) { +- fprintf(header, "%2u%s", _dist_code[i], +- SEPARATOR(i, DIST_CODE_LEN-1, 20)); +- } +- +- fprintf(header, +- "const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n"); +- for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) { +- fprintf(header, "%2u%s", _length_code[i], +- SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20)); +- } +- +- fprintf(header, "local const int base_length[LENGTH_CODES] = {\n"); +- for (i = 0; i < LENGTH_CODES; i++) { +- fprintf(header, "%1u%s", base_length[i], +- SEPARATOR(i, LENGTH_CODES-1, 20)); +- } +- +- fprintf(header, "local const int base_dist[D_CODES] = {\n"); +- for (i = 0; i < D_CODES; i++) { +- fprintf(header, "%5u%s", base_dist[i], +- SEPARATOR(i, D_CODES-1, 10)); +- } +- +- fclose(header); +-} +-#endif /* GEN_TREES_H */ +- +-/* =========================================================================== +- * Initialize the tree data structures for a new zlib stream. +- */ +-void ZLIB_INTERNAL _tr_init(s) +- deflate_state *s; +-{ +- tr_static_init(); +- +- s->l_desc.dyn_tree = s->dyn_ltree; +- s->l_desc.stat_desc = &static_l_desc; +- +- s->d_desc.dyn_tree = s->dyn_dtree; +- s->d_desc.stat_desc = &static_d_desc; +- +- s->bl_desc.dyn_tree = s->bl_tree; +- s->bl_desc.stat_desc = &static_bl_desc; +- +- s->bi_buf = 0; +- s->bi_valid = 0; +- s->last_eob_len = 8; /* enough lookahead for inflate */ +-#ifdef DEBUG +- s->compressed_len = 0L; +- s->bits_sent = 0L; +-#endif +- +- /* Initialize the first block of the first file: */ +- init_block(s); +-} +- +-/* =========================================================================== +- * Initialize a new block. +- */ +-local void init_block(s) +- deflate_state *s; +-{ +- int n; /* iterates over tree elements */ +- +- /* Initialize the trees. */ +- for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0; +- for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0; +- for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0; +- +- s->dyn_ltree[END_BLOCK].Freq = 1; +- s->opt_len = s->static_len = 0L; +- s->last_lit = s->matches = 0; +-} +- +-#define SMALLEST 1 +-/* Index within the heap array of least frequent node in the Huffman tree */ +- +- +-/* =========================================================================== +- * Remove the smallest element from the heap and recreate the heap with +- * one less element. Updates heap and heap_len. +- */ +-#define pqremove(s, tree, top) \ +-{\ +- top = s->heap[SMALLEST]; \ +- s->heap[SMALLEST] = s->heap[s->heap_len--]; \ +- pqdownheap(s, tree, SMALLEST); \ +-} +- +-/* =========================================================================== +- * Compares to subtrees, using the tree depth as tie breaker when +- * the subtrees have equal frequency. This minimizes the worst case length. +- */ +-#define smaller(tree, n, m, depth) \ +- (tree[n].Freq < tree[m].Freq || \ +- (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m])) +- +-/* =========================================================================== +- * Restore the heap property by moving down the tree starting at node k, +- * exchanging a node with the smallest of its two sons if necessary, stopping +- * when the heap property is re-established (each father smaller than its +- * two sons). +- */ +-local void pqdownheap(s, tree, k) +- deflate_state *s; +- ct_data *tree; /* the tree to restore */ +- int k; /* node to move down */ +-{ +- int v = s->heap[k]; +- int j = k << 1; /* left son of k */ +- while (j <= s->heap_len) { +- /* Set j to the smallest of the two sons: */ +- if (j < s->heap_len && +- smaller(tree, s->heap[j+1], s->heap[j], s->depth)) { +- j++; +- } +- /* Exit if v is smaller than both sons */ +- if (smaller(tree, v, s->heap[j], s->depth)) break; +- +- /* Exchange v with the smallest son */ +- s->heap[k] = s->heap[j]; k = j; +- +- /* And continue down the tree, setting j to the left son of k */ +- j <<= 1; +- } +- s->heap[k] = v; +-} +- +-/* =========================================================================== +- * Compute the optimal bit lengths for a tree and update the total bit length +- * for the current block. +- * IN assertion: the fields freq and dad are set, heap[heap_max] and +- * above are the tree nodes sorted by increasing frequency. +- * OUT assertions: the field len is set to the optimal bit length, the +- * array bl_count contains the frequencies for each bit length. +- * The length opt_len is updated; static_len is also updated if stree is +- * not null. +- */ +-local void gen_bitlen(s, desc) +- deflate_state *s; +- tree_desc *desc; /* the tree descriptor */ +-{ +- ct_data *tree = desc->dyn_tree; +- int max_code = desc->max_code; +- const ct_data *stree = desc->stat_desc->static_tree; +- const intf *extra = desc->stat_desc->extra_bits; +- int base = desc->stat_desc->extra_base; +- int max_length = desc->stat_desc->max_length; +- int h; /* heap index */ +- int n, m; /* iterate over the tree elements */ +- int bits; /* bit length */ +- int xbits; /* extra bits */ +- ush f; /* frequency */ +- int overflow = 0; /* number of elements with bit length too large */ +- +- for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0; +- +- /* In a first pass, compute the optimal bit lengths (which may +- * overflow in the case of the bit length tree). +- */ +- tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */ +- +- for (h = s->heap_max+1; h < HEAP_SIZE; h++) { +- n = s->heap[h]; +- bits = tree[tree[n].Dad].Len + 1; +- if (bits > max_length) bits = max_length, overflow++; +- tree[n].Len = (ush)bits; +- /* We overwrite tree[n].Dad which is no longer needed */ +- +- if (n > max_code) continue; /* not a leaf node */ +- +- s->bl_count[bits]++; +- xbits = 0; +- if (n >= base) xbits = extra[n-base]; +- f = tree[n].Freq; +- s->opt_len += (ulg)f * (bits + xbits); +- if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits); +- } +- if (overflow == 0) return; +- +- Trace((stderr,"\nbit length overflow\n")); +- /* This happens for example on obj2 and pic of the Calgary corpus */ +- +- /* Find the first bit length which could increase: */ +- do { +- bits = max_length-1; +- while (s->bl_count[bits] == 0) bits--; +- s->bl_count[bits]--; /* move one leaf down the tree */ +- s->bl_count[bits+1] += 2; /* move one overflow item as its brother */ +- s->bl_count[max_length]--; +- /* The brother of the overflow item also moves one step up, +- * but this does not affect bl_count[max_length] +- */ +- overflow -= 2; +- } while (overflow > 0); +- +- /* Now recompute all bit lengths, scanning in increasing frequency. +- * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all +- * lengths instead of fixing only the wrong ones. This idea is taken +- * from 'ar' written by Haruhiko Okumura.) +- */ +- for (bits = max_length; bits != 0; bits--) { +- n = s->bl_count[bits]; +- while (n != 0) { +- m = s->heap[--h]; +- if (m > max_code) continue; +- if ((unsigned) tree[m].Len != (unsigned) bits) { +- Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); +- s->opt_len += ((long)bits - (long)tree[m].Len) +- *(long)tree[m].Freq; +- tree[m].Len = (ush)bits; +- } +- n--; +- } +- } +-} +- +-/* =========================================================================== +- * Generate the codes for a given tree and bit counts (which need not be +- * optimal). +- * IN assertion: the array bl_count contains the bit length statistics for +- * the given tree and the field len is set for all tree elements. +- * OUT assertion: the field code is set for all tree elements of non +- * zero code length. +- */ +-local void gen_codes (tree, max_code, bl_count) +- ct_data *tree; /* the tree to decorate */ +- int max_code; /* largest code with non zero frequency */ +- ushf *bl_count; /* number of codes at each bit length */ +-{ +- ush next_code[MAX_BITS+1]; /* next code value for each bit length */ +- ush code = 0; /* running code value */ +- int bits; /* bit index */ +- int n; /* code index */ +- +- /* The distribution counts are first used to generate the code values +- * without bit reversal. +- */ +- for (bits = 1; bits <= MAX_BITS; bits++) { +- next_code[bits] = code = (code + bl_count[bits-1]) << 1; +- } +- /* Check that the bit counts in bl_count are consistent. The last code +- * must be all ones. +- */ +- Assert (code + bl_count[MAX_BITS]-1 == (1<dyn_tree; +- const ct_data *stree = desc->stat_desc->static_tree; +- int elems = desc->stat_desc->elems; +- int n, m; /* iterate over heap elements */ +- int max_code = -1; /* largest code with non zero frequency */ +- int node; /* new node being created */ +- +- /* Construct the initial heap, with least frequent element in +- * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. +- * heap[0] is not used. +- */ +- s->heap_len = 0, s->heap_max = HEAP_SIZE; +- +- for (n = 0; n < elems; n++) { +- if (tree[n].Freq != 0) { +- s->heap[++(s->heap_len)] = max_code = n; +- s->depth[n] = 0; +- } else { +- tree[n].Len = 0; +- } +- } +- +- /* The pkzip format requires that at least one distance code exists, +- * and that at least one bit should be sent even if there is only one +- * possible code. So to avoid special checks later on we force at least +- * two codes of non zero frequency. +- */ +- while (s->heap_len < 2) { +- node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0); +- tree[node].Freq = 1; +- s->depth[node] = 0; +- s->opt_len--; if (stree) s->static_len -= stree[node].Len; +- /* node is 0 or 1 so it does not have extra bits */ +- } +- desc->max_code = max_code; +- +- /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, +- * establish sub-heaps of increasing lengths: +- */ +- for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n); +- +- /* Construct the Huffman tree by repeatedly combining the least two +- * frequent nodes. +- */ +- node = elems; /* next internal node of the tree */ +- do { +- pqremove(s, tree, n); /* n = node of least frequency */ +- m = s->heap[SMALLEST]; /* m = node of next least frequency */ +- +- s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */ +- s->heap[--(s->heap_max)] = m; +- +- /* Create a new node father of n and m */ +- tree[node].Freq = tree[n].Freq + tree[m].Freq; +- s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ? +- s->depth[n] : s->depth[m]) + 1); +- tree[n].Dad = tree[m].Dad = (ush)node; +-#ifdef DUMP_BL_TREE +- if (tree == s->bl_tree) { +- fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)", +- node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq); +- } +-#endif +- /* and insert the new node in the heap */ +- s->heap[SMALLEST] = node++; +- pqdownheap(s, tree, SMALLEST); +- +- } while (s->heap_len >= 2); +- +- s->heap[--(s->heap_max)] = s->heap[SMALLEST]; +- +- /* At this point, the fields freq and dad are set. We can now +- * generate the bit lengths. +- */ +- gen_bitlen(s, (tree_desc *)desc); +- +- /* The field len is now set, we can generate the bit codes */ +- gen_codes ((ct_data *)tree, max_code, s->bl_count); +-} +- +-/* =========================================================================== +- * Scan a literal or distance tree to determine the frequencies of the codes +- * in the bit length tree. +- */ +-local void scan_tree (s, tree, max_code) +- deflate_state *s; +- ct_data *tree; /* the tree to be scanned */ +- int max_code; /* and its largest code of non zero frequency */ +-{ +- int n; /* iterates over all tree elements */ +- int prevlen = -1; /* last emitted length */ +- int curlen; /* length of current code */ +- int nextlen = tree[0].Len; /* length of next code */ +- int count = 0; /* repeat count of the current code */ +- int max_count = 7; /* max repeat count */ +- int min_count = 4; /* min repeat count */ +- +- if (nextlen == 0) max_count = 138, min_count = 3; +- tree[max_code+1].Len = (ush)0xffff; /* guard */ +- +- for (n = 0; n <= max_code; n++) { +- curlen = nextlen; nextlen = tree[n+1].Len; +- if (++count < max_count && curlen == nextlen) { +- continue; +- } else if (count < min_count) { +- s->bl_tree[curlen].Freq += count; +- } else if (curlen != 0) { +- if (curlen != prevlen) s->bl_tree[curlen].Freq++; +- s->bl_tree[REP_3_6].Freq++; +- } else if (count <= 10) { +- s->bl_tree[REPZ_3_10].Freq++; +- } else { +- s->bl_tree[REPZ_11_138].Freq++; +- } +- count = 0; prevlen = curlen; +- if (nextlen == 0) { +- max_count = 138, min_count = 3; +- } else if (curlen == nextlen) { +- max_count = 6, min_count = 3; +- } else { +- max_count = 7, min_count = 4; +- } +- } +-} +- +-/* =========================================================================== +- * Send a literal or distance tree in compressed form, using the codes in +- * bl_tree. +- */ +-local void send_tree (s, tree, max_code) +- deflate_state *s; +- ct_data *tree; /* the tree to be scanned */ +- int max_code; /* and its largest code of non zero frequency */ +-{ +- int n; /* iterates over all tree elements */ +- int prevlen = -1; /* last emitted length */ +- int curlen; /* length of current code */ +- int nextlen = tree[0].Len; /* length of next code */ +- int count = 0; /* repeat count of the current code */ +- int max_count = 7; /* max repeat count */ +- int min_count = 4; /* min repeat count */ +- +- /* tree[max_code+1].Len = -1; */ /* guard already set */ +- if (nextlen == 0) max_count = 138, min_count = 3; +- +- for (n = 0; n <= max_code; n++) { +- curlen = nextlen; nextlen = tree[n+1].Len; +- if (++count < max_count && curlen == nextlen) { +- continue; +- } else if (count < min_count) { +- do { send_code(s, curlen, s->bl_tree); } while (--count != 0); +- +- } else if (curlen != 0) { +- if (curlen != prevlen) { +- send_code(s, curlen, s->bl_tree); count--; +- } +- Assert(count >= 3 && count <= 6, " 3_6?"); +- send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2); +- +- } else if (count <= 10) { +- send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3); +- +- } else { +- send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7); +- } +- count = 0; prevlen = curlen; +- if (nextlen == 0) { +- max_count = 138, min_count = 3; +- } else if (curlen == nextlen) { +- max_count = 6, min_count = 3; +- } else { +- max_count = 7, min_count = 4; +- } +- } +-} +- +-/* =========================================================================== +- * Construct the Huffman tree for the bit lengths and return the index in +- * bl_order of the last bit length code to send. +- */ +-local int build_bl_tree(s) +- deflate_state *s; +-{ +- int max_blindex; /* index of last bit length code of non zero freq */ +- +- /* Determine the bit length frequencies for literal and distance trees */ +- scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code); +- scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code); +- +- /* Build the bit length tree: */ +- build_tree(s, (tree_desc *)(&(s->bl_desc))); +- /* opt_len now includes the length of the tree representations, except +- * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. +- */ +- +- /* Determine the number of bit length codes to send. The pkzip format +- * requires that at least 4 bit length codes be sent. (appnote.txt says +- * 3 but the actual value used is 4.) +- */ +- for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) { +- if (s->bl_tree[bl_order[max_blindex]].Len != 0) break; +- } +- /* Update opt_len to include the bit length tree and counts */ +- s->opt_len += 3*(max_blindex+1) + 5+5+4; +- Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", +- s->opt_len, s->static_len)); +- +- return max_blindex; +-} +- +-/* =========================================================================== +- * Send the header for a block using dynamic Huffman trees: the counts, the +- * lengths of the bit length codes, the literal tree and the distance tree. +- * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. +- */ +-local void send_all_trees(s, lcodes, dcodes, blcodes) +- deflate_state *s; +- int lcodes, dcodes, blcodes; /* number of codes for each tree */ +-{ +- int rank; /* index in bl_order */ +- +- Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); +- Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, +- "too many codes"); +- Tracev((stderr, "\nbl counts: ")); +- send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */ +- send_bits(s, dcodes-1, 5); +- send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */ +- for (rank = 0; rank < blcodes; rank++) { +- Tracev((stderr, "\nbl code %2d ", bl_order[rank])); +- send_bits(s, s->bl_tree[bl_order[rank]].Len, 3); +- } +- Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); +- +- send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */ +- Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); +- +- send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */ +- Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); +-} +- +-/* =========================================================================== +- * Send a stored block +- */ +-void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last) +- deflate_state *s; +- charf *buf; /* input block */ +- ulg stored_len; /* length of input block */ +- int last; /* one if this is the last block for a file */ +-{ +- send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */ +-#ifdef DEBUG +- s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; +- s->compressed_len += (stored_len + 4) << 3; +-#endif +- copy_block(s, buf, (unsigned)stored_len, 1); /* with header */ +-} +- +-/* =========================================================================== +- * Send one empty static block to give enough lookahead for inflate. +- * This takes 10 bits, of which 7 may remain in the bit buffer. +- * The current inflate code requires 9 bits of lookahead. If the +- * last two codes for the previous block (real code plus EOB) were coded +- * on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode +- * the last real code. In this case we send two empty static blocks instead +- * of one. (There are no problems if the previous block is stored or fixed.) +- * To simplify the code, we assume the worst case of last real code encoded +- * on one bit only. +- */ +-void ZLIB_INTERNAL _tr_align(s) +- deflate_state *s; +-{ +- send_bits(s, STATIC_TREES<<1, 3); +- send_code(s, END_BLOCK, static_ltree); +-#ifdef DEBUG +- s->compressed_len += 10L; /* 3 for block type, 7 for EOB */ +-#endif +- bi_flush(s); +- /* Of the 10 bits for the empty block, we have already sent +- * (10 - bi_valid) bits. The lookahead for the last real code (before +- * the EOB of the previous block) was thus at least one plus the length +- * of the EOB plus what we have just sent of the empty static block. +- */ +- if (1 + s->last_eob_len + 10 - s->bi_valid < 9) { +- send_bits(s, STATIC_TREES<<1, 3); +- send_code(s, END_BLOCK, static_ltree); +-#ifdef DEBUG +- s->compressed_len += 10L; +-#endif +- bi_flush(s); +- } +- s->last_eob_len = 7; +-} +- +-/* =========================================================================== +- * Determine the best encoding for the current block: dynamic trees, static +- * trees or store, and output the encoded block to the zip file. +- */ +-void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) +- deflate_state *s; +- charf *buf; /* input block, or NULL if too old */ +- ulg stored_len; /* length of input block */ +- int last; /* one if this is the last block for a file */ +-{ +- ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ +- int max_blindex = 0; /* index of last bit length code of non zero freq */ +- +- /* Build the Huffman trees unless a stored block is forced */ +- if (s->level > 0) { +- +- /* Check if the file is binary or text */ +- if (s->strm->data_type == Z_UNKNOWN) +- s->strm->data_type = detect_data_type(s); +- +- /* Construct the literal and distance trees */ +- build_tree(s, (tree_desc *)(&(s->l_desc))); +- Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, +- s->static_len)); +- +- build_tree(s, (tree_desc *)(&(s->d_desc))); +- Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, +- s->static_len)); +- /* At this point, opt_len and static_len are the total bit lengths of +- * the compressed block data, excluding the tree representations. +- */ +- +- /* Build the bit length tree for the above two trees, and get the index +- * in bl_order of the last bit length code to send. +- */ +- max_blindex = build_bl_tree(s); +- +- /* Determine the best encoding. Compute the block lengths in bytes. */ +- opt_lenb = (s->opt_len+3+7)>>3; +- static_lenb = (s->static_len+3+7)>>3; +- +- Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", +- opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, +- s->last_lit)); +- +- if (static_lenb <= opt_lenb) opt_lenb = static_lenb; +- +- } else { +- Assert(buf != (char*)0, "lost buf"); +- opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ +- } +- +-#ifdef FORCE_STORED +- if (buf != (char*)0) { /* force stored block */ +-#else +- if (stored_len+4 <= opt_lenb && buf != (char*)0) { +- /* 4: two words for the lengths */ +-#endif +- /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. +- * Otherwise we can't have processed more than WSIZE input bytes since +- * the last block flush, because compression would have been +- * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to +- * transform a block into a stored block. +- */ +- _tr_stored_block(s, buf, stored_len, last); +- +-#ifdef FORCE_STATIC +- } else if (static_lenb >= 0) { /* force static trees */ +-#else +- } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) { +-#endif +- send_bits(s, (STATIC_TREES<<1)+last, 3); +- compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree); +-#ifdef DEBUG +- s->compressed_len += 3 + s->static_len; +-#endif +- } else { +- send_bits(s, (DYN_TREES<<1)+last, 3); +- send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, +- max_blindex+1); +- compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree); +-#ifdef DEBUG +- s->compressed_len += 3 + s->opt_len; +-#endif +- } +- Assert (s->compressed_len == s->bits_sent, "bad compressed size"); +- /* The above check is made mod 2^32, for files larger than 512 MB +- * and uLong implemented on 32 bits. +- */ +- init_block(s); +- +- if (last) { +- bi_windup(s); +-#ifdef DEBUG +- s->compressed_len += 7; /* align on byte boundary */ +-#endif +- } +- Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, +- s->compressed_len-7*last)); +-} +- +-/* =========================================================================== +- * Save the match info and tally the frequency counts. Return true if +- * the current block must be flushed. +- */ +-int ZLIB_INTERNAL _tr_tally (s, dist, lc) +- deflate_state *s; +- unsigned dist; /* distance of matched string */ +- unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ +-{ +- s->d_buf[s->last_lit] = (ush)dist; +- s->l_buf[s->last_lit++] = (uch)lc; +- if (dist == 0) { +- /* lc is the unmatched char */ +- s->dyn_ltree[lc].Freq++; +- } else { +- s->matches++; +- /* Here, lc is the match length - MIN_MATCH */ +- dist--; /* dist = match distance - 1 */ +- Assert((ush)dist < (ush)MAX_DIST(s) && +- (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && +- (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); +- +- s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++; +- s->dyn_dtree[d_code(dist)].Freq++; +- } +- +-#ifdef TRUNCATE_BLOCK +- /* Try to guess if it is profitable to stop the current block here */ +- if ((s->last_lit & 0x1fff) == 0 && s->level > 2) { +- /* Compute an upper bound for the compressed length */ +- ulg out_length = (ulg)s->last_lit*8L; +- ulg in_length = (ulg)((long)s->strstart - s->block_start); +- int dcode; +- for (dcode = 0; dcode < D_CODES; dcode++) { +- out_length += (ulg)s->dyn_dtree[dcode].Freq * +- (5L+extra_dbits[dcode]); +- } +- out_length >>= 3; +- Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", +- s->last_lit, in_length, out_length, +- 100L - out_length*100L/in_length)); +- if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1; +- } +-#endif +- return (s->last_lit == s->lit_bufsize-1); +- /* We avoid equality with lit_bufsize because of wraparound at 64K +- * on 16 bit machines and because stored blocks are restricted to +- * 64K-1 bytes. +- */ +-} +- +-/* =========================================================================== +- * Send the block data compressed using the given Huffman trees +- */ +-local void compress_block(s, ltree, dtree) +- deflate_state *s; +- ct_data *ltree; /* literal tree */ +- ct_data *dtree; /* distance tree */ +-{ +- unsigned dist; /* distance of matched string */ +- int lc; /* match length or unmatched char (if dist == 0) */ +- unsigned lx = 0; /* running index in l_buf */ +- unsigned code; /* the code to send */ +- int extra; /* number of extra bits to send */ +- +- if (s->last_lit != 0) do { +- dist = s->d_buf[lx]; +- lc = s->l_buf[lx++]; +- if (dist == 0) { +- send_code(s, lc, ltree); /* send a literal byte */ +- Tracecv(isgraph(lc), (stderr," '%c' ", lc)); +- } else { +- /* Here, lc is the match length - MIN_MATCH */ +- code = _length_code[lc]; +- send_code(s, code+LITERALS+1, ltree); /* send the length code */ +- extra = extra_lbits[code]; +- if (extra != 0) { +- lc -= base_length[code]; +- send_bits(s, lc, extra); /* send the extra length bits */ +- } +- dist--; /* dist is now the match distance - 1 */ +- code = d_code(dist); +- Assert (code < D_CODES, "bad d_code"); +- +- send_code(s, code, dtree); /* send the distance code */ +- extra = extra_dbits[code]; +- if (extra != 0) { +- dist -= base_dist[code]; +- send_bits(s, dist, extra); /* send the extra distance bits */ +- } +- } /* literal or match pair ? */ +- +- /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ +- Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx, +- "pendingBuf overflow"); +- +- } while (lx < s->last_lit); +- +- send_code(s, END_BLOCK, ltree); +- s->last_eob_len = ltree[END_BLOCK].Len; +-} +- +-/* =========================================================================== +- * Check if the data type is TEXT or BINARY, using the following algorithm: +- * - TEXT if the two conditions below are satisfied: +- * a) There are no non-portable control characters belonging to the +- * "black list" (0..6, 14..25, 28..31). +- * b) There is at least one printable character belonging to the +- * "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255). +- * - BINARY otherwise. +- * - The following partially-portable control characters form a +- * "gray list" that is ignored in this detection algorithm: +- * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). +- * IN assertion: the fields Freq of dyn_ltree are set. +- */ +-local int detect_data_type(s) +- deflate_state *s; +-{ +- /* black_mask is the bit mask of black-listed bytes +- * set bits 0..6, 14..25, and 28..31 +- * 0xf3ffc07f = binary 11110011111111111100000001111111 +- */ +- unsigned long black_mask = 0xf3ffc07fUL; +- int n; +- +- /* Check for non-textual ("black-listed") bytes. */ +- for (n = 0; n <= 31; n++, black_mask >>= 1) +- if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0)) +- return Z_BINARY; +- +- /* Check for textual ("white-listed") bytes. */ +- if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0 +- || s->dyn_ltree[13].Freq != 0) +- return Z_TEXT; +- for (n = 32; n < LITERALS; n++) +- if (s->dyn_ltree[n].Freq != 0) +- return Z_TEXT; +- +- /* There are no "black-listed" or "white-listed" bytes: +- * this stream either is empty or has tolerated ("gray-listed") bytes only. +- */ +- return Z_BINARY; +-} +- +-/* =========================================================================== +- * Reverse the first len bits of a code, using straightforward code (a faster +- * method would use a table) +- * IN assertion: 1 <= len <= 15 +- */ +-local unsigned bi_reverse(code, len) +- unsigned code; /* the value to invert */ +- int len; /* its bit length */ +-{ +- register unsigned res = 0; +- do { +- res |= code & 1; +- code >>= 1, res <<= 1; +- } while (--len > 0); +- return res >> 1; +-} +- +-/* =========================================================================== +- * Flush the bit buffer, keeping at most 7 bits in it. +- */ +-local void bi_flush(s) +- deflate_state *s; +-{ +- if (s->bi_valid == 16) { +- put_short(s, s->bi_buf); +- s->bi_buf = 0; +- s->bi_valid = 0; +- } else if (s->bi_valid >= 8) { +- put_byte(s, (Byte)s->bi_buf); +- s->bi_buf >>= 8; +- s->bi_valid -= 8; +- } +-} +- +-/* =========================================================================== +- * Flush the bit buffer and align the output on a byte boundary +- */ +-local void bi_windup(s) +- deflate_state *s; +-{ +- if (s->bi_valid > 8) { +- put_short(s, s->bi_buf); +- } else if (s->bi_valid > 0) { +- put_byte(s, (Byte)s->bi_buf); +- } +- s->bi_buf = 0; +- s->bi_valid = 0; +-#ifdef DEBUG +- s->bits_sent = (s->bits_sent+7) & ~7; +-#endif +-} +- +-/* =========================================================================== +- * Copy a stored block, storing first the length and its +- * one's complement if requested. +- */ +-local void copy_block(s, buf, len, header) +- deflate_state *s; +- charf *buf; /* the input data */ +- unsigned len; /* its length */ +- int header; /* true if block header must be written */ +-{ +- bi_windup(s); /* align on byte boundary */ +- s->last_eob_len = 8; /* enough lookahead for inflate */ +- +- if (header) { +- put_short(s, (ush)len); +- put_short(s, (ush)~len); +-#ifdef DEBUG +- s->bits_sent += 2*16; +-#endif +- } +-#ifdef DEBUG +- s->bits_sent += (ulg)len<<3; +-#endif +- while (len--) { +- put_byte(s, *buf++); +- } +-} +diff --git a/thirdparty/zlib/trees.h b/thirdparty/zlib/trees.h +deleted file mode 100644 +index d35639d..0000000 +--- a/thirdparty/zlib/trees.h ++++ /dev/null +@@ -1,128 +0,0 @@ +-/* header created automatically with -DGEN_TREES_H */ +- +-local const ct_data static_ltree[L_CODES+2] = { +-{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}}, +-{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}}, +-{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}}, +-{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}}, +-{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}}, +-{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}}, +-{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}}, +-{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}}, +-{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}}, +-{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}}, +-{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}}, +-{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}}, +-{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}}, +-{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}}, +-{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}}, +-{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}}, +-{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}}, +-{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}}, +-{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}}, +-{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}}, +-{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}}, +-{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}}, +-{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}}, +-{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}}, +-{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}}, +-{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}}, +-{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}}, +-{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}}, +-{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}}, +-{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}}, +-{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}}, +-{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}}, +-{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}}, +-{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}}, +-{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}}, +-{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}}, +-{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}}, +-{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}}, +-{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}}, +-{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}}, +-{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}}, +-{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}}, +-{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}}, +-{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}}, +-{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}}, +-{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}}, +-{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}}, +-{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}}, +-{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}}, +-{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}}, +-{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}}, +-{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}}, +-{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}}, +-{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}}, +-{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}}, +-{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}}, +-{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}}, +-{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}} +-}; +- +-local const ct_data static_dtree[D_CODES] = { +-{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}}, +-{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}}, +-{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}}, +-{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}}, +-{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}}, +-{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}} +-}; +- +-const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = { +- 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, +- 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, +-10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +-11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, +-12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, +-13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, +-13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +-14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +-14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +-14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, +-15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +-15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +-15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, +-18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, +-23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +-24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +-26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +-26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, +-27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +-27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +-28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +-28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +-28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +-29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +-29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +-29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 +-}; +- +-const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= { +- 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, +-13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, +-17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, +-19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, +-21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, +-22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, +-23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +-24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +-25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +-25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, +-26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +-26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +-27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 +-}; +- +-local const int base_length[LENGTH_CODES] = { +-0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, +-64, 80, 96, 112, 128, 160, 192, 224, 0 +-}; +- +-local const int base_dist[D_CODES] = { +- 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, +- 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, +- 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 +-}; +- +diff --git a/thirdparty/zlib/uncompr.c b/thirdparty/zlib/uncompr.c +deleted file mode 100644 +index ad98be3..0000000 +--- a/thirdparty/zlib/uncompr.c ++++ /dev/null +@@ -1,59 +0,0 @@ +-/* uncompr.c -- decompress a memory buffer +- * Copyright (C) 1995-2003, 2010 Jean-loup Gailly. +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* @(#) $Id$ */ +- +-#define ZLIB_INTERNAL +-#include "zlib.h" +- +-/* =========================================================================== +- Decompresses the source buffer into the destination buffer. sourceLen is +- the byte length of the source buffer. Upon entry, destLen is the total +- size of the destination buffer, which must be large enough to hold the +- entire uncompressed data. (The size of the uncompressed data must have +- been saved previously by the compressor and transmitted to the decompressor +- by some mechanism outside the scope of this compression library.) +- Upon exit, destLen is the actual size of the compressed buffer. +- +- uncompress returns Z_OK if success, Z_MEM_ERROR if there was not +- enough memory, Z_BUF_ERROR if there was not enough room in the output +- buffer, or Z_DATA_ERROR if the input data was corrupted. +-*/ +-int ZEXPORT uncompress (dest, destLen, source, sourceLen) +- Bytef *dest; +- uLongf *destLen; +- const Bytef *source; +- uLong sourceLen; +-{ +- z_stream stream; +- int err; +- +- stream.next_in = (Bytef*)source; +- stream.avail_in = (uInt)sourceLen; +- /* Check for source > 64K on 16-bit machine: */ +- if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; +- +- stream.next_out = dest; +- stream.avail_out = (uInt)*destLen; +- if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; +- +- stream.zalloc = (alloc_func)0; +- stream.zfree = (free_func)0; +- +- err = inflateInit(&stream); +- if (err != Z_OK) return err; +- +- err = inflate(&stream, Z_FINISH); +- if (err != Z_STREAM_END) { +- inflateEnd(&stream); +- if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0)) +- return Z_DATA_ERROR; +- return err; +- } +- *destLen = stream.total_out; +- +- err = inflateEnd(&stream); +- return err; +-} +diff --git a/thirdparty/zlib/zconf.h b/thirdparty/zlib/zconf.h +deleted file mode 100644 +index 02ce56c..0000000 +--- a/thirdparty/zlib/zconf.h ++++ /dev/null +@@ -1,428 +0,0 @@ +-/* zconf.h -- configuration of the zlib compression library +- * Copyright (C) 1995-2010 Jean-loup Gailly. +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* @(#) $Id$ */ +- +-#ifndef ZCONF_H +-#define ZCONF_H +- +-/* +- * If you *really* need a unique prefix for all types and library functions, +- * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. +- * Even better than compiling with -DZ_PREFIX would be to use configure to set +- * this permanently in zconf.h using "./configure --zprefix". +- */ +-#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ +- +-/* all linked symbols */ +-# define _dist_code z__dist_code +-# define _length_code z__length_code +-# define _tr_align z__tr_align +-# define _tr_flush_block z__tr_flush_block +-# define _tr_init z__tr_init +-# define _tr_stored_block z__tr_stored_block +-# define _tr_tally z__tr_tally +-# define adler32 z_adler32 +-# define adler32_combine z_adler32_combine +-# define adler32_combine64 z_adler32_combine64 +-# define compress z_compress +-# define compress2 z_compress2 +-# define compressBound z_compressBound +-# define crc32 z_crc32 +-# define crc32_combine z_crc32_combine +-# define crc32_combine64 z_crc32_combine64 +-# define deflate z_deflate +-# define deflateBound z_deflateBound +-# define deflateCopy z_deflateCopy +-# define deflateEnd z_deflateEnd +-# define deflateInit2_ z_deflateInit2_ +-# define deflateInit_ z_deflateInit_ +-# define deflateParams z_deflateParams +-# define deflatePrime z_deflatePrime +-# define deflateReset z_deflateReset +-# define deflateSetDictionary z_deflateSetDictionary +-# define deflateSetHeader z_deflateSetHeader +-# define deflateTune z_deflateTune +-# define deflate_copyright z_deflate_copyright +-# define get_crc_table z_get_crc_table +-# define gz_error z_gz_error +-# define gz_intmax z_gz_intmax +-# define gz_strwinerror z_gz_strwinerror +-# define gzbuffer z_gzbuffer +-# define gzclearerr z_gzclearerr +-# define gzclose z_gzclose +-# define gzclose_r z_gzclose_r +-# define gzclose_w z_gzclose_w +-# define gzdirect z_gzdirect +-# define gzdopen z_gzdopen +-# define gzeof z_gzeof +-# define gzerror z_gzerror +-# define gzflush z_gzflush +-# define gzgetc z_gzgetc +-# define gzgets z_gzgets +-# define gzoffset z_gzoffset +-# define gzoffset64 z_gzoffset64 +-# define gzopen z_gzopen +-# define gzopen64 z_gzopen64 +-# define gzprintf z_gzprintf +-# define gzputc z_gzputc +-# define gzputs z_gzputs +-# define gzread z_gzread +-# define gzrewind z_gzrewind +-# define gzseek z_gzseek +-# define gzseek64 z_gzseek64 +-# define gzsetparams z_gzsetparams +-# define gztell z_gztell +-# define gztell64 z_gztell64 +-# define gzungetc z_gzungetc +-# define gzwrite z_gzwrite +-# define inflate z_inflate +-# define inflateBack z_inflateBack +-# define inflateBackEnd z_inflateBackEnd +-# define inflateBackInit_ z_inflateBackInit_ +-# define inflateCopy z_inflateCopy +-# define inflateEnd z_inflateEnd +-# define inflateGetHeader z_inflateGetHeader +-# define inflateInit2_ z_inflateInit2_ +-# define inflateInit_ z_inflateInit_ +-# define inflateMark z_inflateMark +-# define inflatePrime z_inflatePrime +-# define inflateReset z_inflateReset +-# define inflateReset2 z_inflateReset2 +-# define inflateSetDictionary z_inflateSetDictionary +-# define inflateSync z_inflateSync +-# define inflateSyncPoint z_inflateSyncPoint +-# define inflateUndermine z_inflateUndermine +-# define inflate_copyright z_inflate_copyright +-# define inflate_fast z_inflate_fast +-# define inflate_table z_inflate_table +-# define uncompress z_uncompress +-# define zError z_zError +-# define zcalloc z_zcalloc +-# define zcfree z_zcfree +-# define zlibCompileFlags z_zlibCompileFlags +-# define zlibVersion z_zlibVersion +- +-/* all zlib typedefs in zlib.h and zconf.h */ +-# define Byte z_Byte +-# define Bytef z_Bytef +-# define alloc_func z_alloc_func +-# define charf z_charf +-# define free_func z_free_func +-# define gzFile z_gzFile +-# define gz_header z_gz_header +-# define gz_headerp z_gz_headerp +-# define in_func z_in_func +-# define intf z_intf +-# define out_func z_out_func +-# define uInt z_uInt +-# define uIntf z_uIntf +-# define uLong z_uLong +-# define uLongf z_uLongf +-# define voidp z_voidp +-# define voidpc z_voidpc +-# define voidpf z_voidpf +- +-/* all zlib structs in zlib.h and zconf.h */ +-# define gz_header_s z_gz_header_s +-# define internal_state z_internal_state +- +-#endif +- +-#if defined(__MSDOS__) && !defined(MSDOS) +-# define MSDOS +-#endif +-#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) +-# define OS2 +-#endif +-#if defined(_WINDOWS) && !defined(WINDOWS) +-# define WINDOWS +-#endif +-#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) +-# ifndef WIN32 +-# define WIN32 +-# endif +-#endif +-#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) +-# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +-# ifndef SYS16BIT +-# define SYS16BIT +-# endif +-# endif +-#endif +- +-/* +- * Compile with -DMAXSEG_64K if the alloc function cannot allocate more +- * than 64k bytes at a time (needed on systems with 16-bit int). +- */ +-#ifdef SYS16BIT +-# define MAXSEG_64K +-#endif +-#ifdef MSDOS +-# define UNALIGNED_OK +-#endif +- +-#ifdef __STDC_VERSION__ +-# ifndef STDC +-# define STDC +-# endif +-# if __STDC_VERSION__ >= 199901L +-# ifndef STDC99 +-# define STDC99 +-# endif +-# endif +-#endif +-#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) +-# define STDC +-#endif +-#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) +-# define STDC +-#endif +-#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) +-# define STDC +-#endif +-#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) +-# define STDC +-#endif +- +-#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +-# define STDC +-#endif +- +-#ifndef STDC +-# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +-# define const /* note: need a more gentle solution here */ +-# endif +-#endif +- +-/* Some Mac compilers merge all .h files incorrectly: */ +-#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +-# define NO_DUMMY_DECL +-#endif +- +-/* Maximum value for memLevel in deflateInit2 */ +-#ifndef MAX_MEM_LEVEL +-# ifdef MAXSEG_64K +-# define MAX_MEM_LEVEL 8 +-# else +-# define MAX_MEM_LEVEL 9 +-# endif +-#endif +- +-/* Maximum value for windowBits in deflateInit2 and inflateInit2. +- * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files +- * created by gzip. (Files created by minigzip can still be extracted by +- * gzip.) +- */ +-#ifndef MAX_WBITS +-# define MAX_WBITS 15 /* 32K LZ77 window */ +-#endif +- +-/* The memory requirements for deflate are (in bytes): +- (1 << (windowBits+2)) + (1 << (memLevel+9)) +- that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) +- plus a few kilobytes for small objects. For example, if you want to reduce +- the default memory requirements from 256K to 128K, compile with +- make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" +- Of course this will generally degrade compression (there's no free lunch). +- +- The memory requirements for inflate are (in bytes) 1 << windowBits +- that is, 32K for windowBits=15 (default value) plus a few kilobytes +- for small objects. +-*/ +- +- /* Type declarations */ +- +-#ifndef OF /* function prototypes */ +-# ifdef STDC +-# define OF(args) args +-# else +-# define OF(args) () +-# endif +-#endif +- +-/* The following definitions for FAR are needed only for MSDOS mixed +- * model programming (small or medium model with some far allocations). +- * This was tested only with MSC; for other MSDOS compilers you may have +- * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, +- * just define FAR to be empty. +- */ +-#ifdef SYS16BIT +-# if defined(M_I86SM) || defined(M_I86MM) +- /* MSC small or medium model */ +-# define SMALL_MEDIUM +-# ifdef _MSC_VER +-# define FAR _far +-# else +-# define FAR far +-# endif +-# endif +-# if (defined(__SMALL__) || defined(__MEDIUM__)) +- /* Turbo C small or medium model */ +-# define SMALL_MEDIUM +-# ifdef __BORLANDC__ +-# define FAR _far +-# else +-# define FAR far +-# endif +-# endif +-#endif +- +-#if defined(WINDOWS) || defined(WIN32) +- /* If building or using zlib as a DLL, define ZLIB_DLL. +- * This is not mandatory, but it offers a little performance increase. +- */ +-# ifdef ZLIB_DLL +-# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +-# ifdef ZLIB_INTERNAL +-# define ZEXTERN extern __declspec(dllexport) +-# else +-# define ZEXTERN extern __declspec(dllimport) +-# endif +-# endif +-# endif /* ZLIB_DLL */ +- /* If building or using zlib with the WINAPI/WINAPIV calling convention, +- * define ZLIB_WINAPI. +- * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. +- */ +-# ifdef ZLIB_WINAPI +-# ifdef FAR +-# undef FAR +-# endif +-# include +- /* No need for _export, use ZLIB.DEF instead. */ +- /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +-# define ZEXPORT WINAPI +-# ifdef WIN32 +-# define ZEXPORTVA WINAPIV +-# else +-# define ZEXPORTVA FAR CDECL +-# endif +-# endif +-#endif +- +-#if defined (__BEOS__) +-# ifdef ZLIB_DLL +-# ifdef ZLIB_INTERNAL +-# define ZEXPORT __declspec(dllexport) +-# define ZEXPORTVA __declspec(dllexport) +-# else +-# define ZEXPORT __declspec(dllimport) +-# define ZEXPORTVA __declspec(dllimport) +-# endif +-# endif +-#endif +- +-#ifndef ZEXTERN +-# define ZEXTERN extern +-#endif +-#ifndef ZEXPORT +-# define ZEXPORT +-#endif +-#ifndef ZEXPORTVA +-# define ZEXPORTVA +-#endif +- +-#ifndef FAR +-# define FAR +-#endif +- +-#if !defined(__MACTYPES__) +-typedef unsigned char Byte; /* 8 bits */ +-#endif +-typedef unsigned int uInt; /* 16 bits or more */ +-typedef unsigned long uLong; /* 32 bits or more */ +- +-#ifdef SMALL_MEDIUM +- /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +-# define Bytef Byte FAR +-#else +- typedef Byte FAR Bytef; +-#endif +-typedef char FAR charf; +-typedef int FAR intf; +-typedef uInt FAR uIntf; +-typedef uLong FAR uLongf; +- +-#ifdef STDC +- typedef void const *voidpc; +- typedef void FAR *voidpf; +- typedef void *voidp; +-#else +- typedef Byte const *voidpc; +- typedef Byte FAR *voidpf; +- typedef Byte *voidp; +-#endif +- +-#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ +-# define Z_HAVE_UNISTD_H +-#endif +- +-#ifdef STDC +-# include /* for off_t */ +-#endif +- +-/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and +- * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even +- * though the former does not conform to the LFS document), but considering +- * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as +- * equivalently requesting no 64-bit operations +- */ +-#if -_LARGEFILE64_SOURCE - -1 == 1 +-# undef _LARGEFILE64_SOURCE +-#endif +- +-#if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) +-# include /* for SEEK_* and off_t */ +-# ifdef VMS +-# include /* for off_t */ +-# endif +-# ifndef z_off_t +-# define z_off_t off_t +-# endif +-#endif +- +-#ifndef SEEK_SET +-# define SEEK_SET 0 /* Seek from beginning of file. */ +-# define SEEK_CUR 1 /* Seek from current position. */ +-# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +-#endif +- +-#ifndef z_off_t +-# define z_off_t long +-#endif +- +-#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 +-# define z_off64_t off64_t +-#else +-# define z_off64_t z_off_t +-#endif +- +-#if defined(__OS400__) +-# define NO_vsnprintf +-#endif +- +-#if defined(__MVS__) +-# define NO_vsnprintf +-#endif +- +-/* MVS linker does not support external names larger than 8 bytes */ +-#if defined(__MVS__) +- #pragma map(deflateInit_,"DEIN") +- #pragma map(deflateInit2_,"DEIN2") +- #pragma map(deflateEnd,"DEEND") +- #pragma map(deflateBound,"DEBND") +- #pragma map(inflateInit_,"ININ") +- #pragma map(inflateInit2_,"ININ2") +- #pragma map(inflateEnd,"INEND") +- #pragma map(inflateSync,"INSY") +- #pragma map(inflateSetDictionary,"INSEDI") +- #pragma map(compressBound,"CMBND") +- #pragma map(inflate_table,"INTABL") +- #pragma map(inflate_fast,"INFA") +- #pragma map(inflate_copyright,"INCOPY") +-#endif +- +-#endif /* ZCONF_H */ +diff --git a/thirdparty/zlib/zconf.in.h b/thirdparty/zlib/zconf.in.h +deleted file mode 100644 +index 03a9431..0000000 +--- a/thirdparty/zlib/zconf.in.h ++++ /dev/null +@@ -1,332 +0,0 @@ +-/* zconf.h -- configuration of the zlib compression library +- * Copyright (C) 1995-2005 Jean-loup Gailly. +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* @(#) $Id$ */ +- +-#ifndef ZCONF_H +-#define ZCONF_H +- +-/* +- * If you *really* need a unique prefix for all types and library functions, +- * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. +- */ +-#ifdef Z_PREFIX +-# define deflateInit_ z_deflateInit_ +-# define deflate z_deflate +-# define deflateEnd z_deflateEnd +-# define inflateInit_ z_inflateInit_ +-# define inflate z_inflate +-# define inflateEnd z_inflateEnd +-# define deflateInit2_ z_deflateInit2_ +-# define deflateSetDictionary z_deflateSetDictionary +-# define deflateCopy z_deflateCopy +-# define deflateReset z_deflateReset +-# define deflateParams z_deflateParams +-# define deflateBound z_deflateBound +-# define deflatePrime z_deflatePrime +-# define inflateInit2_ z_inflateInit2_ +-# define inflateSetDictionary z_inflateSetDictionary +-# define inflateSync z_inflateSync +-# define inflateSyncPoint z_inflateSyncPoint +-# define inflateCopy z_inflateCopy +-# define inflateReset z_inflateReset +-# define inflateBack z_inflateBack +-# define inflateBackEnd z_inflateBackEnd +-# define compress z_compress +-# define compress2 z_compress2 +-# define compressBound z_compressBound +-# define uncompress z_uncompress +-# define adler32 z_adler32 +-# define crc32 z_crc32 +-# define get_crc_table z_get_crc_table +-# define zError z_zError +- +-# define alloc_func z_alloc_func +-# define free_func z_free_func +-# define in_func z_in_func +-# define out_func z_out_func +-# define Byte z_Byte +-# define uInt z_uInt +-# define uLong z_uLong +-# define Bytef z_Bytef +-# define charf z_charf +-# define intf z_intf +-# define uIntf z_uIntf +-# define uLongf z_uLongf +-# define voidpf z_voidpf +-# define voidp z_voidp +-#endif +- +-#if defined(__MSDOS__) && !defined(MSDOS) +-# define MSDOS +-#endif +-#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) +-# define OS2 +-#endif +-#if defined(_WINDOWS) && !defined(WINDOWS) +-# define WINDOWS +-#endif +-#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) +-# ifndef WIN32 +-# define WIN32 +-# endif +-#endif +-#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) +-# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +-# ifndef SYS16BIT +-# define SYS16BIT +-# endif +-# endif +-#endif +- +-/* +- * Compile with -DMAXSEG_64K if the alloc function cannot allocate more +- * than 64k bytes at a time (needed on systems with 16-bit int). +- */ +-#ifdef SYS16BIT +-# define MAXSEG_64K +-#endif +-#ifdef MSDOS +-# define UNALIGNED_OK +-#endif +- +-#ifdef __STDC_VERSION__ +-# ifndef STDC +-# define STDC +-# endif +-# if __STDC_VERSION__ >= 199901L +-# ifndef STDC99 +-# define STDC99 +-# endif +-# endif +-#endif +-#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) +-# define STDC +-#endif +-#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) +-# define STDC +-#endif +-#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) +-# define STDC +-#endif +-#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) +-# define STDC +-#endif +- +-#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +-# define STDC +-#endif +- +-#ifndef STDC +-# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +-# define const /* note: need a more gentle solution here */ +-# endif +-#endif +- +-/* Some Mac compilers merge all .h files incorrectly: */ +-#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +-# define NO_DUMMY_DECL +-#endif +- +-/* Maximum value for memLevel in deflateInit2 */ +-#ifndef MAX_MEM_LEVEL +-# ifdef MAXSEG_64K +-# define MAX_MEM_LEVEL 8 +-# else +-# define MAX_MEM_LEVEL 9 +-# endif +-#endif +- +-/* Maximum value for windowBits in deflateInit2 and inflateInit2. +- * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files +- * created by gzip. (Files created by minigzip can still be extracted by +- * gzip.) +- */ +-#ifndef MAX_WBITS +-# define MAX_WBITS 15 /* 32K LZ77 window */ +-#endif +- +-/* The memory requirements for deflate are (in bytes): +- (1 << (windowBits+2)) + (1 << (memLevel+9)) +- that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) +- plus a few kilobytes for small objects. For example, if you want to reduce +- the default memory requirements from 256K to 128K, compile with +- make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" +- Of course this will generally degrade compression (there's no free lunch). +- +- The memory requirements for inflate are (in bytes) 1 << windowBits +- that is, 32K for windowBits=15 (default value) plus a few kilobytes +- for small objects. +-*/ +- +- /* Type declarations */ +- +-#ifndef OF /* function prototypes */ +-# ifdef STDC +-# define OF(args) args +-# else +-# define OF(args) () +-# endif +-#endif +- +-/* The following definitions for FAR are needed only for MSDOS mixed +- * model programming (small or medium model with some far allocations). +- * This was tested only with MSC; for other MSDOS compilers you may have +- * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, +- * just define FAR to be empty. +- */ +-#ifdef SYS16BIT +-# if defined(M_I86SM) || defined(M_I86MM) +- /* MSC small or medium model */ +-# define SMALL_MEDIUM +-# ifdef _MSC_VER +-# define FAR _far +-# else +-# define FAR far +-# endif +-# endif +-# if (defined(__SMALL__) || defined(__MEDIUM__)) +- /* Turbo C small or medium model */ +-# define SMALL_MEDIUM +-# ifdef __BORLANDC__ +-# define FAR _far +-# else +-# define FAR far +-# endif +-# endif +-#endif +- +-#if defined(WINDOWS) || defined(WIN32) +- /* If building or using zlib as a DLL, define ZLIB_DLL. +- * This is not mandatory, but it offers a little performance increase. +- */ +-# ifdef ZLIB_DLL +-# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +-# ifdef ZLIB_INTERNAL +-# define ZEXTERN extern __declspec(dllexport) +-# else +-# define ZEXTERN extern __declspec(dllimport) +-# endif +-# endif +-# endif /* ZLIB_DLL */ +- /* If building or using zlib with the WINAPI/WINAPIV calling convention, +- * define ZLIB_WINAPI. +- * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. +- */ +-# ifdef ZLIB_WINAPI +-# ifdef FAR +-# undef FAR +-# endif +-# include +- /* No need for _export, use ZLIB.DEF instead. */ +- /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +-# define ZEXPORT WINAPI +-# ifdef WIN32 +-# define ZEXPORTVA WINAPIV +-# else +-# define ZEXPORTVA FAR CDECL +-# endif +-# endif +-#endif +- +-#if defined (__BEOS__) +-# ifdef ZLIB_DLL +-# ifdef ZLIB_INTERNAL +-# define ZEXPORT __declspec(dllexport) +-# define ZEXPORTVA __declspec(dllexport) +-# else +-# define ZEXPORT __declspec(dllimport) +-# define ZEXPORTVA __declspec(dllimport) +-# endif +-# endif +-#endif +- +-#ifndef ZEXTERN +-# define ZEXTERN extern +-#endif +-#ifndef ZEXPORT +-# define ZEXPORT +-#endif +-#ifndef ZEXPORTVA +-# define ZEXPORTVA +-#endif +- +-#ifndef FAR +-# define FAR +-#endif +- +-#if !defined(__MACTYPES__) +-typedef unsigned char Byte; /* 8 bits */ +-#endif +-typedef unsigned int uInt; /* 16 bits or more */ +-typedef unsigned long uLong; /* 32 bits or more */ +- +-#ifdef SMALL_MEDIUM +- /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +-# define Bytef Byte FAR +-#else +- typedef Byte FAR Bytef; +-#endif +-typedef char FAR charf; +-typedef int FAR intf; +-typedef uInt FAR uIntf; +-typedef uLong FAR uLongf; +- +-#ifdef STDC +- typedef void const *voidpc; +- typedef void FAR *voidpf; +- typedef void *voidp; +-#else +- typedef Byte const *voidpc; +- typedef Byte FAR *voidpf; +- typedef Byte *voidp; +-#endif +- +-#if 0 /* HAVE_UNISTD_H -- this line is updated by ./configure */ +-# include /* for off_t */ +-# include /* for SEEK_* and off_t */ +-# ifdef VMS +-# include /* for off_t */ +-# endif +-# define z_off_t off_t +-#endif +-#ifndef SEEK_SET +-# define SEEK_SET 0 /* Seek from beginning of file. */ +-# define SEEK_CUR 1 /* Seek from current position. */ +-# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +-#endif +-#ifndef z_off_t +-# define z_off_t long +-#endif +- +-#if defined(__OS400__) +-# define NO_vsnprintf +-#endif +- +-#if defined(__MVS__) +-# define NO_vsnprintf +-# ifdef FAR +-# undef FAR +-# endif +-#endif +- +-/* MVS linker does not support external names larger than 8 bytes */ +-#if defined(__MVS__) +-# pragma map(deflateInit_,"DEIN") +-# pragma map(deflateInit2_,"DEIN2") +-# pragma map(deflateEnd,"DEEND") +-# pragma map(deflateBound,"DEBND") +-# pragma map(inflateInit_,"ININ") +-# pragma map(inflateInit2_,"ININ2") +-# pragma map(inflateEnd,"INEND") +-# pragma map(inflateSync,"INSY") +-# pragma map(inflateSetDictionary,"INSEDI") +-# pragma map(compressBound,"CMBND") +-# pragma map(inflate_table,"INTABL") +-# pragma map(inflate_fast,"INFA") +-# pragma map(inflate_copyright,"INCOPY") +-#endif +- +-#endif /* ZCONF_H */ +diff --git a/thirdparty/zlib/zlib.h b/thirdparty/zlib/zlib.h +deleted file mode 100644 +index bfbba83..0000000 +--- a/thirdparty/zlib/zlib.h ++++ /dev/null +@@ -1,1613 +0,0 @@ +-/* zlib.h -- interface of the 'zlib' general purpose compression library +- version 1.2.5, April 19th, 2010 +- +- Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler +- +- This software is provided 'as-is', without any express or implied +- warranty. In no event will the authors be held liable for any damages +- arising from the use of this software. +- +- Permission is granted to anyone to use this software for any purpose, +- including commercial applications, and to alter it and redistribute it +- freely, subject to the following restrictions: +- +- 1. The origin of this software must not be misrepresented; you must not +- claim that you wrote the original software. If you use this software +- in a product, an acknowledgment in the product documentation would be +- appreciated but is not required. +- 2. Altered source versions must be plainly marked as such, and must not be +- misrepresented as being the original software. +- 3. This notice may not be removed or altered from any source distribution. +- +- Jean-loup Gailly Mark Adler +- jloup@gzip.org madler@alumni.caltech.edu +- +- +- The data format used by the zlib library is described by RFCs (Request for +- Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt +- (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). +-*/ +- +-#ifndef ZLIB_H +-#define ZLIB_H +- +-#include "zconf.h" +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-#define ZLIB_VERSION "1.2.5" +-#define ZLIB_VERNUM 0x1250 +-#define ZLIB_VER_MAJOR 1 +-#define ZLIB_VER_MINOR 2 +-#define ZLIB_VER_REVISION 5 +-#define ZLIB_VER_SUBREVISION 0 +- +-/* +- The 'zlib' compression library provides in-memory compression and +- decompression functions, including integrity checks of the uncompressed data. +- This version of the library supports only one compression method (deflation) +- but other algorithms will be added later and will have the same stream +- interface. +- +- Compression can be done in a single step if the buffers are large enough, +- or can be done by repeated calls of the compression function. In the latter +- case, the application must provide more input and/or consume the output +- (providing more output space) before each call. +- +- The compressed data format used by default by the in-memory functions is +- the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped +- around a deflate stream, which is itself documented in RFC 1951. +- +- The library also supports reading and writing files in gzip (.gz) format +- with an interface similar to that of stdio using the functions that start +- with "gz". The gzip format is different from the zlib format. gzip is a +- gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. +- +- This library can optionally read and write gzip streams in memory as well. +- +- The zlib format was designed to be compact and fast for use in memory +- and on communications channels. The gzip format was designed for single- +- file compression on file systems, has a larger header than zlib to maintain +- directory information, and uses a different, slower check method than zlib. +- +- The library does not install any signal handler. The decoder checks +- the consistency of the compressed data, so the library should never crash +- even in case of corrupted input. +-*/ +- +-typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +-typedef void (*free_func) OF((voidpf opaque, voidpf address)); +- +-struct internal_state; +- +-typedef struct z_stream_s { +- Bytef *next_in; /* next input byte */ +- uInt avail_in; /* number of bytes available at next_in */ +- uLong total_in; /* total nb of input bytes read so far */ +- +- Bytef *next_out; /* next output byte should be put there */ +- uInt avail_out; /* remaining free space at next_out */ +- uLong total_out; /* total nb of bytes output so far */ +- +- char *msg; /* last error message, NULL if no error */ +- struct internal_state FAR *state; /* not visible by applications */ +- +- alloc_func zalloc; /* used to allocate the internal state */ +- free_func zfree; /* used to free the internal state */ +- voidpf opaque; /* private data object passed to zalloc and zfree */ +- +- int data_type; /* best guess about the data type: binary or text */ +- uLong adler; /* adler32 value of the uncompressed data */ +- uLong reserved; /* reserved for future use */ +-} z_stream; +- +-typedef z_stream FAR *z_streamp; +- +-/* +- gzip header information passed to and from zlib routines. See RFC 1952 +- for more details on the meanings of these fields. +-*/ +-typedef struct gz_header_s { +- int text; /* true if compressed data believed to be text */ +- uLong time; /* modification time */ +- int xflags; /* extra flags (not used when writing a gzip file) */ +- int os; /* operating system */ +- Bytef *extra; /* pointer to extra field or Z_NULL if none */ +- uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ +- uInt extra_max; /* space at extra (only when reading header) */ +- Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ +- uInt name_max; /* space at name (only when reading header) */ +- Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ +- uInt comm_max; /* space at comment (only when reading header) */ +- int hcrc; /* true if there was or will be a header crc */ +- int done; /* true when done reading gzip header (not used +- when writing a gzip file) */ +-} gz_header; +- +-typedef gz_header FAR *gz_headerp; +- +-/* +- The application must update next_in and avail_in when avail_in has dropped +- to zero. It must update next_out and avail_out when avail_out has dropped +- to zero. The application must initialize zalloc, zfree and opaque before +- calling the init function. All other fields are set by the compression +- library and must not be updated by the application. +- +- The opaque value provided by the application will be passed as the first +- parameter for calls of zalloc and zfree. This can be useful for custom +- memory management. The compression library attaches no meaning to the +- opaque value. +- +- zalloc must return Z_NULL if there is not enough memory for the object. +- If zlib is used in a multi-threaded application, zalloc and zfree must be +- thread safe. +- +- On 16-bit systems, the functions zalloc and zfree must be able to allocate +- exactly 65536 bytes, but will not be required to allocate more than this if +- the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, pointers +- returned by zalloc for objects of exactly 65536 bytes *must* have their +- offset normalized to zero. The default allocation function provided by this +- library ensures this (see zutil.c). To reduce memory requirements and avoid +- any allocation of 64K objects, at the expense of compression ratio, compile +- the library with -DMAX_WBITS=14 (see zconf.h). +- +- The fields total_in and total_out can be used for statistics or progress +- reports. After compression, total_in holds the total size of the +- uncompressed data and may be saved for use in the decompressor (particularly +- if the decompressor wants to decompress everything in a single step). +-*/ +- +- /* constants */ +- +-#define Z_NO_FLUSH 0 +-#define Z_PARTIAL_FLUSH 1 +-#define Z_SYNC_FLUSH 2 +-#define Z_FULL_FLUSH 3 +-#define Z_FINISH 4 +-#define Z_BLOCK 5 +-#define Z_TREES 6 +-/* Allowed flush values; see deflate() and inflate() below for details */ +- +-#define Z_OK 0 +-#define Z_STREAM_END 1 +-#define Z_NEED_DICT 2 +-#define Z_ERRNO (-1) +-#define Z_STREAM_ERROR (-2) +-#define Z_DATA_ERROR (-3) +-#define Z_MEM_ERROR (-4) +-#define Z_BUF_ERROR (-5) +-#define Z_VERSION_ERROR (-6) +-/* Return codes for the compression/decompression functions. Negative values +- * are errors, positive values are used for special but normal events. +- */ +- +-#define Z_NO_COMPRESSION 0 +-#define Z_BEST_SPEED 1 +-#define Z_BEST_COMPRESSION 9 +-#define Z_DEFAULT_COMPRESSION (-1) +-/* compression levels */ +- +-#define Z_FILTERED 1 +-#define Z_HUFFMAN_ONLY 2 +-#define Z_RLE 3 +-#define Z_FIXED 4 +-#define Z_DEFAULT_STRATEGY 0 +-/* compression strategy; see deflateInit2() below for details */ +- +-#define Z_BINARY 0 +-#define Z_TEXT 1 +-#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ +-#define Z_UNKNOWN 2 +-/* Possible values of the data_type field (though see inflate()) */ +- +-#define Z_DEFLATED 8 +-/* The deflate compression method (the only one supported in this version) */ +- +-#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ +- +-#define zlib_version zlibVersion() +-/* for compatibility with versions < 1.0.2 */ +- +- +- /* basic functions */ +- +-ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +-/* The application can compare zlibVersion and ZLIB_VERSION for consistency. +- If the first character differs, the library code actually used is not +- compatible with the zlib.h header file used by the application. This check +- is automatically made by deflateInit and inflateInit. +- */ +- +-/* +-ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); +- +- Initializes the internal stream state for compression. The fields +- zalloc, zfree and opaque must be initialized before by the caller. If +- zalloc and zfree are set to Z_NULL, deflateInit updates them to use default +- allocation functions. +- +- The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: +- 1 gives best speed, 9 gives best compression, 0 gives no compression at all +- (the input data is simply copied a block at a time). Z_DEFAULT_COMPRESSION +- requests a default compromise between speed and compression (currently +- equivalent to level 6). +- +- deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough +- memory, Z_STREAM_ERROR if level is not a valid compression level, or +- Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible +- with the version assumed by the caller (ZLIB_VERSION). msg is set to null +- if there is no error message. deflateInit does not perform any compression: +- this will be done by deflate(). +-*/ +- +- +-ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +-/* +- deflate compresses as much data as possible, and stops when the input +- buffer becomes empty or the output buffer becomes full. It may introduce +- some output latency (reading input without producing any output) except when +- forced to flush. +- +- The detailed semantics are as follows. deflate performs one or both of the +- following actions: +- +- - Compress more input starting at next_in and update next_in and avail_in +- accordingly. If not all input can be processed (because there is not +- enough room in the output buffer), next_in and avail_in are updated and +- processing will resume at this point for the next call of deflate(). +- +- - Provide more output starting at next_out and update next_out and avail_out +- accordingly. This action is forced if the parameter flush is non zero. +- Forcing flush frequently degrades the compression ratio, so this parameter +- should be set only when necessary (in interactive applications). Some +- output may be provided even if flush is not set. +- +- Before the call of deflate(), the application should ensure that at least +- one of the actions is possible, by providing more input and/or consuming more +- output, and updating avail_in or avail_out accordingly; avail_out should +- never be zero before the call. The application can consume the compressed +- output when it wants, for example when the output buffer is full (avail_out +- == 0), or after each call of deflate(). If deflate returns Z_OK and with +- zero avail_out, it must be called again after making room in the output +- buffer because there might be more output pending. +- +- Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to +- decide how much data to accumulate before producing output, in order to +- maximize compression. +- +- If the parameter flush is set to Z_SYNC_FLUSH, all pending output is +- flushed to the output buffer and the output is aligned on a byte boundary, so +- that the decompressor can get all input data available so far. (In +- particular avail_in is zero after the call if enough output space has been +- provided before the call.) Flushing may degrade compression for some +- compression algorithms and so it should be used only when necessary. This +- completes the current deflate block and follows it with an empty stored block +- that is three bits plus filler bits to the next byte, followed by four bytes +- (00 00 ff ff). +- +- If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the +- output buffer, but the output is not aligned to a byte boundary. All of the +- input data so far will be available to the decompressor, as for Z_SYNC_FLUSH. +- This completes the current deflate block and follows it with an empty fixed +- codes block that is 10 bits long. This assures that enough bytes are output +- in order for the decompressor to finish the block before the empty fixed code +- block. +- +- If flush is set to Z_BLOCK, a deflate block is completed and emitted, as +- for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to +- seven bits of the current block are held to be written as the next byte after +- the next deflate block is completed. In this case, the decompressor may not +- be provided enough bits at this point in order to complete decompression of +- the data provided so far to the compressor. It may need to wait for the next +- block to be emitted. This is for advanced applications that need to control +- the emission of deflate blocks. +- +- If flush is set to Z_FULL_FLUSH, all output is flushed as with +- Z_SYNC_FLUSH, and the compression state is reset so that decompression can +- restart from this point if previous compressed data has been damaged or if +- random access is desired. Using Z_FULL_FLUSH too often can seriously degrade +- compression. +- +- If deflate returns with avail_out == 0, this function must be called again +- with the same value of the flush parameter and more output space (updated +- avail_out), until the flush is complete (deflate returns with non-zero +- avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that +- avail_out is greater than six to avoid repeated flush markers due to +- avail_out == 0 on return. +- +- If the parameter flush is set to Z_FINISH, pending input is processed, +- pending output is flushed and deflate returns with Z_STREAM_END if there was +- enough output space; if deflate returns with Z_OK, this function must be +- called again with Z_FINISH and more output space (updated avail_out) but no +- more input data, until it returns with Z_STREAM_END or an error. After +- deflate has returned Z_STREAM_END, the only possible operations on the stream +- are deflateReset or deflateEnd. +- +- Z_FINISH can be used immediately after deflateInit if all the compression +- is to be done in a single step. In this case, avail_out must be at least the +- value returned by deflateBound (see below). If deflate does not return +- Z_STREAM_END, then it must be called again as described above. +- +- deflate() sets strm->adler to the adler32 checksum of all input read +- so far (that is, total_in bytes). +- +- deflate() may update strm->data_type if it can make a good guess about +- the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered +- binary. This field is only for information purposes and does not affect the +- compression algorithm in any manner. +- +- deflate() returns Z_OK if some progress has been made (more input +- processed or more output produced), Z_STREAM_END if all input has been +- consumed and all output has been produced (only when flush is set to +- Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example +- if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible +- (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not +- fatal, and deflate() can be called again with more input and more output +- space to continue compressing. +-*/ +- +- +-ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); +-/* +- All dynamically allocated data structures for this stream are freed. +- This function discards any unprocessed input and does not flush any pending +- output. +- +- deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the +- stream state was inconsistent, Z_DATA_ERROR if the stream was freed +- prematurely (some input or output was discarded). In the error case, msg +- may be set but then points to a static string (which must not be +- deallocated). +-*/ +- +- +-/* +-ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); +- +- Initializes the internal stream state for decompression. The fields +- next_in, avail_in, zalloc, zfree and opaque must be initialized before by +- the caller. If next_in is not Z_NULL and avail_in is large enough (the +- exact value depends on the compression method), inflateInit determines the +- compression method from the zlib header and allocates all data structures +- accordingly; otherwise the allocation will be deferred to the first call of +- inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to +- use default allocation functions. +- +- inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough +- memory, Z_VERSION_ERROR if the zlib library version is incompatible with the +- version assumed by the caller, or Z_STREAM_ERROR if the parameters are +- invalid, such as a null pointer to the structure. msg is set to null if +- there is no error message. inflateInit does not perform any decompression +- apart from possibly reading the zlib header if present: actual decompression +- will be done by inflate(). (So next_in and avail_in may be modified, but +- next_out and avail_out are unused and unchanged.) The current implementation +- of inflateInit() does not process any header information -- that is deferred +- until inflate() is called. +-*/ +- +- +-ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); +-/* +- inflate decompresses as much data as possible, and stops when the input +- buffer becomes empty or the output buffer becomes full. It may introduce +- some output latency (reading input without producing any output) except when +- forced to flush. +- +- The detailed semantics are as follows. inflate performs one or both of the +- following actions: +- +- - Decompress more input starting at next_in and update next_in and avail_in +- accordingly. If not all input can be processed (because there is not +- enough room in the output buffer), next_in is updated and processing will +- resume at this point for the next call of inflate(). +- +- - Provide more output starting at next_out and update next_out and avail_out +- accordingly. inflate() provides as much output as possible, until there is +- no more input data or no more space in the output buffer (see below about +- the flush parameter). +- +- Before the call of inflate(), the application should ensure that at least +- one of the actions is possible, by providing more input and/or consuming more +- output, and updating the next_* and avail_* values accordingly. The +- application can consume the uncompressed output when it wants, for example +- when the output buffer is full (avail_out == 0), or after each call of +- inflate(). If inflate returns Z_OK and with zero avail_out, it must be +- called again after making room in the output buffer because there might be +- more output pending. +- +- The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH, +- Z_BLOCK, or Z_TREES. Z_SYNC_FLUSH requests that inflate() flush as much +- output as possible to the output buffer. Z_BLOCK requests that inflate() +- stop if and when it gets to the next deflate block boundary. When decoding +- the zlib or gzip format, this will cause inflate() to return immediately +- after the header and before the first block. When doing a raw inflate, +- inflate() will go ahead and process the first block, and will return when it +- gets to the end of that block, or when it runs out of data. +- +- The Z_BLOCK option assists in appending to or combining deflate streams. +- Also to assist in this, on return inflate() will set strm->data_type to the +- number of unused bits in the last byte taken from strm->next_in, plus 64 if +- inflate() is currently decoding the last block in the deflate stream, plus +- 128 if inflate() returned immediately after decoding an end-of-block code or +- decoding the complete header up to just before the first byte of the deflate +- stream. The end-of-block will not be indicated until all of the uncompressed +- data from that block has been written to strm->next_out. The number of +- unused bits may in general be greater than seven, except when bit 7 of +- data_type is set, in which case the number of unused bits will be less than +- eight. data_type is set as noted here every time inflate() returns for all +- flush options, and so can be used to determine the amount of currently +- consumed input in bits. +- +- The Z_TREES option behaves as Z_BLOCK does, but it also returns when the +- end of each deflate block header is reached, before any actual data in that +- block is decoded. This allows the caller to determine the length of the +- deflate block header for later use in random access within a deflate block. +- 256 is added to the value of strm->data_type when inflate() returns +- immediately after reaching the end of the deflate block header. +- +- inflate() should normally be called until it returns Z_STREAM_END or an +- error. However if all decompression is to be performed in a single step (a +- single call of inflate), the parameter flush should be set to Z_FINISH. In +- this case all pending input is processed and all pending output is flushed; +- avail_out must be large enough to hold all the uncompressed data. (The size +- of the uncompressed data may have been saved by the compressor for this +- purpose.) The next operation on this stream must be inflateEnd to deallocate +- the decompression state. The use of Z_FINISH is never required, but can be +- used to inform inflate that a faster approach may be used for the single +- inflate() call. +- +- In this implementation, inflate() always flushes as much output as +- possible to the output buffer, and always uses the faster approach on the +- first call. So the only effect of the flush parameter in this implementation +- is on the return value of inflate(), as noted below, or when it returns early +- because Z_BLOCK or Z_TREES is used. +- +- If a preset dictionary is needed after this call (see inflateSetDictionary +- below), inflate sets strm->adler to the adler32 checksum of the dictionary +- chosen by the compressor and returns Z_NEED_DICT; otherwise it sets +- strm->adler to the adler32 checksum of all output produced so far (that is, +- total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described +- below. At the end of the stream, inflate() checks that its computed adler32 +- checksum is equal to that saved by the compressor and returns Z_STREAM_END +- only if the checksum is correct. +- +- inflate() can decompress and check either zlib-wrapped or gzip-wrapped +- deflate data. The header type is detected automatically, if requested when +- initializing with inflateInit2(). Any information contained in the gzip +- header is not retained, so applications that need that information should +- instead use raw inflate, see inflateInit2() below, or inflateBack() and +- perform their own processing of the gzip header and trailer. +- +- inflate() returns Z_OK if some progress has been made (more input processed +- or more output produced), Z_STREAM_END if the end of the compressed data has +- been reached and all uncompressed output has been produced, Z_NEED_DICT if a +- preset dictionary is needed at this point, Z_DATA_ERROR if the input data was +- corrupted (input stream not conforming to the zlib format or incorrect check +- value), Z_STREAM_ERROR if the stream structure was inconsistent (for example +- next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory, +- Z_BUF_ERROR if no progress is possible or if there was not enough room in the +- output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and +- inflate() can be called again with more input and more output space to +- continue decompressing. If Z_DATA_ERROR is returned, the application may +- then call inflateSync() to look for a good compression block if a partial +- recovery of the data is desired. +-*/ +- +- +-ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); +-/* +- All dynamically allocated data structures for this stream are freed. +- This function discards any unprocessed input and does not flush any pending +- output. +- +- inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state +- was inconsistent. In the error case, msg may be set but then points to a +- static string (which must not be deallocated). +-*/ +- +- +- /* Advanced functions */ +- +-/* +- The following functions are needed only in some special applications. +-*/ +- +-/* +-ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, +- int level, +- int method, +- int windowBits, +- int memLevel, +- int strategy)); +- +- This is another version of deflateInit with more compression options. The +- fields next_in, zalloc, zfree and opaque must be initialized before by the +- caller. +- +- The method parameter is the compression method. It must be Z_DEFLATED in +- this version of the library. +- +- The windowBits parameter is the base two logarithm of the window size +- (the size of the history buffer). It should be in the range 8..15 for this +- version of the library. Larger values of this parameter result in better +- compression at the expense of memory usage. The default value is 15 if +- deflateInit is used instead. +- +- windowBits can also be -8..-15 for raw deflate. In this case, -windowBits +- determines the window size. deflate() will then generate raw deflate data +- with no zlib header or trailer, and will not compute an adler32 check value. +- +- windowBits can also be greater than 15 for optional gzip encoding. Add +- 16 to windowBits to write a simple gzip header and trailer around the +- compressed data instead of a zlib wrapper. The gzip header will have no +- file name, no extra data, no comment, no modification time (set to zero), no +- header crc, and the operating system will be set to 255 (unknown). If a +- gzip stream is being written, strm->adler is a crc32 instead of an adler32. +- +- The memLevel parameter specifies how much memory should be allocated +- for the internal compression state. memLevel=1 uses minimum memory but is +- slow and reduces compression ratio; memLevel=9 uses maximum memory for +- optimal speed. The default value is 8. See zconf.h for total memory usage +- as a function of windowBits and memLevel. +- +- The strategy parameter is used to tune the compression algorithm. Use the +- value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a +- filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no +- string match), or Z_RLE to limit match distances to one (run-length +- encoding). Filtered data consists mostly of small values with a somewhat +- random distribution. In this case, the compression algorithm is tuned to +- compress them better. The effect of Z_FILTERED is to force more Huffman +- coding and less string matching; it is somewhat intermediate between +- Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as +- fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data. The +- strategy parameter only affects the compression ratio but not the +- correctness of the compressed output even if it is not set appropriately. +- Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler +- decoder for special applications. +- +- deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough +- memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid +- method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is +- incompatible with the version assumed by the caller (ZLIB_VERSION). msg is +- set to null if there is no error message. deflateInit2 does not perform any +- compression: this will be done by deflate(). +-*/ +- +-ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, +- const Bytef *dictionary, +- uInt dictLength)); +-/* +- Initializes the compression dictionary from the given byte sequence +- without producing any compressed output. This function must be called +- immediately after deflateInit, deflateInit2 or deflateReset, before any call +- of deflate. The compressor and decompressor must use exactly the same +- dictionary (see inflateSetDictionary). +- +- The dictionary should consist of strings (byte sequences) that are likely +- to be encountered later in the data to be compressed, with the most commonly +- used strings preferably put towards the end of the dictionary. Using a +- dictionary is most useful when the data to be compressed is short and can be +- predicted with good accuracy; the data can then be compressed better than +- with the default empty dictionary. +- +- Depending on the size of the compression data structures selected by +- deflateInit or deflateInit2, a part of the dictionary may in effect be +- discarded, for example if the dictionary is larger than the window size +- provided in deflateInit or deflateInit2. Thus the strings most likely to be +- useful should be put at the end of the dictionary, not at the front. In +- addition, the current implementation of deflate will use at most the window +- size minus 262 bytes of the provided dictionary. +- +- Upon return of this function, strm->adler is set to the adler32 value +- of the dictionary; the decompressor may later use this value to determine +- which dictionary has been used by the compressor. (The adler32 value +- applies to the whole dictionary even if only a subset of the dictionary is +- actually used by the compressor.) If a raw deflate was requested, then the +- adler32 value is not computed and strm->adler is not set. +- +- deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a +- parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is +- inconsistent (for example if deflate has already been called for this stream +- or if the compression method is bsort). deflateSetDictionary does not +- perform any compression: this will be done by deflate(). +-*/ +- +-ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, +- z_streamp source)); +-/* +- Sets the destination stream as a complete copy of the source stream. +- +- This function can be useful when several compression strategies will be +- tried, for example when there are several ways of pre-processing the input +- data with a filter. The streams that will be discarded should then be freed +- by calling deflateEnd. Note that deflateCopy duplicates the internal +- compression state which can be quite large, so this strategy is slow and can +- consume lots of memory. +- +- deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not +- enough memory, Z_STREAM_ERROR if the source stream state was inconsistent +- (such as zalloc being Z_NULL). msg is left unchanged in both source and +- destination. +-*/ +- +-ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +-/* +- This function is equivalent to deflateEnd followed by deflateInit, +- but does not free and reallocate all the internal compression state. The +- stream will keep the same compression level and any other attributes that +- may have been set by deflateInit2. +- +- deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source +- stream state was inconsistent (such as zalloc or state being Z_NULL). +-*/ +- +-ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, +- int level, +- int strategy)); +-/* +- Dynamically update the compression level and compression strategy. The +- interpretation of level and strategy is as in deflateInit2. This can be +- used to switch between compression and straight copy of the input data, or +- to switch to a different kind of input data requiring a different strategy. +- If the compression level is changed, the input available so far is +- compressed with the old level (and may be flushed); the new level will take +- effect only at the next call of deflate(). +- +- Before the call of deflateParams, the stream state must be set as for +- a call of deflate(), since the currently available input may have to be +- compressed and flushed. In particular, strm->avail_out must be non-zero. +- +- deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source +- stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if +- strm->avail_out was zero. +-*/ +- +-ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, +- int good_length, +- int max_lazy, +- int nice_length, +- int max_chain)); +-/* +- Fine tune deflate's internal compression parameters. This should only be +- used by someone who understands the algorithm used by zlib's deflate for +- searching for the best matching string, and even then only by the most +- fanatic optimizer trying to squeeze out the last compressed bit for their +- specific input data. Read the deflate.c source code for the meaning of the +- max_lazy, good_length, nice_length, and max_chain parameters. +- +- deflateTune() can be called after deflateInit() or deflateInit2(), and +- returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. +- */ +- +-ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, +- uLong sourceLen)); +-/* +- deflateBound() returns an upper bound on the compressed size after +- deflation of sourceLen bytes. It must be called after deflateInit() or +- deflateInit2(), and after deflateSetHeader(), if used. This would be used +- to allocate an output buffer for deflation in a single pass, and so would be +- called before deflate(). +-*/ +- +-ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, +- int bits, +- int value)); +-/* +- deflatePrime() inserts bits in the deflate output stream. The intent +- is that this function is used to start off the deflate output with the bits +- leftover from a previous deflate stream when appending to it. As such, this +- function can only be used for raw deflate, and must be used before the first +- deflate() call after a deflateInit2() or deflateReset(). bits must be less +- than or equal to 16, and that many of the least significant bits of value +- will be inserted in the output. +- +- deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source +- stream state was inconsistent. +-*/ +- +-ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, +- gz_headerp head)); +-/* +- deflateSetHeader() provides gzip header information for when a gzip +- stream is requested by deflateInit2(). deflateSetHeader() may be called +- after deflateInit2() or deflateReset() and before the first call of +- deflate(). The text, time, os, extra field, name, and comment information +- in the provided gz_header structure are written to the gzip header (xflag is +- ignored -- the extra flags are set according to the compression level). The +- caller must assure that, if not Z_NULL, name and comment are terminated with +- a zero byte, and that if extra is not Z_NULL, that extra_len bytes are +- available there. If hcrc is true, a gzip header crc is included. Note that +- the current versions of the command-line version of gzip (up through version +- 1.3.x) do not support header crc's, and will report that it is a "multi-part +- gzip file" and give up. +- +- If deflateSetHeader is not used, the default gzip header has text false, +- the time set to zero, and os set to 255, with no extra, name, or comment +- fields. The gzip header is returned to the default state by deflateReset(). +- +- deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source +- stream state was inconsistent. +-*/ +- +-/* +-ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, +- int windowBits)); +- +- This is another version of inflateInit with an extra parameter. The +- fields next_in, avail_in, zalloc, zfree and opaque must be initialized +- before by the caller. +- +- The windowBits parameter is the base two logarithm of the maximum window +- size (the size of the history buffer). It should be in the range 8..15 for +- this version of the library. The default value is 15 if inflateInit is used +- instead. windowBits must be greater than or equal to the windowBits value +- provided to deflateInit2() while compressing, or it must be equal to 15 if +- deflateInit2() was not used. If a compressed stream with a larger window +- size is given as input, inflate() will return with the error code +- Z_DATA_ERROR instead of trying to allocate a larger window. +- +- windowBits can also be zero to request that inflate use the window size in +- the zlib header of the compressed stream. +- +- windowBits can also be -8..-15 for raw inflate. In this case, -windowBits +- determines the window size. inflate() will then process raw deflate data, +- not looking for a zlib or gzip header, not generating a check value, and not +- looking for any check values for comparison at the end of the stream. This +- is for use with other formats that use the deflate compressed data format +- such as zip. Those formats provide their own check values. If a custom +- format is developed using the raw deflate format for compressed data, it is +- recommended that a check value such as an adler32 or a crc32 be applied to +- the uncompressed data as is done in the zlib, gzip, and zip formats. For +- most applications, the zlib format should be used as is. Note that comments +- above on the use in deflateInit2() applies to the magnitude of windowBits. +- +- windowBits can also be greater than 15 for optional gzip decoding. Add +- 32 to windowBits to enable zlib and gzip decoding with automatic header +- detection, or add 16 to decode only the gzip format (the zlib format will +- return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a +- crc32 instead of an adler32. +- +- inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough +- memory, Z_VERSION_ERROR if the zlib library version is incompatible with the +- version assumed by the caller, or Z_STREAM_ERROR if the parameters are +- invalid, such as a null pointer to the structure. msg is set to null if +- there is no error message. inflateInit2 does not perform any decompression +- apart from possibly reading the zlib header if present: actual decompression +- will be done by inflate(). (So next_in and avail_in may be modified, but +- next_out and avail_out are unused and unchanged.) The current implementation +- of inflateInit2() does not process any header information -- that is +- deferred until inflate() is called. +-*/ +- +-ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, +- const Bytef *dictionary, +- uInt dictLength)); +-/* +- Initializes the decompression dictionary from the given uncompressed byte +- sequence. This function must be called immediately after a call of inflate, +- if that call returned Z_NEED_DICT. The dictionary chosen by the compressor +- can be determined from the adler32 value returned by that call of inflate. +- The compressor and decompressor must use exactly the same dictionary (see +- deflateSetDictionary). For raw inflate, this function can be called +- immediately after inflateInit2() or inflateReset() and before any call of +- inflate() to set the dictionary. The application must insure that the +- dictionary that was used for compression is provided. +- +- inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a +- parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is +- inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the +- expected one (incorrect adler32 value). inflateSetDictionary does not +- perform any decompression: this will be done by subsequent calls of +- inflate(). +-*/ +- +-ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +-/* +- Skips invalid compressed data until a full flush point (see above the +- description of deflate with Z_FULL_FLUSH) can be found, or until all +- available input is skipped. No output is provided. +- +- inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR +- if no more input was provided, Z_DATA_ERROR if no flush point has been +- found, or Z_STREAM_ERROR if the stream structure was inconsistent. In the +- success case, the application may save the current current value of total_in +- which indicates where valid compressed data was found. In the error case, +- the application may repeatedly call inflateSync, providing more input each +- time, until success or end of the input data. +-*/ +- +-ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, +- z_streamp source)); +-/* +- Sets the destination stream as a complete copy of the source stream. +- +- This function can be useful when randomly accessing a large stream. The +- first pass through the stream can periodically record the inflate state, +- allowing restarting inflate at those points when randomly accessing the +- stream. +- +- inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not +- enough memory, Z_STREAM_ERROR if the source stream state was inconsistent +- (such as zalloc being Z_NULL). msg is left unchanged in both source and +- destination. +-*/ +- +-ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); +-/* +- This function is equivalent to inflateEnd followed by inflateInit, +- but does not free and reallocate all the internal decompression state. The +- stream will keep attributes that may have been set by inflateInit2. +- +- inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source +- stream state was inconsistent (such as zalloc or state being Z_NULL). +-*/ +- +-ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, +- int windowBits)); +-/* +- This function is the same as inflateReset, but it also permits changing +- the wrap and window size requests. The windowBits parameter is interpreted +- the same as it is for inflateInit2. +- +- inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source +- stream state was inconsistent (such as zalloc or state being Z_NULL), or if +- the windowBits parameter is invalid. +-*/ +- +-ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, +- int bits, +- int value)); +-/* +- This function inserts bits in the inflate input stream. The intent is +- that this function is used to start inflating at a bit position in the +- middle of a byte. The provided bits will be used before any bytes are used +- from next_in. This function should only be used with raw inflate, and +- should be used before the first inflate() call after inflateInit2() or +- inflateReset(). bits must be less than or equal to 16, and that many of the +- least significant bits of value will be inserted in the input. +- +- If bits is negative, then the input stream bit buffer is emptied. Then +- inflatePrime() can be called again to put bits in the buffer. This is used +- to clear out bits leftover after feeding inflate a block description prior +- to feeding inflate codes. +- +- inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source +- stream state was inconsistent. +-*/ +- +-ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); +-/* +- This function returns two values, one in the lower 16 bits of the return +- value, and the other in the remaining upper bits, obtained by shifting the +- return value down 16 bits. If the upper value is -1 and the lower value is +- zero, then inflate() is currently decoding information outside of a block. +- If the upper value is -1 and the lower value is non-zero, then inflate is in +- the middle of a stored block, with the lower value equaling the number of +- bytes from the input remaining to copy. If the upper value is not -1, then +- it is the number of bits back from the current bit position in the input of +- the code (literal or length/distance pair) currently being processed. In +- that case the lower value is the number of bytes already emitted for that +- code. +- +- A code is being processed if inflate is waiting for more input to complete +- decoding of the code, or if it has completed decoding but is waiting for +- more output space to write the literal or match data. +- +- inflateMark() is used to mark locations in the input data for random +- access, which may be at bit positions, and to note those cases where the +- output of a code may span boundaries of random access blocks. The current +- location in the input stream can be determined from avail_in and data_type +- as noted in the description for the Z_BLOCK flush parameter for inflate. +- +- inflateMark returns the value noted above or -1 << 16 if the provided +- source stream state was inconsistent. +-*/ +- +-ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, +- gz_headerp head)); +-/* +- inflateGetHeader() requests that gzip header information be stored in the +- provided gz_header structure. inflateGetHeader() may be called after +- inflateInit2() or inflateReset(), and before the first call of inflate(). +- As inflate() processes the gzip stream, head->done is zero until the header +- is completed, at which time head->done is set to one. If a zlib stream is +- being decoded, then head->done is set to -1 to indicate that there will be +- no gzip header information forthcoming. Note that Z_BLOCK or Z_TREES can be +- used to force inflate() to return immediately after header processing is +- complete and before any actual data is decompressed. +- +- The text, time, xflags, and os fields are filled in with the gzip header +- contents. hcrc is set to true if there is a header CRC. (The header CRC +- was valid if done is set to one.) If extra is not Z_NULL, then extra_max +- contains the maximum number of bytes to write to extra. Once done is true, +- extra_len contains the actual extra field length, and extra contains the +- extra field, or that field truncated if extra_max is less than extra_len. +- If name is not Z_NULL, then up to name_max characters are written there, +- terminated with a zero unless the length is greater than name_max. If +- comment is not Z_NULL, then up to comm_max characters are written there, +- terminated with a zero unless the length is greater than comm_max. When any +- of extra, name, or comment are not Z_NULL and the respective field is not +- present in the header, then that field is set to Z_NULL to signal its +- absence. This allows the use of deflateSetHeader() with the returned +- structure to duplicate the header. However if those fields are set to +- allocated memory, then the application will need to save those pointers +- elsewhere so that they can be eventually freed. +- +- If inflateGetHeader is not used, then the header information is simply +- discarded. The header is always checked for validity, including the header +- CRC if present. inflateReset() will reset the process to discard the header +- information. The application would need to call inflateGetHeader() again to +- retrieve the header from the next gzip stream. +- +- inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source +- stream state was inconsistent. +-*/ +- +-/* +-ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, +- unsigned char FAR *window)); +- +- Initialize the internal stream state for decompression using inflateBack() +- calls. The fields zalloc, zfree and opaque in strm must be initialized +- before the call. If zalloc and zfree are Z_NULL, then the default library- +- derived memory allocation routines are used. windowBits is the base two +- logarithm of the window size, in the range 8..15. window is a caller +- supplied buffer of that size. Except for special applications where it is +- assured that deflate was used with small window sizes, windowBits must be 15 +- and a 32K byte window must be supplied to be able to decompress general +- deflate streams. +- +- See inflateBack() for the usage of these routines. +- +- inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of +- the paramaters are invalid, Z_MEM_ERROR if the internal state could not be +- allocated, or Z_VERSION_ERROR if the version of the library does not match +- the version of the header file. +-*/ +- +-typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); +-typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); +- +-ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, +- in_func in, void FAR *in_desc, +- out_func out, void FAR *out_desc)); +-/* +- inflateBack() does a raw inflate with a single call using a call-back +- interface for input and output. This is more efficient than inflate() for +- file i/o applications in that it avoids copying between the output and the +- sliding window by simply making the window itself the output buffer. This +- function trusts the application to not change the output buffer passed by +- the output function, at least until inflateBack() returns. +- +- inflateBackInit() must be called first to allocate the internal state +- and to initialize the state with the user-provided window buffer. +- inflateBack() may then be used multiple times to inflate a complete, raw +- deflate stream with each call. inflateBackEnd() is then called to free the +- allocated state. +- +- A raw deflate stream is one with no zlib or gzip header or trailer. +- This routine would normally be used in a utility that reads zip or gzip +- files and writes out uncompressed files. The utility would decode the +- header and process the trailer on its own, hence this routine expects only +- the raw deflate stream to decompress. This is different from the normal +- behavior of inflate(), which expects either a zlib or gzip header and +- trailer around the deflate stream. +- +- inflateBack() uses two subroutines supplied by the caller that are then +- called by inflateBack() for input and output. inflateBack() calls those +- routines until it reads a complete deflate stream and writes out all of the +- uncompressed data, or until it encounters an error. The function's +- parameters and return types are defined above in the in_func and out_func +- typedefs. inflateBack() will call in(in_desc, &buf) which should return the +- number of bytes of provided input, and a pointer to that input in buf. If +- there is no input available, in() must return zero--buf is ignored in that +- case--and inflateBack() will return a buffer error. inflateBack() will call +- out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() +- should return zero on success, or non-zero on failure. If out() returns +- non-zero, inflateBack() will return with an error. Neither in() nor out() +- are permitted to change the contents of the window provided to +- inflateBackInit(), which is also the buffer that out() uses to write from. +- The length written by out() will be at most the window size. Any non-zero +- amount of input may be provided by in(). +- +- For convenience, inflateBack() can be provided input on the first call by +- setting strm->next_in and strm->avail_in. If that input is exhausted, then +- in() will be called. Therefore strm->next_in must be initialized before +- calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called +- immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in +- must also be initialized, and then if strm->avail_in is not zero, input will +- initially be taken from strm->next_in[0 .. strm->avail_in - 1]. +- +- The in_desc and out_desc parameters of inflateBack() is passed as the +- first parameter of in() and out() respectively when they are called. These +- descriptors can be optionally used to pass any information that the caller- +- supplied in() and out() functions need to do their job. +- +- On return, inflateBack() will set strm->next_in and strm->avail_in to +- pass back any unused input that was provided by the last in() call. The +- return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR +- if in() or out() returned an error, Z_DATA_ERROR if there was a format error +- in the deflate stream (in which case strm->msg is set to indicate the nature +- of the error), or Z_STREAM_ERROR if the stream was not properly initialized. +- In the case of Z_BUF_ERROR, an input or output error can be distinguished +- using strm->next_in which will be Z_NULL only if in() returned an error. If +- strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning +- non-zero. (in() will always be called before out(), so strm->next_in is +- assured to be defined if out() returns non-zero.) Note that inflateBack() +- cannot return Z_OK. +-*/ +- +-ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); +-/* +- All memory allocated by inflateBackInit() is freed. +- +- inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream +- state was inconsistent. +-*/ +- +-ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); +-/* Return flags indicating compile-time options. +- +- Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: +- 1.0: size of uInt +- 3.2: size of uLong +- 5.4: size of voidpf (pointer) +- 7.6: size of z_off_t +- +- Compiler, assembler, and debug options: +- 8: DEBUG +- 9: ASMV or ASMINF -- use ASM code +- 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention +- 11: 0 (reserved) +- +- One-time table building (smaller code, but not thread-safe if true): +- 12: BUILDFIXED -- build static block decoding tables when needed +- 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed +- 14,15: 0 (reserved) +- +- Library content (indicates missing functionality): +- 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking +- deflate code when not needed) +- 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect +- and decode gzip streams (to avoid linking crc code) +- 18-19: 0 (reserved) +- +- Operation variations (changes in library functionality): +- 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate +- 21: FASTEST -- deflate algorithm with only one, lowest compression level +- 22,23: 0 (reserved) +- +- The sprintf variant used by gzprintf (zero is best): +- 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format +- 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! +- 26: 0 = returns value, 1 = void -- 1 means inferred string length returned +- +- Remainder: +- 27-31: 0 (reserved) +- */ +- +- +- /* utility functions */ +- +-/* +- The following utility functions are implemented on top of the basic +- stream-oriented functions. To simplify the interface, some default options +- are assumed (compression level and memory usage, standard memory allocation +- functions). The source code of these utility functions can be modified if +- you need special options. +-*/ +- +-ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, +- const Bytef *source, uLong sourceLen)); +-/* +- Compresses the source buffer into the destination buffer. sourceLen is +- the byte length of the source buffer. Upon entry, destLen is the total size +- of the destination buffer, which must be at least the value returned by +- compressBound(sourceLen). Upon exit, destLen is the actual size of the +- compressed buffer. +- +- compress returns Z_OK if success, Z_MEM_ERROR if there was not +- enough memory, Z_BUF_ERROR if there was not enough room in the output +- buffer. +-*/ +- +-ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, +- const Bytef *source, uLong sourceLen, +- int level)); +-/* +- Compresses the source buffer into the destination buffer. The level +- parameter has the same meaning as in deflateInit. sourceLen is the byte +- length of the source buffer. Upon entry, destLen is the total size of the +- destination buffer, which must be at least the value returned by +- compressBound(sourceLen). Upon exit, destLen is the actual size of the +- compressed buffer. +- +- compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough +- memory, Z_BUF_ERROR if there was not enough room in the output buffer, +- Z_STREAM_ERROR if the level parameter is invalid. +-*/ +- +-ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); +-/* +- compressBound() returns an upper bound on the compressed size after +- compress() or compress2() on sourceLen bytes. It would be used before a +- compress() or compress2() call to allocate the destination buffer. +-*/ +- +-ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, +- const Bytef *source, uLong sourceLen)); +-/* +- Decompresses the source buffer into the destination buffer. sourceLen is +- the byte length of the source buffer. Upon entry, destLen is the total size +- of the destination buffer, which must be large enough to hold the entire +- uncompressed data. (The size of the uncompressed data must have been saved +- previously by the compressor and transmitted to the decompressor by some +- mechanism outside the scope of this compression library.) Upon exit, destLen +- is the actual size of the uncompressed buffer. +- +- uncompress returns Z_OK if success, Z_MEM_ERROR if there was not +- enough memory, Z_BUF_ERROR if there was not enough room in the output +- buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. +-*/ +- +- +- /* gzip file access functions */ +- +-/* +- This library supports reading and writing files in gzip (.gz) format with +- an interface similar to that of stdio, using the functions that start with +- "gz". The gzip format is different from the zlib format. gzip is a gzip +- wrapper, documented in RFC 1952, wrapped around a deflate stream. +-*/ +- +-typedef voidp gzFile; /* opaque gzip file descriptor */ +- +-/* +-ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); +- +- Opens a gzip (.gz) file for reading or writing. The mode parameter is as +- in fopen ("rb" or "wb") but can also include a compression level ("wb9") or +- a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only +- compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F' +- for fixed code compression as in "wb9F". (See the description of +- deflateInit2 for more information about the strategy parameter.) Also "a" +- can be used instead of "w" to request that the gzip stream that will be +- written be appended to the file. "+" will result in an error, since reading +- and writing to the same gzip file is not supported. +- +- gzopen can be used to read a file which is not in gzip format; in this +- case gzread will directly read from the file without decompression. +- +- gzopen returns NULL if the file could not be opened, if there was +- insufficient memory to allocate the gzFile state, or if an invalid mode was +- specified (an 'r', 'w', or 'a' was not provided, or '+' was provided). +- errno can be checked to determine if the reason gzopen failed was that the +- file could not be opened. +-*/ +- +-ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +-/* +- gzdopen associates a gzFile with the file descriptor fd. File descriptors +- are obtained from calls like open, dup, creat, pipe or fileno (if the file +- has been previously opened with fopen). The mode parameter is as in gzopen. +- +- The next call of gzclose on the returned gzFile will also close the file +- descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor +- fd. If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd, +- mode);. The duplicated descriptor should be saved to avoid a leak, since +- gzdopen does not close fd if it fails. +- +- gzdopen returns NULL if there was insufficient memory to allocate the +- gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not +- provided, or '+' was provided), or if fd is -1. The file descriptor is not +- used until the next gz* read, write, seek, or close operation, so gzdopen +- will not detect if fd is invalid (unless fd is -1). +-*/ +- +-ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); +-/* +- Set the internal buffer size used by this library's functions. The +- default buffer size is 8192 bytes. This function must be called after +- gzopen() or gzdopen(), and before any other calls that read or write the +- file. The buffer memory allocation is always deferred to the first read or +- write. Two buffers are allocated, either both of the specified size when +- writing, or one of the specified size and the other twice that size when +- reading. A larger buffer size of, for example, 64K or 128K bytes will +- noticeably increase the speed of decompression (reading). +- +- The new buffer size also affects the maximum length for gzprintf(). +- +- gzbuffer() returns 0 on success, or -1 on failure, such as being called +- too late. +-*/ +- +-ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +-/* +- Dynamically update the compression level or strategy. See the description +- of deflateInit2 for the meaning of these parameters. +- +- gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not +- opened for writing. +-*/ +- +-ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +-/* +- Reads the given number of uncompressed bytes from the compressed file. If +- the input file was not in gzip format, gzread copies the given number of +- bytes into the buffer. +- +- After reaching the end of a gzip stream in the input, gzread will continue +- to read, looking for another gzip stream, or failing that, reading the rest +- of the input file directly without decompression. The entire input file +- will be read if gzread is called until it returns less than the requested +- len. +- +- gzread returns the number of uncompressed bytes actually read, less than +- len for end of file, or -1 for error. +-*/ +- +-ZEXTERN int ZEXPORT gzwrite OF((gzFile file, +- voidpc buf, unsigned len)); +-/* +- Writes the given number of uncompressed bytes into the compressed file. +- gzwrite returns the number of uncompressed bytes written or 0 in case of +- error. +-*/ +- +-ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); +-/* +- Converts, formats, and writes the arguments to the compressed file under +- control of the format string, as in fprintf. gzprintf returns the number of +- uncompressed bytes actually written, or 0 in case of error. The number of +- uncompressed bytes written is limited to 8191, or one less than the buffer +- size given to gzbuffer(). The caller should assure that this limit is not +- exceeded. If it is exceeded, then gzprintf() will return an error (0) with +- nothing written. In this case, there may also be a buffer overflow with +- unpredictable consequences, which is possible only if zlib was compiled with +- the insecure functions sprintf() or vsprintf() because the secure snprintf() +- or vsnprintf() functions were not available. This can be determined using +- zlibCompileFlags(). +-*/ +- +-ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +-/* +- Writes the given null-terminated string to the compressed file, excluding +- the terminating null character. +- +- gzputs returns the number of characters written, or -1 in case of error. +-*/ +- +-ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +-/* +- Reads bytes from the compressed file until len-1 characters are read, or a +- newline character is read and transferred to buf, or an end-of-file +- condition is encountered. If any characters are read or if len == 1, the +- string is terminated with a null character. If no characters are read due +- to an end-of-file or len < 1, then the buffer is left untouched. +- +- gzgets returns buf which is a null-terminated string, or it returns NULL +- for end-of-file or in case of error. If there was an error, the contents at +- buf are indeterminate. +-*/ +- +-ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +-/* +- Writes c, converted to an unsigned char, into the compressed file. gzputc +- returns the value that was written, or -1 in case of error. +-*/ +- +-ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +-/* +- Reads one byte from the compressed file. gzgetc returns this byte or -1 +- in case of end of file or error. +-*/ +- +-ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); +-/* +- Push one character back onto the stream to be read as the first character +- on the next read. At least one character of push-back is allowed. +- gzungetc() returns the character pushed, or -1 on failure. gzungetc() will +- fail if c is -1, and may fail if a character has been pushed but not read +- yet. If gzungetc is used immediately after gzopen or gzdopen, at least the +- output buffer size of pushed characters is allowed. (See gzbuffer above.) +- The pushed character will be discarded if the stream is repositioned with +- gzseek() or gzrewind(). +-*/ +- +-ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +-/* +- Flushes all pending output into the compressed file. The parameter flush +- is as in the deflate() function. The return value is the zlib error number +- (see function gzerror below). gzflush is only permitted when writing. +- +- If the flush parameter is Z_FINISH, the remaining data is written and the +- gzip stream is completed in the output. If gzwrite() is called again, a new +- gzip stream will be started in the output. gzread() is able to read such +- concatented gzip streams. +- +- gzflush should be called only when strictly necessary because it will +- degrade compression if called too often. +-*/ +- +-/* +-ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, +- z_off_t offset, int whence)); +- +- Sets the starting position for the next gzread or gzwrite on the given +- compressed file. The offset represents a number of bytes in the +- uncompressed data stream. The whence parameter is defined as in lseek(2); +- the value SEEK_END is not supported. +- +- If the file is opened for reading, this function is emulated but can be +- extremely slow. If the file is opened for writing, only forward seeks are +- supported; gzseek then compresses a sequence of zeroes up to the new +- starting position. +- +- gzseek returns the resulting offset location as measured in bytes from +- the beginning of the uncompressed stream, or -1 in case of error, in +- particular if the file is opened for writing and the new starting position +- would be before the current position. +-*/ +- +-ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +-/* +- Rewinds the given file. This function is supported only for reading. +- +- gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) +-*/ +- +-/* +-ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); +- +- Returns the starting position for the next gzread or gzwrite on the given +- compressed file. This position represents a number of bytes in the +- uncompressed data stream, and is zero when starting, even if appending or +- reading a gzip stream from the middle of a file using gzdopen(). +- +- gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +-*/ +- +-/* +-ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); +- +- Returns the current offset in the file being read or written. This offset +- includes the count of bytes that precede the gzip stream, for example when +- appending or when using gzdopen() for reading. When reading, the offset +- does not include as yet unused buffered input. This information can be used +- for a progress indicator. On error, gzoffset() returns -1. +-*/ +- +-ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +-/* +- Returns true (1) if the end-of-file indicator has been set while reading, +- false (0) otherwise. Note that the end-of-file indicator is set only if the +- read tried to go past the end of the input, but came up short. Therefore, +- just like feof(), gzeof() may return false even if there is no more data to +- read, in the event that the last read request was for the exact number of +- bytes remaining in the input file. This will happen if the input file size +- is an exact multiple of the buffer size. +- +- If gzeof() returns true, then the read functions will return no more data, +- unless the end-of-file indicator is reset by gzclearerr() and the input file +- has grown since the previous end of file was detected. +-*/ +- +-ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); +-/* +- Returns true (1) if file is being copied directly while reading, or false +- (0) if file is a gzip stream being decompressed. This state can change from +- false to true while reading the input file if the end of a gzip stream is +- reached, but is followed by data that is not another gzip stream. +- +- If the input file is empty, gzdirect() will return true, since the input +- does not contain a gzip stream. +- +- If gzdirect() is used immediately after gzopen() or gzdopen() it will +- cause buffers to be allocated to allow reading the file to determine if it +- is a gzip file. Therefore if gzbuffer() is used, it should be called before +- gzdirect(). +-*/ +- +-ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +-/* +- Flushes all pending output if necessary, closes the compressed file and +- deallocates the (de)compression state. Note that once file is closed, you +- cannot call gzerror with file, since its structures have been deallocated. +- gzclose must not be called more than once on the same file, just as free +- must not be called more than once on the same allocation. +- +- gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a +- file operation error, or Z_OK on success. +-*/ +- +-ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); +-ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); +-/* +- Same as gzclose(), but gzclose_r() is only for use when reading, and +- gzclose_w() is only for use when writing or appending. The advantage to +- using these instead of gzclose() is that they avoid linking in zlib +- compression or decompression code that is not used when only reading or only +- writing respectively. If gzclose() is used, then both compression and +- decompression code will be included the application when linking to a static +- zlib library. +-*/ +- +-ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +-/* +- Returns the error message for the last error which occurred on the given +- compressed file. errnum is set to zlib error number. If an error occurred +- in the file system and not in the compression library, errnum is set to +- Z_ERRNO and the application may consult errno to get the exact error code. +- +- The application must not modify the returned string. Future calls to +- this function may invalidate the previously returned string. If file is +- closed, then the string previously returned by gzerror will no longer be +- available. +- +- gzerror() should be used to distinguish errors from end-of-file for those +- functions above that do not distinguish those cases in their return values. +-*/ +- +-ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); +-/* +- Clears the error and end-of-file flags for file. This is analogous to the +- clearerr() function in stdio. This is useful for continuing to read a gzip +- file that is being written concurrently. +-*/ +- +- +- /* checksum functions */ +- +-/* +- These functions are not related to compression but are exported +- anyway because they might be useful in applications using the compression +- library. +-*/ +- +-ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); +-/* +- Update a running Adler-32 checksum with the bytes buf[0..len-1] and +- return the updated checksum. If buf is Z_NULL, this function returns the +- required initial value for the checksum. +- +- An Adler-32 checksum is almost as reliable as a CRC32 but can be computed +- much faster. +- +- Usage example: +- +- uLong adler = adler32(0L, Z_NULL, 0); +- +- while (read_buffer(buffer, length) != EOF) { +- adler = adler32(adler, buffer, length); +- } +- if (adler != original_adler) error(); +-*/ +- +-/* +-ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, +- z_off_t len2)); +- +- Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 +- and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for +- each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of +- seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. +-*/ +- +-ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +-/* +- Update a running CRC-32 with the bytes buf[0..len-1] and return the +- updated CRC-32. If buf is Z_NULL, this function returns the required +- initial value for the for the crc. Pre- and post-conditioning (one's +- complement) is performed within this function so it shouldn't be done by the +- application. +- +- Usage example: +- +- uLong crc = crc32(0L, Z_NULL, 0); +- +- while (read_buffer(buffer, length) != EOF) { +- crc = crc32(crc, buffer, length); +- } +- if (crc != original_crc) error(); +-*/ +- +-/* +-ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); +- +- Combine two CRC-32 check values into one. For two sequences of bytes, +- seq1 and seq2 with lengths len1 and len2, CRC-32 check values were +- calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 +- check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and +- len2. +-*/ +- +- +- /* various hacks, don't look :) */ +- +-/* deflateInit and inflateInit are macros to allow checking the zlib version +- * and the compiler's view of z_stream: +- */ +-ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, +- const char *version, int stream_size)); +-ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, +- const char *version, int stream_size)); +-ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, +- int windowBits, int memLevel, +- int strategy, const char *version, +- int stream_size)); +-ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, +- const char *version, int stream_size)); +-ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, +- unsigned char FAR *window, +- const char *version, +- int stream_size)); +-#define deflateInit(strm, level) \ +- deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) +-#define inflateInit(strm) \ +- inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) +-#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ +- deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ +- (strategy), ZLIB_VERSION, sizeof(z_stream)) +-#define inflateInit2(strm, windowBits) \ +- inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) +-#define inflateBackInit(strm, windowBits, window) \ +- inflateBackInit_((strm), (windowBits), (window), \ +- ZLIB_VERSION, sizeof(z_stream)) +- +-/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or +- * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if +- * both are true, the application gets the *64 functions, and the regular +- * functions are changed to 64 bits) -- in case these are set on systems +- * without large file support, _LFS64_LARGEFILE must also be true +- */ +-#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 +- ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); +- ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); +- ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); +- ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); +- ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t)); +- ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); +-#endif +- +-#if !defined(ZLIB_INTERNAL) && _FILE_OFFSET_BITS-0 == 64 && _LFS64_LARGEFILE-0 +-# define gzopen gzopen64 +-# define gzseek gzseek64 +-# define gztell gztell64 +-# define gzoffset gzoffset64 +-# define adler32_combine adler32_combine64 +-# define crc32_combine crc32_combine64 +-# ifdef _LARGEFILE64_SOURCE +- ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); +- ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); +- ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); +- ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); +- ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); +- ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); +-# endif +-#else +- ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); +- ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); +- ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); +- ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); +- ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); +- ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); +-#endif +- +-/* hack for buggy compilers */ +-#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) +- struct internal_state {int dummy;}; +-#endif +- +-/* undocumented functions */ +-ZEXTERN const char * ZEXPORT zError OF((int)); +-ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); +-ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); +-ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif /* ZLIB_H */ +diff --git a/thirdparty/zlib/zlib_vs2010.vcxproj b/thirdparty/zlib/zlib_vs2010.vcxproj +deleted file mode 100644 +index 5717376..0000000 +--- a/thirdparty/zlib/zlib_vs2010.vcxproj ++++ /dev/null +@@ -1,246 +0,0 @@ +- +- +- +- +- Debug +- Win32 +- +- +- Debug +- x64 +- +- +- Release LIB +- Win32 +- +- +- Release LIB +- x64 +- +- +- Release +- Win32 +- +- +- Release +- x64 +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- zlib +- {00929DA3-31A1-4853-ABCE-145385A4AC63} +- zlib +- Win32Proj +- +- +- +- StaticLibrary +- Unicode +- true +- +- +- StaticLibrary +- Unicode +- true +- +- +- StaticLibrary +- Unicode +- true +- +- +- StaticLibrary +- Unicode +- true +- +- +- StaticLibrary +- Unicode +- +- +- StaticLibrary +- Unicode +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- <_ProjectFileVersion>10.0.30319.1 +- $(SolutionDir)thirdparty\lib\ +- $(SolutionDir)thirdparty\lib\$(Platform)\ +- $(Configuration)\ +- $(SolutionDir)\thirdparty\lib\ +- $(SolutionDir)\thirdparty\lib\$(Platform)\ +- $(Configuration)\ +- $(SolutionDir)\thirdparty\lib\ +- $(SolutionDir)\thirdparty\lib\$(Platform)\ +- $(Configuration)\ +- $(Configuration)\ +- AllRules.ruleset +- AllRules.ruleset +- +- +- +- +- AllRules.ruleset +- AllRules.ruleset +- +- +- +- +- AllRules.ruleset +- AllRules.ruleset +- +- +- +- +- zlibd +- zlibd +- zlib +- zlib +- zlib +- zlib +- +- +- +- Disabled +- WIN32;_DEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions) +- EnableFastChecks +- MultiThreadedDebugDLL +- +- +- Level3 +- EditAndContinue +- 4996;4267;%(DisableSpecificWarnings) +- true +- +- +- +- +- +- Disabled +- _WIN64;_DEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions) +- EnableFastChecks +- MultiThreadedDebugDLL +- +- +- Level3 +- ProgramDatabase +- 4996;4267;%(DisableSpecificWarnings) +- true +- +- +- +- +- +- WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) +- MultiThreadedDLL +- +- +- Level3 +- ProgramDatabase +- 4996;4267;%(DisableSpecificWarnings) +- MinSpace +- Size +- true +- +- +- +- +- +- WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) +- MultiThreadedDLL +- +- +- Level3 +- ProgramDatabase +- 4996;4267;%(DisableSpecificWarnings) +- MinSpace +- Size +- true +- +- +- +- +- +- WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) +- MultiThreaded +- +- +- Level3 +- ProgramDatabase +- 4996;4267;%(DisableSpecificWarnings) +- MinSpace +- Size +- true +- +- +- +- +- +- WIN64;NDEBUG;_LIB;%(PreprocessorDefinitions) +- MultiThreaded +- +- +- Level3 +- ProgramDatabase +- 4996;4267;%(DisableSpecificWarnings) +- true +- +- +- +- +- +- +- +\ No newline at end of file +diff --git a/thirdparty/zlib/zutil.c b/thirdparty/zlib/zutil.c +deleted file mode 100644 +index 898ed34..0000000 +--- a/thirdparty/zlib/zutil.c ++++ /dev/null +@@ -1,318 +0,0 @@ +-/* zutil.c -- target dependent utility functions for the compression library +- * Copyright (C) 1995-2005, 2010 Jean-loup Gailly. +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* @(#) $Id$ */ +- +-#include "zutil.h" +- +-#ifndef NO_DUMMY_DECL +-struct internal_state {int dummy;}; /* for buggy compilers */ +-#endif +- +-const char * const z_errmsg[10] = { +-"need dictionary", /* Z_NEED_DICT 2 */ +-"stream end", /* Z_STREAM_END 1 */ +-"", /* Z_OK 0 */ +-"file error", /* Z_ERRNO (-1) */ +-"stream error", /* Z_STREAM_ERROR (-2) */ +-"data error", /* Z_DATA_ERROR (-3) */ +-"insufficient memory", /* Z_MEM_ERROR (-4) */ +-"buffer error", /* Z_BUF_ERROR (-5) */ +-"incompatible version",/* Z_VERSION_ERROR (-6) */ +-""}; +- +- +-const char * ZEXPORT zlibVersion() +-{ +- return ZLIB_VERSION; +-} +- +-uLong ZEXPORT zlibCompileFlags() +-{ +- uLong flags; +- +- flags = 0; +- switch ((int)(sizeof(uInt))) { +- case 2: break; +- case 4: flags += 1; break; +- case 8: flags += 2; break; +- default: flags += 3; +- } +- switch ((int)(sizeof(uLong))) { +- case 2: break; +- case 4: flags += 1 << 2; break; +- case 8: flags += 2 << 2; break; +- default: flags += 3 << 2; +- } +- switch ((int)(sizeof(voidpf))) { +- case 2: break; +- case 4: flags += 1 << 4; break; +- case 8: flags += 2 << 4; break; +- default: flags += 3 << 4; +- } +- switch ((int)(sizeof(z_off_t))) { +- case 2: break; +- case 4: flags += 1 << 6; break; +- case 8: flags += 2 << 6; break; +- default: flags += 3 << 6; +- } +-#ifdef DEBUG +- flags += 1 << 8; +-#endif +-#if defined(ASMV) || defined(ASMINF) +- flags += 1 << 9; +-#endif +-#ifdef ZLIB_WINAPI +- flags += 1 << 10; +-#endif +-#ifdef BUILDFIXED +- flags += 1 << 12; +-#endif +-#ifdef DYNAMIC_CRC_TABLE +- flags += 1 << 13; +-#endif +-#ifdef NO_GZCOMPRESS +- flags += 1L << 16; +-#endif +-#ifdef NO_GZIP +- flags += 1L << 17; +-#endif +-#ifdef PKZIP_BUG_WORKAROUND +- flags += 1L << 20; +-#endif +-#ifdef FASTEST +- flags += 1L << 21; +-#endif +-#ifdef STDC +-# ifdef NO_vsnprintf +- flags += 1L << 25; +-# ifdef HAS_vsprintf_void +- flags += 1L << 26; +-# endif +-# else +-# ifdef HAS_vsnprintf_void +- flags += 1L << 26; +-# endif +-# endif +-#else +- flags += 1L << 24; +-# ifdef NO_snprintf +- flags += 1L << 25; +-# ifdef HAS_sprintf_void +- flags += 1L << 26; +-# endif +-# else +-# ifdef HAS_snprintf_void +- flags += 1L << 26; +-# endif +-# endif +-#endif +- return flags; +-} +- +-#ifdef DEBUG +- +-# ifndef verbose +-# define verbose 0 +-# endif +-int ZLIB_INTERNAL z_verbose = verbose; +- +-void ZLIB_INTERNAL z_error (m) +- char *m; +-{ +- fprintf(stderr, "%s\n", m); +- exit(1); +-} +-#endif +- +-/* exported to allow conversion of error code to string for compress() and +- * uncompress() +- */ +-const char * ZEXPORT zError(err) +- int err; +-{ +- return ERR_MSG(err); +-} +- +-#if defined(_WIN32_WCE) +- /* The Microsoft C Run-Time Library for Windows CE doesn't have +- * errno. We define it as a global variable to simplify porting. +- * Its value is always 0 and should not be used. +- */ +- int errno = 0; +-#endif +- +-#ifndef HAVE_MEMCPY +- +-void ZLIB_INTERNAL zmemcpy(dest, source, len) +- Bytef* dest; +- const Bytef* source; +- uInt len; +-{ +- if (len == 0) return; +- do { +- *dest++ = *source++; /* ??? to be unrolled */ +- } while (--len != 0); +-} +- +-int ZLIB_INTERNAL zmemcmp(s1, s2, len) +- const Bytef* s1; +- const Bytef* s2; +- uInt len; +-{ +- uInt j; +- +- for (j = 0; j < len; j++) { +- if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1; +- } +- return 0; +-} +- +-void ZLIB_INTERNAL zmemzero(dest, len) +- Bytef* dest; +- uInt len; +-{ +- if (len == 0) return; +- do { +- *dest++ = 0; /* ??? to be unrolled */ +- } while (--len != 0); +-} +-#endif +- +- +-#ifdef SYS16BIT +- +-#ifdef __TURBOC__ +-/* Turbo C in 16-bit mode */ +- +-# define MY_ZCALLOC +- +-/* Turbo C malloc() does not allow dynamic allocation of 64K bytes +- * and farmalloc(64K) returns a pointer with an offset of 8, so we +- * must fix the pointer. Warning: the pointer must be put back to its +- * original form in order to free it, use zcfree(). +- */ +- +-#define MAX_PTR 10 +-/* 10*64K = 640K */ +- +-local int next_ptr = 0; +- +-typedef struct ptr_table_s { +- voidpf org_ptr; +- voidpf new_ptr; +-} ptr_table; +- +-local ptr_table table[MAX_PTR]; +-/* This table is used to remember the original form of pointers +- * to large buffers (64K). Such pointers are normalized with a zero offset. +- * Since MSDOS is not a preemptive multitasking OS, this table is not +- * protected from concurrent access. This hack doesn't work anyway on +- * a protected system like OS/2. Use Microsoft C instead. +- */ +- +-voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size) +-{ +- voidpf buf = opaque; /* just to make some compilers happy */ +- ulg bsize = (ulg)items*size; +- +- /* If we allocate less than 65520 bytes, we assume that farmalloc +- * will return a usable pointer which doesn't have to be normalized. +- */ +- if (bsize < 65520L) { +- buf = farmalloc(bsize); +- if (*(ush*)&buf != 0) return buf; +- } else { +- buf = farmalloc(bsize + 16L); +- } +- if (buf == NULL || next_ptr >= MAX_PTR) return NULL; +- table[next_ptr].org_ptr = buf; +- +- /* Normalize the pointer to seg:0 */ +- *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; +- *(ush*)&buf = 0; +- table[next_ptr++].new_ptr = buf; +- return buf; +-} +- +-void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) +-{ +- int n; +- if (*(ush*)&ptr != 0) { /* object < 64K */ +- farfree(ptr); +- return; +- } +- /* Find the original pointer */ +- for (n = 0; n < next_ptr; n++) { +- if (ptr != table[n].new_ptr) continue; +- +- farfree(table[n].org_ptr); +- while (++n < next_ptr) { +- table[n-1] = table[n]; +- } +- next_ptr--; +- return; +- } +- ptr = opaque; /* just to make some compilers happy */ +- Assert(0, "zcfree: ptr not found"); +-} +- +-#endif /* __TURBOC__ */ +- +- +-#ifdef M_I86 +-/* Microsoft C in 16-bit mode */ +- +-# define MY_ZCALLOC +- +-#if (!defined(_MSC_VER) || (_MSC_VER <= 600)) +-# define _halloc halloc +-# define _hfree hfree +-#endif +- +-voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size) +-{ +- if (opaque) opaque = 0; /* to make compiler happy */ +- return _halloc((long)items, size); +-} +- +-void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) +-{ +- if (opaque) opaque = 0; /* to make compiler happy */ +- _hfree(ptr); +-} +- +-#endif /* M_I86 */ +- +-#endif /* SYS16BIT */ +- +- +-#ifndef MY_ZCALLOC /* Any system without a special alloc function */ +- +-#ifndef STDC +-extern voidp malloc OF((uInt size)); +-extern voidp calloc OF((uInt items, uInt size)); +-extern void free OF((voidpf ptr)); +-#endif +- +-voidpf ZLIB_INTERNAL zcalloc (opaque, items, size) +- voidpf opaque; +- unsigned items; +- unsigned size; +-{ +- if (opaque) items += size - size; /* make compiler happy */ +- return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : +- (voidpf)calloc(items, size); +-} +- +-void ZLIB_INTERNAL zcfree (opaque, ptr) +- voidpf opaque; +- voidpf ptr; +-{ +- free(ptr); +- if (opaque) return; /* make compiler happy */ +-} +- +-#endif /* MY_ZCALLOC */ +diff --git a/thirdparty/zlib/zutil.h b/thirdparty/zlib/zutil.h +deleted file mode 100644 +index 258fa88..0000000 +--- a/thirdparty/zlib/zutil.h ++++ /dev/null +@@ -1,274 +0,0 @@ +-/* zutil.h -- internal interface and configuration of the compression library +- * Copyright (C) 1995-2010 Jean-loup Gailly. +- * For conditions of distribution and use, see copyright notice in zlib.h +- */ +- +-/* WARNING: this file should *not* be used by applications. It is +- part of the implementation of the compression library and is +- subject to change. Applications should only use zlib.h. +- */ +- +-/* @(#) $Id$ */ +- +-#ifndef ZUTIL_H +-#define ZUTIL_H +- +-#if ((__GNUC__-0) * 10 + __GNUC_MINOR__-0 >= 33) && !defined(NO_VIZ) +-# define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) +-#else +-# define ZLIB_INTERNAL +-#endif +- +-#include "zlib.h" +- +-#ifdef STDC +-# if !(defined(_WIN32_WCE) && defined(_MSC_VER)) +-# include +-# endif +-# include +-# include +-#endif +- +-#ifndef local +-# define local static +-#endif +-/* compile with -Dlocal if your debugger can't find static symbols */ +- +-typedef unsigned char uch; +-typedef uch FAR uchf; +-typedef unsigned short ush; +-typedef ush FAR ushf; +-typedef unsigned long ulg; +- +-extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ +-/* (size given to avoid silly warnings with Visual C++) */ +- +-#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)] +- +-#define ERR_RETURN(strm,err) \ +- return (strm->msg = (char*)ERR_MSG(err), (err)) +-/* To be used only when the state is known to be valid */ +- +- /* common constants */ +- +-#ifndef DEF_WBITS +-# define DEF_WBITS MAX_WBITS +-#endif +-/* default windowBits for decompression. MAX_WBITS is for compression only */ +- +-#if MAX_MEM_LEVEL >= 8 +-# define DEF_MEM_LEVEL 8 +-#else +-# define DEF_MEM_LEVEL MAX_MEM_LEVEL +-#endif +-/* default memLevel */ +- +-#define STORED_BLOCK 0 +-#define STATIC_TREES 1 +-#define DYN_TREES 2 +-/* The three kinds of block type */ +- +-#define MIN_MATCH 3 +-#define MAX_MATCH 258 +-/* The minimum and maximum match lengths */ +- +-#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */ +- +- /* target dependencies */ +- +-#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32)) +-# define OS_CODE 0x00 +-# if defined(__TURBOC__) || defined(__BORLANDC__) +-# if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) +- /* Allow compilation with ANSI keywords only enabled */ +- void _Cdecl farfree( void *block ); +- void *_Cdecl farmalloc( unsigned long nbytes ); +-# else +-# include +-# endif +-# else /* MSC or DJGPP */ +-# include +-# endif +-#endif +- +-#ifdef AMIGA +-# define OS_CODE 0x01 +-#endif +- +-#if defined(VAXC) || defined(VMS) +-# define OS_CODE 0x02 +-# define F_OPEN(name, mode) \ +- fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512") +-#endif +- +-#if defined(ATARI) || defined(atarist) +-# define OS_CODE 0x05 +-#endif +- +-#ifdef OS2 +-# define OS_CODE 0x06 +-# ifdef M_I86 +-# include +-# endif +-#endif +- +-#if defined(MACOS) || defined(TARGET_OS_MAC) +-# define OS_CODE 0x07 +-# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os +-# include /* for fdopen */ +-# else +-# ifndef fdopen +-# define fdopen(fd,mode) NULL /* No fdopen() */ +-# endif +-# endif +-#endif +- +-#ifdef TOPS20 +-# define OS_CODE 0x0a +-#endif +- +-#ifdef WIN32 +-# ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */ +-# define OS_CODE 0x0b +-# endif +-#endif +- +-#ifdef __50SERIES /* Prime/PRIMOS */ +-# define OS_CODE 0x0f +-#endif +- +-#if defined(_BEOS_) || defined(RISCOS) +-# define fdopen(fd,mode) NULL /* No fdopen() */ +-#endif +- +-#if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX +-# if defined(_WIN32_WCE) +-# define fdopen(fd,mode) NULL /* No fdopen() */ +-# ifndef _PTRDIFF_T_DEFINED +- typedef int ptrdiff_t; +-# define _PTRDIFF_T_DEFINED +-# endif +-# else +-# define fdopen(fd,type) _fdopen(fd,type) +-# endif +-#endif +- +-#if defined(__BORLANDC__) +- #pragma warn -8004 +- #pragma warn -8008 +- #pragma warn -8066 +-#endif +- +-/* provide prototypes for these when building zlib without LFS */ +-#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 +- ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); +- ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); +-#endif +- +- /* common defaults */ +- +-#ifndef OS_CODE +-# define OS_CODE 0x03 /* assume Unix */ +-#endif +- +-#ifndef F_OPEN +-# define F_OPEN(name, mode) fopen((name), (mode)) +-#endif +- +- /* functions */ +- +-#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550) +-# ifndef HAVE_VSNPRINTF +-# define HAVE_VSNPRINTF +-# endif +-#endif +-#if defined(__CYGWIN__) +-# ifndef HAVE_VSNPRINTF +-# define HAVE_VSNPRINTF +-# endif +-#endif +-#ifndef HAVE_VSNPRINTF +-# ifdef MSDOS +- /* vsnprintf may exist on some MS-DOS compilers (DJGPP?), +- but for now we just assume it doesn't. */ +-# define NO_vsnprintf +-# endif +-# ifdef __TURBOC__ +-# define NO_vsnprintf +-# endif +-# ifdef WIN32 +- /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */ +-# if !defined(vsnprintf) && !defined(NO_vsnprintf) +-# if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 ) +-# define vsnprintf _vsnprintf +-# endif +-# endif +-# endif +-# ifdef __SASC +-# define NO_vsnprintf +-# endif +-#endif +-#ifdef VMS +-# define NO_vsnprintf +-#endif +- +-#if defined(pyr) +-# define NO_MEMCPY +-#endif +-#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) +- /* Use our own functions for small and medium model with MSC <= 5.0. +- * You may have to use the same strategy for Borland C (untested). +- * The __SC__ check is for Symantec. +- */ +-# define NO_MEMCPY +-#endif +-#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY) +-# define HAVE_MEMCPY +-#endif +-#ifdef HAVE_MEMCPY +-# ifdef SMALL_MEDIUM /* MSDOS small or medium model */ +-# define zmemcpy _fmemcpy +-# define zmemcmp _fmemcmp +-# define zmemzero(dest, len) _fmemset(dest, 0, len) +-# else +-# define zmemcpy memcpy +-# define zmemcmp memcmp +-# define zmemzero(dest, len) memset(dest, 0, len) +-# endif +-#else +- void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); +- int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); +- void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len)); +-#endif +- +-/* Diagnostic functions */ +-#ifdef DEBUG +-# include +- extern int ZLIB_INTERNAL z_verbose; +- extern void ZLIB_INTERNAL z_error OF((char *m)); +-# define Assert(cond,msg) {if(!(cond)) z_error(msg);} +-# define Trace(x) {if (z_verbose>=0) fprintf x ;} +-# define Tracev(x) {if (z_verbose>0) fprintf x ;} +-# define Tracevv(x) {if (z_verbose>1) fprintf x ;} +-# define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;} +-# define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;} +-#else +-# define Assert(cond,msg) +-# define Trace(x) +-# define Tracev(x) +-# define Tracevv(x) +-# define Tracec(c,x) +-# define Tracecv(c,x) +-#endif +- +- +-voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items, +- unsigned size)); +-void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr)); +- +-#define ZALLOC(strm, items, size) \ +- (*((strm)->zalloc))((strm)->opaque, (items), (size)) +-#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) +-#define TRY_FREE(s, p) {if (p) ZFREE(s, p);} +- +-#endif /* ZUTIL_H */ diff --git a/ports/crashrpt/CONTROL b/ports/crashrpt/CONTROL index ce3eb3af820b0c..0d78e16c008be2 100644 --- a/ports/crashrpt/CONTROL +++ b/ports/crashrpt/CONTROL @@ -1,4 +1,5 @@ Source: crashrpt Version: 1.4.3 Description: A crash reporting system for Windows applications -Homepage: http://crashrpt.sourceforge.net/ \ No newline at end of file +Homepage: http://crashrpt.sourceforge.net/ +Build-Depends: libpng, minizip, zlib diff --git a/ports/crashrpt/portfile.cmake b/ports/crashrpt/portfile.cmake index 1a91de8dce4132..a71f273c3fd3a6 100644 --- a/ports/crashrpt/portfile.cmake +++ b/ports/crashrpt/portfile.cmake @@ -14,8 +14,16 @@ vcpkg_from_git( REF 4616504670be5a425a525376648d912a72ce18f2 PATCHES 001-cmake-install.patch + 002-find-minizip-png-zlib.patch ) +# Remove vendored dependencies to ensure they are not picked up by the build +foreach(DEPENDENCY libpng minizip zlib) + if(EXISTS ${SOURCE_PATH}/thirdparty/${DEPENDENCY}) + file(REMOVE_RECURSE ${SOURCE_PATH}/thirdparty/${DEPENDENCY}) + endif() +endforeach() + string(COMPARE EQUAL "${VCPKG_LIBRARY_LINKAGE}" "dynamic" CRASHRPT_BUILD_SHARED_LIBS) string(COMPARE EQUAL "${VCPKG_CRT_LINKAGE}" "dynamic" CRASHRPT_LINK_CRT_AS_DLL) @@ -28,7 +36,6 @@ vcpkg_configure_cmake( -DCRASHRPT_BUILD_SHARED_LIBS=${CRASHRPT_BUILD_SHARED_LIBS} -DCRASHRPT_LINK_CRT_AS_DLL=${CRASHRPT_LINK_CRT_AS_DLL} -DCRASHRPT_BUILD_DEMOS=OFF - -DCRASHRPT_BUILD_PROBE=OFF -DCRASHRPT_BUILD_TESTS=OFF ) From e2f412c7bf409d8f523598ae78ce2cca2b70ff59 Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Thu, 23 Apr 2020 18:39:45 -0400 Subject: [PATCH 06/20] Fix 002-find-minizip-png-zlib.patch, accidentally included folder move/renaming in previous commit --- .../crashrpt/002-find-minizip-png-zlib.patch | 59292 ---------------- 1 file changed, 59292 deletions(-) diff --git a/ports/crashrpt/002-find-minizip-png-zlib.patch b/ports/crashrpt/002-find-minizip-png-zlib.patch index 964f26689b68c6..7294e317d2a190 100644 --- a/ports/crashrpt/002-find-minizip-png-zlib.patch +++ b/ports/crashrpt/002-find-minizip-png-zlib.patch @@ -187,59295 +187,3 @@ index c183c19..ca26160 100644 // Disable warning C4611: interaction between '_setjmp' and C++ object destruction is non-portable #pragma warning(disable:4611) -diff --git a/thirdparty/libpng/CMakeLists.txt b/thirdparty/libpng/CMakeLists.txt -deleted file mode 100644 -index b358c4e..0000000 ---- a/thirdparty/libpng/CMakeLists.txt -+++ /dev/null -@@ -1,20 +0,0 @@ --project(libpng) -- --# Create the list of source files --aux_source_directory( . source_files ) -- --# Define _UNICODE (use wide-char encoding) --add_definitions(-D_UNICODE -D_CRT_SECURE_NO_DEPRECATE /wd4244 /wd4267) -- --# Add include dir --include_directories( ${CMAKE_SOURCE_DIR}/thirdparty/zlib ) -- --fix_default_compiler_settings_() -- --# Add library build target --add_library(libpng STATIC ${source_files}) -- --# Add linker input libraries --target_link_libraries(libpng zlib) -- --set_target_properties(libpng PROPERTIES DEBUG_POSTFIX d ) -\ No newline at end of file -diff --git a/thirdparty/libpng/LICENSE b/thirdparty/libpng/LICENSE -deleted file mode 100644 -index 6b81b55..0000000 ---- a/thirdparty/libpng/LICENSE -+++ /dev/null -@@ -1,109 +0,0 @@ -- --This copy of the libpng notices is provided for your convenience. In case of --any discrepancy between this copy and the notices in the file png.h that is --included in the libpng distribution, the latter shall prevail. -- --COPYRIGHT NOTICE, DISCLAIMER, and LICENSE: -- --If you modify libpng you may insert additional notices immediately following --this sentence. -- --libpng versions 1.2.6, August 15, 2004, through 1.2.24, December 14, 2007, are --Copyright (c) 2004, 2006-2007 Glenn Randers-Pehrson, and are --distributed according to the same disclaimer and license as libpng-1.2.5 --with the following individual added to the list of Contributing Authors -- -- Cosmin Truta -- --libpng versions 1.0.7, July 1, 2000, through 1.2.5 - October 3, 2002, are --Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are --distributed according to the same disclaimer and license as libpng-1.0.6 --with the following individuals added to the list of Contributing Authors -- -- Simon-Pierre Cadieux -- Eric S. Raymond -- Gilles Vollant -- --and with the following additions to the disclaimer: -- -- There is no warranty against interference with your enjoyment of the -- library or against infringement. There is no warranty that our -- efforts or the library will fulfill any of your particular purposes -- or needs. This library is provided with all faults, and the entire -- risk of satisfactory quality, performance, accuracy, and effort is with -- the user. -- --libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are --Copyright (c) 1998, 1999 Glenn Randers-Pehrson, and are --distributed according to the same disclaimer and license as libpng-0.96, --with the following individuals added to the list of Contributing Authors: -- -- Tom Lane -- Glenn Randers-Pehrson -- Willem van Schaik -- --libpng versions 0.89, June 1996, through 0.96, May 1997, are --Copyright (c) 1996, 1997 Andreas Dilger --Distributed according to the same disclaimer and license as libpng-0.88, --with the following individuals added to the list of Contributing Authors: -- -- John Bowler -- Kevin Bracey -- Sam Bushell -- Magnus Holmgren -- Greg Roelofs -- Tom Tanner -- --libpng versions 0.5, May 1995, through 0.88, January 1996, are --Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc. -- --For the purposes of this copyright and license, "Contributing Authors" --is defined as the following set of individuals: -- -- Andreas Dilger -- Dave Martindale -- Guy Eric Schalnat -- Paul Schmidt -- Tim Wegner -- --The PNG Reference Library is supplied "AS IS". The Contributing Authors --and Group 42, Inc. disclaim all warranties, expressed or implied, --including, without limitation, the warranties of merchantability and of --fitness for any purpose. The Contributing Authors and Group 42, Inc. --assume no liability for direct, indirect, incidental, special, exemplary, --or consequential damages, which may result from the use of the PNG --Reference Library, even if advised of the possibility of such damage. -- --Permission is hereby granted to use, copy, modify, and distribute this --source code, or portions hereof, for any purpose, without fee, subject --to the following restrictions: -- --1. The origin of this source code must not be misrepresented. -- --2. Altered versions must be plainly marked as such and must not -- be misrepresented as being the original source. -- --3. This Copyright notice may not be removed or altered from any -- source or altered source distribution. -- --The Contributing Authors and Group 42, Inc. specifically permit, without --fee, and encourage the use of this source code as a component to --supporting the PNG file format in commercial products. If you use this --source code in a product, acknowledgment is not required but would be --appreciated. -- -- --A "png_get_copyright" function is available, for convenient use in "about" --boxes and the like: -- -- printf("%s",png_get_copyright(NULL)); -- --Also, the PNG logo (in PNG format, of course) is supplied in the --files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31). -- --Libpng is OSI Certified Open Source Software. OSI Certified Open Source is a --certification mark of the Open Source Initiative. -- --Glenn Randers-Pehrson --glennrp at users.sourceforge.net --December 14, 2007 -diff --git a/thirdparty/libpng/libpng-1.2.24.txt b/thirdparty/libpng/libpng-1.2.24.txt -deleted file mode 100644 -index 5b8dc53..0000000 ---- a/thirdparty/libpng/libpng-1.2.24.txt -+++ /dev/null -@@ -1,2851 +0,0 @@ --libpng.txt - A description on how to use and modify libpng -- -- libpng version 1.2.24 - December 14, 2007 -- Updated and distributed by Glenn Randers-Pehrson -- -- Copyright (c) 1998-2007 Glenn Randers-Pehrson -- For conditions of distribution and use, see copyright -- notice in png.h. -- -- based on: -- -- libpng 1.0 beta 6 version 0.96 May 28, 1997 -- Updated and distributed by Andreas Dilger -- Copyright (c) 1996, 1997 Andreas Dilger -- -- libpng 1.0 beta 2 - version 0.88 January 26, 1996 -- For conditions of distribution and use, see copyright -- notice in png.h. Copyright (c) 1995, 1996 Guy Eric -- Schalnat, Group 42, Inc. -- -- Updated/rewritten per request in the libpng FAQ -- Copyright (c) 1995, 1996 Frank J. T. Wojcik -- December 18, 1995 & January 20, 1996 -- --I. Introduction -- --This file describes how to use and modify the PNG reference library --(known as libpng) for your own use. There are five sections to this --file: introduction, structures, reading, writing, and modification and --configuration notes for various special platforms. In addition to this --file, example.c is a good starting point for using the library, as --it is heavily commented and should include everything most people --will need. We assume that libpng is already installed; see the --INSTALL file for instructions on how to install libpng. -- --For examples of libpng usage, see the files "example.c", "pngtest.c", --and the files in the "contrib" directory, all of which are included in the --libpng distribution. -- --Libpng was written as a companion to the PNG specification, as a way --of reducing the amount of time and effort it takes to support the PNG --file format in application programs. -- --The PNG specification (second edition), November 2003, is available as --a W3C Recommendation and as an ISO Standard (ISO/IEC 15948:2003 (E)) at -- -- --The PNG-1.0 specification is available --as RFC 2083 and as a --W3C Recommendation . Some --additional chunks are described in the special-purpose public chunks --documents at . -- --Other information --about PNG, and the latest version of libpng, can be found at the PNG home --page, . -- --Most users will not have to modify the library significantly; advanced --users may want to modify it more. All attempts were made to make it as --complete as possible, while keeping the code easy to understand. --Currently, this library only supports C. Support for other languages --is being considered. -- --Libpng has been designed to handle multiple sessions at one time, --to be easily modifiable, to be portable to the vast majority of --machines (ANSI, K&R, 16-, 32-, and 64-bit) available, and to be easy --to use. The ultimate goal of libpng is to promote the acceptance of --the PNG file format in whatever way possible. While there is still --work to be done (see the TODO file), libpng should cover the --majority of the needs of its users. -- --Libpng uses zlib for its compression and decompression of PNG files. --Further information about zlib, and the latest version of zlib, can --be found at the zlib home page, . --The zlib compression utility is a general purpose utility that is --useful for more than PNG files, and can be used without libpng. --See the documentation delivered with zlib for more details. --You can usually find the source files for the zlib utility wherever you --find the libpng source files. -- --Libpng is thread safe, provided the threads are using different --instances of the structures. Each thread should have its own --png_struct and png_info instances, and thus its own image. --Libpng does not protect itself against two threads using the --same instance of a structure. -- --II. Structures -- --There are two main structures that are important to libpng, png_struct --and png_info. The first, png_struct, is an internal structure that --will not, for the most part, be used by a user except as the first --variable passed to every libpng function call. -- --The png_info structure is designed to provide information about the --PNG file. At one time, the fields of png_info were intended to be --directly accessible to the user. However, this tended to cause problems --with applications using dynamically loaded libraries, and as a result --a set of interface functions for png_info (the png_get_*() and png_set_*() --functions) was developed. The fields of png_info are still available for --older applications, but it is suggested that applications use the new --interfaces if at all possible. -- --Applications that do make direct access to the members of png_struct (except --for png_ptr->jmpbuf) must be recompiled whenever the library is updated, --and applications that make direct access to the members of png_info must --be recompiled if they were compiled or loaded with libpng version 1.0.6, --in which the members were in a different order. In version 1.0.7, the --members of the png_info structure reverted to the old order, as they were --in versions 0.97c through 1.0.5. Starting with version 2.0.0, both --structures are going to be hidden, and the contents of the structures will --only be accessible through the png_get/png_set functions. -- --The png.h header file is an invaluable reference for programming with libpng. --And while I'm on the topic, make sure you include the libpng header file: -- --#include -- --III. Reading -- --We'll now walk you through the possible functions to call when reading --in a PNG file sequentially, briefly explaining the syntax and purpose --of each one. See example.c and png.h for more detail. While --progressive reading is covered in the next section, you will still --need some of the functions discussed in this section to read a PNG --file. -- --Setup -- --You will want to do the I/O initialization(*) before you get into libpng, --so if it doesn't work, you don't have much to undo. Of course, you --will also want to insure that you are, in fact, dealing with a PNG --file. Libpng provides a simple check to see if a file is a PNG file. --To use it, pass in the first 1 to 8 bytes of the file to the function --png_sig_cmp(), and it will return 0 if the bytes match the corresponding --bytes of the PNG signature, or nonzero otherwise. Of course, the more bytes --you pass in, the greater the accuracy of the prediction. -- --If you are intending to keep the file pointer open for use in libpng, --you must ensure you don't read more than 8 bytes from the beginning --of the file, and you also have to make a call to png_set_sig_bytes_read() --with the number of bytes you read from the beginning. Libpng will --then only check the bytes (if any) that your program didn't read. -- --(*): If you are not using the standard I/O functions, you will need --to replace them with custom functions. See the discussion under --Customizing libpng. -- -- -- FILE *fp = fopen(file_name, "rb"); -- if (!fp) -- { -- return (ERROR); -- } -- fread(header, 1, number, fp); -- is_png = !png_sig_cmp(header, 0, number); -- if (!is_png) -- { -- return (NOT_PNG); -- } -- -- --Next, png_struct and png_info need to be allocated and initialized. In --order to ensure that the size of these structures is correct even with a --dynamically linked libpng, there are functions to initialize and --allocate the structures. We also pass the library version, optional --pointers to error handling functions, and a pointer to a data struct for --use by the error functions, if necessary (the pointer and functions can --be NULL if the default error handlers are to be used). See the section --on Changes to Libpng below regarding the old initialization functions. --The structure allocation functions quietly return NULL if they fail to --create the structure, so your application should check for that. -- -- png_structp png_ptr = png_create_read_struct -- (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, -- user_error_fn, user_warning_fn); -- if (!png_ptr) -- return (ERROR); -- -- png_infop info_ptr = png_create_info_struct(png_ptr); -- if (!info_ptr) -- { -- png_destroy_read_struct(&png_ptr, -- (png_infopp)NULL, (png_infopp)NULL); -- return (ERROR); -- } -- -- png_infop end_info = png_create_info_struct(png_ptr); -- if (!end_info) -- { -- png_destroy_read_struct(&png_ptr, &info_ptr, -- (png_infopp)NULL); -- return (ERROR); -- } -- --If you want to use your own memory allocation routines, --define PNG_USER_MEM_SUPPORTED and use --png_create_read_struct_2() instead of png_create_read_struct(): -- -- png_structp png_ptr = png_create_read_struct_2 -- (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, -- user_error_fn, user_warning_fn, (png_voidp) -- user_mem_ptr, user_malloc_fn, user_free_fn); -- --The error handling routines passed to png_create_read_struct() --and the memory alloc/free routines passed to png_create_struct_2() --are only necessary if you are not using the libpng supplied error --handling and memory alloc/free functions. -- --When libpng encounters an error, it expects to longjmp back --to your routine. Therefore, you will need to call setjmp and pass --your png_jmpbuf(png_ptr). If you read the file from different --routines, you will need to update the jmpbuf field every time you enter --a new routine that will call a png_*() function. -- --See your documentation of setjmp/longjmp for your compiler for more --information on setjmp/longjmp. See the discussion on libpng error --handling in the Customizing Libpng section below for more information --on the libpng error handling. If an error occurs, and libpng longjmp's --back to your setjmp, you will want to call png_destroy_read_struct() to --free any memory. -- -- if (setjmp(png_jmpbuf(png_ptr))) -- { -- png_destroy_read_struct(&png_ptr, &info_ptr, -- &end_info); -- fclose(fp); -- return (ERROR); -- } -- --If you would rather avoid the complexity of setjmp/longjmp issues, --you can compile libpng with PNG_SETJMP_NOT_SUPPORTED, in which case --errors will result in a call to PNG_ABORT() which defaults to abort(). -- --Now you need to set up the input code. The default for libpng is to --use the C function fread(). If you use this, you will need to pass a --valid FILE * in the function png_init_io(). Be sure that the file is --opened in binary mode. If you wish to handle reading data in another --way, you need not call the png_init_io() function, but you must then --implement the libpng I/O methods discussed in the Customizing Libpng --section below. -- -- png_init_io(png_ptr, fp); -- --If you had previously opened the file and read any of the signature from --the beginning in order to see if this was a PNG file, you need to let --libpng know that there are some bytes missing from the start of the file. -- -- png_set_sig_bytes(png_ptr, number); -- --Setting up callback code -- --You can set up a callback function to handle any unknown chunks in the --input stream. You must supply the function -- -- read_chunk_callback(png_ptr ptr, -- png_unknown_chunkp chunk); -- { -- /* The unknown chunk structure contains your -- chunk data: */ -- png_byte name[5]; -- png_byte *data; -- png_size_t size; -- /* Note that libpng has already taken care of -- the CRC handling */ -- -- /* put your code here. Return one of the -- following: */ -- -- return (-n); /* chunk had an error */ -- return (0); /* did not recognize */ -- return (n); /* success */ -- } -- --(You can give your function another name that you like instead of --"read_chunk_callback") -- --To inform libpng about your function, use -- -- png_set_read_user_chunk_fn(png_ptr, user_chunk_ptr, -- read_chunk_callback); -- --This names not only the callback function, but also a user pointer that --you can retrieve with -- -- png_get_user_chunk_ptr(png_ptr); -- --At this point, you can set up a callback function that will be --called after each row has been read, which you can use to control --a progress meter or the like. It's demonstrated in pngtest.c. --You must supply a function -- -- void read_row_callback(png_ptr ptr, png_uint_32 row, -- int pass); -- { -- /* put your code here */ -- } -- --(You can give it another name that you like instead of "read_row_callback") -- --To inform libpng about your function, use -- -- png_set_read_status_fn(png_ptr, read_row_callback); -- --Width and height limits -- --The PNG specification allows the width and height of an image to be as --large as 2^31-1 (0x7fffffff), or about 2.147 billion rows and columns. --Since very few applications really need to process such large images, --we have imposed an arbitrary 1-million limit on rows and columns. --Larger images will be rejected immediately with a png_error() call. If --you wish to override this limit, you can use -- -- png_set_user_limits(png_ptr, width_max, height_max); -- --to set your own limits, or use width_max = height_max = 0x7fffffffL --to allow all valid dimensions (libpng may reject some very large images --anyway because of potential buffer overflow conditions). -- --You should put this statement after you create the PNG structure and --before calling png_read_info(), png_read_png(), or png_process_data(). --If you need to retrieve the limits that are being applied, use -- -- width_max = png_get_user_width_max(png_ptr); -- height_max = png_get_user_height_max(png_ptr); -- --Unknown-chunk handling -- --Now you get to set the way the library processes unknown chunks in the --input PNG stream. Both known and unknown chunks will be read. Normal --behavior is that known chunks will be parsed into information in --various info_ptr members; unknown chunks will be discarded. To change --this, you can call: -- -- png_set_keep_unknown_chunks(png_ptr, keep, -- chunk_list, num_chunks); -- keep - 0: do not handle as unknown -- 1: do not keep -- 2: keep only if safe-to-copy -- 3: keep even if unsafe-to-copy -- You can use these definitions: -- PNG_HANDLE_CHUNK_AS_DEFAULT 0 -- PNG_HANDLE_CHUNK_NEVER 1 -- PNG_HANDLE_CHUNK_IF_SAFE 2 -- PNG_HANDLE_CHUNK_ALWAYS 3 -- chunk_list - list of chunks affected (a byte string, -- five bytes per chunk, NULL or '\0' if -- num_chunks is 0) -- num_chunks - number of chunks affected; if 0, all -- unknown chunks are affected. If nonzero, -- only the chunks in the list are affected -- --Unknown chunks declared in this way will be saved as raw data onto a --list of png_unknown_chunk structures. If a chunk that is normally --known to libpng is named in the list, it will be handled as unknown, --according to the "keep" directive. If a chunk is named in successive --instances of png_set_keep_unknown_chunks(), the final instance will --take precedence. The IHDR and IEND chunks should not be named in --chunk_list; if they are, libpng will process them normally anyway. -- --The high-level read interface -- --At this point there are two ways to proceed; through the high-level --read interface, or through a sequence of low-level read operations. --You can use the high-level interface if (a) you are willing to read --the entire image into memory, and (b) the input transformations --you want to do are limited to the following set: -- -- PNG_TRANSFORM_IDENTITY No transformation -- PNG_TRANSFORM_STRIP_16 Strip 16-bit samples to -- 8 bits -- PNG_TRANSFORM_STRIP_ALPHA Discard the alpha channel -- PNG_TRANSFORM_PACKING Expand 1, 2 and 4-bit -- samples to bytes -- PNG_TRANSFORM_PACKSWAP Change order of packed -- pixels to LSB first -- PNG_TRANSFORM_EXPAND Perform set_expand() -- PNG_TRANSFORM_INVERT_MONO Invert monochrome images -- PNG_TRANSFORM_SHIFT Normalize pixels to the -- sBIT depth -- PNG_TRANSFORM_BGR Flip RGB to BGR, RGBA -- to BGRA -- PNG_TRANSFORM_SWAP_ALPHA Flip RGBA to ARGB or GA -- to AG -- PNG_TRANSFORM_INVERT_ALPHA Change alpha from opacity -- to transparency -- PNG_TRANSFORM_SWAP_ENDIAN Byte-swap 16-bit samples -- --(This excludes setting a background color, doing gamma transformation, --dithering, and setting filler.) If this is the case, simply do this: -- -- png_read_png(png_ptr, info_ptr, png_transforms, NULL) -- --where png_transforms is an integer containing the bitwise OR of --some set of transformation flags. This call is equivalent to png_read_info(), --followed the set of transformations indicated by the transform mask, --then png_read_image(), and finally png_read_end(). -- --(The final parameter of this call is not yet used. Someday it might point --to transformation parameters required by some future input transform.) -- --You must use png_transforms and not call any png_set_transform() functions --when you use png_read_png(). -- --After you have called png_read_png(), you can retrieve the image data --with -- -- row_pointers = png_get_rows(png_ptr, info_ptr); -- --where row_pointers is an array of pointers to the pixel data for each row: -- -- png_bytep row_pointers[height]; -- --If you know your image size and pixel size ahead of time, you can allocate --row_pointers prior to calling png_read_png() with -- -- if (height > PNG_UINT_32_MAX/png_sizeof(png_byte)) -- png_error (png_ptr, -- "Image is too tall to process in memory"); -- if (width > PNG_UINT_32_MAX/pixel_size) -- png_error (png_ptr, -- "Image is too wide to process in memory"); -- row_pointers = png_malloc(png_ptr, -- height*png_sizeof(png_bytep)); -- for (int i=0; i) and --png_get_(png_ptr, info_ptr, ...) functions return non-zero if the --data has been read, or zero if it is missing. The parameters to the --png_get_ are set directly if they are simple data types, or a pointer --into the info_ptr is returned for any complex types. -- -- png_get_PLTE(png_ptr, info_ptr, &palette, -- &num_palette); -- palette - the palette for the file -- (array of png_color) -- num_palette - number of entries in the palette -- -- png_get_gAMA(png_ptr, info_ptr, &gamma); -- gamma - the gamma the file is written -- at (PNG_INFO_gAMA) -- -- png_get_sRGB(png_ptr, info_ptr, &srgb_intent); -- srgb_intent - the rendering intent (PNG_INFO_sRGB) -- The presence of the sRGB chunk -- means that the pixel data is in the -- sRGB color space. This chunk also -- implies specific values of gAMA and -- cHRM. -- -- png_get_iCCP(png_ptr, info_ptr, &name, -- &compression_type, &profile, &proflen); -- name - The profile name. -- compression - The compression type; always -- PNG_COMPRESSION_TYPE_BASE for PNG 1.0. -- You may give NULL to this argument to -- ignore it. -- profile - International Color Consortium color -- profile data. May contain NULs. -- proflen - length of profile data in bytes. -- -- png_get_sBIT(png_ptr, info_ptr, &sig_bit); -- sig_bit - the number of significant bits for -- (PNG_INFO_sBIT) each of the gray, -- red, green, and blue channels, -- whichever are appropriate for the -- given color type (png_color_16) -- -- png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, -- &trans_values); -- trans - array of transparent entries for -- palette (PNG_INFO_tRNS) -- trans_values - graylevel or color sample values of -- the single transparent color for -- non-paletted images (PNG_INFO_tRNS) -- num_trans - number of transparent entries -- (PNG_INFO_tRNS) -- -- png_get_hIST(png_ptr, info_ptr, &hist); -- (PNG_INFO_hIST) -- hist - histogram of palette (array of -- png_uint_16) -- -- png_get_tIME(png_ptr, info_ptr, &mod_time); -- mod_time - time image was last modified -- (PNG_VALID_tIME) -- -- png_get_bKGD(png_ptr, info_ptr, &background); -- background - background color (PNG_VALID_bKGD) -- valid 16-bit red, green and blue -- values, regardless of color_type -- -- num_comments = png_get_text(png_ptr, info_ptr, -- &text_ptr, &num_text); -- num_comments - number of comments -- text_ptr - array of png_text holding image -- comments -- text_ptr[i].compression - type of compression used -- on "text" PNG_TEXT_COMPRESSION_NONE -- PNG_TEXT_COMPRESSION_zTXt -- PNG_ITXT_COMPRESSION_NONE -- PNG_ITXT_COMPRESSION_zTXt -- text_ptr[i].key - keyword for comment. Must contain -- 1-79 characters. -- text_ptr[i].text - text comments for current -- keyword. Can be empty. -- text_ptr[i].text_length - length of text string, -- after decompression, 0 for iTXt -- text_ptr[i].itxt_length - length of itxt string, -- after decompression, 0 for tEXt/zTXt -- text_ptr[i].lang - language of comment (empty -- string for unknown). -- text_ptr[i].lang_key - keyword in UTF-8 -- (empty string for unknown). -- num_text - number of comments (same as -- num_comments; you can put NULL here -- to avoid the duplication) -- Note while png_set_text() will accept text, language, -- and translated keywords that can be NULL pointers, the -- structure returned by png_get_text will always contain -- regular zero-terminated C strings. They might be -- empty strings but they will never be NULL pointers. -- -- num_spalettes = png_get_sPLT(png_ptr, info_ptr, -- &palette_ptr); -- palette_ptr - array of palette structures holding -- contents of one or more sPLT chunks -- read. -- num_spalettes - number of sPLT chunks read. -- -- png_get_oFFs(png_ptr, info_ptr, &offset_x, &offset_y, -- &unit_type); -- offset_x - positive offset from the left edge -- of the screen -- offset_y - positive offset from the top edge -- of the screen -- unit_type - PNG_OFFSET_PIXEL, PNG_OFFSET_MICROMETER -- -- png_get_pHYs(png_ptr, info_ptr, &res_x, &res_y, -- &unit_type); -- res_x - pixels/unit physical resolution in -- x direction -- res_y - pixels/unit physical resolution in -- x direction -- unit_type - PNG_RESOLUTION_UNKNOWN, -- PNG_RESOLUTION_METER -- -- png_get_sCAL(png_ptr, info_ptr, &unit, &width, -- &height) -- unit - physical scale units (an integer) -- width - width of a pixel in physical scale units -- height - height of a pixel in physical scale units -- (width and height are doubles) -- -- png_get_sCAL_s(png_ptr, info_ptr, &unit, &width, -- &height) -- unit - physical scale units (an integer) -- width - width of a pixel in physical scale units -- height - height of a pixel in physical scale units -- (width and height are strings like "2.54") -- -- num_unknown_chunks = png_get_unknown_chunks(png_ptr, -- info_ptr, &unknowns) -- unknowns - array of png_unknown_chunk -- structures holding unknown chunks -- unknowns[i].name - name of unknown chunk -- unknowns[i].data - data of unknown chunk -- unknowns[i].size - size of unknown chunk's data -- unknowns[i].location - position of chunk in file -- -- The value of "i" corresponds to the order in which the -- chunks were read from the PNG file or inserted with the -- png_set_unknown_chunks() function. -- --The data from the pHYs chunk can be retrieved in several convenient --forms: -- -- res_x = png_get_x_pixels_per_meter(png_ptr, -- info_ptr) -- res_y = png_get_y_pixels_per_meter(png_ptr, -- info_ptr) -- res_x_and_y = png_get_pixels_per_meter(png_ptr, -- info_ptr) -- res_x = png_get_x_pixels_per_inch(png_ptr, -- info_ptr) -- res_y = png_get_y_pixels_per_inch(png_ptr, -- info_ptr) -- res_x_and_y = png_get_pixels_per_inch(png_ptr, -- info_ptr) -- aspect_ratio = png_get_pixel_aspect_ratio(png_ptr, -- info_ptr) -- -- (Each of these returns 0 [signifying "unknown"] if -- the data is not present or if res_x is 0; -- res_x_and_y is 0 if res_x != res_y) -- --The data from the oFFs chunk can be retrieved in several convenient --forms: -- -- x_offset = png_get_x_offset_microns(png_ptr, info_ptr); -- y_offset = png_get_y_offset_microns(png_ptr, info_ptr); -- x_offset = png_get_x_offset_inches(png_ptr, info_ptr); -- y_offset = png_get_y_offset_inches(png_ptr, info_ptr); -- -- (Each of these returns 0 [signifying "unknown" if both -- x and y are 0] if the data is not present or if the -- chunk is present but the unit is the pixel) -- --For more information, see the png_info definition in png.h and the --PNG specification for chunk contents. Be careful with trusting --rowbytes, as some of the transformations could increase the space --needed to hold a row (expand, filler, gray_to_rgb, etc.). --See png_read_update_info(), below. -- --A quick word about text_ptr and num_text. PNG stores comments in --keyword/text pairs, one pair per chunk, with no limit on the number --of text chunks, and a 2^31 byte limit on their size. While there are --suggested keywords, there is no requirement to restrict the use to these --strings. It is strongly suggested that keywords and text be sensible --to humans (that's the point), so don't use abbreviations. Non-printing --symbols are not allowed. See the PNG specification for more details. --There is also no requirement to have text after the keyword. -- --Keywords should be limited to 79 Latin-1 characters without leading or --trailing spaces, but non-consecutive spaces are allowed within the --keyword. It is possible to have the same keyword any number of times. --The text_ptr is an array of png_text structures, each holding a --pointer to a language string, a pointer to a keyword and a pointer to --a text string. The text string, language code, and translated --keyword may be empty or NULL pointers. The keyword/text --pairs are put into the array in the order that they are received. --However, some or all of the text chunks may be after the image, so, to --make sure you have read all the text chunks, don't mess with these --until after you read the stuff after the image. This will be --mentioned again below in the discussion that goes with png_read_end(). -- --Input transformations -- --After you've read the header information, you can set up the library --to handle any special transformations of the image data. The various --ways to transform the data will be described in the order that they --should occur. This is important, as some of these change the color --type and/or bit depth of the data, and some others only work on --certain color types and bit depths. Even though each transformation --checks to see if it has data that it can do something with, you should --make sure to only enable a transformation if it will be valid for the --data. For example, don't swap red and blue on grayscale data. -- --The colors used for the background and transparency values should be --supplied in the same format/depth as the current image data. They --are stored in the same format/depth as the image data in a bKGD or tRNS --chunk, so this is what libpng expects for this data. The colors are --transformed to keep in sync with the image data when an application --calls the png_read_update_info() routine (see below). -- --Data will be decoded into the supplied row buffers packed into bytes --unless the library has been told to transform it into another format. --For example, 4 bit/pixel paletted or grayscale data will be returned --2 pixels/byte with the leftmost pixel in the high-order bits of the --byte, unless png_set_packing() is called. 8-bit RGB data will be stored --in RGB RGB RGB format unless png_set_filler() or png_set_add_alpha() --is called to insert filler bytes, either before or after each RGB triplet. --16-bit RGB data will be returned RRGGBB RRGGBB, with the most significant --byte of the color value first, unless png_set_strip_16() is called to --transform it to regular RGB RGB triplets, or png_set_filler() or --png_set_add alpha() is called to insert filler bytes, either before or --after each RRGGBB triplet. Similarly, 8-bit or 16-bit grayscale data can --be modified with --png_set_filler(), png_set_add_alpha(), or png_set_strip_16(). -- --The following code transforms grayscale images of less than 8 to 8 bits, --changes paletted images to RGB, and adds a full alpha channel if there is --transparency information in a tRNS chunk. This is most useful on --grayscale images with bit depths of 2 or 4 or if there is a multiple-image --viewing application that wishes to treat all images in the same way. -- -- if (color_type == PNG_COLOR_TYPE_PALETTE) -- png_set_palette_to_rgb(png_ptr); -- -- if (color_type == PNG_COLOR_TYPE_GRAY && -- bit_depth < 8) png_set_expand_gray_1_2_4_to_8(png_ptr); -- -- if (png_get_valid(png_ptr, info_ptr, -- PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png_ptr); -- --These three functions are actually aliases for png_set_expand(), added --in libpng version 1.0.4, with the function names expanded to improve code --readability. In some future version they may actually do different --things. -- --As of libpng version 1.2.9, png_set_expand_gray_1_2_4_to_8() was --added. It expands the sample depth without changing tRNS to alpha. --At the same time, png_set_gray_1_2_4_to_8() was deprecated, and it --will be removed from a future version. -- --PNG can have files with 16 bits per channel. If you only can handle --8 bits per channel, this will strip the pixels down to 8 bit. -- -- if (bit_depth == 16) -- png_set_strip_16(png_ptr); -- --If, for some reason, you don't need the alpha channel on an image, --and you want to remove it rather than combining it with the background --(but the image author certainly had in mind that you *would* combine --it with the background, so that's what you should probably do): -- -- if (color_type & PNG_COLOR_MASK_ALPHA) -- png_set_strip_alpha(png_ptr); -- --In PNG files, the alpha channel in an image --is the level of opacity. If you need the alpha channel in an image to --be the level of transparency instead of opacity, you can invert the --alpha channel (or the tRNS chunk data) after it's read, so that 0 is --fully opaque and 255 (in 8-bit or paletted images) or 65535 (in 16-bit --images) is fully transparent, with -- -- png_set_invert_alpha(png_ptr); -- --PNG files pack pixels of bit depths 1, 2, and 4 into bytes as small as --they can, resulting in, for example, 8 pixels per byte for 1 bit --files. This code expands to 1 pixel per byte without changing the --values of the pixels: -- -- if (bit_depth < 8) -- png_set_packing(png_ptr); -- --PNG files have possible bit depths of 1, 2, 4, 8, and 16. All pixels --stored in a PNG image have been "scaled" or "shifted" up to the next --higher possible bit depth (e.g. from 5 bits/sample in the range [0,31] to --8 bits/sample in the range [0, 255]). However, it is also possible to --convert the PNG pixel data back to the original bit depth of the image. --This call reduces the pixels back down to the original bit depth: -- -- png_color_8p sig_bit; -- -- if (png_get_sBIT(png_ptr, info_ptr, &sig_bit)) -- png_set_shift(png_ptr, sig_bit); -- --PNG files store 3-color pixels in red, green, blue order. This code --changes the storage of the pixels to blue, green, red: -- -- if (color_type == PNG_COLOR_TYPE_RGB || -- color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- png_set_bgr(png_ptr); -- --PNG files store RGB pixels packed into 3 or 6 bytes. This code expands them --into 4 or 8 bytes for windowing systems that need them in this format: -- -- if (color_type == PNG_COLOR_TYPE_RGB) -- png_set_filler(png_ptr, filler, PNG_FILLER_BEFORE); -- --where "filler" is the 8 or 16-bit number to fill with, and the location is --either PNG_FILLER_BEFORE or PNG_FILLER_AFTER, depending upon whether --you want the filler before the RGB or after. This transformation --does not affect images that already have full alpha channels. To add an --opaque alpha channel, use filler=0xff or 0xffff and PNG_FILLER_AFTER which --will generate RGBA pixels. -- --Note that png_set_filler() does not change the color type. If you want --to do that, you can add a true alpha channel with -- -- if (color_type == PNG_COLOR_TYPE_RGB || -- color_type == PNG_COLOR_TYPE_GRAY) -- png_set_add_alpha(png_ptr, filler, PNG_FILLER_AFTER); -- --where "filler" contains the alpha value to assign to each pixel. --This function was added in libpng-1.2.7. -- --If you are reading an image with an alpha channel, and you need the --data as ARGB instead of the normal PNG format RGBA: -- -- if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- png_set_swap_alpha(png_ptr); -- --For some uses, you may want a grayscale image to be represented as --RGB. This code will do that conversion: -- -- if (color_type == PNG_COLOR_TYPE_GRAY || -- color_type == PNG_COLOR_TYPE_GRAY_ALPHA) -- png_set_gray_to_rgb(png_ptr); -- --Conversely, you can convert an RGB or RGBA image to grayscale or grayscale --with alpha. -- -- if (color_type == PNG_COLOR_TYPE_RGB || -- color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- png_set_rgb_to_gray_fixed(png_ptr, error_action, -- int red_weight, int green_weight); -- -- error_action = 1: silently do the conversion -- error_action = 2: issue a warning if the original -- image has any pixel where -- red != green or red != blue -- error_action = 3: issue an error and abort the -- conversion if the original -- image has any pixel where -- red != green or red != blue -- -- red_weight: weight of red component times 100000 -- green_weight: weight of green component times 100000 -- If either weight is negative, default -- weights (21268, 71514) are used. -- --If you have set error_action = 1 or 2, you can --later check whether the image really was gray, after processing --the image rows, with the png_get_rgb_to_gray_status(png_ptr) function. --It will return a png_byte that is zero if the image was gray or --1 if there were any non-gray pixels. bKGD and sBIT data --will be silently converted to grayscale, using the green channel --data, regardless of the error_action setting. -- --With red_weight+green_weight<=100000, --the normalized graylevel is computed: -- -- int rw = red_weight * 65536; -- int gw = green_weight * 65536; -- int bw = 65536 - (rw + gw); -- gray = (rw*red + gw*green + bw*blue)/65536; -- --The default values approximate those recommended in the Charles --Poynton's Color FAQ, --Copyright (c) 1998-01-04 Charles Poynton -- -- Y = 0.212671 * R + 0.715160 * G + 0.072169 * B -- --Libpng approximates this with -- -- Y = 0.21268 * R + 0.7151 * G + 0.07217 * B -- --which can be expressed with integers as -- -- Y = (6969 * R + 23434 * G + 2365 * B)/32768 -- --The calculation is done in a linear colorspace, if the image gamma --is known. -- --If you have a grayscale and you are using png_set_expand_depth(), --png_set_expand(), or png_set_gray_to_rgb to change to truecolor or to --a higher bit-depth, you must either supply the background color as a gray --value at the original file bit-depth (need_expand = 1) or else supply the --background color as an RGB triplet at the final, expanded bit depth --(need_expand = 0). Similarly, if you are reading a paletted image, you --must either supply the background color as a palette index (need_expand = 1) --or as an RGB triplet that may or may not be in the palette (need_expand = 0). -- -- png_color_16 my_background; -- png_color_16p image_background; -- -- if (png_get_bKGD(png_ptr, info_ptr, &image_background)) -- png_set_background(png_ptr, image_background, -- PNG_BACKGROUND_GAMMA_FILE, 1, 1.0); -- else -- png_set_background(png_ptr, &my_background, -- PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0); -- --The png_set_background() function tells libpng to composite images --with alpha or simple transparency against the supplied background --color. If the PNG file contains a bKGD chunk (PNG_INFO_bKGD valid), --you may use this color, or supply another color more suitable for --the current display (e.g., the background color from a web page). You --need to tell libpng whether the color is in the gamma space of the --display (PNG_BACKGROUND_GAMMA_SCREEN for colors you supply), the file --(PNG_BACKGROUND_GAMMA_FILE for colors from the bKGD chunk), or one --that is neither of these gammas (PNG_BACKGROUND_GAMMA_UNIQUE - I don't --know why anyone would use this, but it's here). -- --To properly display PNG images on any kind of system, the application needs --to know what the display gamma is. Ideally, the user will know this, and --the application will allow them to set it. One method of allowing the user --to set the display gamma separately for each system is to check for a --SCREEN_GAMMA or DISPLAY_GAMMA environment variable, which will hopefully be --correctly set. -- --Note that display_gamma is the overall gamma correction required to produce --pleasing results, which depends on the lighting conditions in the surrounding --environment. In a dim or brightly lit room, no compensation other than --the physical gamma exponent of the monitor is needed, while in a dark room --a slightly smaller exponent is better. -- -- double gamma, screen_gamma; -- -- if (/* We have a user-defined screen -- gamma value */) -- { -- screen_gamma = user_defined_screen_gamma; -- } -- /* One way that applications can share the same -- screen gamma value */ -- else if ((gamma_str = getenv("SCREEN_GAMMA")) -- != NULL) -- { -- screen_gamma = (double)atof(gamma_str); -- } -- /* If we don't have another value */ -- else -- { -- screen_gamma = 2.2; /* A good guess for a -- PC monitor in a bright office or a dim room */ -- screen_gamma = 2.0; /* A good guess for a -- PC monitor in a dark room */ -- screen_gamma = 1.7 or 1.0; /* A good -- guess for Mac systems */ -- } -- --The png_set_gamma() function handles gamma transformations of the data. --Pass both the file gamma and the current screen_gamma. If the file does --not have a gamma value, you can pass one anyway if you have an idea what --it is (usually 0.45455 is a good guess for GIF images on PCs). Note --that file gammas are inverted from screen gammas. See the discussions --on gamma in the PNG specification for an excellent description of what --gamma is, and why all applications should support it. It is strongly --recommended that PNG viewers support gamma correction. -- -- if (png_get_gAMA(png_ptr, info_ptr, &gamma)) -- png_set_gamma(png_ptr, screen_gamma, gamma); -- else -- png_set_gamma(png_ptr, screen_gamma, 0.45455); -- --If you need to reduce an RGB file to a paletted file, or if a paletted --file has more entries then will fit on your screen, png_set_dither() --will do that. Note that this is a simple match dither that merely --finds the closest color available. This should work fairly well with --optimized palettes, and fairly badly with linear color cubes. If you --pass a palette that is larger then maximum_colors, the file will --reduce the number of colors in the palette so it will fit into --maximum_colors. If there is a histogram, it will use it to make --more intelligent choices when reducing the palette. If there is no --histogram, it may not do as good a job. -- -- if (color_type & PNG_COLOR_MASK_COLOR) -- { -- if (png_get_valid(png_ptr, info_ptr, -- PNG_INFO_PLTE)) -- { -- png_uint_16p histogram = NULL; -- -- png_get_hIST(png_ptr, info_ptr, -- &histogram); -- png_set_dither(png_ptr, palette, num_palette, -- max_screen_colors, histogram, 1); -- } -- else -- { -- png_color std_color_cube[MAX_SCREEN_COLORS] = -- { ... colors ... }; -- -- png_set_dither(png_ptr, std_color_cube, -- MAX_SCREEN_COLORS, MAX_SCREEN_COLORS, -- NULL,0); -- } -- } -- --PNG files describe monochrome as black being zero and white being one. --The following code will reverse this (make black be one and white be --zero): -- -- if (bit_depth == 1 && color_type == PNG_COLOR_TYPE_GRAY) -- png_set_invert_mono(png_ptr); -- --This function can also be used to invert grayscale and gray-alpha images: -- -- if (color_type == PNG_COLOR_TYPE_GRAY || -- color_type == PNG_COLOR_TYPE_GRAY_ALPHA) -- png_set_invert_mono(png_ptr); -- --PNG files store 16 bit pixels in network byte order (big-endian, --ie. most significant bits first). This code changes the storage to the --other way (little-endian, i.e. least significant bits first, the --way PCs store them): -- -- if (bit_depth == 16) -- png_set_swap(png_ptr); -- --If you are using packed-pixel images (1, 2, or 4 bits/pixel), and you --need to change the order the pixels are packed into bytes, you can use: -- -- if (bit_depth < 8) -- png_set_packswap(png_ptr); -- --Finally, you can write your own transformation function if none of --the existing ones meets your needs. This is done by setting a callback --with -- -- png_set_read_user_transform_fn(png_ptr, -- read_transform_fn); -- --You must supply the function -- -- void read_transform_fn(png_ptr ptr, row_info_ptr -- row_info, png_bytep data) -- --See pngtest.c for a working example. Your function will be called --after all of the other transformations have been processed. -- --You can also set up a pointer to a user structure for use by your --callback function, and you can inform libpng that your transform --function will change the number of channels or bit depth with the --function -- -- png_set_user_transform_info(png_ptr, user_ptr, -- user_depth, user_channels); -- --The user's application, not libpng, is responsible for allocating and --freeing any memory required for the user structure. -- --You can retrieve the pointer via the function --png_get_user_transform_ptr(). For example: -- -- voidp read_user_transform_ptr = -- png_get_user_transform_ptr(png_ptr); -- --The last thing to handle is interlacing; this is covered in detail below, --but you must call the function here if you want libpng to handle expansion --of the interlaced image. -- -- number_of_passes = png_set_interlace_handling(png_ptr); -- --After setting the transformations, libpng can update your png_info --structure to reflect any transformations you've requested with this --call. This is most useful to update the info structure's rowbytes --field so you can use it to allocate your image memory. This function --will also update your palette with the correct screen_gamma and --background if these have been given with the calls above. -- -- png_read_update_info(png_ptr, info_ptr); -- --After you call png_read_update_info(), you can allocate any --memory you need to hold the image. The row data is simply --raw byte data for all forms of images. As the actual allocation --varies among applications, no example will be given. If you --are allocating one large chunk, you will need to build an --array of pointers to each row, as it will be needed for some --of the functions below. -- --Reading image data -- --After you've allocated memory, you can read the image data. --The simplest way to do this is in one function call. If you are --allocating enough memory to hold the whole image, you can just --call png_read_image() and libpng will read in all the image data --and put it in the memory area supplied. You will need to pass in --an array of pointers to each row. -- --This function automatically handles interlacing, so you don't need --to call png_set_interlace_handling() or call this function multiple --times, or any of that other stuff necessary with png_read_rows(). -- -- png_read_image(png_ptr, row_pointers); -- --where row_pointers is: -- -- png_bytep row_pointers[height]; -- --You can point to void or char or whatever you use for pixels. -- --If you don't want to read in the whole image at once, you can --use png_read_rows() instead. If there is no interlacing (check --interlace_type == PNG_INTERLACE_NONE), this is simple: -- -- png_read_rows(png_ptr, row_pointers, NULL, -- number_of_rows); -- --where row_pointers is the same as in the png_read_image() call. -- --If you are doing this just one row at a time, you can do this with --a single row_pointer instead of an array of row_pointers: -- -- png_bytep row_pointer = row; -- png_read_row(png_ptr, row_pointer, NULL); -- --If the file is interlaced (interlace_type != 0 in the IHDR chunk), things --get somewhat harder. The only current (PNG Specification version 1.2) --interlacing type for PNG is (interlace_type == PNG_INTERLACE_ADAM7) --is a somewhat complicated 2D interlace scheme, known as Adam7, that --breaks down an image into seven smaller images of varying size, based --on an 8x8 grid. -- --libpng can fill out those images or it can give them to you "as is". --If you want them filled out, there are two ways to do that. The one --mentioned in the PNG specification is to expand each pixel to cover --those pixels that have not been read yet (the "rectangle" method). --This results in a blocky image for the first pass, which gradually --smooths out as more pixels are read. The other method is the "sparkle" --method, where pixels are drawn only in their final locations, with the --rest of the image remaining whatever colors they were initialized to --before the start of the read. The first method usually looks better, --but tends to be slower, as there are more pixels to put in the rows. -- --If you don't want libpng to handle the interlacing details, just call --png_read_rows() seven times to read in all seven images. Each of the --images is a valid image by itself, or they can all be combined on an --8x8 grid to form a single image (although if you intend to combine them --you would be far better off using the libpng interlace handling). -- --The first pass will return an image 1/8 as wide as the entire image --(every 8th column starting in column 0) and 1/8 as high as the original --(every 8th row starting in row 0), the second will be 1/8 as wide --(starting in column 4) and 1/8 as high (also starting in row 0). The --third pass will be 1/4 as wide (every 4th pixel starting in column 0) and --1/8 as high (every 8th row starting in row 4), and the fourth pass will --be 1/4 as wide and 1/4 as high (every 4th column starting in column 2, --and every 4th row starting in row 0). The fifth pass will return an --image 1/2 as wide, and 1/4 as high (starting at column 0 and row 2), --while the sixth pass will be 1/2 as wide and 1/2 as high as the original --(starting in column 1 and row 0). The seventh and final pass will be as --wide as the original, and 1/2 as high, containing all of the odd --numbered scanlines. Phew! -- --If you want libpng to expand the images, call this before calling --png_start_read_image() or png_read_update_info(): -- -- if (interlace_type == PNG_INTERLACE_ADAM7) -- number_of_passes -- = png_set_interlace_handling(png_ptr); -- --This will return the number of passes needed. Currently, this --is seven, but may change if another interlace type is added. --This function can be called even if the file is not interlaced, --where it will return one pass. -- --If you are not going to display the image after each pass, but are --going to wait until the entire image is read in, use the sparkle --effect. This effect is faster and the end result of either method --is exactly the same. If you are planning on displaying the image --after each pass, the "rectangle" effect is generally considered the --better looking one. -- --If you only want the "sparkle" effect, just call png_read_rows() as --normal, with the third parameter NULL. Make sure you make pass over --the image number_of_passes times, and you don't change the data in the --rows between calls. You can change the locations of the data, just --not the data. Each pass only writes the pixels appropriate for that --pass, and assumes the data from previous passes is still valid. -- -- png_read_rows(png_ptr, row_pointers, NULL, -- number_of_rows); -- --If you only want the first effect (the rectangles), do the same as --before except pass the row buffer in the third parameter, and leave --the second parameter NULL. -- -- png_read_rows(png_ptr, NULL, row_pointers, -- number_of_rows); -- --Finishing a sequential read -- --After you are finished reading the image through the --low-level interface, you can finish reading the file. If you are --interested in comments or time, which may be stored either before or --after the image data, you should pass the separate png_info struct if --you want to keep the comments from before and after the image --separate. If you are not interested, you can pass NULL. -- -- png_read_end(png_ptr, end_info); -- --When you are done, you can free all memory allocated by libpng like this: -- -- png_destroy_read_struct(&png_ptr, &info_ptr, -- &end_info); -- --It is also possible to individually free the info_ptr members that --point to libpng-allocated storage with the following function: -- -- png_free_data(png_ptr, info_ptr, mask, seq) -- mask - identifies data to be freed, a mask -- containing the bitwise OR of one or -- more of -- PNG_FREE_PLTE, PNG_FREE_TRNS, -- PNG_FREE_HIST, PNG_FREE_ICCP, -- PNG_FREE_PCAL, PNG_FREE_ROWS, -- PNG_FREE_SCAL, PNG_FREE_SPLT, -- PNG_FREE_TEXT, PNG_FREE_UNKN, -- or simply PNG_FREE_ALL -- seq - sequence number of item to be freed -- (-1 for all items) -- --This function may be safely called when the relevant storage has --already been freed, or has not yet been allocated, or was allocated --by the user and not by libpng, and will in those --cases do nothing. The "seq" parameter is ignored if only one item --of the selected data type, such as PLTE, is allowed. If "seq" is not ---1, and multiple items are allowed for the data type identified in --the mask, such as text or sPLT, only the n'th item in the structure --is freed, where n is "seq". -- --The default behavior is only to free data that was allocated internally --by libpng. This can be changed, so that libpng will not free the data, --or so that it will free data that was allocated by the user with png_malloc() --or png_zalloc() and passed in via a png_set_*() function, with -- -- png_data_freer(png_ptr, info_ptr, freer, mask) -- mask - which data elements are affected -- same choices as in png_free_data() -- freer - one of -- PNG_DESTROY_WILL_FREE_DATA -- PNG_SET_WILL_FREE_DATA -- PNG_USER_WILL_FREE_DATA -- --This function only affects data that has already been allocated. --You can call this function after reading the PNG data but before calling --any png_set_*() functions, to control whether the user or the png_set_*() --function is responsible for freeing any existing data that might be present, --and again after the png_set_*() functions to control whether the user --or png_destroy_*() is supposed to free the data. When the user assumes --responsibility for libpng-allocated data, the application must use --png_free() to free it, and when the user transfers responsibility to libpng --for data that the user has allocated, the user must have used png_malloc() --or png_zalloc() to allocate it. -- --If you allocated your row_pointers in a single block, as suggested above in --the description of the high level read interface, you must not transfer --responsibility for freeing it to the png_set_rows or png_read_destroy function, --because they would also try to free the individual row_pointers[i]. -- --If you allocated text_ptr.text, text_ptr.lang, and text_ptr.translated_keyword --separately, do not transfer responsibility for freeing text_ptr to libpng, --because when libpng fills a png_text structure it combines these members with --the key member, and png_free_data() will free only text_ptr.key. Similarly, --if you transfer responsibility for free'ing text_ptr from libpng to your --application, your application must not separately free those members. -- --The png_free_data() function will turn off the "valid" flag for anything --it frees. If you need to turn the flag off for a chunk that was freed by your --application instead of by libpng, you can use -- -- png_set_invalid(png_ptr, info_ptr, mask); -- mask - identifies the chunks to be made invalid, -- containing the bitwise OR of one or -- more of -- PNG_INFO_gAMA, PNG_INFO_sBIT, -- PNG_INFO_cHRM, PNG_INFO_PLTE, -- PNG_INFO_tRNS, PNG_INFO_bKGD, -- PNG_INFO_hIST, PNG_INFO_pHYs, -- PNG_INFO_oFFs, PNG_INFO_tIME, -- PNG_INFO_pCAL, PNG_INFO_sRGB, -- PNG_INFO_iCCP, PNG_INFO_sPLT, -- PNG_INFO_sCAL, PNG_INFO_IDAT -- --For a more compact example of reading a PNG image, see the file example.c. -- --Reading PNG files progressively -- --The progressive reader is slightly different then the non-progressive --reader. Instead of calling png_read_info(), png_read_rows(), and --png_read_end(), you make one call to png_process_data(), which calls --callbacks when it has the info, a row, or the end of the image. You --set up these callbacks with png_set_progressive_read_fn(). You don't --have to worry about the input/output functions of libpng, as you are --giving the library the data directly in png_process_data(). I will --assume that you have read the section on reading PNG files above, --so I will only highlight the differences (although I will show --all of the code). -- --png_structp png_ptr; --png_infop info_ptr; -- -- /* An example code fragment of how you would -- initialize the progressive reader in your -- application. */ -- int -- initialize_png_reader() -- { -- png_ptr = png_create_read_struct -- (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, -- user_error_fn, user_warning_fn); -- if (!png_ptr) -- return (ERROR); -- info_ptr = png_create_info_struct(png_ptr); -- if (!info_ptr) -- { -- png_destroy_read_struct(&png_ptr, (png_infopp)NULL, -- (png_infopp)NULL); -- return (ERROR); -- } -- -- if (setjmp(png_jmpbuf(png_ptr))) -- { -- png_destroy_read_struct(&png_ptr, &info_ptr, -- (png_infopp)NULL); -- return (ERROR); -- } -- -- /* This one's new. You can provide functions -- to be called when the header info is valid, -- when each row is completed, and when the image -- is finished. If you aren't using all functions, -- you can specify NULL parameters. Even when all -- three functions are NULL, you need to call -- png_set_progressive_read_fn(). You can use -- any struct as the user_ptr (cast to a void pointer -- for the function call), and retrieve the pointer -- from inside the callbacks using the function -- -- png_get_progressive_ptr(png_ptr); -- -- which will return a void pointer, which you have -- to cast appropriately. -- */ -- png_set_progressive_read_fn(png_ptr, (void *)user_ptr, -- info_callback, row_callback, end_callback); -- -- return 0; -- } -- -- /* A code fragment that you call as you receive blocks -- of data */ -- int -- process_data(png_bytep buffer, png_uint_32 length) -- { -- if (setjmp(png_jmpbuf(png_ptr))) -- { -- png_destroy_read_struct(&png_ptr, &info_ptr, -- (png_infopp)NULL); -- return (ERROR); -- } -- -- /* This one's new also. Simply give it a chunk -- of data from the file stream (in order, of -- course). On machines with segmented memory -- models machines, don't give it any more than -- 64K. The library seems to run fine with sizes -- of 4K. Although you can give it much less if -- necessary (I assume you can give it chunks of -- 1 byte, I haven't tried less then 256 bytes -- yet). When this function returns, you may -- want to display any rows that were generated -- in the row callback if you don't already do -- so there. -- */ -- png_process_data(png_ptr, info_ptr, buffer, length); -- return 0; -- } -- -- /* This function is called (as set by -- png_set_progressive_read_fn() above) when enough data -- has been supplied so all of the header has been -- read. -- */ -- void -- info_callback(png_structp png_ptr, png_infop info) -- { -- /* Do any setup here, including setting any of -- the transformations mentioned in the Reading -- PNG files section. For now, you _must_ call -- either png_start_read_image() or -- png_read_update_info() after all the -- transformations are set (even if you don't set -- any). You may start getting rows before -- png_process_data() returns, so this is your -- last chance to prepare for that. -- */ -- } -- -- /* This function is called when each row of image -- data is complete */ -- void -- row_callback(png_structp png_ptr, png_bytep new_row, -- png_uint_32 row_num, int pass) -- { -- /* If the image is interlaced, and you turned -- on the interlace handler, this function will -- be called for every row in every pass. Some -- of these rows will not be changed from the -- previous pass. When the row is not changed, -- the new_row variable will be NULL. The rows -- and passes are called in order, so you don't -- really need the row_num and pass, but I'm -- supplying them because it may make your life -- easier. -- -- For the non-NULL rows of interlaced images, -- you must call png_progressive_combine_row() -- passing in the row and the old row. You can -- call this function for NULL rows (it will just -- return) and for non-interlaced images (it just -- does the memcpy for you) if it will make the -- code easier. Thus, you can just do this for -- all cases: -- */ -- -- png_progressive_combine_row(png_ptr, old_row, -- new_row); -- -- /* where old_row is what was displayed for -- previously for the row. Note that the first -- pass (pass == 0, really) will completely cover -- the old row, so the rows do not have to be -- initialized. After the first pass (and only -- for interlaced images), you will have to pass -- the current row, and the function will combine -- the old row and the new row. -- */ -- } -- -- void -- end_callback(png_structp png_ptr, png_infop info) -- { -- /* This function is called after the whole image -- has been read, including any chunks after the -- image (up to and including the IEND). You -- will usually have the same info chunk as you -- had in the header, although some data may have -- been added to the comments and time fields. -- -- Most people won't do much here, perhaps setting -- a flag that marks the image as finished. -- */ -- } -- -- -- --IV. Writing -- --Much of this is very similar to reading. However, everything of --importance is repeated here, so you won't have to constantly look --back up in the reading section to understand writing. -- --Setup -- --You will want to do the I/O initialization before you get into libpng, --so if it doesn't work, you don't have anything to undo. If you are not --using the standard I/O functions, you will need to replace them with --custom writing functions. See the discussion under Customizing libpng. -- -- FILE *fp = fopen(file_name, "wb"); -- if (!fp) -- { -- return (ERROR); -- } -- --Next, png_struct and png_info need to be allocated and initialized. --As these can be both relatively large, you may not want to store these --on the stack, unless you have stack space to spare. Of course, you --will want to check if they return NULL. If you are also reading, --you won't want to name your read structure and your write structure --both "png_ptr"; you can call them anything you like, such as --"read_ptr" and "write_ptr". Look at pngtest.c, for example. -- -- png_structp png_ptr = png_create_write_struct -- (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, -- user_error_fn, user_warning_fn); -- if (!png_ptr) -- return (ERROR); -- -- png_infop info_ptr = png_create_info_struct(png_ptr); -- if (!info_ptr) -- { -- png_destroy_write_struct(&png_ptr, -- (png_infopp)NULL); -- return (ERROR); -- } -- --If you want to use your own memory allocation routines, --define PNG_USER_MEM_SUPPORTED and use --png_create_write_struct_2() instead of png_create_write_struct(): -- -- png_structp png_ptr = png_create_write_struct_2 -- (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, -- user_error_fn, user_warning_fn, (png_voidp) -- user_mem_ptr, user_malloc_fn, user_free_fn); -- --After you have these structures, you will need to set up the --error handling. When libpng encounters an error, it expects to --longjmp() back to your routine. Therefore, you will need to call --setjmp() and pass the png_jmpbuf(png_ptr). If you --write the file from different routines, you will need to update --the png_jmpbuf(png_ptr) every time you enter a new routine that will --call a png_*() function. See your documentation of setjmp/longjmp --for your compiler for more information on setjmp/longjmp. See --the discussion on libpng error handling in the Customizing Libpng --section below for more information on the libpng error handling. -- -- if (setjmp(png_jmpbuf(png_ptr))) -- { -- png_destroy_write_struct(&png_ptr, &info_ptr); -- fclose(fp); -- return (ERROR); -- } -- ... -- return; -- --If you would rather avoid the complexity of setjmp/longjmp issues, --you can compile libpng with PNG_SETJMP_NOT_SUPPORTED, in which case --errors will result in a call to PNG_ABORT() which defaults to abort(). -- --Now you need to set up the output code. The default for libpng is to --use the C function fwrite(). If you use this, you will need to pass a --valid FILE * in the function png_init_io(). Be sure that the file is --opened in binary mode. Again, if you wish to handle writing data in --another way, see the discussion on libpng I/O handling in the Customizing --Libpng section below. -- -- png_init_io(png_ptr, fp); -- --If you are embedding your PNG into a datastream such as MNG, and don't --want libpng to write the 8-byte signature, or if you have already --written the signature in your application, use -- -- png_set_sig_bytes(png_ptr, 8); -- --to inform libpng that it should not write a signature. -- --Write callbacks -- --At this point, you can set up a callback function that will be --called after each row has been written, which you can use to control --a progress meter or the like. It's demonstrated in pngtest.c. --You must supply a function -- -- void write_row_callback(png_ptr, png_uint_32 row, -- int pass); -- { -- /* put your code here */ -- } -- --(You can give it another name that you like instead of "write_row_callback") -- --To inform libpng about your function, use -- -- png_set_write_status_fn(png_ptr, write_row_callback); -- --You now have the option of modifying how the compression library will --run. The following functions are mainly for testing, but may be useful --in some cases, like if you need to write PNG files extremely fast and --are willing to give up some compression, or if you want to get the --maximum possible compression at the expense of slower writing. If you --have no special needs in this area, let the library do what it wants by --not calling this function at all, as it has been tuned to deliver a good --speed/compression ratio. The second parameter to png_set_filter() is --the filter method, for which the only valid values are 0 (as of the --July 1999 PNG specification, version 1.2) or 64 (if you are writing --a PNG datastream that is to be embedded in a MNG datastream). The third --parameter is a flag that indicates which filter type(s) are to be tested --for each scanline. See the PNG specification for details on the specific filter --types. -- -- -- /* turn on or off filtering, and/or choose -- specific filters. You can use either a single -- PNG_FILTER_VALUE_NAME or the bitwise OR of one -- or more PNG_FILTER_NAME masks. */ -- png_set_filter(png_ptr, 0, -- PNG_FILTER_NONE | PNG_FILTER_VALUE_NONE | -- PNG_FILTER_SUB | PNG_FILTER_VALUE_SUB | -- PNG_FILTER_UP | PNG_FILTER_VALUE_UP | -- PNG_FILTER_AVE | PNG_FILTER_VALUE_AVE | -- PNG_FILTER_PAETH | PNG_FILTER_VALUE_PAETH| -- PNG_ALL_FILTERS); -- --If an application --wants to start and stop using particular filters during compression, --it should start out with all of the filters (to ensure that the previous --row of pixels will be stored in case it's needed later), and then add --and remove them after the start of compression. -- --If you are writing a PNG datastream that is to be embedded in a MNG --datastream, the second parameter can be either 0 or 64. -- --The png_set_compression_*() functions interface to the zlib compression --library, and should mostly be ignored unless you really know what you are --doing. The only generally useful call is png_set_compression_level() --which changes how much time zlib spends on trying to compress the image --data. See the Compression Library (zlib.h and algorithm.txt, distributed --with zlib) for details on the compression levels. -- -- /* set the zlib compression level */ -- png_set_compression_level(png_ptr, -- Z_BEST_COMPRESSION); -- -- /* set other zlib parameters */ -- png_set_compression_mem_level(png_ptr, 8); -- png_set_compression_strategy(png_ptr, -- Z_DEFAULT_STRATEGY); -- png_set_compression_window_bits(png_ptr, 15); -- png_set_compression_method(png_ptr, 8); -- png_set_compression_buffer_size(png_ptr, 8192) -- --extern PNG_EXPORT(void,png_set_zbuf_size) -- --Setting the contents of info for output -- --You now need to fill in the png_info structure with all the data you --wish to write before the actual image. Note that the only thing you --are allowed to write after the image is the text chunks and the time --chunk (as of PNG Specification 1.2, anyway). See png_write_end() and --the latest PNG specification for more information on that. If you --wish to write them before the image, fill them in now, and flag that --data as being valid. If you want to wait until after the data, don't --fill them until png_write_end(). For all the fields in png_info and --their data types, see png.h. For explanations of what the fields --contain, see the PNG specification. -- --Some of the more important parts of the png_info are: -- -- png_set_IHDR(png_ptr, info_ptr, width, height, -- bit_depth, color_type, interlace_type, -- compression_type, filter_method) -- width - holds the width of the image -- in pixels (up to 2^31). -- height - holds the height of the image -- in pixels (up to 2^31). -- bit_depth - holds the bit depth of one of the -- image channels. -- (valid values are 1, 2, 4, 8, 16 -- and depend also on the -- color_type. See also significant -- bits (sBIT) below). -- color_type - describes which color/alpha -- channels are present. -- PNG_COLOR_TYPE_GRAY -- (bit depths 1, 2, 4, 8, 16) -- PNG_COLOR_TYPE_GRAY_ALPHA -- (bit depths 8, 16) -- PNG_COLOR_TYPE_PALETTE -- (bit depths 1, 2, 4, 8) -- PNG_COLOR_TYPE_RGB -- (bit_depths 8, 16) -- PNG_COLOR_TYPE_RGB_ALPHA -- (bit_depths 8, 16) -- -- PNG_COLOR_MASK_PALETTE -- PNG_COLOR_MASK_COLOR -- PNG_COLOR_MASK_ALPHA -- -- interlace_type - PNG_INTERLACE_NONE or -- PNG_INTERLACE_ADAM7 -- compression_type - (must be -- PNG_COMPRESSION_TYPE_DEFAULT) -- filter_method - (must be PNG_FILTER_TYPE_DEFAULT -- or, if you are writing a PNG to -- be embedded in a MNG datastream, -- can also be -- PNG_INTRAPIXEL_DIFFERENCING) -- -- png_set_PLTE(png_ptr, info_ptr, palette, -- num_palette); -- palette - the palette for the file -- (array of png_color) -- num_palette - number of entries in the palette -- -- png_set_gAMA(png_ptr, info_ptr, gamma); -- gamma - the gamma the image was created -- at (PNG_INFO_gAMA) -- -- png_set_sRGB(png_ptr, info_ptr, srgb_intent); -- srgb_intent - the rendering intent -- (PNG_INFO_sRGB) The presence of -- the sRGB chunk means that the pixel -- data is in the sRGB color space. -- This chunk also implies specific -- values of gAMA and cHRM. Rendering -- intent is the CSS-1 property that -- has been defined by the International -- Color Consortium -- (http://www.color.org). -- It can be one of -- PNG_sRGB_INTENT_SATURATION, -- PNG_sRGB_INTENT_PERCEPTUAL, -- PNG_sRGB_INTENT_ABSOLUTE, or -- PNG_sRGB_INTENT_RELATIVE. -- -- -- png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, -- srgb_intent); -- srgb_intent - the rendering intent -- (PNG_INFO_sRGB) The presence of the -- sRGB chunk means that the pixel -- data is in the sRGB color space. -- This function also causes gAMA and -- cHRM chunks with the specific values -- that are consistent with sRGB to be -- written. -- -- png_set_iCCP(png_ptr, info_ptr, name, compression_type, -- profile, proflen); -- name - The profile name. -- compression - The compression type; always -- PNG_COMPRESSION_TYPE_BASE for PNG 1.0. -- You may give NULL to this argument to -- ignore it. -- profile - International Color Consortium color -- profile data. May contain NULs. -- proflen - length of profile data in bytes. -- -- png_set_sBIT(png_ptr, info_ptr, sig_bit); -- sig_bit - the number of significant bits for -- (PNG_INFO_sBIT) each of the gray, red, -- green, and blue channels, whichever are -- appropriate for the given color type -- (png_color_16) -- -- png_set_tRNS(png_ptr, info_ptr, trans, num_trans, -- trans_values); -- trans - array of transparent entries for -- palette (PNG_INFO_tRNS) -- trans_values - graylevel or color sample values of -- the single transparent color for -- non-paletted images (PNG_INFO_tRNS) -- num_trans - number of transparent entries -- (PNG_INFO_tRNS) -- -- png_set_hIST(png_ptr, info_ptr, hist); -- (PNG_INFO_hIST) -- hist - histogram of palette (array of -- png_uint_16) -- -- png_set_tIME(png_ptr, info_ptr, mod_time); -- mod_time - time image was last modified -- (PNG_VALID_tIME) -- -- png_set_bKGD(png_ptr, info_ptr, background); -- background - background color (PNG_VALID_bKGD) -- -- png_set_text(png_ptr, info_ptr, text_ptr, num_text); -- text_ptr - array of png_text holding image -- comments -- text_ptr[i].compression - type of compression used -- on "text" PNG_TEXT_COMPRESSION_NONE -- PNG_TEXT_COMPRESSION_zTXt -- PNG_ITXT_COMPRESSION_NONE -- PNG_ITXT_COMPRESSION_zTXt -- text_ptr[i].key - keyword for comment. Must contain -- 1-79 characters. -- text_ptr[i].text - text comments for current -- keyword. Can be NULL or empty. -- text_ptr[i].text_length - length of text string, -- after decompression, 0 for iTXt -- text_ptr[i].itxt_length - length of itxt string, -- after decompression, 0 for tEXt/zTXt -- text_ptr[i].lang - language of comment (NULL or -- empty for unknown). -- text_ptr[i].translated_keyword - keyword in UTF-8 (NULL -- or empty for unknown). -- num_text - number of comments -- -- png_set_sPLT(png_ptr, info_ptr, &palette_ptr, -- num_spalettes); -- palette_ptr - array of png_sPLT_struct structures -- to be added to the list of palettes -- in the info structure. -- num_spalettes - number of palette structures to be -- added. -- -- png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, -- unit_type); -- offset_x - positive offset from the left -- edge of the screen -- offset_y - positive offset from the top -- edge of the screen -- unit_type - PNG_OFFSET_PIXEL, PNG_OFFSET_MICROMETER -- -- png_set_pHYs(png_ptr, info_ptr, res_x, res_y, -- unit_type); -- res_x - pixels/unit physical resolution -- in x direction -- res_y - pixels/unit physical resolution -- in y direction -- unit_type - PNG_RESOLUTION_UNKNOWN, -- PNG_RESOLUTION_METER -- -- png_set_sCAL(png_ptr, info_ptr, unit, width, height) -- unit - physical scale units (an integer) -- width - width of a pixel in physical scale units -- height - height of a pixel in physical scale units -- (width and height are doubles) -- -- png_set_sCAL_s(png_ptr, info_ptr, unit, width, height) -- unit - physical scale units (an integer) -- width - width of a pixel in physical scale units -- height - height of a pixel in physical scale units -- (width and height are strings like "2.54") -- -- png_set_unknown_chunks(png_ptr, info_ptr, &unknowns, -- num_unknowns) -- unknowns - array of png_unknown_chunk -- structures holding unknown chunks -- unknowns[i].name - name of unknown chunk -- unknowns[i].data - data of unknown chunk -- unknowns[i].size - size of unknown chunk's data -- unknowns[i].location - position to write chunk in file -- 0: do not write chunk -- PNG_HAVE_IHDR: before PLTE -- PNG_HAVE_PLTE: before IDAT -- PNG_AFTER_IDAT: after IDAT -- --The "location" member is set automatically according to --what part of the output file has already been written. --You can change its value after calling png_set_unknown_chunks() --as demonstrated in pngtest.c. Within each of the "locations", --the chunks are sequenced according to their position in the --structure (that is, the value of "i", which is the order in which --the chunk was either read from the input file or defined with --png_set_unknown_chunks). -- --A quick word about text and num_text. text is an array of png_text --structures. num_text is the number of valid structures in the array. --Each png_text structure holds a language code, a keyword, a text value, --and a compression type. -- --The compression types have the same valid numbers as the compression --types of the image data. Currently, the only valid number is zero. --However, you can store text either compressed or uncompressed, unlike --images, which always have to be compressed. So if you don't want the --text compressed, set the compression type to PNG_TEXT_COMPRESSION_NONE. --Because tEXt and zTXt chunks don't have a language field, if you --specify PNG_TEXT_COMPRESSION_NONE or PNG_TEXT_COMPRESSION_zTXt --any language code or translated keyword will not be written out. -- --Until text gets around 1000 bytes, it is not worth compressing it. --After the text has been written out to the file, the compression type --is set to PNG_TEXT_COMPRESSION_NONE_WR or PNG_TEXT_COMPRESSION_zTXt_WR, --so that it isn't written out again at the end (in case you are calling --png_write_end() with the same struct. -- --The keywords that are given in the PNG Specification are: -- -- Title Short (one line) title or -- caption for image -- Author Name of image's creator -- Description Description of image (possibly long) -- Copyright Copyright notice -- Creation Time Time of original image creation -- (usually RFC 1123 format, see below) -- Software Software used to create the image -- Disclaimer Legal disclaimer -- Warning Warning of nature of content -- Source Device used to create the image -- Comment Miscellaneous comment; conversion -- from other image format -- --The keyword-text pairs work like this. Keywords should be short --simple descriptions of what the comment is about. Some typical --keywords are found in the PNG specification, as is some recommendations --on keywords. You can repeat keywords in a file. You can even write --some text before the image and some after. For example, you may want --to put a description of the image before the image, but leave the --disclaimer until after, so viewers working over modem connections --don't have to wait for the disclaimer to go over the modem before --they start seeing the image. Finally, keywords should be full --words, not abbreviations. Keywords and text are in the ISO 8859-1 --(Latin-1) character set (a superset of regular ASCII) and can not --contain NUL characters, and should not contain control or other --unprintable characters. To make the comments widely readable, stick --with basic ASCII, and avoid machine specific character set extensions --like the IBM-PC character set. The keyword must be present, but --you can leave off the text string on non-compressed pairs. --Compressed pairs must have a text string, as only the text string --is compressed anyway, so the compression would be meaningless. -- --PNG supports modification time via the png_time structure. Two --conversion routines are provided, png_convert_from_time_t() for --time_t and png_convert_from_struct_tm() for struct tm. The --time_t routine uses gmtime(). You don't have to use either of --these, but if you wish to fill in the png_time structure directly, --you should provide the time in universal time (GMT) if possible --instead of your local time. Note that the year number is the full --year (e.g. 1998, rather than 98 - PNG is year 2000 compliant!), and --that months start with 1. -- --If you want to store the time of the original image creation, you should --use a plain tEXt chunk with the "Creation Time" keyword. This is --necessary because the "creation time" of a PNG image is somewhat vague, --depending on whether you mean the PNG file, the time the image was --created in a non-PNG format, a still photo from which the image was --scanned, or possibly the subject matter itself. In order to facilitate --machine-readable dates, it is recommended that the "Creation Time" --tEXt chunk use RFC 1123 format dates (e.g. "22 May 1997 18:07:10 GMT"), --although this isn't a requirement. Unlike the tIME chunk, the --"Creation Time" tEXt chunk is not expected to be automatically changed --by the software. To facilitate the use of RFC 1123 dates, a function --png_convert_to_rfc1123(png_timep) is provided to convert from PNG --time to an RFC 1123 format string. -- --Writing unknown chunks -- --You can use the png_set_unknown_chunks function to queue up chunks --for writing. You give it a chunk name, raw data, and a size; that's --all there is to it. The chunks will be written by the next following --png_write_info_before_PLTE, png_write_info, or png_write_end function. --Any chunks previously read into the info structure's unknown-chunk --list will also be written out in a sequence that satisfies the PNG --specification's ordering rules. -- --The high-level write interface -- --At this point there are two ways to proceed; through the high-level --write interface, or through a sequence of low-level write operations. --You can use the high-level interface if your image data is present --in the info structure. All defined output --transformations are permitted, enabled by the following masks. -- -- PNG_TRANSFORM_IDENTITY No transformation -- PNG_TRANSFORM_PACKING Pack 1, 2 and 4-bit samples -- PNG_TRANSFORM_PACKSWAP Change order of packed -- pixels to LSB first -- PNG_TRANSFORM_INVERT_MONO Invert monochrome images -- PNG_TRANSFORM_SHIFT Normalize pixels to the -- sBIT depth -- PNG_TRANSFORM_BGR Flip RGB to BGR, RGBA -- to BGRA -- PNG_TRANSFORM_SWAP_ALPHA Flip RGBA to ARGB or GA -- to AG -- PNG_TRANSFORM_INVERT_ALPHA Change alpha from opacity -- to transparency -- PNG_TRANSFORM_SWAP_ENDIAN Byte-swap 16-bit samples -- PNG_TRANSFORM_STRIP_FILLER Strip out filler bytes. -- --If you have valid image data in the info structure (you can use --png_set_rows() to put image data in the info structure), simply do this: -- -- png_write_png(png_ptr, info_ptr, png_transforms, NULL) -- --where png_transforms is an integer containing the bitwise OR of some set of --transformation flags. This call is equivalent to png_write_info(), --followed the set of transformations indicated by the transform mask, --then png_write_image(), and finally png_write_end(). -- --(The final parameter of this call is not yet used. Someday it might point --to transformation parameters required by some future output transform.) -- --You must use png_transforms and not call any png_set_transform() functions --when you use png_write_png(). -- --The low-level write interface -- --If you are going the low-level route instead, you are now ready to --write all the file information up to the actual image data. You do --this with a call to png_write_info(). -- -- png_write_info(png_ptr, info_ptr); -- --Note that there is one transformation you may need to do before --png_write_info(). In PNG files, the alpha channel in an image is the --level of opacity. If your data is supplied as a level of --transparency, you can invert the alpha channel before you write it, so --that 0 is fully transparent and 255 (in 8-bit or paletted images) or --65535 (in 16-bit images) is fully opaque, with -- -- png_set_invert_alpha(png_ptr); -- --This must appear before png_write_info() instead of later with the --other transformations because in the case of paletted images the tRNS --chunk data has to be inverted before the tRNS chunk is written. If --your image is not a paletted image, the tRNS data (which in such cases --represents a single color to be rendered as transparent) won't need to --be changed, and you can safely do this transformation after your --png_write_info() call. -- --If you need to write a private chunk that you want to appear before --the PLTE chunk when PLTE is present, you can write the PNG info in --two steps, and insert code to write your own chunk between them: -- -- png_write_info_before_PLTE(png_ptr, info_ptr); -- png_set_unknown_chunks(png_ptr, info_ptr, ...); -- png_write_info(png_ptr, info_ptr); -- --After you've written the file information, you can set up the library --to handle any special transformations of the image data. The various --ways to transform the data will be described in the order that they --should occur. This is important, as some of these change the color --type and/or bit depth of the data, and some others only work on --certain color types and bit depths. Even though each transformation --checks to see if it has data that it can do something with, you should --make sure to only enable a transformation if it will be valid for the --data. For example, don't swap red and blue on grayscale data. -- --PNG files store RGB pixels packed into 3 or 6 bytes. This code tells --the library to strip input data that has 4 or 8 bytes per pixel down --to 3 or 6 bytes (or strip 2 or 4-byte grayscale+filler data to 1 or 2 --bytes per pixel). -- -- png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); -- --where the 0 is unused, and the location is either PNG_FILLER_BEFORE or --PNG_FILLER_AFTER, depending upon whether the filler byte in the pixel --is stored XRGB or RGBX. -- --PNG files pack pixels of bit depths 1, 2, and 4 into bytes as small as --they can, resulting in, for example, 8 pixels per byte for 1 bit files. --If the data is supplied at 1 pixel per byte, use this code, which will --correctly pack the pixels into a single byte: -- -- png_set_packing(png_ptr); -- --PNG files reduce possible bit depths to 1, 2, 4, 8, and 16. If your --data is of another bit depth, you can write an sBIT chunk into the --file so that decoders can recover the original data if desired. -- -- /* Set the true bit depth of the image data */ -- if (color_type & PNG_COLOR_MASK_COLOR) -- { -- sig_bit.red = true_bit_depth; -- sig_bit.green = true_bit_depth; -- sig_bit.blue = true_bit_depth; -- } -- else -- { -- sig_bit.gray = true_bit_depth; -- } -- if (color_type & PNG_COLOR_MASK_ALPHA) -- { -- sig_bit.alpha = true_bit_depth; -- } -- -- png_set_sBIT(png_ptr, info_ptr, &sig_bit); -- --If the data is stored in the row buffer in a bit depth other than --one supported by PNG (e.g. 3 bit data in the range 0-7 for a 4-bit PNG), --this will scale the values to appear to be the correct bit depth as --is required by PNG. -- -- png_set_shift(png_ptr, &sig_bit); -- --PNG files store 16 bit pixels in network byte order (big-endian, --ie. most significant bits first). This code would be used if they are --supplied the other way (little-endian, i.e. least significant bits --first, the way PCs store them): -- -- if (bit_depth > 8) -- png_set_swap(png_ptr); -- --If you are using packed-pixel images (1, 2, or 4 bits/pixel), and you --need to change the order the pixels are packed into bytes, you can use: -- -- if (bit_depth < 8) -- png_set_packswap(png_ptr); -- --PNG files store 3 color pixels in red, green, blue order. This code --would be used if they are supplied as blue, green, red: -- -- png_set_bgr(png_ptr); -- --PNG files describe monochrome as black being zero and white being --one. This code would be used if the pixels are supplied with this reversed --(black being one and white being zero): -- -- png_set_invert_mono(png_ptr); -- --Finally, you can write your own transformation function if none of --the existing ones meets your needs. This is done by setting a callback --with -- -- png_set_write_user_transform_fn(png_ptr, -- write_transform_fn); -- --You must supply the function -- -- void write_transform_fn(png_ptr ptr, row_info_ptr -- row_info, png_bytep data) -- --See pngtest.c for a working example. Your function will be called --before any of the other transformations are processed. -- --You can also set up a pointer to a user structure for use by your --callback function. -- -- png_set_user_transform_info(png_ptr, user_ptr, 0, 0); -- --The user_channels and user_depth parameters of this function are ignored --when writing; you can set them to zero as shown. -- --You can retrieve the pointer via the function png_get_user_transform_ptr(). --For example: -- -- voidp write_user_transform_ptr = -- png_get_user_transform_ptr(png_ptr); -- --It is possible to have libpng flush any pending output, either manually, --or automatically after a certain number of lines have been written. To --flush the output stream a single time call: -- -- png_write_flush(png_ptr); -- --and to have libpng flush the output stream periodically after a certain --number of scanlines have been written, call: -- -- png_set_flush(png_ptr, nrows); -- --Note that the distance between rows is from the last time png_write_flush() --was called, or the first row of the image if it has never been called. --So if you write 50 lines, and then png_set_flush 25, it will flush the --output on the next scanline, and every 25 lines thereafter, unless --png_write_flush() is called before 25 more lines have been written. --If nrows is too small (less than about 10 lines for a 640 pixel wide --RGB image) the image compression may decrease noticeably (although this --may be acceptable for real-time applications). Infrequent flushing will --only degrade the compression performance by a few percent over images --that do not use flushing. -- --Writing the image data -- --That's it for the transformations. Now you can write the image data. --The simplest way to do this is in one function call. If you have the --whole image in memory, you can just call png_write_image() and libpng --will write the image. You will need to pass in an array of pointers to --each row. This function automatically handles interlacing, so you don't --need to call png_set_interlace_handling() or call this function multiple --times, or any of that other stuff necessary with png_write_rows(). -- -- png_write_image(png_ptr, row_pointers); -- --where row_pointers is: -- -- png_byte *row_pointers[height]; -- --You can point to void or char or whatever you use for pixels. -- --If you don't want to write the whole image at once, you can --use png_write_rows() instead. If the file is not interlaced, --this is simple: -- -- png_write_rows(png_ptr, row_pointers, -- number_of_rows); -- --row_pointers is the same as in the png_write_image() call. -- --If you are just writing one row at a time, you can do this with --a single row_pointer instead of an array of row_pointers: -- -- png_bytep row_pointer = row; -- -- png_write_row(png_ptr, row_pointer); -- --When the file is interlaced, things can get a good deal more --complicated. The only currently (as of the PNG Specification --version 1.2, dated July 1999) defined interlacing scheme for PNG files --is the "Adam7" interlace scheme, that breaks down an --image into seven smaller images of varying size. libpng will build --these images for you, or you can do them yourself. If you want to --build them yourself, see the PNG specification for details of which --pixels to write when. -- --If you don't want libpng to handle the interlacing details, just --use png_set_interlace_handling() and call png_write_rows() the --correct number of times to write all seven sub-images. -- --If you want libpng to build the sub-images, call this before you start --writing any rows: -- -- number_of_passes = -- png_set_interlace_handling(png_ptr); -- --This will return the number of passes needed. Currently, this --is seven, but may change if another interlace type is added. -- --Then write the complete image number_of_passes times. -- -- png_write_rows(png_ptr, row_pointers, -- number_of_rows); -- --As some of these rows are not used, and thus return immediately, --you may want to read about interlacing in the PNG specification, --and only update the rows that are actually used. -- --Finishing a sequential write -- --After you are finished writing the image, you should finish writing --the file. If you are interested in writing comments or time, you should --pass an appropriately filled png_info pointer. If you are not interested, --you can pass NULL. -- -- png_write_end(png_ptr, info_ptr); -- --When you are done, you can free all memory used by libpng like this: -- -- png_destroy_write_struct(&png_ptr, &info_ptr); -- --It is also possible to individually free the info_ptr members that --point to libpng-allocated storage with the following function: -- -- png_free_data(png_ptr, info_ptr, mask, seq) -- mask - identifies data to be freed, a mask -- containing the bitwise OR of one or -- more of -- PNG_FREE_PLTE, PNG_FREE_TRNS, -- PNG_FREE_HIST, PNG_FREE_ICCP, -- PNG_FREE_PCAL, PNG_FREE_ROWS, -- PNG_FREE_SCAL, PNG_FREE_SPLT, -- PNG_FREE_TEXT, PNG_FREE_UNKN, -- or simply PNG_FREE_ALL -- seq - sequence number of item to be freed -- (-1 for all items) -- --This function may be safely called when the relevant storage has --already been freed, or has not yet been allocated, or was allocated --by the user and not by libpng, and will in those --cases do nothing. The "seq" parameter is ignored if only one item --of the selected data type, such as PLTE, is allowed. If "seq" is not ---1, and multiple items are allowed for the data type identified in --the mask, such as text or sPLT, only the n'th item in the structure --is freed, where n is "seq". -- --If you allocated data such as a palette that you passed --in to libpng with png_set_*, you must not free it until just before the call to --png_destroy_write_struct(). -- --The default behavior is only to free data that was allocated internally --by libpng. This can be changed, so that libpng will not free the data, --or so that it will free data that was allocated by the user with png_malloc() --or png_zalloc() and passed in via a png_set_*() function, with -- -- png_data_freer(png_ptr, info_ptr, freer, mask) -- mask - which data elements are affected -- same choices as in png_free_data() -- freer - one of -- PNG_DESTROY_WILL_FREE_DATA -- PNG_SET_WILL_FREE_DATA -- PNG_USER_WILL_FREE_DATA -- --For example, to transfer responsibility for some data from a read structure --to a write structure, you could use -- -- png_data_freer(read_ptr, read_info_ptr, -- PNG_USER_WILL_FREE_DATA, -- PNG_FREE_PLTE|PNG_FREE_tRNS|PNG_FREE_hIST) -- png_data_freer(write_ptr, write_info_ptr, -- PNG_DESTROY_WILL_FREE_DATA, -- PNG_FREE_PLTE|PNG_FREE_tRNS|PNG_FREE_hIST) -- --thereby briefly reassigning responsibility for freeing to the user but --immediately afterwards reassigning it once more to the write_destroy --function. Having done this, it would then be safe to destroy the read --structure and continue to use the PLTE, tRNS, and hIST data in the write --structure. -- --This function only affects data that has already been allocated. --You can call this function before calling after the png_set_*() functions --to control whether the user or png_destroy_*() is supposed to free the data. --When the user assumes responsibility for libpng-allocated data, the --application must use --png_free() to free it, and when the user transfers responsibility to libpng --for data that the user has allocated, the user must have used png_malloc() --or png_zalloc() to allocate it. -- --If you allocated text_ptr.text, text_ptr.lang, and text_ptr.translated_keyword --separately, do not transfer responsibility for freeing text_ptr to libpng, --because when libpng fills a png_text structure it combines these members with --the key member, and png_free_data() will free only text_ptr.key. Similarly, --if you transfer responsibility for free'ing text_ptr from libpng to your --application, your application must not separately free those members. --For a more compact example of writing a PNG image, see the file example.c. -- --V. Modifying/Customizing libpng: -- --There are two issues here. The first is changing how libpng does --standard things like memory allocation, input/output, and error handling. --The second deals with more complicated things like adding new chunks, --adding new transformations, and generally changing how libpng works. --Both of those are compile-time issues; that is, they are generally --determined at the time the code is written, and there is rarely a need --to provide the user with a means of changing them. -- --Memory allocation, input/output, and error handling -- --All of the memory allocation, input/output, and error handling in libpng --goes through callbacks that are user-settable. The default routines are --in pngmem.c, pngrio.c, pngwio.c, and pngerror.c, respectively. To change --these functions, call the appropriate png_set_*_fn() function. -- --Memory allocation is done through the functions png_malloc() --and png_free(). These currently just call the standard C functions. If --your pointers can't access more then 64K at a time, you will want to set --MAXSEG_64K in zlib.h. Since it is unlikely that the method of handling --memory allocation on a platform will change between applications, these --functions must be modified in the library at compile time. If you prefer --to use a different method of allocating and freeing data, you can use --png_create_read_struct_2() or png_create_write_struct_2() to register --your own functions as described above. --These functions also provide a void pointer that can be retrieved via -- -- mem_ptr=png_get_mem_ptr(png_ptr); -- --Your replacement memory functions must have prototypes as follows: -- -- png_voidp malloc_fn(png_structp png_ptr, -- png_size_t size); -- void free_fn(png_structp png_ptr, png_voidp ptr); -- --Your malloc_fn() must return NULL in case of failure. The png_malloc() --function will normally call png_error() if it receives a NULL from the --system memory allocator or from your replacement malloc_fn(). -- --Input/Output in libpng is done through png_read() and png_write(), --which currently just call fread() and fwrite(). The FILE * is stored in --png_struct and is initialized via png_init_io(). If you wish to change --the method of I/O, the library supplies callbacks that you can set --through the function png_set_read_fn() and png_set_write_fn() at run --time, instead of calling the png_init_io() function. These functions --also provide a void pointer that can be retrieved via the function --png_get_io_ptr(). For example: -- -- png_set_read_fn(png_structp read_ptr, -- voidp read_io_ptr, png_rw_ptr read_data_fn) -- -- png_set_write_fn(png_structp write_ptr, -- voidp write_io_ptr, png_rw_ptr write_data_fn, -- png_flush_ptr output_flush_fn); -- -- voidp read_io_ptr = png_get_io_ptr(read_ptr); -- voidp write_io_ptr = png_get_io_ptr(write_ptr); -- --The replacement I/O functions must have prototypes as follows: -- -- void user_read_data(png_structp png_ptr, -- png_bytep data, png_size_t length); -- void user_write_data(png_structp png_ptr, -- png_bytep data, png_size_t length); -- void user_flush_data(png_structp png_ptr); -- --Supplying NULL for the read, write, or flush functions sets them back --to using the default C stream functions. It is an error to read from --a write stream, and vice versa. -- --Error handling in libpng is done through png_error() and png_warning(). --Errors handled through png_error() are fatal, meaning that png_error() --should never return to its caller. Currently, this is handled via --setjmp() and longjmp() (unless you have compiled libpng with --PNG_SETJMP_NOT_SUPPORTED, in which case it is handled via PNG_ABORT()), --but you could change this to do things like exit() if you should wish. -- --On non-fatal errors, png_warning() is called --to print a warning message, and then control returns to the calling code. --By default png_error() and png_warning() print a message on stderr via --fprintf() unless the library is compiled with PNG_NO_CONSOLE_IO defined --(because you don't want the messages) or PNG_NO_STDIO defined (because --fprintf() isn't available). If you wish to change the behavior of the error --functions, you will need to set up your own message callbacks. These --functions are normally supplied at the time that the png_struct is created. --It is also possible to redirect errors and warnings to your own replacement --functions after png_create_*_struct() has been called by calling: -- -- png_set_error_fn(png_structp png_ptr, -- png_voidp error_ptr, png_error_ptr error_fn, -- png_error_ptr warning_fn); -- -- png_voidp error_ptr = png_get_error_ptr(png_ptr); -- --If NULL is supplied for either error_fn or warning_fn, then the libpng --default function will be used, calling fprintf() and/or longjmp() if a --problem is encountered. The replacement error functions should have --parameters as follows: -- -- void user_error_fn(png_structp png_ptr, -- png_const_charp error_msg); -- void user_warning_fn(png_structp png_ptr, -- png_const_charp warning_msg); -- --The motivation behind using setjmp() and longjmp() is the C++ throw and --catch exception handling methods. This makes the code much easier to write, --as there is no need to check every return code of every function call. --However, there are some uncertainties about the status of local variables --after a longjmp, so the user may want to be careful about doing anything after --setjmp returns non-zero besides returning itself. Consult your compiler --documentation for more details. For an alternative approach, you may wish --to use the "cexcept" facility (see http://cexcept.sourceforge.net). -- --Custom chunks -- --If you need to read or write custom chunks, you may need to get deeper --into the libpng code. The library now has mechanisms for storing --and writing chunks of unknown type; you can even declare callbacks --for custom chunks. However, this may not be good enough if the --library code itself needs to know about interactions between your --chunk and existing `intrinsic' chunks. -- --If you need to write a new intrinsic chunk, first read the PNG --specification. Acquire a first level of --understanding of how it works. Pay particular attention to the --sections that describe chunk names, and look at how other chunks were --designed, so you can do things similarly. Second, check out the --sections of libpng that read and write chunks. Try to find a chunk --that is similar to yours and use it as a template. More details can --be found in the comments inside the code. It is best to handle unknown --chunks in a generic method, via callback functions, instead of by --modifying libpng functions. -- --If you wish to write your own transformation for the data, look through --the part of the code that does the transformations, and check out some of --the simpler ones to get an idea of how they work. Try to find a similar --transformation to the one you want to add and copy off of it. More details --can be found in the comments inside the code itself. -- --Configuring for 16 bit platforms -- --You will want to look into zconf.h to tell zlib (and thus libpng) that --it cannot allocate more then 64K at a time. Even if you can, the memory --won't be accessible. So limit zlib and libpng to 64K by defining MAXSEG_64K. -- --Configuring for DOS -- --For DOS users who only have access to the lower 640K, you will --have to limit zlib's memory usage via a png_set_compression_mem_level() --call. See zlib.h or zconf.h in the zlib library for more information. -- --Configuring for Medium Model -- --Libpng's support for medium model has been tested on most of the popular --compilers. Make sure MAXSEG_64K gets defined, USE_FAR_KEYWORD gets --defined, and FAR gets defined to far in pngconf.h, and you should be --all set. Everything in the library (except for zlib's structure) is --expecting far data. You must use the typedefs with the p or pp on --the end for pointers (or at least look at them and be careful). Make --note that the rows of data are defined as png_bytepp, which is an --unsigned char far * far *. -- --Configuring for gui/windowing platforms: -- --You will need to write new error and warning functions that use the GUI --interface, as described previously, and set them to be the error and --warning functions at the time that png_create_*_struct() is called, --in order to have them available during the structure initialization. --They can be changed later via png_set_error_fn(). On some compilers, --you may also have to change the memory allocators (png_malloc, etc.). -- --Configuring for compiler xxx: -- --All includes for libpng are in pngconf.h. If you need to add/change/delete --an include, this is the place to do it. The includes that are not --needed outside libpng are protected by the PNG_INTERNAL definition, --which is only defined for those routines inside libpng itself. The --files in libpng proper only include png.h, which includes pngconf.h. -- --Configuring zlib: -- --There are special functions to configure the compression. Perhaps the --most useful one changes the compression level, which currently uses --input compression values in the range 0 - 9. The library normally --uses the default compression level (Z_DEFAULT_COMPRESSION = 6). Tests --have shown that for a large majority of images, compression values in --the range 3-6 compress nearly as well as higher levels, and do so much --faster. For online applications it may be desirable to have maximum speed --(Z_BEST_SPEED = 1). With versions of zlib after v0.99, you can also --specify no compression (Z_NO_COMPRESSION = 0), but this would create --files larger than just storing the raw bitmap. You can specify the --compression level by calling: -- -- png_set_compression_level(png_ptr, level); -- --Another useful one is to reduce the memory level used by the library. --The memory level defaults to 8, but it can be lowered if you are --short on memory (running DOS, for example, where you only have 640K). --Note that the memory level does have an effect on compression; among --other things, lower levels will result in sections of incompressible --data being emitted in smaller stored blocks, with a correspondingly --larger relative overhead of up to 15% in the worst case. -- -- png_set_compression_mem_level(png_ptr, level); -- --The other functions are for configuring zlib. They are not recommended --for normal use and may result in writing an invalid PNG file. See --zlib.h for more information on what these mean. -- -- png_set_compression_strategy(png_ptr, -- strategy); -- png_set_compression_window_bits(png_ptr, -- window_bits); -- png_set_compression_method(png_ptr, method); -- png_set_compression_buffer_size(png_ptr, size); -- --Controlling row filtering -- --If you want to control whether libpng uses filtering or not, which --filters are used, and how it goes about picking row filters, you --can call one of these functions. The selection and configuration --of row filters can have a significant impact on the size and --encoding speed and a somewhat lesser impact on the decoding speed --of an image. Filtering is enabled by default for RGB and grayscale --images (with and without alpha), but not for paletted images nor --for any images with bit depths less than 8 bits/pixel. -- --The 'method' parameter sets the main filtering method, which is --currently only '0' in the PNG 1.2 specification. The 'filters' --parameter sets which filter(s), if any, should be used for each --scanline. Possible values are PNG_ALL_FILTERS and PNG_NO_FILTERS --to turn filtering on and off, respectively. -- --Individual filter types are PNG_FILTER_NONE, PNG_FILTER_SUB, --PNG_FILTER_UP, PNG_FILTER_AVG, PNG_FILTER_PAETH, which can be bitwise --ORed together with '|' to specify one or more filters to use. --These filters are described in more detail in the PNG specification. --If you intend to change the filter type during the course of writing --the image, you should start with flags set for all of the filters --you intend to use so that libpng can initialize its internal --structures appropriately for all of the filter types. (Note that this --means the first row must always be adaptively filtered, because libpng --currently does not allocate the filter buffers until png_write_row() --is called for the first time.) -- -- filters = PNG_FILTER_NONE | PNG_FILTER_SUB -- PNG_FILTER_UP | PNG_FILTER_AVE | -- PNG_FILTER_PAETH | PNG_ALL_FILTERS; -- -- png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, -- filters); -- The second parameter can also be -- PNG_INTRAPIXEL_DIFFERENCING if you are -- writing a PNG to be embedded in a MNG -- datastream. This parameter must be the -- same as the value of filter_method used -- in png_set_IHDR(). -- --It is also possible to influence how libpng chooses from among the --available filters. This is done in one or both of two ways - by --telling it how important it is to keep the same filter for successive --rows, and by telling it the relative computational costs of the filters. -- -- double weights[3] = {1.5, 1.3, 1.1}, -- costs[PNG_FILTER_VALUE_LAST] = -- {1.0, 1.3, 1.3, 1.5, 1.7}; -- -- png_set_filter_heuristics(png_ptr, -- PNG_FILTER_HEURISTIC_WEIGHTED, 3, -- weights, costs); -- --The weights are multiplying factors that indicate to libpng that the --row filter should be the same for successive rows unless another row filter --is that many times better than the previous filter. In the above example, --if the previous 3 filters were SUB, SUB, NONE, the SUB filter could have a --"sum of absolute differences" 1.5 x 1.3 times higher than other filters --and still be chosen, while the NONE filter could have a sum 1.1 times --higher than other filters and still be chosen. Unspecified weights are --taken to be 1.0, and the specified weights should probably be declining --like those above in order to emphasize recent filters over older filters. -- --The filter costs specify for each filter type a relative decoding cost --to be considered when selecting row filters. This means that filters --with higher costs are less likely to be chosen over filters with lower --costs, unless their "sum of absolute differences" is that much smaller. --The costs do not necessarily reflect the exact computational speeds of --the various filters, since this would unduly influence the final image --size. -- --Note that the numbers above were invented purely for this example and --are given only to help explain the function usage. Little testing has --been done to find optimum values for either the costs or the weights. -- --Removing unwanted object code -- --There are a bunch of #define's in pngconf.h that control what parts of --libpng are compiled. All the defines end in _SUPPORTED. If you are --never going to use a capability, you can change the #define to #undef --before recompiling libpng and save yourself code and data space, or --you can turn off individual capabilities with defines that begin with --PNG_NO_. -- --You can also turn all of the transforms and ancillary chunk capabilities --off en masse with compiler directives that define --PNG_NO_READ[or WRITE]_TRANSFORMS, or PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS, --or all four, --along with directives to turn on any of the capabilities that you do --want. The PNG_NO_READ[or WRITE]_TRANSFORMS directives disable --the extra transformations but still leave the library fully capable of reading --and writing PNG files with all known public chunks --Use of the PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS directive --produces a library that is incapable of reading or writing ancillary chunks. --If you are not using the progressive reading capability, you can --turn that off with PNG_NO_PROGRESSIVE_READ (don't confuse --this with the INTERLACING capability, which you'll still have). -- --All the reading and writing specific code are in separate files, so the --linker should only grab the files it needs. However, if you want to --make sure, or if you are building a stand alone library, all the --reading files start with pngr and all the writing files start with --pngw. The files that don't match either (like png.c, pngtrans.c, etc.) --are used for both reading and writing, and always need to be included. --The progressive reader is in pngpread.c -- --If you are creating or distributing a dynamically linked library (a .so --or DLL file), you should not remove or disable any parts of the library, --as this will cause applications linked with different versions of the --library to fail if they call functions not available in your library. --The size of the library itself should not be an issue, because only --those sections that are actually used will be loaded into memory. -- --Requesting debug printout -- --The macro definition PNG_DEBUG can be used to request debugging --printout. Set it to an integer value in the range 0 to 3. Higher --numbers result in increasing amounts of debugging information. The --information is printed to the "stderr" file, unless another file --name is specified in the PNG_DEBUG_FILE macro definition. -- --When PNG_DEBUG > 0, the following functions (macros) become available: -- -- png_debug(level, message) -- png_debug1(level, message, p1) -- png_debug2(level, message, p1, p2) -- --in which "level" is compared to PNG_DEBUG to decide whether to print --the message, "message" is the formatted string to be printed, --and p1 and p2 are parameters that are to be embedded in the string --according to printf-style formatting directives. For example, -- -- png_debug1(2, "foo=%d\n", foo); -- --is expanded to -- -- if(PNG_DEBUG > 2) -- fprintf(PNG_DEBUG_FILE, "foo=%d\n", foo); -- --When PNG_DEBUG is defined but is zero, the macros aren't defined, but you --can still use PNG_DEBUG to control your own debugging: -- -- #ifdef PNG_DEBUG -- fprintf(stderr, ... -- #endif -- --When PNG_DEBUG = 1, the macros are defined, but only png_debug statements --having level = 0 will be printed. There aren't any such statements in --this version of libpng, but if you insert some they will be printed. -- --VII. MNG support -- --The MNG specification (available at http://www.libpng.org/pub/mng) allows --certain extensions to PNG for PNG images that are embedded in MNG datastreams. --Libpng can support some of these extensions. To enable them, use the --png_permit_mng_features() function: -- -- feature_set = png_permit_mng_features(png_ptr, mask) -- mask is a png_uint_32 containing the bitwise OR of the -- features you want to enable. These include -- PNG_FLAG_MNG_EMPTY_PLTE -- PNG_FLAG_MNG_FILTER_64 -- PNG_ALL_MNG_FEATURES -- feature_set is a png_uint_32 that is the bitwise AND of -- your mask with the set of MNG features that is -- supported by the version of libpng that you are using. -- --It is an error to use this function when reading or writing a standalone --PNG file with the PNG 8-byte signature. The PNG datastream must be wrapped --in a MNG datastream. As a minimum, it must have the MNG 8-byte signature --and the MHDR and MEND chunks. Libpng does not provide support for these --or any other MNG chunks; your application must provide its own support for --them. You may wish to consider using libmng (available at --http://www.libmng.com) instead. -- --VIII. Changes to Libpng from version 0.88 -- --It should be noted that versions of libpng later than 0.96 are not --distributed by the original libpng author, Guy Schalnat, nor by --Andreas Dilger, who had taken over from Guy during 1996 and 1997, and --distributed versions 0.89 through 0.96, but rather by another member --of the original PNG Group, Glenn Randers-Pehrson. Guy and Andreas are --still alive and well, but they have moved on to other things. -- --The old libpng functions png_read_init(), png_write_init(), --png_info_init(), png_read_destroy(), and png_write_destroy() have been --moved to PNG_INTERNAL in version 0.95 to discourage their use. These --functions will be removed from libpng version 2.0.0. -- --The preferred method of creating and initializing the libpng structures is --via the png_create_read_struct(), png_create_write_struct(), and --png_create_info_struct() because they isolate the size of the structures --from the application, allow version error checking, and also allow the --use of custom error handling routines during the initialization, which --the old functions do not. The functions png_read_destroy() and --png_write_destroy() do not actually free the memory that libpng --allocated for these structs, but just reset the data structures, so they --can be used instead of png_destroy_read_struct() and --png_destroy_write_struct() if you feel there is too much system overhead --allocating and freeing the png_struct for each image read. -- --Setting the error callbacks via png_set_message_fn() before --png_read_init() as was suggested in libpng-0.88 is no longer supported --because this caused applications that do not use custom error functions --to fail if the png_ptr was not initialized to zero. It is still possible --to set the error callbacks AFTER png_read_init(), or to change them with --png_set_error_fn(), which is essentially the same function, but with a new --name to force compilation errors with applications that try to use the old --method. -- --Starting with version 1.0.7, you can find out which version of the library --you are using at run-time: -- -- png_uint_32 libpng_vn = png_access_version_number(); -- --The number libpng_vn is constructed from the major version, minor --version with leading zero, and release number with leading zero, --(e.g., libpng_vn for version 1.0.7 is 10007). -- --You can also check which version of png.h you used when compiling your --application: -- -- png_uint_32 application_vn = PNG_LIBPNG_VER; -- --IX. Y2K Compliance in libpng -- --December 14, 2007 -- --Since the PNG Development group is an ad-hoc body, we can't make --an official declaration. -- --This is your unofficial assurance that libpng from version 0.71 and --upward through 1.2.24 are Y2K compliant. It is my belief that earlier --versions were also Y2K compliant. -- --Libpng only has three year fields. One is a 2-byte unsigned integer that --will hold years up to 65535. The other two hold the date in text --format, and will hold years up to 9999. -- --The integer is -- "png_uint_16 year" in png_time_struct. -- --The strings are -- "png_charp time_buffer" in png_struct and -- "near_time_buffer", which is a local character string in png.c. -- --There are seven time-related functions: -- -- png_convert_to_rfc_1123() in png.c -- (formerly png_convert_to_rfc_1152() in error) -- png_convert_from_struct_tm() in pngwrite.c, called -- in pngwrite.c -- png_convert_from_time_t() in pngwrite.c -- png_get_tIME() in pngget.c -- png_handle_tIME() in pngrutil.c, called in pngread.c -- png_set_tIME() in pngset.c -- png_write_tIME() in pngwutil.c, called in pngwrite.c -- --All appear to handle dates properly in a Y2K environment. The --png_convert_from_time_t() function calls gmtime() to convert from system --clock time, which returns (year - 1900), which we properly convert to --the full 4-digit year. There is a possibility that applications using --libpng are not passing 4-digit years into the png_convert_to_rfc_1123() --function, or that they are incorrectly passing only a 2-digit year --instead of "year - 1900" into the png_convert_from_struct_tm() function, --but this is not under our control. The libpng documentation has always --stated that it works with 4-digit years, and the APIs have been --documented as such. -- --The tIME chunk itself is also Y2K compliant. It uses a 2-byte unsigned --integer to hold the year, and can hold years as large as 65535. -- --zlib, upon which libpng depends, is also Y2K compliant. It contains --no date-related code. -- -- -- Glenn Randers-Pehrson -- libpng maintainer -- PNG Development Group -diff --git a/thirdparty/libpng/libpng_vs2010.vcxproj b/thirdparty/libpng/libpng_vs2010.vcxproj -deleted file mode 100644 -index 6f4a6c0..0000000 ---- a/thirdparty/libpng/libpng_vs2010.vcxproj -+++ /dev/null -@@ -1,246 +0,0 @@ -- -- -- -- -- Debug -- Win32 -- -- -- Debug -- x64 -- -- -- Release LIB -- Win32 -- -- -- Release LIB -- x64 -- -- -- Release -- Win32 -- -- -- Release -- x64 -- -- -- -- {71DADA6A-5801-4188-8793-A4A48BAC164B} -- libpng -- Win32Proj -- libpng -- -- -- -- StaticLibrary -- Unicode -- true -- -- -- StaticLibrary -- Unicode -- true -- -- -- StaticLibrary -- Unicode -- true -- -- -- StaticLibrary -- Unicode -- true -- -- -- StaticLibrary -- Unicode -- -- -- StaticLibrary -- Unicode -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- <_ProjectFileVersion>10.0.30319.1 -- $(SolutionDir)\thirdparty\lib\ -- $(SolutionDir)\thirdparty\lib\$(Platform)\ -- $(Configuration)\ -- $(SolutionDir)\thirdparty\lib\ -- $(SolutionDir)\thirdparty\lib\$(Platform)\ -- $(Configuration)\ -- $(SolutionDir)\thirdparty\lib\ -- $(SolutionDir)\thirdparty\lib\$(Platform)\ -- $(Configuration)\ -- $(Configuration)\ -- AllRules.ruleset -- AllRules.ruleset -- -- -- -- -- AllRules.ruleset -- AllRules.ruleset -- -- -- -- -- AllRules.ruleset -- AllRules.ruleset -- -- -- -- -- libpngd -- libpngd -- libpng -- libpng -- libpng -- libpng -- -- -- -- Disabled -- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) -- WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions) -- EnableFastChecks -- MultiThreadedDebugDLL -- -- -- Level3 -- EditAndContinue -- 4267;4996;%(DisableSpecificWarnings) -- true -- -- -- -- -- -- Disabled -- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) -- _WIN64;_DEBUG;_LIB;%(PreprocessorDefinitions) -- EnableFastChecks -- MultiThreadedDebugDLL -- -- -- Level3 -- ProgramDatabase -- 4267;4996;%(DisableSpecificWarnings) -- true -- -- -- -- -- -- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) -- WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions) -- MultiThreadedDLL -- -- -- Level3 -- ProgramDatabase -- 4267;4996;%(DisableSpecificWarnings) -- MinSpace -- Size -- true -- -- -- -- -- -- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) -- WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions) -- MultiThreadedDLL -- -- -- Level3 -- ProgramDatabase -- 4267;4996;%(DisableSpecificWarnings) -- MinSpace -- Size -- true -- -- -- -- -- -- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) -- WIN32;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions) -- MultiThreaded -- -- -- Level3 -- ProgramDatabase -- 4267;4996;%(DisableSpecificWarnings) -- MinSpace -- Size -- true -- -- -- -- -- -- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) -- WIN64;NDEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions) -- MultiThreaded -- -- -- Level3 -- ProgramDatabase -- 4267;4996;%(DisableSpecificWarnings) -- true -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -\ No newline at end of file -diff --git a/thirdparty/libpng/png.c b/thirdparty/libpng/png.c -deleted file mode 100644 -index 4baa697..0000000 ---- a/thirdparty/libpng/png.c -+++ /dev/null -@@ -1,826 +0,0 @@ -- --/* png.c - location for general purpose libpng functions -- * -- * libpng version 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- */ -- --#define PNG_INTERNAL --#define PNG_NO_EXTERN --#include "png.h" -- --/* Generate a compiler error if there is an old png.h in the search path. */ --typedef version_1_2_7 Your_png_h_is_not_version_1_2_7; -- --/* Version information for C files. This had better match the version -- * string defined in png.h. */ -- --#ifdef PNG_USE_GLOBAL_ARRAYS --/* png_libpng_ver was changed to a function in version 1.0.5c */ --const char png_libpng_ver[18] = PNG_LIBPNG_VER_STRING; -- --/* png_sig was changed to a function in version 1.0.5c */ --/* Place to hold the signature string for a PNG file. */ --const png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10}; -- --/* Invoke global declarations for constant strings for known chunk types */ --PNG_IHDR; --PNG_IDAT; --PNG_IEND; --PNG_PLTE; --PNG_bKGD; --PNG_cHRM; --PNG_gAMA; --PNG_hIST; --PNG_iCCP; --PNG_iTXt; --PNG_oFFs; --PNG_pCAL; --PNG_sCAL; --PNG_pHYs; --PNG_sBIT; --PNG_sPLT; --PNG_sRGB; --PNG_tEXt; --PNG_tIME; --PNG_tRNS; --PNG_zTXt; -- --/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ -- --/* start of interlace block */ --const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; -- --/* offset to next interlace block */ --const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; -- --/* start of interlace block in the y direction */ --const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; -- --/* offset to next interlace block in the y direction */ --const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; -- --/* width of interlace block (used in assembler routines only) */ --#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW --const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; --#endif -- --/* Height of interlace block. This is not currently used - if you need -- * it, uncomment it here and in png.h --const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; --*/ -- --/* Mask to determine which pixels are valid in a pass */ --const int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; -- --/* Mask to determine which pixels to overwrite while displaying */ --const int FARDATA png_pass_dsp_mask[] -- = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; -- --#endif -- --/* Tells libpng that we have already handled the first "num_bytes" bytes -- * of the PNG file signature. If the PNG data is embedded into another -- * stream we can set num_bytes = 8 so that libpng will not attempt to read -- * or write any of the magic bytes before it starts on the IHDR. -- */ -- --void PNGAPI --png_set_sig_bytes(png_structp png_ptr, int num_bytes) --{ -- png_debug(1, "in png_set_sig_bytes\n"); -- if (num_bytes > 8) -- png_error(png_ptr, "Too many bytes for PNG signature."); -- -- png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes); --} -- --/* Checks whether the supplied bytes match the PNG signature. We allow -- * checking less than the full 8-byte signature so that those apps that -- * already read the first few bytes of a file to determine the file type -- * can simply check the remaining bytes for extra assurance. Returns -- * an integer less than, equal to, or greater than zero if sig is found, -- * respectively, to be less than, to match, or be greater than the correct -- * PNG signature (this is the same behaviour as strcmp, memcmp, etc). -- */ --int PNGAPI --png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check) --{ -- png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; -- if (num_to_check > 8) -- num_to_check = 8; -- else if (num_to_check < 1) -- return (0); -- -- if (start > 7) -- return (0); -- -- if (start + num_to_check > 8) -- num_to_check = 8 - start; -- -- return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check))); --} -- --/* (Obsolete) function to check signature bytes. It does not allow one -- * to check a partial signature. This function might be removed in the -- * future - use png_sig_cmp(). Returns true (nonzero) if the file is a PNG. -- */ --int PNGAPI --png_check_sig(png_bytep sig, int num) --{ -- return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num)); --} -- --/* Function to allocate memory for zlib and clear it to 0. */ --#ifdef PNG_1_0_X --voidpf PNGAPI --#else --voidpf /* private */ --#endif --png_zalloc(voidpf png_ptr, uInt items, uInt size) --{ -- png_voidp ptr; -- png_structp p=png_ptr; -- png_uint_32 save_flags=p->flags; -- png_uint_32 num_bytes; -- -- if (items > PNG_UINT_32_MAX/size) -- { -- png_warning (png_ptr, "Potential overflow in png_zalloc()"); -- return (NULL); -- } -- num_bytes = (png_uint_32)items * size; -- -- p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; -- ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes); -- p->flags=save_flags; -- --#if defined(PNG_1_0_X) && !defined(PNG_NO_ZALLOC_ZERO) -- if (ptr == NULL) -- return ((voidpf)ptr); -- -- if (num_bytes > (png_uint_32)0x8000L) -- { -- png_memset(ptr, 0, (png_size_t)0x8000L); -- png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0, -- (png_size_t)(num_bytes - (png_uint_32)0x8000L)); -- } -- else -- { -- png_memset(ptr, 0, (png_size_t)num_bytes); -- } --#endif -- return ((voidpf)ptr); --} -- --/* function to free memory for zlib */ --#ifdef PNG_1_0_X --void PNGAPI --#else --void /* private */ --#endif --png_zfree(voidpf png_ptr, voidpf ptr) --{ -- png_free((png_structp)png_ptr, (png_voidp)ptr); --} -- --/* Reset the CRC variable to 32 bits of 1's. Care must be taken -- * in case CRC is > 32 bits to leave the top bits 0. -- */ --void /* PRIVATE */ --png_reset_crc(png_structp png_ptr) --{ -- png_ptr->crc = crc32(0, Z_NULL, 0); --} -- --/* Calculate the CRC over a section of data. We can only pass as -- * much data to this routine as the largest single buffer size. We -- * also check that this data will actually be used before going to the -- * trouble of calculating it. -- */ --void /* PRIVATE */ --png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length) --{ -- int need_crc = 1; -- -- if (png_ptr->chunk_name[0] & 0x20) /* ancillary */ -- { -- if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == -- (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) -- need_crc = 0; -- } -- else /* critical */ -- { -- if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) -- need_crc = 0; -- } -- -- if (need_crc) -- png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length); --} -- --/* Allocate the memory for an info_struct for the application. We don't -- * really need the png_ptr, but it could potentially be useful in the -- * future. This should be used in favour of malloc(png_sizeof(png_info)) -- * and png_info_init() so that applications that want to use a shared -- * libpng don't have to be recompiled if png_info changes size. -- */ --png_infop PNGAPI --png_create_info_struct(png_structp png_ptr) --{ -- png_infop info_ptr; -- -- png_debug(1, "in png_create_info_struct\n"); -- if(png_ptr == NULL) return (NULL); --#ifdef PNG_USER_MEM_SUPPORTED -- info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO, -- png_ptr->malloc_fn, png_ptr->mem_ptr); --#else -- info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); --#endif -- if (info_ptr != NULL) -- png_info_init_3(&info_ptr, png_sizeof(png_info)); -- -- return (info_ptr); --} -- --/* This function frees the memory associated with a single info struct. -- * Normally, one would use either png_destroy_read_struct() or -- * png_destroy_write_struct() to free an info struct, but this may be -- * useful for some applications. -- */ --void PNGAPI --png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr) --{ -- png_infop info_ptr = NULL; -- -- png_debug(1, "in png_destroy_info_struct\n"); -- if (info_ptr_ptr != NULL) -- info_ptr = *info_ptr_ptr; -- -- if (info_ptr != NULL) -- { -- png_info_destroy(png_ptr, info_ptr); -- --#ifdef PNG_USER_MEM_SUPPORTED -- png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn, -- png_ptr->mem_ptr); --#else -- png_destroy_struct((png_voidp)info_ptr); --#endif -- *info_ptr_ptr = NULL; -- } --} -- --/* Initialize the info structure. This is now an internal function (0.89) -- * and applications using it are urged to use png_create_info_struct() -- * instead. -- */ --#undef png_info_init --void PNGAPI --png_info_init(png_infop info_ptr) --{ -- /* We only come here via pre-1.0.12-compiled applications */ -- png_info_init_3(&info_ptr, 0); --} -- --void PNGAPI --png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size) --{ -- png_infop info_ptr = *ptr_ptr; -- -- png_debug(1, "in png_info_init_3\n"); -- -- if(png_sizeof(png_info) > png_info_struct_size) -- { -- png_destroy_struct(info_ptr); -- info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); -- *ptr_ptr = info_ptr; -- } -- -- /* set everything to 0 */ -- png_memset(info_ptr, 0, png_sizeof (png_info)); --} -- --#ifdef PNG_FREE_ME_SUPPORTED --void PNGAPI --png_data_freer(png_structp png_ptr, png_infop info_ptr, -- int freer, png_uint_32 mask) --{ -- png_debug(1, "in png_data_freer\n"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- if(freer == PNG_DESTROY_WILL_FREE_DATA) -- info_ptr->free_me |= mask; -- else if(freer == PNG_USER_WILL_FREE_DATA) -- info_ptr->free_me &= ~mask; -- else -- png_warning(png_ptr, -- "Unknown freer parameter in png_data_freer."); --} --#endif -- --void PNGAPI --png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, -- int num) --{ -- png_debug(1, "in png_free_data\n"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- --#if defined(PNG_TEXT_SUPPORTED) --/* free text item num or (if num == -1) all text items */ --#ifdef PNG_FREE_ME_SUPPORTED --if ((mask & PNG_FREE_TEXT) & info_ptr->free_me) --#else --if (mask & PNG_FREE_TEXT) --#endif --{ -- if (num != -1) -- { -- if (info_ptr->text && info_ptr->text[num].key) -- { -- png_free(png_ptr, info_ptr->text[num].key); -- info_ptr->text[num].key = NULL; -- } -- } -- else -- { -- int i; -- for (i = 0; i < info_ptr->num_text; i++) -- png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i); -- png_free(png_ptr, info_ptr->text); -- info_ptr->text = NULL; -- info_ptr->num_text=0; -- } --} --#endif -- --#if defined(PNG_tRNS_SUPPORTED) --/* free any tRNS entry */ --#ifdef PNG_FREE_ME_SUPPORTED --if ((mask & PNG_FREE_TRNS) & info_ptr->free_me) --#else --if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS)) --#endif --{ -- png_free(png_ptr, info_ptr->trans); -- info_ptr->valid &= ~PNG_INFO_tRNS; --#ifndef PNG_FREE_ME_SUPPORTED -- png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; --#endif -- info_ptr->trans = NULL; --} --#endif -- --#if defined(PNG_sCAL_SUPPORTED) --/* free any sCAL entry */ --#ifdef PNG_FREE_ME_SUPPORTED --if ((mask & PNG_FREE_SCAL) & info_ptr->free_me) --#else --if (mask & PNG_FREE_SCAL) --#endif --{ --#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) -- png_free(png_ptr, info_ptr->scal_s_width); -- png_free(png_ptr, info_ptr->scal_s_height); -- info_ptr->scal_s_width = NULL; -- info_ptr->scal_s_height = NULL; --#endif -- info_ptr->valid &= ~PNG_INFO_sCAL; --} --#endif -- --#if defined(PNG_pCAL_SUPPORTED) --/* free any pCAL entry */ --#ifdef PNG_FREE_ME_SUPPORTED --if ((mask & PNG_FREE_PCAL) & info_ptr->free_me) --#else --if (mask & PNG_FREE_PCAL) --#endif --{ -- png_free(png_ptr, info_ptr->pcal_purpose); -- png_free(png_ptr, info_ptr->pcal_units); -- info_ptr->pcal_purpose = NULL; -- info_ptr->pcal_units = NULL; -- if (info_ptr->pcal_params != NULL) -- { -- int i; -- for (i = 0; i < (int)info_ptr->pcal_nparams; i++) -- { -- png_free(png_ptr, info_ptr->pcal_params[i]); -- info_ptr->pcal_params[i]=NULL; -- } -- png_free(png_ptr, info_ptr->pcal_params); -- info_ptr->pcal_params = NULL; -- } -- info_ptr->valid &= ~PNG_INFO_pCAL; --} --#endif -- --#if defined(PNG_iCCP_SUPPORTED) --/* free any iCCP entry */ --#ifdef PNG_FREE_ME_SUPPORTED --if ((mask & PNG_FREE_ICCP) & info_ptr->free_me) --#else --if (mask & PNG_FREE_ICCP) --#endif --{ -- png_free(png_ptr, info_ptr->iccp_name); -- png_free(png_ptr, info_ptr->iccp_profile); -- info_ptr->iccp_name = NULL; -- info_ptr->iccp_profile = NULL; -- info_ptr->valid &= ~PNG_INFO_iCCP; --} --#endif -- --#if defined(PNG_sPLT_SUPPORTED) --/* free a given sPLT entry, or (if num == -1) all sPLT entries */ --#ifdef PNG_FREE_ME_SUPPORTED --if ((mask & PNG_FREE_SPLT) & info_ptr->free_me) --#else --if (mask & PNG_FREE_SPLT) --#endif --{ -- if (num != -1) -- { -- if(info_ptr->splt_palettes) -- { -- png_free(png_ptr, info_ptr->splt_palettes[num].name); -- png_free(png_ptr, info_ptr->splt_palettes[num].entries); -- info_ptr->splt_palettes[num].name = NULL; -- info_ptr->splt_palettes[num].entries = NULL; -- } -- } -- else -- { -- if(info_ptr->splt_palettes_num) -- { -- int i; -- for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) -- png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i); -- -- png_free(png_ptr, info_ptr->splt_palettes); -- info_ptr->splt_palettes = NULL; -- info_ptr->splt_palettes_num = 0; -- } -- info_ptr->valid &= ~PNG_INFO_sPLT; -- } --} --#endif -- --#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) --#ifdef PNG_FREE_ME_SUPPORTED --if ((mask & PNG_FREE_UNKN) & info_ptr->free_me) --#else --if (mask & PNG_FREE_UNKN) --#endif --{ -- if (num != -1) -- { -- if(info_ptr->unknown_chunks) -- { -- png_free(png_ptr, info_ptr->unknown_chunks[num].data); -- info_ptr->unknown_chunks[num].data = NULL; -- } -- } -- else -- { -- int i; -- -- if(info_ptr->unknown_chunks_num) -- { -- for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++) -- png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i); -- -- png_free(png_ptr, info_ptr->unknown_chunks); -- info_ptr->unknown_chunks = NULL; -- info_ptr->unknown_chunks_num = 0; -- } -- } --} --#endif -- --#if defined(PNG_hIST_SUPPORTED) --/* free any hIST entry */ --#ifdef PNG_FREE_ME_SUPPORTED --if ((mask & PNG_FREE_HIST) & info_ptr->free_me) --#else --if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST)) --#endif --{ -- png_free(png_ptr, info_ptr->hist); -- info_ptr->hist = NULL; -- info_ptr->valid &= ~PNG_INFO_hIST; --#ifndef PNG_FREE_ME_SUPPORTED -- png_ptr->flags &= ~PNG_FLAG_FREE_HIST; --#endif --} --#endif -- --/* free any PLTE entry that was internally allocated */ --#ifdef PNG_FREE_ME_SUPPORTED --if ((mask & PNG_FREE_PLTE) & info_ptr->free_me) --#else --if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE)) --#endif --{ -- png_zfree(png_ptr, info_ptr->palette); -- info_ptr->palette = NULL; -- info_ptr->valid &= ~PNG_INFO_PLTE; --#ifndef PNG_FREE_ME_SUPPORTED -- png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; --#endif -- info_ptr->num_palette = 0; --} -- --#if defined(PNG_INFO_IMAGE_SUPPORTED) --/* free any image bits attached to the info structure */ --#ifdef PNG_FREE_ME_SUPPORTED --if ((mask & PNG_FREE_ROWS) & info_ptr->free_me) --#else --if (mask & PNG_FREE_ROWS) --#endif --{ -- if(info_ptr->row_pointers) -- { -- int row; -- for (row = 0; row < (int)info_ptr->height; row++) -- { -- png_free(png_ptr, info_ptr->row_pointers[row]); -- info_ptr->row_pointers[row]=NULL; -- } -- png_free(png_ptr, info_ptr->row_pointers); -- info_ptr->row_pointers=NULL; -- } -- info_ptr->valid &= ~PNG_INFO_IDAT; --} --#endif -- --#ifdef PNG_FREE_ME_SUPPORTED -- if(num == -1) -- info_ptr->free_me &= ~mask; -- else -- info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL); --#endif --} -- --/* This is an internal routine to free any memory that the info struct is -- * pointing to before re-using it or freeing the struct itself. Recall -- * that png_free() checks for NULL pointers for us. -- */ --void /* PRIVATE */ --png_info_destroy(png_structp png_ptr, png_infop info_ptr) --{ -- png_debug(1, "in png_info_destroy\n"); -- -- png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); -- --#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) -- if (png_ptr->num_chunk_list) -- { -- png_free(png_ptr, png_ptr->chunk_list); -- png_ptr->chunk_list=NULL; -- png_ptr->num_chunk_list=0; -- } --#endif -- -- png_info_init_3(&info_ptr, png_sizeof(png_info)); --} -- --/* This function returns a pointer to the io_ptr associated with the user -- * functions. The application should free any memory associated with this -- * pointer before png_write_destroy() or png_read_destroy() are called. -- */ --png_voidp PNGAPI --png_get_io_ptr(png_structp png_ptr) --{ -- return (png_ptr->io_ptr); --} -- --#if !defined(PNG_NO_STDIO) --/* Initialize the default input/output functions for the PNG file. If you -- * use your own read or write routines, you can call either png_set_read_fn() -- * or png_set_write_fn() instead of png_init_io(). If you have defined -- * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't -- * necessarily available. -- */ --void PNGAPI --png_init_io(png_structp png_ptr, png_FILE_p fp) --{ -- png_debug(1, "in png_init_io\n"); -- png_ptr->io_ptr = (png_voidp)fp; --} --#endif -- --#if defined(PNG_TIME_RFC1123_SUPPORTED) --/* Convert the supplied time into an RFC 1123 string suitable for use in -- * a "Creation Time" or other text-based time string. -- */ --png_charp PNGAPI --png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime) --{ -- static PNG_CONST char short_months[12][4] = -- {"Jan", "Feb", "Mar", "Apr", "May", "Jun", -- "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; -- -- if (png_ptr->time_buffer == NULL) -- { -- png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29* -- png_sizeof(char))); -- } -- --#if defined(_WIN32_WCE) -- { -- wchar_t time_buf[29]; -- wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"), -- ptime->day % 32, short_months[(ptime->month - 1) % 12], -- ptime->year, ptime->hour % 24, ptime->minute % 60, -- ptime->second % 61); -- WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29, -- NULL, NULL); -- } --#else --#ifdef USE_FAR_KEYWORD -- { -- char near_time_buf[29]; -- sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000", -- ptime->day % 32, short_months[(ptime->month - 1) % 12], -- ptime->year, ptime->hour % 24, ptime->minute % 60, -- ptime->second % 61); -- png_memcpy(png_ptr->time_buffer, near_time_buf, -- 29*png_sizeof(char)); -- } --#else -- sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000", -- ptime->day % 32, short_months[(ptime->month - 1) % 12], -- ptime->year, ptime->hour % 24, ptime->minute % 60, -- ptime->second % 61); --#endif --#endif /* _WIN32_WCE */ -- return ((png_charp)png_ptr->time_buffer); --} --#endif /* PNG_TIME_RFC1123_SUPPORTED */ -- --#if 0 --/* Signature string for a PNG file. */ --png_bytep PNGAPI --png_sig_bytes(void) --{ -- return ((png_bytep)"\211\120\116\107\015\012\032\012"); --} --#endif -- --png_charp PNGAPI --png_get_copyright(png_structp png_ptr) --{ -- if (&png_ptr != NULL) /* silence compiler warning about unused png_ptr */ -- return ((png_charp) "\n libpng version 1.2.7 - September 12, 2004\n\ -- Copyright (c) 1998-2004 Glenn Randers-Pehrson\n\ -- Copyright (c) 1996-1997 Andreas Dilger\n\ -- Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n"); -- return ((png_charp) ""); --} -- --/* The following return the library version as a short string in the -- * format 1.0.0 through 99.99.99zz. To get the version of *.h files -- * used with your application, print out PNG_LIBPNG_VER_STRING, which -- * is defined in png.h. -- * Note: now there is no difference between png_get_libpng_ver() and -- * png_get_header_ver(). Due to the version_nn_nn_nn typedef guard, -- * it is guaranteed that png.c uses the correct version of png.h. -- */ --png_charp PNGAPI --png_get_libpng_ver(png_structp png_ptr) --{ -- /* Version of *.c files used when building libpng */ -- if (&png_ptr != NULL) /* silence compiler warning about unused png_ptr */ -- return ((png_charp) PNG_LIBPNG_VER_STRING); -- return ((png_charp) ""); --} -- --png_charp PNGAPI --png_get_header_ver(png_structp png_ptr) --{ -- /* Version of *.h files used when building libpng */ -- if (&png_ptr != NULL) /* silence compiler warning about unused png_ptr */ -- return ((png_charp) PNG_LIBPNG_VER_STRING); -- return ((png_charp) ""); --} -- --png_charp PNGAPI --png_get_header_version(png_structp png_ptr) --{ -- /* Returns longer string containing both version and date */ -- if (&png_ptr != NULL) /* silence compiler warning about unused png_ptr */ -- return ((png_charp) PNG_HEADER_VERSION_STRING); -- return ((png_charp) ""); --} -- --#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED --int PNGAPI --png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name) --{ -- /* check chunk_name and return "keep" value if it's on the list, else 0 */ -- int i; -- png_bytep p; -- if((png_ptr == NULL && chunk_name == NULL) || png_ptr->num_chunk_list<=0) -- return 0; -- p=png_ptr->chunk_list+png_ptr->num_chunk_list*5-5; -- for (i = png_ptr->num_chunk_list; i; i--, p-=5) -- if (!png_memcmp(chunk_name, p, 4)) -- return ((int)*(p+4)); -- return 0; --} --#endif -- --/* This function, added to libpng-1.0.6g, is untested. */ --int PNGAPI --png_reset_zstream(png_structp png_ptr) --{ -- return (inflateReset(&png_ptr->zstream)); --} -- --/* This function was added to libpng-1.0.7 */ --png_uint_32 PNGAPI --png_access_version_number(void) --{ -- /* Version of *.c files used when building libpng */ -- return((png_uint_32) PNG_LIBPNG_VER); --} -- -- --#if !defined(PNG_1_0_X) --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) -- /* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */ --/* this INTERNAL function was added to libpng 1.2.0 */ --void /* PRIVATE */ --png_init_mmx_flags (png_structp png_ptr) --{ -- png_ptr->mmx_rowbytes_threshold = 0; -- png_ptr->mmx_bitdepth_threshold = 0; -- --# if (defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD)) -- -- png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_COMPILED; -- -- if (png_mmx_support() > 0) { -- png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU --# ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW -- | PNG_ASM_FLAG_MMX_READ_COMBINE_ROW --# endif --# ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE -- | PNG_ASM_FLAG_MMX_READ_INTERLACE --# endif --# ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW -- ; --# else -- | PNG_ASM_FLAG_MMX_READ_FILTER_SUB -- | PNG_ASM_FLAG_MMX_READ_FILTER_UP -- | PNG_ASM_FLAG_MMX_READ_FILTER_AVG -- | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ; -- -- png_ptr->mmx_rowbytes_threshold = PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT; -- png_ptr->mmx_bitdepth_threshold = PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT; --# endif -- } else { -- png_ptr->asm_flags &= ~( PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU -- | PNG_MMX_READ_FLAGS -- | PNG_MMX_WRITE_FLAGS ); -- } -- --# else /* !((PNGVCRD || PNGGCCRD) && PNG_ASSEMBLER_CODE_SUPPORTED)) */ -- -- /* clear all MMX flags; no support is compiled in */ -- png_ptr->asm_flags &= ~( PNG_MMX_FLAGS ); -- --# endif /* ?(PNGVCRD || PNGGCCRD) */ --} -- --#endif /* !(PNG_ASSEMBLER_CODE_SUPPORTED) */ -- --/* this function was added to libpng 1.2.0 */ --#if !defined(PNG_USE_PNGGCCRD) && \ -- !(defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD)) --int PNGAPI --png_mmx_support(void) --{ -- return -1; --} --#endif --#endif /* PNG_1_0_X */ -- --#ifdef PNG_SIZE_T --/* Added at libpng version 1.2.6 */ -- PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size)); --png_size_t PNGAPI --png_convert_size(size_t size) --{ -- if (size > (png_size_t)-1) -- PNG_ABORT(); /* We haven't got access to png_ptr, so no png_error() */ -- return ((png_size_t)size); --} --#endif /* PNG_SIZE_T */ -diff --git a/thirdparty/libpng/png.h b/thirdparty/libpng/png.h -deleted file mode 100644 -index 6209cb6..0000000 ---- a/thirdparty/libpng/png.h -+++ /dev/null -@@ -1,3361 +0,0 @@ --/* png.h - header file for PNG reference library -- * -- * libpng version 1.2.7 - September 12, 2004 -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- * -- * Authors and maintainers: -- * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat -- * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger -- * libpng versions 0.97, January 1998, through 1.2.7 - September 12, 2004: Glenn -- * See also "Contributing Authors", below. -- * -- * Note about libpng version numbers: -- * -- * Due to various miscommunications, unforeseen code incompatibilities -- * and occasional factors outside the authors' control, version numbering -- * on the library has not always been consistent and straightforward. -- * The following table summarizes matters since version 0.89c, which was -- * the first widely used release: -- * -- * source png.h png.h shared-lib -- * version string int version -- * ------- ------ ----- ---------- -- * 0.89c "1.0 beta 3" 0.89 89 1.0.89 -- * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90] -- * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95] -- * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96] -- * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97] -- * 0.97c 0.97 97 2.0.97 -- * 0.98 0.98 98 2.0.98 -- * 0.99 0.99 98 2.0.99 -- * 0.99a-m 0.99 99 2.0.99 -- * 1.00 1.00 100 2.1.0 [100 should be 10000] -- * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000] -- * 1.0.1 png.h string is 10001 2.1.0 -- * 1.0.1a-e identical to the 10002 from here on, the shared library -- * 1.0.2 source version) 10002 is 2.V where V is the source code -- * 1.0.2a-b 10003 version, except as noted. -- * 1.0.3 10003 -- * 1.0.3a-d 10004 -- * 1.0.4 10004 -- * 1.0.4a-f 10005 -- * 1.0.5 (+ 2 patches) 10005 -- * 1.0.5a-d 10006 -- * 1.0.5e-r 10100 (not source compatible) -- * 1.0.5s-v 10006 (not binary compatible) -- * 1.0.6 (+ 3 patches) 10006 (still binary incompatible) -- * 1.0.6d-f 10007 (still binary incompatible) -- * 1.0.6g 10007 -- * 1.0.6h 10007 10.6h (testing xy.z so-numbering) -- * 1.0.6i 10007 10.6i -- * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0) -- * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible) -- * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible) -- * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible) -- * 1.0.7 1 10007 (still compatible) -- * 1.0.8beta1-4 1 10008 2.1.0.8beta1-4 -- * 1.0.8rc1 1 10008 2.1.0.8rc1 -- * 1.0.8 1 10008 2.1.0.8 -- * 1.0.9beta1-6 1 10009 2.1.0.9beta1-6 -- * 1.0.9rc1 1 10009 2.1.0.9rc1 -- * 1.0.9beta7-10 1 10009 2.1.0.9beta7-10 -- * 1.0.9rc2 1 10009 2.1.0.9rc2 -- * 1.0.9 1 10009 2.1.0.9 -- * 1.0.10beta1 1 10010 2.1.0.10beta1 -- * 1.0.10rc1 1 10010 2.1.0.10rc1 -- * 1.0.10 1 10010 2.1.0.10 -- * 1.0.11beta1-3 1 10011 2.1.0.11beta1-3 -- * 1.0.11rc1 1 10011 2.1.0.11rc1 -- * 1.0.11 1 10011 2.1.0.11 -- * 1.0.12beta1-2 2 10012 2.1.0.12beta1-2 -- * 1.0.12rc1 2 10012 2.1.0.12rc1 -- * 1.0.12 2 10012 2.1.0.12 -- * 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned) -- * 1.2.0beta1-2 2 10200 2.1.2.0beta1-2 -- * 1.2.0beta3-5 3 10200 3.1.2.0beta3-5 -- * 1.2.0rc1 3 10200 3.1.2.0rc1 -- * 1.2.0 3 10200 3.1.2.0 -- * 1.2.1beta1-4 3 10201 3.1.2.1beta1-4 -- * 1.2.1rc1-2 3 10201 3.1.2.1rc1-2 -- * 1.2.1 3 10201 3.1.2.1 -- * 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6 -- * 1.0.13beta1 10 10013 10.so.0.1.0.13beta1 -- * 1.0.13rc1 10 10013 10.so.0.1.0.13rc1 -- * 1.2.2rc1 12 10202 12.so.0.1.2.2rc1 -- * 1.0.13 10 10013 10.so.0.1.0.13 -- * 1.2.2 12 10202 12.so.0.1.2.2 -- * 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6 -- * 1.2.3 12 10203 12.so.0.1.2.3 -- * 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3 -- * 1.0.14rc1 13 10014 10.so.0.1.0.14rc1 -- * 1.2.4rc1 13 10204 12.so.0.1.2.4rc1 -- * 1.0.14 10 10014 10.so.0.1.0.14 -- * 1.2.4 13 10204 12.so.0.1.2.4 -- * 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2 -- * 1.0.15rc1-3 10 10015 10.so.0.1.0.15rc1-3 -- * 1.2.5rc1-3 13 10205 12.so.0.1.2.5rc1-3 -- * 1.0.15 10 10015 10.so.0.1.0.15 -- * 1.2.5 13 10205 12.so.0.1.2.5 -- * 1.2.6beta1-4 13 10206 12.so.0.1.2.6beta1-4 -- * 1.0.16 10 10016 10.so.0.1.0.16 -- * 1.2.6 13 10206 12.so.0.1.2.6 -- * 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2 -- * 1.0.17rc1 10 10017 12.so.0.1.0.17rc1 -- * 1.2.7rc1 13 10207 12.so.0.1.2.7rc1 -- * 1.0.17 10 10017 12.so.0.1.0.17 -- * 1.2.7 13 10207 12.so.0.1.2.7 -- * -- * Henceforth the source version will match the shared-library major -- * and minor numbers; the shared-library major version number will be -- * used for changes in backward compatibility, as it is intended. The -- * PNG_LIBPNG_VER macro, which is not used within libpng but is available -- * for applications, is an unsigned integer of the form xyyzz corresponding -- * to the source version x.y.z (leading zeros in y and z). Beta versions -- * were given the previous public release number plus a letter, until -- * version 1.0.6j; from then on they were given the upcoming public -- * release number plus "betaNN" or "rcN". -- * -- * Binary incompatibility exists only when applications make direct access -- * to the info_ptr or png_ptr members through png.h, and the compiled -- * application is loaded with a different version of the library. -- * -- * DLLNUM will change each time there are forward or backward changes -- * in binary compatibility (e.g., when a new feature is added). -- * -- * See libpng.txt or libpng.3 for more information. The PNG specification -- * is available as a W3C Recommendation and as an ISO Specification, -- * defines should NOT be changed. -- */ --#define PNG_INFO_gAMA 0x0001 --#define PNG_INFO_sBIT 0x0002 --#define PNG_INFO_cHRM 0x0004 --#define PNG_INFO_PLTE 0x0008 --#define PNG_INFO_tRNS 0x0010 --#define PNG_INFO_bKGD 0x0020 --#define PNG_INFO_hIST 0x0040 --#define PNG_INFO_pHYs 0x0080 --#define PNG_INFO_oFFs 0x0100 --#define PNG_INFO_tIME 0x0200 --#define PNG_INFO_pCAL 0x0400 --#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ --#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ --#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ --#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ --#define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */ -- --/* This is used for the transformation routines, as some of them -- * change these values for the row. It also should enable using -- * the routines for other purposes. -- */ --typedef struct png_row_info_struct --{ -- png_uint_32 width; /* width of row */ -- png_uint_32 rowbytes; /* number of bytes in row */ -- png_byte color_type; /* color type of row */ -- png_byte bit_depth; /* bit depth of row */ -- png_byte channels; /* number of channels (1, 2, 3, or 4) */ -- png_byte pixel_depth; /* bits per pixel (depth * channels) */ --} png_row_info; -- --typedef png_row_info FAR * png_row_infop; --typedef png_row_info FAR * FAR * png_row_infopp; -- --/* These are the function types for the I/O functions and for the functions -- * that allow the user to override the default I/O functions with his or her -- * own. The png_error_ptr type should match that of user-supplied warning -- * and error functions, while the png_rw_ptr type should match that of the -- * user read/write data functions. -- */ --typedef struct png_struct_def png_struct; --typedef png_struct FAR * png_structp; -- --typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp)); --typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t)); --typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp)); --typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32, -- int)); --typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32, -- int)); -- --#ifdef PNG_PROGRESSIVE_READ_SUPPORTED --typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop)); --typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop)); --typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep, -- png_uint_32, int)); --#endif -- --#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ -- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ -- defined(PNG_LEGACY_SUPPORTED) --typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp, -- png_row_infop, png_bytep)); --#endif -- --#if defined(PNG_USER_CHUNKS_SUPPORTED) --typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp)); --#endif --#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) --typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp)); --#endif -- --/* Transform masks for the high-level interface */ --#define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */ --#define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */ --#define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */ --#define PNG_TRANSFORM_PACKING 0x0004 /* read and write */ --#define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */ --#define PNG_TRANSFORM_EXPAND 0x0010 /* read only */ --#define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */ --#define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */ --#define PNG_TRANSFORM_BGR 0x0080 /* read and write */ --#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ --#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ --#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ --#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* WRITE only */ -- --/* Flags for MNG supported features */ --#define PNG_FLAG_MNG_EMPTY_PLTE 0x01 --#define PNG_FLAG_MNG_FILTER_64 0x04 --#define PNG_ALL_MNG_FEATURES 0x05 -- --typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t)); --typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp)); -- --/* The structure that holds the information to read and write PNG files. -- * The only people who need to care about what is inside of this are the -- * people who will be modifying the library for their own special needs. -- * It should NOT be accessed directly by an application, except to store -- * the jmp_buf. -- */ -- --struct png_struct_def --{ --#ifdef PNG_SETJMP_SUPPORTED -- jmp_buf jmpbuf; /* used in png_error */ --#endif -- png_error_ptr error_fn; /* function for printing errors and aborting */ -- png_error_ptr warning_fn; /* function for printing warnings */ -- png_voidp error_ptr; /* user supplied struct for error functions */ -- png_rw_ptr write_data_fn; /* function for writing output data */ -- png_rw_ptr read_data_fn; /* function for reading input data */ -- png_voidp io_ptr; /* ptr to application struct for I/O functions */ -- --#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) -- png_user_transform_ptr read_user_transform_fn; /* user read transform */ --#endif -- --#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) -- png_user_transform_ptr write_user_transform_fn; /* user write transform */ --#endif -- --/* These were added in libpng-1.0.2 */ --#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) --#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ -- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) -- png_voidp user_transform_ptr; /* user supplied struct for user transform */ -- png_byte user_transform_depth; /* bit depth of user transformed pixels */ -- png_byte user_transform_channels; /* channels in user transformed pixels */ --#endif --#endif -- -- png_uint_32 mode; /* tells us where we are in the PNG file */ -- png_uint_32 flags; /* flags indicating various things to libpng */ -- png_uint_32 transformations; /* which transformations to perform */ -- -- z_stream zstream; /* pointer to decompression structure (below) */ -- png_bytep zbuf; /* buffer for zlib */ -- png_size_t zbuf_size; /* size of zbuf */ -- int zlib_level; /* holds zlib compression level */ -- int zlib_method; /* holds zlib compression method */ -- int zlib_window_bits; /* holds zlib compression window bits */ -- int zlib_mem_level; /* holds zlib compression memory level */ -- int zlib_strategy; /* holds zlib compression strategy */ -- -- png_uint_32 width; /* width of image in pixels */ -- png_uint_32 height; /* height of image in pixels */ -- png_uint_32 num_rows; /* number of rows in current pass */ -- png_uint_32 usr_width; /* width of row at start of write */ -- png_uint_32 rowbytes; /* size of row in bytes */ -- png_uint_32 irowbytes; /* size of current interlaced row in bytes */ -- png_uint_32 iwidth; /* width of current interlaced row in pixels */ -- png_uint_32 row_number; /* current row in interlace pass */ -- png_bytep prev_row; /* buffer to save previous (unfiltered) row */ -- png_bytep row_buf; /* buffer to save current (unfiltered) row */ -- png_bytep sub_row; /* buffer to save "sub" row when filtering */ -- png_bytep up_row; /* buffer to save "up" row when filtering */ -- png_bytep avg_row; /* buffer to save "avg" row when filtering */ -- png_bytep paeth_row; /* buffer to save "Paeth" row when filtering */ -- png_row_info row_info; /* used for transformation routines */ -- -- png_uint_32 idat_size; /* current IDAT size for read */ -- png_uint_32 crc; /* current chunk CRC value */ -- png_colorp palette; /* palette from the input file */ -- png_uint_16 num_palette; /* number of color entries in palette */ -- png_uint_16 num_trans; /* number of transparency values */ -- png_byte chunk_name[5]; /* null-terminated name of current chunk */ -- png_byte compression; /* file compression type (always 0) */ -- png_byte filter; /* file filter type (always 0) */ -- png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ -- png_byte pass; /* current interlace pass (0 - 6) */ -- png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */ -- png_byte color_type; /* color type of file */ -- png_byte bit_depth; /* bit depth of file */ -- png_byte usr_bit_depth; /* bit depth of users row */ -- png_byte pixel_depth; /* number of bits per pixel */ -- png_byte channels; /* number of channels in file */ -- png_byte usr_channels; /* channels at start of write */ -- png_byte sig_bytes; /* magic bytes read/written from start of file */ -- --#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) --#ifdef PNG_LEGACY_SUPPORTED -- png_byte filler; /* filler byte for pixel expansion */ --#else -- png_uint_16 filler; /* filler bytes for pixel expansion */ --#endif --#endif -- --#if defined(PNG_bKGD_SUPPORTED) -- png_byte background_gamma_type; --# ifdef PNG_FLOATING_POINT_SUPPORTED -- float background_gamma; --# endif -- png_color_16 background; /* background color in screen gamma space */ --#if defined(PNG_READ_GAMMA_SUPPORTED) -- png_color_16 background_1; /* background normalized to gamma 1.0 */ --#endif --#endif /* PNG_bKGD_SUPPORTED */ -- --#if defined(PNG_WRITE_FLUSH_SUPPORTED) -- png_flush_ptr output_flush_fn;/* Function for flushing output */ -- png_uint_32 flush_dist; /* how many rows apart to flush, 0 - no flush */ -- png_uint_32 flush_rows; /* number of rows written since last flush */ --#endif -- --#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) -- int gamma_shift; /* number of "insignificant" bits 16-bit gamma */ --#ifdef PNG_FLOATING_POINT_SUPPORTED -- float gamma; /* file gamma value */ -- float screen_gamma; /* screen gamma value (display_exponent) */ --#endif --#endif -- --#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) -- png_bytep gamma_table; /* gamma table for 8-bit depth files */ -- png_bytep gamma_from_1; /* converts from 1.0 to screen */ -- png_bytep gamma_to_1; /* converts from file to 1.0 */ -- png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */ -- png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */ -- png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */ --#endif -- --#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED) -- png_color_8 sig_bit; /* significant bits in each available channel */ --#endif -- --#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) -- png_color_8 shift; /* shift for significant bit tranformation */ --#endif -- --#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \ -- || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) -- png_bytep trans; /* transparency values for paletted files */ -- png_color_16 trans_values; /* transparency values for non-paletted files */ --#endif -- -- png_read_status_ptr read_row_fn; /* called after each row is decoded */ -- png_write_status_ptr write_row_fn; /* called after each row is encoded */ --#ifdef PNG_PROGRESSIVE_READ_SUPPORTED -- png_progressive_info_ptr info_fn; /* called after header data fully read */ -- png_progressive_row_ptr row_fn; /* called after each prog. row is decoded */ -- png_progressive_end_ptr end_fn; /* called after image is complete */ -- png_bytep save_buffer_ptr; /* current location in save_buffer */ -- png_bytep save_buffer; /* buffer for previously read data */ -- png_bytep current_buffer_ptr; /* current location in current_buffer */ -- png_bytep current_buffer; /* buffer for recently used data */ -- png_uint_32 push_length; /* size of current input chunk */ -- png_uint_32 skip_length; /* bytes to skip in input data */ -- png_size_t save_buffer_size; /* amount of data now in save_buffer */ -- png_size_t save_buffer_max; /* total size of save_buffer */ -- png_size_t buffer_size; /* total amount of available input data */ -- png_size_t current_buffer_size; /* amount of data now in current_buffer */ -- int process_mode; /* what push library is currently doing */ -- int cur_palette; /* current push library palette index */ -- --# if defined(PNG_TEXT_SUPPORTED) -- png_size_t current_text_size; /* current size of text input data */ -- png_size_t current_text_left; /* how much text left to read in input */ -- png_charp current_text; /* current text chunk buffer */ -- png_charp current_text_ptr; /* current location in current_text */ --# endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_TEXT_SUPPORTED */ -- --#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ -- --#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) --/* for the Borland special 64K segment handler */ -- png_bytepp offset_table_ptr; -- png_bytep offset_table; -- png_uint_16 offset_table_number; -- png_uint_16 offset_table_count; -- png_uint_16 offset_table_count_free; --#endif -- --#if defined(PNG_READ_DITHER_SUPPORTED) -- png_bytep palette_lookup; /* lookup table for dithering */ -- png_bytep dither_index; /* index translation for palette files */ --#endif -- --#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED) -- png_uint_16p hist; /* histogram */ --#endif -- --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) -- png_byte heuristic_method; /* heuristic for row filter selection */ -- png_byte num_prev_filters; /* number of weights for previous rows */ -- png_bytep prev_filters; /* filter type(s) of previous row(s) */ -- png_uint_16p filter_weights; /* weight(s) for previous line(s) */ -- png_uint_16p inv_filter_weights; /* 1/weight(s) for previous line(s) */ -- png_uint_16p filter_costs; /* relative filter calculation cost */ -- png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */ --#endif -- --#if defined(PNG_TIME_RFC1123_SUPPORTED) -- png_charp time_buffer; /* String to hold RFC 1123 time text */ --#endif -- --/* New members added in libpng-1.0.6 */ -- --#ifdef PNG_FREE_ME_SUPPORTED -- png_uint_32 free_me; /* flags items libpng is responsible for freeing */ --#endif -- --#if defined(PNG_USER_CHUNKS_SUPPORTED) -- png_voidp user_chunk_ptr; -- png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */ --#endif -- --#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) -- int num_chunk_list; -- png_bytep chunk_list; --#endif -- --/* New members added in libpng-1.0.3 */ --#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) -- png_byte rgb_to_gray_status; -- /* These were changed from png_byte in libpng-1.0.6 */ -- png_uint_16 rgb_to_gray_red_coeff; -- png_uint_16 rgb_to_gray_green_coeff; -- png_uint_16 rgb_to_gray_blue_coeff; --#endif -- --/* New member added in libpng-1.0.4 (renamed in 1.0.9) */ --#if defined(PNG_MNG_FEATURES_SUPPORTED) || \ -- defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ -- defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) --/* changed from png_byte to png_uint_32 at version 1.2.0 */ --#ifdef PNG_1_0_X -- png_byte mng_features_permitted; --#else -- png_uint_32 mng_features_permitted; --#endif /* PNG_1_0_X */ --#endif -- --/* New member added in libpng-1.0.7 */ --#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) -- png_fixed_point int_gamma; --#endif -- --/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */ --#if defined(PNG_MNG_FEATURES_SUPPORTED) -- png_byte filter_type; --#endif -- --#if defined(PNG_1_0_X) || (defined(PNG_DEBUG) && defined(PNG_USE_PNGGCCRD)) --/* New member added in libpng-1.0.10, ifdef'ed out in 1.2.0 */ -- png_uint_32 row_buf_size; --#endif -- --/* New members added in libpng-1.2.0 */ --#if !defined(PNG_1_0_X) && defined(PNG_ASSEMBLER_CODE_SUPPORTED) -- png_byte mmx_bitdepth_threshold; -- png_uint_32 mmx_rowbytes_threshold; -- png_uint_32 asm_flags; --#endif -- --/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */ --#ifdef PNG_USER_MEM_SUPPORTED -- png_voidp mem_ptr; /* user supplied struct for mem functions */ -- png_malloc_ptr malloc_fn; /* function for allocating memory */ -- png_free_ptr free_fn; /* function for freeing memory */ --#endif -- --/* New member added in libpng-1.0.13 and 1.2.0 */ -- png_bytep big_row_buf; /* buffer to save current (unfiltered) row */ -- --#if defined(PNG_READ_DITHER_SUPPORTED) --/* The following three members were added at version 1.0.14 and 1.2.4 */ -- png_bytep dither_sort; /* working sort array */ -- png_bytep index_to_palette; /* where the original index currently is */ -- /* in the palette */ -- png_bytep palette_to_index; /* which original index points to this */ -- /* palette color */ --#endif -- --/* New members added in libpng-1.0.16 and 1.2.6 */ -- png_byte compression_type; -- --#ifdef PNG_SET_USER_LIMITS_SUPPORTED -- png_uint_32 user_width_max; -- png_uint_32 user_height_max; --#endif -- --}; -- -- --/* This triggers a compiler error in png.c, if png.c and png.h -- * do not agree upon the version number. -- */ --typedef png_structp version_1_2_7; -- --typedef png_struct FAR * FAR * png_structpp; -- --/* Here are the function definitions most commonly used. This is not -- * the place to find out how to use libpng. See libpng.txt for the -- * full explanation, see example.c for the summary. This just provides -- * a simple one line description of the use of each function. -- */ -- --/* Returns the version number of the library */ --extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void)); -- --/* Tell lib we have already handled the first magic bytes. -- * Handling more than 8 bytes from the beginning of the file is an error. -- */ --extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr, -- int num_bytes)); -- --/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a -- * PNG file. Returns zero if the supplied bytes match the 8-byte PNG -- * signature, and non-zero otherwise. Having num_to_check == 0 or -- * start > 7 will always fail (ie return non-zero). -- */ --extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start, -- png_size_t num_to_check)); -- --/* Simple signature checking function. This is the same as calling -- * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). -- */ --extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num)); -- --/* Allocate and initialize png_ptr struct for reading, and any other memory. */ --extern PNG_EXPORT(png_structp,png_create_read_struct) -- PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, -- png_error_ptr error_fn, png_error_ptr warn_fn)); -- --/* Allocate and initialize png_ptr struct for writing, and any other memory */ --extern PNG_EXPORT(png_structp,png_create_write_struct) -- PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, -- png_error_ptr error_fn, png_error_ptr warn_fn)); -- --#ifdef PNG_WRITE_SUPPORTED --extern PNG_EXPORT(png_uint_32,png_get_compression_buffer_size) -- PNGARG((png_structp png_ptr)); --#endif -- --#ifdef PNG_WRITE_SUPPORTED --extern PNG_EXPORT(void,png_set_compression_buffer_size) -- PNGARG((png_structp png_ptr, png_uint_32 size)); --#endif -- --/* Reset the compression stream */ --extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr)); -- --/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ --#ifdef PNG_USER_MEM_SUPPORTED --extern PNG_EXPORT(png_structp,png_create_read_struct_2) -- PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, -- png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, -- png_malloc_ptr malloc_fn, png_free_ptr free_fn)); --extern PNG_EXPORT(png_structp,png_create_write_struct_2) -- PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, -- png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, -- png_malloc_ptr malloc_fn, png_free_ptr free_fn)); --#endif -- --/* Write a PNG chunk - size, type, (optional) data, CRC. */ --extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr, -- png_bytep chunk_name, png_bytep data, png_size_t length)); -- --/* Write the start of a PNG chunk - length and chunk name. */ --extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr, -- png_bytep chunk_name, png_uint_32 length)); -- --/* Write the data of a PNG chunk started with png_write_chunk_start(). */ --extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr, -- png_bytep data, png_size_t length)); -- --/* Finish a chunk started with png_write_chunk_start() (includes CRC). */ --extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr)); -- --/* Allocate and initialize the info structure */ --extern PNG_EXPORT(png_infop,png_create_info_struct) -- PNGARG((png_structp png_ptr)); -- --/* Initialize the info structure (old interface - DEPRECATED) */ --extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr)); --#undef png_info_init --#define png_info_init(info_ptr) png_info_init_3(&info_ptr,\ -- png_sizeof(png_info)); --extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr, -- png_size_t png_info_struct_size)); -- --/* Writes all the PNG information before the image. */ --extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr, -- png_infop info_ptr)); --extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr, -- png_infop info_ptr)); -- --#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED --/* read the information before the actual image data. */ --extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr, -- png_infop info_ptr)); --#endif -- --#if defined(PNG_TIME_RFC1123_SUPPORTED) --extern PNG_EXPORT(png_charp,png_convert_to_rfc1123) -- PNGARG((png_structp png_ptr, png_timep ptime)); --#endif -- --#if !defined(_WIN32_WCE) --/* "time.h" functions are not supported on WindowsCE */ --#if defined(PNG_WRITE_tIME_SUPPORTED) --/* convert from a struct tm to png_time */ --extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime, -- struct tm FAR * ttime)); -- --/* convert from time_t to png_time. Uses gmtime() */ --extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime, -- time_t ttime)); --#endif /* PNG_WRITE_tIME_SUPPORTED */ --#endif /* _WIN32_WCE */ -- --#if defined(PNG_READ_EXPAND_SUPPORTED) --/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ --extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr)); --extern PNG_EXPORT(void,png_set_gray_1_2_4_to_8) PNGARG((png_structp png_ptr)); --extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr)); --extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr)); --#endif -- --#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) --/* Use blue, green, red order for pixels. */ --extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr)); --#endif -- --#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) --/* Expand the grayscale to 24-bit RGB if necessary. */ --extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr)); --#endif -- --#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) --/* Reduce RGB to grayscale. */ --#ifdef PNG_FLOATING_POINT_SUPPORTED --extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr, -- int error_action, double red, double green )); --#endif --extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr, -- int error_action, png_fixed_point red, png_fixed_point green )); --extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp -- png_ptr)); --#endif -- --extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth, -- png_colorp palette)); -- --#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) --extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr)); --#endif -- --#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ -- defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) --extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr)); --#endif -- --#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ -- defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) --extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr)); --#endif -- --#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) --/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */ --extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr, -- png_uint_32 filler, int flags)); --/* The values of the PNG_FILLER_ defines should NOT be changed */ --#define PNG_FILLER_BEFORE 0 --#define PNG_FILLER_AFTER 1 --/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */ --#if !defined(PNG_1_0_X) --extern PNG_EXPORT(void,png_set_add_alpha) PNGARG((png_structp png_ptr, -- png_uint_32 filler, int flags)); --#endif --#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ -- --#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) --/* Swap bytes in 16-bit depth files. */ --extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr)); --#endif -- --#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) --/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ --extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr)); --#endif -- --#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) --/* Swap packing order of pixels in bytes. */ --extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr)); --#endif -- --#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) --/* Converts files to legal bit depths. */ --extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr, -- png_color_8p true_bits)); --#endif -- --#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ -- defined(PNG_WRITE_INTERLACING_SUPPORTED) --/* Have the code handle the interlacing. Returns the number of passes. */ --extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr)); --#endif -- --#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) --/* Invert monochrome files */ --extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr)); --#endif -- --#if defined(PNG_READ_BACKGROUND_SUPPORTED) --/* Handle alpha and tRNS by replacing with a background color. */ --#ifdef PNG_FLOATING_POINT_SUPPORTED --extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr, -- png_color_16p background_color, int background_gamma_code, -- int need_expand, double background_gamma)); --#endif --#define PNG_BACKGROUND_GAMMA_UNKNOWN 0 --#define PNG_BACKGROUND_GAMMA_SCREEN 1 --#define PNG_BACKGROUND_GAMMA_FILE 2 --#define PNG_BACKGROUND_GAMMA_UNIQUE 3 --#endif -- --#if defined(PNG_READ_16_TO_8_SUPPORTED) --/* strip the second byte of information from a 16-bit depth file. */ --extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr)); --#endif -- --#if defined(PNG_READ_DITHER_SUPPORTED) --/* Turn on dithering, and reduce the palette to the number of colors available. */ --extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr, -- png_colorp palette, int num_palette, int maximum_colors, -- png_uint_16p histogram, int full_dither)); --#endif -- --#if defined(PNG_READ_GAMMA_SUPPORTED) --/* Handle gamma correction. Screen_gamma=(display_exponent) */ --#ifdef PNG_FLOATING_POINT_SUPPORTED --extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr, -- double screen_gamma, double default_file_gamma)); --#endif --#endif -- --#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ -- defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) --/* Permit or disallow empty PLTE (0: not permitted, 1: permitted) */ --/* Deprecated and will be removed. Use png_permit_mng_features() instead. */ --extern PNG_EXPORT(void,png_permit_empty_plte) PNGARG((png_structp png_ptr, -- int empty_plte_permitted)); --#endif -- --#if defined(PNG_WRITE_FLUSH_SUPPORTED) --/* Set how many lines between output flushes - 0 for no flushing */ --extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows)); --/* Flush the current PNG output buffer */ --extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr)); --#endif -- --/* optional update palette with requested transformations */ --extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr)); -- --/* optional call to update the users info structure */ --extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr, -- png_infop info_ptr)); -- --#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED --/* read one or more rows of image data. */ --extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr, -- png_bytepp row, png_bytepp display_row, png_uint_32 num_rows)); --#endif -- --#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED --/* read a row of data. */ --extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr, -- png_bytep row, -- png_bytep display_row)); --#endif -- --#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED --/* read the whole image into memory at once. */ --extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr, -- png_bytepp image)); --#endif -- --/* write a row of image data */ --extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr, -- png_bytep row)); -- --/* write a few rows of image data */ --extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr, -- png_bytepp row, png_uint_32 num_rows)); -- --/* write the image data */ --extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr, -- png_bytepp image)); -- --/* writes the end of the PNG file. */ --extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr, -- png_infop info_ptr)); -- --#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED --/* read the end of the PNG file. */ --extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr, -- png_infop info_ptr)); --#endif -- --/* free any memory associated with the png_info_struct */ --extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr, -- png_infopp info_ptr_ptr)); -- --/* free any memory associated with the png_struct and the png_info_structs */ --extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp -- png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); -- --/* free all memory used by the read (old method - NOT DLL EXPORTED) */ --extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_infop end_info_ptr)); -- --/* free any memory associated with the png_struct and the png_info_structs */ --extern PNG_EXPORT(void,png_destroy_write_struct) -- PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)); -- --/* free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */ --extern void png_write_destroy PNGARG((png_structp png_ptr)); -- --/* set the libpng method of handling chunk CRC errors */ --extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr, -- int crit_action, int ancil_action)); -- --/* Values for png_set_crc_action() to say how to handle CRC errors in -- * ancillary and critical chunks, and whether to use the data contained -- * therein. Note that it is impossible to "discard" data in a critical -- * chunk. For versions prior to 0.90, the action was always error/quit, -- * whereas in version 0.90 and later, the action for CRC errors in ancillary -- * chunks is warn/discard. These values should NOT be changed. -- * -- * value action:critical action:ancillary -- */ --#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */ --#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */ --#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */ --#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */ --#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ --#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ -- --/* These functions give the user control over the scan-line filtering in -- * libpng and the compression methods used by zlib. These functions are -- * mainly useful for testing, as the defaults should work with most users. -- * Those users who are tight on memory or want faster performance at the -- * expense of compression can modify them. See the compression library -- * header file (zlib.h) for an explination of the compression functions. -- */ -- --/* set the filtering method(s) used by libpng. Currently, the only valid -- * value for "method" is 0. -- */ --extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, -- int filters)); -- --/* Flags for png_set_filter() to say which filters to use. The flags -- * are chosen so that they don't conflict with real filter types -- * below, in case they are supplied instead of the #defined constants. -- * These values should NOT be changed. -- */ --#define PNG_NO_FILTERS 0x00 --#define PNG_FILTER_NONE 0x08 --#define PNG_FILTER_SUB 0x10 --#define PNG_FILTER_UP 0x20 --#define PNG_FILTER_AVG 0x40 --#define PNG_FILTER_PAETH 0x80 --#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ -- PNG_FILTER_AVG | PNG_FILTER_PAETH) -- --/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. -- * These defines should NOT be changed. -- */ --#define PNG_FILTER_VALUE_NONE 0 --#define PNG_FILTER_VALUE_SUB 1 --#define PNG_FILTER_VALUE_UP 2 --#define PNG_FILTER_VALUE_AVG 3 --#define PNG_FILTER_VALUE_PAETH 4 --#define PNG_FILTER_VALUE_LAST 5 -- --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* EXPERIMENTAL */ --/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_ -- * defines, either the default (minimum-sum-of-absolute-differences), or -- * the experimental method (weighted-minimum-sum-of-absolute-differences). -- * -- * Weights are factors >= 1.0, indicating how important it is to keep the -- * filter type consistent between rows. Larger numbers mean the current -- * filter is that many times as likely to be the same as the "num_weights" -- * previous filters. This is cumulative for each previous row with a weight. -- * There needs to be "num_weights" values in "filter_weights", or it can be -- * NULL if the weights aren't being specified. Weights have no influence on -- * the selection of the first row filter. Well chosen weights can (in theory) -- * improve the compression for a given image. -- * -- * Costs are factors >= 1.0 indicating the relative decoding costs of a -- * filter type. Higher costs indicate more decoding expense, and are -- * therefore less likely to be selected over a filter with lower computational -- * costs. There needs to be a value in "filter_costs" for each valid filter -- * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't -- * setting the costs. Costs try to improve the speed of decompression without -- * unduly increasing the compressed image size. -- * -- * A negative weight or cost indicates the default value is to be used, and -- * values in the range [0.0, 1.0) indicate the value is to remain unchanged. -- * The default values for both weights and costs are currently 1.0, but may -- * change if good general weighting/cost heuristics can be found. If both -- * the weights and costs are set to 1.0, this degenerates the WEIGHTED method -- * to the UNWEIGHTED method, but with added encoding time/computation. -- */ --#ifdef PNG_FLOATING_POINT_SUPPORTED --extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr, -- int heuristic_method, int num_weights, png_doublep filter_weights, -- png_doublep filter_costs)); --#endif --#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ -- --/* Heuristic used for row filter selection. These defines should NOT be -- * changed. -- */ --#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */ --#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */ --#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ --#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ -- --/* Set the library compression level. Currently, valid values range from -- * 0 - 9, corresponding directly to the zlib compression levels 0 - 9 -- * (0 - no compression, 9 - "maximal" compression). Note that tests have -- * shown that zlib compression levels 3-6 usually perform as well as level 9 -- * for PNG images, and do considerably fewer caclulations. In the future, -- * these values may not correspond directly to the zlib compression levels. -- */ --extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr, -- int level)); -- --extern PNG_EXPORT(void,png_set_compression_mem_level) -- PNGARG((png_structp png_ptr, int mem_level)); -- --extern PNG_EXPORT(void,png_set_compression_strategy) -- PNGARG((png_structp png_ptr, int strategy)); -- --extern PNG_EXPORT(void,png_set_compression_window_bits) -- PNGARG((png_structp png_ptr, int window_bits)); -- --extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr, -- int method)); -- --/* These next functions are called for input/output, memory, and error -- * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, -- * and call standard C I/O routines such as fread(), fwrite(), and -- * fprintf(). These functions can be made to use other I/O routines -- * at run time for those applications that need to handle I/O in a -- * different manner by calling png_set_???_fn(). See libpng.txt for -- * more information. -- */ -- --#if !defined(PNG_NO_STDIO) --/* Initialize the input/output for the PNG file to the default functions. */ --extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp)); --#endif -- --/* Replace the (error and abort), and warning functions with user -- * supplied functions. If no messages are to be printed you must still -- * write and use replacement functions. The replacement error_fn should -- * still do a longjmp to the last setjmp location if you are using this -- * method of error handling. If error_fn or warning_fn is NULL, the -- * default function will be used. -- */ -- --extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr, -- png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); -- --/* Return the user pointer associated with the error functions */ --extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr)); -- --/* Replace the default data output functions with a user supplied one(s). -- * If buffered output is not used, then output_flush_fn can be set to NULL. -- * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time -- * output_flush_fn will be ignored (and thus can be NULL). -- */ --extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr, -- png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); -- --/* Replace the default data input function with a user supplied one. */ --extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr, -- png_voidp io_ptr, png_rw_ptr read_data_fn)); -- --/* Return the user pointer associated with the I/O functions */ --extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr)); -- --extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr, -- png_read_status_ptr read_row_fn)); -- --extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr, -- png_write_status_ptr write_row_fn)); -- --#ifdef PNG_USER_MEM_SUPPORTED --/* Replace the default memory allocation functions with user supplied one(s). */ --extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr, -- png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)); --/* Return the user pointer associated with the memory functions */ --extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr)); --#endif -- --#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ -- defined(PNG_LEGACY_SUPPORTED) --extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp -- png_ptr, png_user_transform_ptr read_user_transform_fn)); --#endif -- --#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ -- defined(PNG_LEGACY_SUPPORTED) --extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp -- png_ptr, png_user_transform_ptr write_user_transform_fn)); --#endif -- --#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ -- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ -- defined(PNG_LEGACY_SUPPORTED) --extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp -- png_ptr, png_voidp user_transform_ptr, int user_transform_depth, -- int user_transform_channels)); --/* Return the user pointer associated with the user transform functions */ --extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr) -- PNGARG((png_structp png_ptr)); --#endif -- --#ifdef PNG_USER_CHUNKS_SUPPORTED --extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr, -- png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); --extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp -- png_ptr)); --#endif -- --#ifdef PNG_PROGRESSIVE_READ_SUPPORTED --/* Sets the function callbacks for the push reader, and a pointer to a -- * user-defined structure available to the callback functions. -- */ --extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr, -- png_voidp progressive_ptr, -- png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, -- png_progressive_end_ptr end_fn)); -- --/* returns the user pointer associated with the push read functions */ --extern PNG_EXPORT(png_voidp,png_get_progressive_ptr) -- PNGARG((png_structp png_ptr)); -- --/* function to be called when data becomes available */ --extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_bytep buffer, png_size_t buffer_size)); -- --/* function that combines rows. Not very much different than the -- * png_combine_row() call. Is this even used????? -- */ --extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr, -- png_bytep old_row, png_bytep new_row)); --#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ -- --extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr, -- png_uint_32 size)); -- --#if defined(PNG_1_0_X) --# define png_malloc_warn png_malloc --#else --/* Added at libpng version 1.2.4 */ --extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr, -- png_uint_32 size)); --#endif -- --/* frees a pointer allocated by png_malloc() */ --extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr)); -- --#if defined(PNG_1_0_X) --/* Function to allocate memory for zlib. */ --extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items, -- uInt size)); -- --/* Function to free memory for zlib */ --extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr)); --#endif -- --/* Free data that was allocated internally */ --extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_uint_32 free_me, int num)); --#ifdef PNG_FREE_ME_SUPPORTED --/* Reassign responsibility for freeing existing data, whether allocated -- * by libpng or by the application */ --extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr, -- png_infop info_ptr, int freer, png_uint_32 mask)); --#endif --/* assignments for png_data_freer */ --#define PNG_DESTROY_WILL_FREE_DATA 1 --#define PNG_SET_WILL_FREE_DATA 1 --#define PNG_USER_WILL_FREE_DATA 2 --/* Flags for png_ptr->free_me and info_ptr->free_me */ --#define PNG_FREE_HIST 0x0008 --#define PNG_FREE_ICCP 0x0010 --#define PNG_FREE_SPLT 0x0020 --#define PNG_FREE_ROWS 0x0040 --#define PNG_FREE_PCAL 0x0080 --#define PNG_FREE_SCAL 0x0100 --#define PNG_FREE_UNKN 0x0200 --#define PNG_FREE_LIST 0x0400 --#define PNG_FREE_PLTE 0x1000 --#define PNG_FREE_TRNS 0x2000 --#define PNG_FREE_TEXT 0x4000 --#define PNG_FREE_ALL 0x7fff --#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ -- --#ifdef PNG_USER_MEM_SUPPORTED --extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr, -- png_uint_32 size)); --extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr, -- png_voidp ptr)); --#endif -- --extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr, -- png_voidp s1, png_voidp s2, png_uint_32 size)); -- --extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr, -- png_voidp s1, int value, png_uint_32 size)); -- --#if defined(USE_FAR_KEYWORD) /* memory model conversion function */ --extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr, -- int check)); --#endif /* USE_FAR_KEYWORD */ -- --/* Fatal error in PNG image of libpng - can't continue */ --extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr, -- png_const_charp error_message)); -- --/* The same, but the chunk name is prepended to the error string. */ --extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr, -- png_const_charp error_message)); -- --/* Non-fatal error in libpng. Can continue, but may have a problem. */ --extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr, -- png_const_charp warning_message)); -- --/* Non-fatal error in libpng, chunk name is prepended to message. */ --extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr, -- png_const_charp warning_message)); -- --/* The png_set_ functions are for storing values in the png_info_struct. -- * Similarly, the png_get_ calls are used to read values from the -- * png_info_struct, either storing the parameters in the passed variables, or -- * setting pointers into the png_info_struct where the data is stored. The -- * png_get_ functions return a non-zero value if the data was available -- * in info_ptr, or return zero and do not change any of the parameters if the -- * data was not available. -- * -- * These functions should be used instead of directly accessing png_info -- * to avoid problems with future changes in the size and internal layout of -- * png_info_struct. -- */ --/* Returns "flag" if chunk data is valid in info_ptr. */ --extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr, --png_infop info_ptr, png_uint_32 flag)); -- --/* Returns number of bytes needed to hold a transformed row. */ --extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr, --png_infop info_ptr)); -- --#if defined(PNG_INFO_IMAGE_SUPPORTED) --/* Returns row_pointers, which is an array of pointers to scanlines that was --returned from png_read_png(). */ --extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr, --png_infop info_ptr)); --/* Set row_pointers, which is an array of pointers to scanlines for use --by png_write_png(). */ --extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_bytepp row_pointers)); --#endif -- --/* Returns number of color channels in image. */ --extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr, --png_infop info_ptr)); -- --#ifdef PNG_EASY_ACCESS_SUPPORTED --/* Returns image width in pixels. */ --extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp --png_ptr, png_infop info_ptr)); -- --/* Returns image height in pixels. */ --extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp --png_ptr, png_infop info_ptr)); -- --/* Returns image bit_depth. */ --extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp --png_ptr, png_infop info_ptr)); -- --/* Returns image color_type. */ --extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp --png_ptr, png_infop info_ptr)); -- --/* Returns image filter_type. */ --extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp --png_ptr, png_infop info_ptr)); -- --/* Returns image interlace_type. */ --extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp --png_ptr, png_infop info_ptr)); -- --/* Returns image compression_type. */ --extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp --png_ptr, png_infop info_ptr)); -- --/* Returns image resolution in pixels per meter, from pHYs chunk data. */ --extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp --png_ptr, png_infop info_ptr)); --extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp --png_ptr, png_infop info_ptr)); --extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp --png_ptr, png_infop info_ptr)); -- --/* Returns pixel aspect ratio, computed from pHYs chunk data. */ --#ifdef PNG_FLOATING_POINT_SUPPORTED --extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp --png_ptr, png_infop info_ptr)); --#endif -- --/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ --extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp --png_ptr, png_infop info_ptr)); --extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp --png_ptr, png_infop info_ptr)); --extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp --png_ptr, png_infop info_ptr)); --extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp --png_ptr, png_infop info_ptr)); -- --#endif /* PNG_EASY_ACCESS_SUPPORTED */ -- --/* Returns pointer to signature string read from PNG header */ --extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr, --png_infop info_ptr)); -- --#if defined(PNG_bKGD_SUPPORTED) --extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_color_16p *background)); --#endif -- --#if defined(PNG_bKGD_SUPPORTED) --extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_color_16p background)); --#endif -- --#if defined(PNG_cHRM_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED --extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr, -- png_infop info_ptr, double *white_x, double *white_y, double *red_x, -- double *red_y, double *green_x, double *green_y, double *blue_x, -- double *blue_y)); --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED --extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point -- *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y, -- png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point -- *int_blue_x, png_fixed_point *int_blue_y)); --#endif --#endif -- --#if defined(PNG_cHRM_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED --extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr, -- png_infop info_ptr, double white_x, double white_y, double red_x, -- double red_y, double green_x, double green_y, double blue_x, double blue_y)); --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED --extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y, -- png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point -- int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, -- png_fixed_point int_blue_y)); --#endif --#endif -- --#if defined(PNG_gAMA_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED --extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr, -- png_infop info_ptr, double *file_gamma)); --#endif --extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_fixed_point *int_file_gamma)); --#endif -- --#if defined(PNG_gAMA_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED --extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr, -- png_infop info_ptr, double file_gamma)); --#endif --extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_fixed_point int_file_gamma)); --#endif -- --#if defined(PNG_hIST_SUPPORTED) --extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_uint_16p *hist)); --#endif -- --#if defined(PNG_hIST_SUPPORTED) --extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_uint_16p hist)); --#endif -- --extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_uint_32 *width, png_uint_32 *height, -- int *bit_depth, int *color_type, int *interlace_method, -- int *compression_method, int *filter_method)); -- --extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, -- int color_type, int interlace_method, int compression_method, -- int filter_method)); -- --#if defined(PNG_oFFs_SUPPORTED) --extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, -- int *unit_type)); --#endif -- --#if defined(PNG_oFFs_SUPPORTED) --extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y, -- int unit_type)); --#endif -- --#if defined(PNG_pCAL_SUPPORTED) --extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1, -- int *type, int *nparams, png_charp *units, png_charpp *params)); --#endif -- --#if defined(PNG_pCAL_SUPPORTED) --extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, -- int type, int nparams, png_charp units, png_charpp params)); --#endif -- --#if defined(PNG_pHYs_SUPPORTED) --extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); --#endif -- --#if defined(PNG_pHYs_SUPPORTED) --extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); --#endif -- --extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_colorp *palette, int *num_palette)); -- --extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_colorp palette, int num_palette)); -- --#if defined(PNG_sBIT_SUPPORTED) --extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_color_8p *sig_bit)); --#endif -- --#if defined(PNG_sBIT_SUPPORTED) --extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_color_8p sig_bit)); --#endif -- --#if defined(PNG_sRGB_SUPPORTED) --extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr, -- png_infop info_ptr, int *intent)); --#endif -- --#if defined(PNG_sRGB_SUPPORTED) --extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr, -- png_infop info_ptr, int intent)); --extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr, -- png_infop info_ptr, int intent)); --#endif -- --#if defined(PNG_iCCP_SUPPORTED) --extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_charpp name, int *compression_type, -- png_charpp profile, png_uint_32 *proflen)); -- /* Note to maintainer: profile should be png_bytepp */ --#endif -- --#if defined(PNG_iCCP_SUPPORTED) --extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_charp name, int compression_type, -- png_charp profile, png_uint_32 proflen)); -- /* Note to maintainer: profile should be png_bytep */ --#endif -- --#if defined(PNG_sPLT_SUPPORTED) --extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_sPLT_tpp entries)); --#endif -- --#if defined(PNG_sPLT_SUPPORTED) --extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_sPLT_tp entries, int nentries)); --#endif -- --#if defined(PNG_TEXT_SUPPORTED) --/* png_get_text also returns the number of text chunks in *num_text */ --extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_textp *text_ptr, int *num_text)); --#endif -- --/* -- * Note while png_set_text() will accept a structure whose text, -- * language, and translated keywords are NULL pointers, the structure -- * returned by png_get_text will always contain regular -- * zero-terminated C strings. They might be empty strings but -- * they will never be NULL pointers. -- */ -- --#if defined(PNG_TEXT_SUPPORTED) --extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_textp text_ptr, int num_text)); --#endif -- --#if defined(PNG_tIME_SUPPORTED) --extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_timep *mod_time)); --#endif -- --#if defined(PNG_tIME_SUPPORTED) --extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_timep mod_time)); --#endif -- --#if defined(PNG_tRNS_SUPPORTED) --extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_bytep *trans, int *num_trans, -- png_color_16p *trans_values)); --#endif -- --#if defined(PNG_tRNS_SUPPORTED) --extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_bytep trans, int num_trans, -- png_color_16p trans_values)); --#endif -- --#if defined(PNG_tRNS_SUPPORTED) --#endif -- --#if defined(PNG_sCAL_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED --extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr, -- png_infop info_ptr, int *unit, double *width, double *height)); --#else --#ifdef PNG_FIXED_POINT_SUPPORTED --extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr, -- png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight)); --#endif --#endif --#endif /* PNG_sCAL_SUPPORTED */ -- --#if defined(PNG_sCAL_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED --extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr, -- png_infop info_ptr, int unit, double width, double height)); --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED --extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr, -- png_infop info_ptr, int unit, png_charp swidth, png_charp sheight)); --#endif --#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */ -- --#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) --/* provide a list of chunks and how they are to be handled, if the built-in -- handling or default unknown chunk handling is not desired. Any chunks not -- listed will be handled in the default manner. The IHDR and IEND chunks -- must not be listed. -- keep = 0: follow default behavour -- = 1: do not keep -- = 2: keep only if safe-to-copy -- = 3: keep even if unsafe-to-copy --*/ --extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp -- png_ptr, int keep, png_bytep chunk_list, int num_chunks)); --extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)); --extern PNG_EXPORT(void, png_set_unknown_chunk_location) -- PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location)); --extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp -- png_ptr, png_infop info_ptr, png_unknown_chunkpp entries)); --#endif --#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED --PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep -- chunk_name)); --#endif -- --/* Png_free_data() will turn off the "valid" flag for anything it frees. -- If you need to turn it off for a chunk that your application has freed, -- you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); */ --extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr, -- png_infop info_ptr, int mask)); -- --#if defined(PNG_INFO_IMAGE_SUPPORTED) --/* The "params" pointer is currently not used and is for future expansion. */ --extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr, -- png_infop info_ptr, -- int transforms, -- png_voidp params)); --extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr, -- png_infop info_ptr, -- int transforms, -- png_voidp params)); --#endif -- --/* Define PNG_DEBUG at compile time for debugging information. Higher -- * numbers for PNG_DEBUG mean more debugging information. This has -- * only been added since version 0.95 so it is not implemented throughout -- * libpng yet, but more support will be added as needed. -- */ --#ifdef PNG_DEBUG --#if (PNG_DEBUG > 0) --#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER) --#include --#if (PNG_DEBUG > 1) --#define png_debug(l,m) _RPT0(_CRT_WARN,m) --#define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m,p1) --#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m,p1,p2) --#endif --#else /* PNG_DEBUG_FILE || !_MSC_VER */ --#ifndef PNG_DEBUG_FILE --#define PNG_DEBUG_FILE stderr --#endif /* PNG_DEBUG_FILE */ --#if (PNG_DEBUG > 1) --#define png_debug(l,m) \ --{ \ -- int num_tabs=l; \ -- fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ -- (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \ --} --#define png_debug1(l,m,p1) \ --{ \ -- int num_tabs=l; \ -- fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ -- (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \ --} --#define png_debug2(l,m,p1,p2) \ --{ \ -- int num_tabs=l; \ -- fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ -- (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \ --} --#endif /* (PNG_DEBUG > 1) */ --#endif /* _MSC_VER */ --#endif /* (PNG_DEBUG > 0) */ --#endif /* PNG_DEBUG */ --#ifndef png_debug --#define png_debug(l, m) --#endif --#ifndef png_debug1 --#define png_debug1(l, m, p1) --#endif --#ifndef png_debug2 --#define png_debug2(l, m, p1, p2) --#endif -- --extern PNG_EXPORT(png_bytep,png_sig_bytes) PNGARG((void)); -- --extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr)); --extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr)); --extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr)); --extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr)); -- --#ifdef PNG_MNG_FEATURES_SUPPORTED --extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp -- png_ptr, png_uint_32 mng_features_permitted)); --#endif -- --/* For use in png_set_keep_unknown, added to version 1.2.6 */ --#define PNG_HANDLE_CHUNK_AS_DEFAULT 0 --#define PNG_HANDLE_CHUNK_NEVER 1 --#define PNG_HANDLE_CHUNK_IF_SAFE 2 --#define PNG_HANDLE_CHUNK_ALWAYS 3 -- --/* Added to version 1.2.0 */ --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) --#define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED 0x01 /* not user-settable */ --#define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU 0x02 /* not user-settable */ --#define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW 0x04 --#define PNG_ASM_FLAG_MMX_READ_INTERLACE 0x08 --#define PNG_ASM_FLAG_MMX_READ_FILTER_SUB 0x10 --#define PNG_ASM_FLAG_MMX_READ_FILTER_UP 0x20 --#define PNG_ASM_FLAG_MMX_READ_FILTER_AVG 0x40 --#define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80 --#define PNG_ASM_FLAGS_INITIALIZED 0x80000000 /* not user-settable */ -- --#define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \ -- | PNG_ASM_FLAG_MMX_READ_INTERLACE \ -- | PNG_ASM_FLAG_MMX_READ_FILTER_SUB \ -- | PNG_ASM_FLAG_MMX_READ_FILTER_UP \ -- | PNG_ASM_FLAG_MMX_READ_FILTER_AVG \ -- | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ) --#define PNG_MMX_WRITE_FLAGS ( 0 ) -- --#define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED \ -- | PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU \ -- | PNG_MMX_READ_FLAGS \ -- | PNG_MMX_WRITE_FLAGS ) -- --#define PNG_SELECT_READ 1 --#define PNG_SELECT_WRITE 2 -- --#if !defined(PNG_1_0_X) --/* pngget.c */ --extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask) -- PNGARG((int flag_select, int *compilerID)); -- --/* pngget.c */ --extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask) -- PNGARG((int flag_select)); -- --/* pngget.c */ --extern PNG_EXPORT(png_uint_32,png_get_asm_flags) -- PNGARG((png_structp png_ptr)); -- --/* pngget.c */ --extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold) -- PNGARG((png_structp png_ptr)); -- --/* pngget.c */ --extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold) -- PNGARG((png_structp png_ptr)); -- --/* pngset.c */ --extern PNG_EXPORT(void,png_set_asm_flags) -- PNGARG((png_structp png_ptr, png_uint_32 asm_flags)); -- --/* pngset.c */ --extern PNG_EXPORT(void,png_set_mmx_thresholds) -- PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold, -- png_uint_32 mmx_rowbytes_threshold)); -- --#endif /* PNG_1_0_X */ --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ -- --#if !defined(PNG_1_0_X) --/* png.c, pnggccrd.c, or pngvcrd.c */ --extern PNG_EXPORT(int,png_mmx_support) PNGARG((void)); -- --/* Strip the prepended error numbers ("#nnn ") from error and warning -- * messages before passing them to the error or warning handler. */ --#ifdef PNG_ERROR_NUMBERS_SUPPORTED --extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp -- png_ptr, png_uint_32 strip_mode)); --#endif -- --#endif /* PNG_1_0_X */ -- --/* Added at libpng-1.2.6 */ --#ifdef PNG_SET_USER_LIMITS_SUPPORTED --extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp -- png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max)); --extern PNG_EXPORT(png_uint_32,png_get_user_width_max) PNGARG((png_structp -- png_ptr)); --extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp -- png_ptr)); --#endif -- --/* Maintainer: Put new public prototypes here ^, in libpng.3, and project defs */ -- --#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED --/* With these routines we avoid an integer divide, which will be slower on -- * most machines. However, it does take more operations than the corresponding -- * divide method, so it may be slower on a few RISC systems. There are two -- * shifts (by 8 or 16 bits) and an addition, versus a single integer divide. -- * -- * Note that the rounding factors are NOT supposed to be the same! 128 and -- * 32768 are correct for the NODIV code; 127 and 32767 are correct for the -- * standard method. -- * -- * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] -- */ -- -- /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ -- --# define png_composite(composite, fg, alpha, bg) \ -- { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \ -- + (png_uint_16)(bg)*(png_uint_16)(255 - \ -- (png_uint_16)(alpha)) + (png_uint_16)128); \ -- (composite) = (png_byte)((temp + (temp >> 8)) >> 8); } -- --# define png_composite_16(composite, fg, alpha, bg) \ -- { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \ -- + (png_uint_32)(bg)*(png_uint_32)(65535L - \ -- (png_uint_32)(alpha)) + (png_uint_32)32768L); \ -- (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } -- --#else /* standard method using integer division */ -- --# define png_composite(composite, fg, alpha, bg) \ -- (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ -- (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ -- (png_uint_16)127) / 255) -- --# define png_composite_16(composite, fg, alpha, bg) \ -- (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ -- (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \ -- (png_uint_32)32767) / (png_uint_32)65535L) -- --#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ -- --/* These next functions are used internally in the code. They generally -- * shouldn't be used unless you are writing code to add or replace some -- * functionality in libpng. More information about most functions can -- * be found in the files where the functions are located. -- */ -- --#if defined(PNG_INTERNAL) -- --/* Various modes of operation. Note that after an init, mode is set to -- * zero automatically when the structure is created. -- */ --#define PNG_HAVE_IHDR 0x01 --#define PNG_HAVE_PLTE 0x02 --#define PNG_HAVE_IDAT 0x04 --#define PNG_AFTER_IDAT 0x08 --#define PNG_HAVE_IEND 0x10 --#define PNG_HAVE_gAMA 0x20 --#define PNG_HAVE_cHRM 0x40 --#define PNG_HAVE_sRGB 0x80 --#define PNG_HAVE_CHUNK_HEADER 0x100 --#define PNG_WROTE_tIME 0x200 --#define PNG_WROTE_INFO_BEFORE_PLTE 0x400 --#define PNG_BACKGROUND_IS_GRAY 0x800 --#define PNG_HAVE_PNG_SIGNATURE 0x1000 -- --/* flags for the transformations the PNG library does on the image data */ --#define PNG_BGR 0x0001 --#define PNG_INTERLACE 0x0002 --#define PNG_PACK 0x0004 --#define PNG_SHIFT 0x0008 --#define PNG_SWAP_BYTES 0x0010 --#define PNG_INVERT_MONO 0x0020 --#define PNG_DITHER 0x0040 --#define PNG_BACKGROUND 0x0080 --#define PNG_BACKGROUND_EXPAND 0x0100 -- /* 0x0200 unused */ --#define PNG_16_TO_8 0x0400 --#define PNG_RGBA 0x0800 --#define PNG_EXPAND 0x1000 --#define PNG_GAMMA 0x2000 --#define PNG_GRAY_TO_RGB 0x4000 --#define PNG_FILLER 0x8000L --#define PNG_PACKSWAP 0x10000L --#define PNG_SWAP_ALPHA 0x20000L --#define PNG_STRIP_ALPHA 0x40000L --#define PNG_INVERT_ALPHA 0x80000L --#define PNG_USER_TRANSFORM 0x100000L --#define PNG_RGB_TO_GRAY_ERR 0x200000L --#define PNG_RGB_TO_GRAY_WARN 0x400000L --#define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */ --#define PNG_ADD_ALPHA 0x1000000L /* Added to libpng-1.2.7 */ -- --/* flags for png_create_struct */ --#define PNG_STRUCT_PNG 0x0001 --#define PNG_STRUCT_INFO 0x0002 -- --/* Scaling factor for filter heuristic weighting calculations */ --#define PNG_WEIGHT_SHIFT 8 --#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT)) --#define PNG_COST_SHIFT 3 --#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT)) -- --/* flags for the png_ptr->flags rather than declaring a byte for each one */ --#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001 --#define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002 --#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004 --#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008 --#define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010 --#define PNG_FLAG_ZLIB_FINISHED 0x0020 --#define PNG_FLAG_ROW_INIT 0x0040 --#define PNG_FLAG_FILLER_AFTER 0x0080 --#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100 --#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200 --#define PNG_FLAG_CRC_CRITICAL_USE 0x0400 --#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800 --#define PNG_FLAG_FREE_PLTE 0x1000 --#define PNG_FLAG_FREE_TRNS 0x2000 --#define PNG_FLAG_FREE_HIST 0x4000 --#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L --#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L --#define PNG_FLAG_LIBRARY_MISMATCH 0x20000L --#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L --#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L --#define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L -- --#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \ -- PNG_FLAG_CRC_ANCILLARY_NOWARN) -- --#define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \ -- PNG_FLAG_CRC_CRITICAL_IGNORE) -- --#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \ -- PNG_FLAG_CRC_CRITICAL_MASK) -- --/* save typing and make code easier to understand */ -- --#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \ -- abs((int)((c1).green) - (int)((c2).green)) + \ -- abs((int)((c1).blue) - (int)((c2).blue))) -- --/* Added to libpng-1.2.6 JB */ --#define PNG_ROWBYTES(pixel_bits, width) \ -- ((pixel_bits) >= 8 ? \ -- ((width) * (((png_uint_32)(pixel_bits)) >> 3)) : \ -- (( ((width) * ((png_uint_32)(pixel_bits))) + 7) >> 3) ) -- --/* PNG_OUT_OF_RANGE returns true if value is outside the range -- ideal-delta..ideal+delta. Each argument is evaluated twice. -- "ideal" and "delta" should be constants, normally simple -- integers, "value" a variable. Added to libpng-1.2.6 JB */ --#define PNG_OUT_OF_RANGE(value, ideal, delta) \ -- ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) ) -- --/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */ --#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) --/* place to hold the signature string for a PNG file. */ --#ifdef PNG_USE_GLOBAL_ARRAYS -- PNG_EXPORT_VAR (const png_byte FARDATA) png_sig[8]; --#else --#define png_sig png_sig_bytes(NULL) --#endif --#endif /* PNG_NO_EXTERN */ -- --/* Constant strings for known chunk types. If you need to add a chunk, -- * define the name here, and add an invocation of the macro in png.c and -- * wherever it's needed. -- */ --#define PNG_IHDR const png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'} --#define PNG_IDAT const png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'} --#define PNG_IEND const png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'} --#define PNG_PLTE const png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'} --#define PNG_bKGD const png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'} --#define PNG_cHRM const png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'} --#define PNG_gAMA const png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'} --#define PNG_hIST const png_byte png_hIST[5] = {104, 73, 83, 84, '\0'} --#define PNG_iCCP const png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'} --#define PNG_iTXt const png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'} --#define PNG_oFFs const png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'} --#define PNG_pCAL const png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'} --#define PNG_sCAL const png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'} --#define PNG_pHYs const png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'} --#define PNG_sBIT const png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'} --#define PNG_sPLT const png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'} --#define PNG_sRGB const png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'} --#define PNG_tEXt const png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'} --#define PNG_tIME const png_byte png_tIME[5] = {116, 73, 77, 69, '\0'} --#define PNG_tRNS const png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'} --#define PNG_zTXt const png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'} -- --#ifdef PNG_USE_GLOBAL_ARRAYS --PNG_EXPORT_VAR (const png_byte FARDATA) png_IHDR[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_IDAT[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_IEND[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_PLTE[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_bKGD[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_cHRM[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_gAMA[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_hIST[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_iCCP[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_iTXt[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_oFFs[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_pCAL[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_sCAL[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_pHYs[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_sBIT[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_sPLT[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_sRGB[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_tEXt[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_tIME[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_tRNS[5]; --PNG_EXPORT_VAR (const png_byte FARDATA) png_zTXt[5]; --#endif /* PNG_USE_GLOBAL_ARRAYS */ -- -- --/* Inline macros to do direct reads of bytes from the input buffer. These -- * require that you are using an architecture that uses PNG byte ordering -- * (MSB first) and supports unaligned data storage. I think that PowerPC -- * in big-endian mode and 680x0 are the only ones that will support this. -- * The x86 line of processors definitely do not. The png_get_int_32() -- * routine also assumes we are using two's complement format for negative -- * values, which is almost certainly true. -- */ --#if defined(PNG_READ_BIG_ENDIAN_SUPPORTED) --# if defined(PNG_pCAL_SUPPORTED) || defined(PNG_oFFs_SUPPORTED) --# define png_get_int_32(buf) ( *((png_int_32p) (buf))) --# endif --# define png_get_uint_32(buf) ( *((png_uint_32p) (buf))) --# define png_get_uint_16(buf) ( *((png_uint_16p) (buf))) --#else --# if defined(PNG_pCAL_SUPPORTED) || defined(PNG_oFFs_SUPPORTED) --PNG_EXTERN png_int_32 png_get_int_32 PNGARG((png_bytep buf)); --# endif --PNG_EXTERN png_uint_32 png_get_uint_32 PNGARG((png_bytep buf)); --PNG_EXTERN png_uint_16 png_get_uint_16 PNGARG((png_bytep buf)); --#endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */ --PNG_EXTERN png_uint_32 png_get_uint_31 PNGARG((png_structp png_ptr, -- png_bytep buf)); -- --/* Initialize png_ptr struct for reading, and allocate any other memory. -- * (old interface - DEPRECATED - use png_create_read_struct instead). -- */ --extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr)); --#undef png_read_init --#define png_read_init(png_ptr) png_read_init_3(&png_ptr, \ -- PNG_LIBPNG_VER_STRING, png_sizeof(png_struct)); --extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr, -- png_const_charp user_png_ver, png_size_t png_struct_size)); --extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr, -- png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t -- png_info_size)); -- --/* Initialize png_ptr struct for writing, and allocate any other memory. -- * (old interface - DEPRECATED - use png_create_write_struct instead). -- */ --extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr)); --#undef png_write_init --#define png_write_init(png_ptr) png_write_init_3(&png_ptr, \ -- PNG_LIBPNG_VER_STRING, png_sizeof(png_struct)); --extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr, -- png_const_charp user_png_ver, png_size_t png_struct_size)); --extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr, -- png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t -- png_info_size)); -- --/* Allocate memory for an internal libpng struct */ --PNG_EXTERN png_voidp png_create_struct PNGARG((int type)); -- --/* Free memory from internal libpng struct */ --PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr)); -- --PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr -- malloc_fn, png_voidp mem_ptr)); --PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr, -- png_free_ptr free_fn, png_voidp mem_ptr)); -- --/* Free any memory that info_ptr points to and reset struct. */ --PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr, -- png_infop info_ptr)); -- --#ifndef PNG_1_0_X --/* Function to allocate memory for zlib. */ --PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size)); -- --/* Function to free memory for zlib */ --PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)); -- --#ifdef PNG_SIZE_T --/* Function to convert a sizeof an item to png_sizeof item */ -- PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size)); --#endif -- --/* Next four functions are used internally as callbacks. PNGAPI is required -- * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3. */ -- --PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr, -- png_bytep data, png_size_t length)); -- --#ifdef PNG_PROGRESSIVE_READ_SUPPORTED --PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr, -- png_bytep buffer, png_size_t length)); --#endif -- --PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr, -- png_bytep data, png_size_t length)); -- --#if defined(PNG_WRITE_FLUSH_SUPPORTED) --#if !defined(PNG_NO_STDIO) --PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr)); --#endif --#endif --#else /* PNG_1_0_X */ --#ifdef PNG_PROGRESSIVE_READ_SUPPORTED --PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr, -- png_bytep buffer, png_size_t length)); --#endif --#endif /* PNG_1_0_X */ -- --/* Reset the CRC variable */ --PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr)); -- --/* Write the "data" buffer to whatever output you are using. */ --PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data, -- png_size_t length)); -- --/* Read data from whatever input you are using into the "data" buffer */ --PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data, -- png_size_t length)); -- --/* Read bytes into buf, and update png_ptr->crc */ --PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf, -- png_size_t length)); -- --/* Decompress data in a chunk that uses compression */ --#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \ -- defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) --PNG_EXTERN png_charp png_decompress_chunk PNGARG((png_structp png_ptr, -- int comp_type, png_charp chunkdata, png_size_t chunklength, -- png_size_t prefix_length, png_size_t *data_length)); --#endif -- --/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */ --PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip)); -- --/* Read the CRC from the file and compare it to the libpng calculated CRC */ --PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr)); -- --/* Calculate the CRC over a section of data. Note that we are only -- * passing a maximum of 64K on systems that have this as a memory limit, -- * since this is the maximum buffer size we can specify. -- */ --PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr, -- png_size_t length)); -- --#if defined(PNG_WRITE_FLUSH_SUPPORTED) --PNG_EXTERN void png_flush PNGARG((png_structp png_ptr)); --#endif -- -- --/* Place a 32-bit number into a buffer in PNG byte order (big-endian). -- * The only currently known PNG chunks that use signed numbers are -- * the ancillary extension chunks, oFFs and pCAL. -- */ --PNG_EXTERN void png_save_uint_32 PNGARG((png_bytep buf, png_uint_32 i)); -- --#if defined(PNG_WRITE_pCAL_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED) --PNG_EXTERN void png_save_int_32 PNGARG((png_bytep buf, png_int_32 i)); --#endif -- --/* Place a 16-bit number into a buffer in PNG byte order. -- * The parameter is declared unsigned int, not png_uint_16, -- * just to avoid potential problems on pre-ANSI C compilers. -- */ --PNG_EXTERN void png_save_uint_16 PNGARG((png_bytep buf, unsigned int i)); -- --/* simple function to write the signature */ --PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr)); -- --/* write various chunks */ -- --/* Write the IHDR chunk, and update the png_struct with the necessary -- * information. -- */ --PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width, -- png_uint_32 height, -- int bit_depth, int color_type, int compression_method, int filter_method, -- int interlace_method)); -- --PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette, -- png_uint_32 num_pal)); -- --PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data, -- png_size_t length)); -- --PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr)); -- --#if defined(PNG_WRITE_gAMA_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED --PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma)); --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED --PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, png_fixed_point -- file_gamma)); --#endif --#endif -- --#if defined(PNG_WRITE_sBIT_SUPPORTED) --PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit, -- int color_type)); --#endif -- --#if defined(PNG_WRITE_cHRM_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED --PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr, -- double white_x, double white_y, -- double red_x, double red_y, double green_x, double green_y, -- double blue_x, double blue_y)); --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED --PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr, -- png_fixed_point int_white_x, png_fixed_point int_white_y, -- png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point -- int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, -- png_fixed_point int_blue_y)); --#endif --#endif -- --#if defined(PNG_WRITE_sRGB_SUPPORTED) --PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr, -- int intent)); --#endif -- --#if defined(PNG_WRITE_iCCP_SUPPORTED) --PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr, -- png_charp name, int compression_type, -- png_charp profile, int proflen)); -- /* Note to maintainer: profile should be png_bytep */ --#endif -- --#if defined(PNG_WRITE_sPLT_SUPPORTED) --PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr, -- png_sPLT_tp palette)); --#endif -- --#if defined(PNG_WRITE_tRNS_SUPPORTED) --PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans, -- png_color_16p values, int number, int color_type)); --#endif -- --#if defined(PNG_WRITE_bKGD_SUPPORTED) --PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr, -- png_color_16p values, int color_type)); --#endif -- --#if defined(PNG_WRITE_hIST_SUPPORTED) --PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist, -- int num_hist)); --#endif -- --#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ -- defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) --PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr, -- png_charp key, png_charpp new_key)); --#endif -- --#if defined(PNG_WRITE_tEXt_SUPPORTED) --PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key, -- png_charp text, png_size_t text_len)); --#endif -- --#if defined(PNG_WRITE_zTXt_SUPPORTED) --PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key, -- png_charp text, png_size_t text_len, int compression)); --#endif -- --#if defined(PNG_WRITE_iTXt_SUPPORTED) --PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr, -- int compression, png_charp key, png_charp lang, png_charp lang_key, -- png_charp text)); --#endif -- --#if defined(PNG_TEXT_SUPPORTED) /* Added at version 1.0.14 and 1.2.4 */ --PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_textp text_ptr, int num_text)); --#endif -- --#if defined(PNG_WRITE_oFFs_SUPPORTED) --PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr, -- png_int_32 x_offset, png_int_32 y_offset, int unit_type)); --#endif -- --#if defined(PNG_WRITE_pCAL_SUPPORTED) --PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose, -- png_int_32 X0, png_int_32 X1, int type, int nparams, -- png_charp units, png_charpp params)); --#endif -- --#if defined(PNG_WRITE_pHYs_SUPPORTED) --PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr, -- png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, -- int unit_type)); --#endif -- --#if defined(PNG_WRITE_tIME_SUPPORTED) --PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr, -- png_timep mod_time)); --#endif -- --#if defined(PNG_WRITE_sCAL_SUPPORTED) --#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) --PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr, -- int unit, double width, double height)); --#else --#ifdef PNG_FIXED_POINT_SUPPORTED --PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr, -- int unit, png_charp width, png_charp height)); --#endif --#endif --#endif -- --/* Called when finished processing a row of data */ --PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr)); -- --/* Internal use only. Called before first row of data */ --PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr)); -- --#if defined(PNG_READ_GAMMA_SUPPORTED) --PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr)); --#endif -- --/* combine a row of data, dealing with alpha, etc. if requested */ --PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row, -- int mask)); -- --#if defined(PNG_READ_INTERLACING_SUPPORTED) --/* expand an interlaced row */ --/* OLD pre-1.0.9 interface: --PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info, -- png_bytep row, int pass, png_uint_32 transformations)); -- */ --PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr)); --#endif -- --/* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */ -- --#if defined(PNG_WRITE_INTERLACING_SUPPORTED) --/* grab pixels out of a row for an interlaced pass */ --PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info, -- png_bytep row, int pass)); --#endif -- --/* unfilter a row */ --PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr, -- png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter)); -- --/* Choose the best filter to use and filter the row data */ --PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr, -- png_row_infop row_info)); -- --/* Write out the filtered row. */ --PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr, -- png_bytep filtered_row)); --/* finish a row while reading, dealing with interlacing passes, etc. */ --PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr)); -- --/* initialize the row buffers, etc. */ --PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr)); --/* optional call to update the users info structure */ --PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr, -- png_infop info_ptr)); -- --/* these are the functions that do the transformations */ --#if defined(PNG_READ_FILLER_SUPPORTED) --PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info, -- png_bytep row, png_uint_32 filler, png_uint_32 flags)); --#endif -- --#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) --PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info, -- png_bytep row)); --#endif -- --#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) --PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info, -- png_bytep row)); --#endif -- --#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) --PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info, -- png_bytep row)); --#endif -- --#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) --PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info, -- png_bytep row)); --#endif -- --#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ -- defined(PNG_READ_STRIP_ALPHA_SUPPORTED) --PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info, -- png_bytep row, png_uint_32 flags)); --#endif -- --#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) --PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row)); --#endif -- --#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) --PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row)); --#endif -- --#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) --PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop -- row_info, png_bytep row)); --#endif -- --#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) --PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info, -- png_bytep row)); --#endif -- --#if defined(PNG_READ_PACK_SUPPORTED) --PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row)); --#endif -- --#if defined(PNG_READ_SHIFT_SUPPORTED) --PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row, -- png_color_8p sig_bits)); --#endif -- --#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) --PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row)); --#endif -- --#if defined(PNG_READ_16_TO_8_SUPPORTED) --PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row)); --#endif -- --#if defined(PNG_READ_DITHER_SUPPORTED) --PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info, -- png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup)); -- --# if defined(PNG_CORRECT_PALETTE_SUPPORTED) --PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr, -- png_colorp palette, int num_palette)); --# endif --#endif -- --#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) --PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row)); --#endif -- --#if defined(PNG_WRITE_PACK_SUPPORTED) --PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info, -- png_bytep row, png_uint_32 bit_depth)); --#endif -- --#if defined(PNG_WRITE_SHIFT_SUPPORTED) --PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row, -- png_color_8p bit_depth)); --#endif -- --#if defined(PNG_READ_BACKGROUND_SUPPORTED) --#if defined(PNG_READ_GAMMA_SUPPORTED) --PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, -- png_color_16p trans_values, png_color_16p background, -- png_color_16p background_1, -- png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, -- png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, -- png_uint_16pp gamma_16_to_1, int gamma_shift)); --#else --PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, -- png_color_16p trans_values, png_color_16p background)); --#endif --#endif -- --#if defined(PNG_READ_GAMMA_SUPPORTED) --PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row, -- png_bytep gamma_table, png_uint_16pp gamma_16_table, -- int gamma_shift)); --#endif -- --#if defined(PNG_READ_EXPAND_SUPPORTED) --PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info, -- png_bytep row, png_colorp palette, png_bytep trans, int num_trans)); --PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info, -- png_bytep row, png_color_16p trans_value)); --#endif -- --/* The following decodes the appropriate chunks, and does error correction, -- * then calls the appropriate callback for the chunk if it is valid. -- */ -- --/* decode the IHDR chunk */ --PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); -- --#if defined(PNG_READ_bKGD_SUPPORTED) --PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif -- --#if defined(PNG_READ_cHRM_SUPPORTED) --PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif -- --#if defined(PNG_READ_gAMA_SUPPORTED) --PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif -- --#if defined(PNG_READ_hIST_SUPPORTED) --PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif -- --#if defined(PNG_READ_iCCP_SUPPORTED) --extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif /* PNG_READ_iCCP_SUPPORTED */ -- --#if defined(PNG_READ_iTXt_SUPPORTED) --PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif -- --#if defined(PNG_READ_oFFs_SUPPORTED) --PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif -- --#if defined(PNG_READ_pCAL_SUPPORTED) --PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif -- --#if defined(PNG_READ_pHYs_SUPPORTED) --PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif -- --#if defined(PNG_READ_sBIT_SUPPORTED) --PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif -- --#if defined(PNG_READ_sCAL_SUPPORTED) --PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif -- --#if defined(PNG_READ_sPLT_SUPPORTED) --extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif /* PNG_READ_sPLT_SUPPORTED */ -- --#if defined(PNG_READ_sRGB_SUPPORTED) --PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif -- --#if defined(PNG_READ_tEXt_SUPPORTED) --PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif -- --#if defined(PNG_READ_tIME_SUPPORTED) --PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif -- --#if defined(PNG_READ_tRNS_SUPPORTED) --PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif -- --#if defined(PNG_READ_zTXt_SUPPORTED) --PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr, -- png_uint_32 length)); --#endif -- --PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_uint_32 length)); -- --PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr, -- png_bytep chunk_name)); -- --/* handle the transformations for reading and writing */ --PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr)); --PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr)); -- --PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr)); -- --#ifdef PNG_PROGRESSIVE_READ_SUPPORTED --PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr, -- png_infop info_ptr)); --PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr, -- png_infop info_ptr)); --PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr)); --PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr, -- png_uint_32 length)); --PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr)); --PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr)); --PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr, -- png_bytep buffer, png_size_t buffer_length)); --PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr)); --PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr, -- png_bytep buffer, png_size_t buffer_length)); --PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr)); --PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_uint_32 length)); --PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr, -- png_infop info_ptr)); --PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr, -- png_infop info_ptr)); --PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row)); --PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr, -- png_infop info_ptr)); --PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr, -- png_infop info_ptr)); --PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr)); --#if defined(PNG_READ_tEXt_SUPPORTED) --PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_uint_32 length)); --PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr, -- png_infop info_ptr)); --#endif --#if defined(PNG_READ_zTXt_SUPPORTED) --PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_uint_32 length)); --PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr, -- png_infop info_ptr)); --#endif --#if defined(PNG_READ_iTXt_SUPPORTED) --PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr, -- png_infop info_ptr, png_uint_32 length)); --PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr, -- png_infop info_ptr)); --#endif -- --#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ -- --#ifdef PNG_MNG_FEATURES_SUPPORTED --PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info, -- png_bytep row)); --PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info, -- png_bytep row)); --#endif -- --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) --/* png.c */ /* PRIVATE */ --PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr)); --#endif --/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ -- --#endif /* PNG_INTERNAL */ -- --#ifdef __cplusplus --} --#endif -- --#endif /* PNG_VERSION_INFO_ONLY */ --/* do not put anything past this line */ --#endif /* PNG_H */ -diff --git a/thirdparty/libpng/pngconf.h b/thirdparty/libpng/pngconf.h -deleted file mode 100644 -index b0aedb4..0000000 ---- a/thirdparty/libpng/pngconf.h -+++ /dev/null -@@ -1,1376 +0,0 @@ -- --/* pngconf.h - machine configurable file for libpng -- * -- * libpng version 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- */ -- --/* Any machine specific code is near the front of this file, so if you -- * are configuring libpng for a machine, you may want to read the section -- * starting here down to where it starts to typedef png_color, png_text, -- * and png_info. -- */ -- --#ifndef PNGCONF_H --#define PNGCONF_H -- --#ifdef PNG_USER_CONFIG --#include "pngusr.h" --#endif -- --/* This is the size of the compression buffer, and thus the size of -- * an IDAT chunk. Make this whatever size you feel is best for your -- * machine. One of these will be allocated per png_struct. When this -- * is full, it writes the data to the disk, and does some other -- * calculations. Making this an extremely small size will slow -- * the library down, but you may want to experiment to determine -- * where it becomes significant, if you are concerned with memory -- * usage. Note that zlib allocates at least 32Kb also. For readers, -- * this describes the size of the buffer available to read the data in. -- * Unless this gets smaller than the size of a row (compressed), -- * it should not make much difference how big this is. -- */ -- --#ifndef PNG_ZBUF_SIZE --# define PNG_ZBUF_SIZE 8192 --#endif -- --/* Enable if you want a write-only libpng */ -- --#ifndef PNG_NO_READ_SUPPORTED --# define PNG_READ_SUPPORTED --#endif -- --/* Enable if you want a read-only libpng */ -- --#ifndef PNG_NO_WRITE_SUPPORTED --# define PNG_WRITE_SUPPORTED --#endif -- --/* Enabled by default in 1.2.0. You can disable this if you don't need to -- support PNGs that are embedded in MNG datastreams */ --#if !defined(PNG_1_0_X) && !defined(PNG_NO_MNG_FEATURES) --# ifndef PNG_MNG_FEATURES_SUPPORTED --# define PNG_MNG_FEATURES_SUPPORTED --# endif --#endif -- --#ifndef PNG_NO_FLOATING_POINT_SUPPORTED --# ifndef PNG_FLOATING_POINT_SUPPORTED --# define PNG_FLOATING_POINT_SUPPORTED --# endif --#endif -- --/* If you are running on a machine where you cannot allocate more -- * than 64K of memory at once, uncomment this. While libpng will not -- * normally need that much memory in a chunk (unless you load up a very -- * large file), zlib needs to know how big of a chunk it can use, and -- * libpng thus makes sure to check any memory allocation to verify it -- * will fit into memory. --#define PNG_MAX_MALLOC_64K -- */ --#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) --# define PNG_MAX_MALLOC_64K --#endif -- --/* Special munging to support doing things the 'cygwin' way: -- * 'Normal' png-on-win32 defines/defaults: -- * PNG_BUILD_DLL -- building dll -- * PNG_USE_DLL -- building an application, linking to dll -- * (no define) -- building static library, or building an -- * application and linking to the static lib -- * 'Cygwin' defines/defaults: -- * PNG_BUILD_DLL -- (ignored) building the dll -- * (no define) -- (ignored) building an application, linking to the dll -- * PNG_STATIC -- (ignored) building the static lib, or building an -- * application that links to the static lib. -- * ALL_STATIC -- (ignored) building various static libs, or building an -- * application that links to the static libs. -- * Thus, -- * a cygwin user should define either PNG_BUILD_DLL or PNG_STATIC, and -- * this bit of #ifdefs will define the 'correct' config variables based on -- * that. If a cygwin user *wants* to define 'PNG_USE_DLL' that's okay, but -- * unnecessary. -- * -- * Also, the precedence order is: -- * ALL_STATIC (since we can't #undef something outside our namespace) -- * PNG_BUILD_DLL -- * PNG_STATIC -- * (nothing) == PNG_USE_DLL -- * -- * CYGWIN (2002-01-20): The preceding is now obsolete. With the advent -- * of auto-import in binutils, we no longer need to worry about -- * __declspec(dllexport) / __declspec(dllimport) and friends. Therefore, -- * we don't need to worry about PNG_STATIC or ALL_STATIC when it comes -- * to __declspec() stuff. However, we DO need to worry about -- * PNG_BUILD_DLL and PNG_STATIC because those change some defaults -- * such as CONSOLE_IO and whether GLOBAL_ARRAYS are allowed. -- */ --#if defined(__CYGWIN__) --# if defined(ALL_STATIC) --# if defined(PNG_BUILD_DLL) --# undef PNG_BUILD_DLL --# endif --# if defined(PNG_USE_DLL) --# undef PNG_USE_DLL --# endif --# if defined(PNG_DLL) --# undef PNG_DLL --# endif --# if !defined(PNG_STATIC) --# define PNG_STATIC --# endif --# else --# if defined (PNG_BUILD_DLL) --# if defined(PNG_STATIC) --# undef PNG_STATIC --# endif --# if defined(PNG_USE_DLL) --# undef PNG_USE_DLL --# endif --# if !defined(PNG_DLL) --# define PNG_DLL --# endif --# else --# if defined(PNG_STATIC) --# if defined(PNG_USE_DLL) --# undef PNG_USE_DLL --# endif --# if defined(PNG_DLL) --# undef PNG_DLL --# endif --# else --# if !defined(PNG_USE_DLL) --# define PNG_USE_DLL --# endif --# if !defined(PNG_DLL) --# define PNG_DLL --# endif --# endif --# endif --# endif --#endif -- --/* This protects us against compilers that run on a windowing system -- * and thus don't have or would rather us not use the stdio types: -- * stdin, stdout, and stderr. The only one currently used is stderr -- * in png_error() and png_warning(). #defining PNG_NO_CONSOLE_IO will -- * prevent these from being compiled and used. #defining PNG_NO_STDIO -- * will also prevent these, plus will prevent the entire set of stdio -- * macros and functions (FILE *, printf, etc.) from being compiled and used, -- * unless (PNG_DEBUG > 0) has been #defined. -- * -- * #define PNG_NO_CONSOLE_IO -- * #define PNG_NO_STDIO -- */ -- --#if defined(_WIN32_WCE) --# include -- /* Console I/O functions are not supported on WindowsCE */ --# define PNG_NO_CONSOLE_IO --# ifdef PNG_DEBUG --# undef PNG_DEBUG --# endif --#endif -- --#ifdef PNG_BUILD_DLL --# ifndef PNG_CONSOLE_IO_SUPPORTED --# ifndef PNG_NO_CONSOLE_IO --# define PNG_NO_CONSOLE_IO --# endif --# endif --#endif -- --# ifdef PNG_NO_STDIO --# ifndef PNG_NO_CONSOLE_IO --# define PNG_NO_CONSOLE_IO --# endif --# ifdef PNG_DEBUG --# if (PNG_DEBUG > 0) --# include --# endif --# endif --# else --# if !defined(_WIN32_WCE) --/* "stdio.h" functions are not supported on WindowsCE */ --# include --# endif --# endif -- --/* This macro protects us against machines that don't have function -- * prototypes (ie K&R style headers). If your compiler does not handle -- * function prototypes, define this macro and use the included ansi2knr. -- * I've always been able to use _NO_PROTO as the indicator, but you may -- * need to drag the empty declaration out in front of here, or change the -- * ifdef to suit your own needs. -- */ --#ifndef PNGARG -- --#ifdef OF /* zlib prototype munger */ --# define PNGARG(arglist) OF(arglist) --#else -- --#ifdef _NO_PROTO --# define PNGARG(arglist) () --# ifndef PNG_TYPECAST_NULL --# define PNG_TYPECAST_NULL --# endif --#else --# define PNGARG(arglist) arglist --#endif /* _NO_PROTO */ -- --#endif /* OF */ -- --#endif /* PNGARG */ -- --/* Try to determine if we are compiling on a Mac. Note that testing for -- * just __MWERKS__ is not good enough, because the Codewarrior is now used -- * on non-Mac platforms. -- */ --#ifndef MACOS --# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \ -- defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC) --# define MACOS --# endif --#endif -- --/* enough people need this for various reasons to include it here */ --#if !defined(MACOS) && !defined(RISCOS) && !defined(_WIN32_WCE) --# include --#endif -- --#if !defined(PNG_SETJMP_NOT_SUPPORTED) && !defined(PNG_NO_SETJMP_SUPPORTED) --# define PNG_SETJMP_SUPPORTED --#endif -- --#ifdef PNG_SETJMP_SUPPORTED --/* This is an attempt to force a single setjmp behaviour on Linux. If -- * the X config stuff didn't define _BSD_SOURCE we wouldn't need this. -- */ -- --# ifdef __linux__ --# ifdef _BSD_SOURCE --# define PNG_SAVE_BSD_SOURCE --# undef _BSD_SOURCE --# endif --# ifdef _SETJMP_H -- /* If you encounter a compiler error here, see the explanation -- * near the end of INSTALL. -- */ -- __png.h__ already includes setjmp.h; -- __dont__ include it again.; --# endif --# endif /* __linux__ */ -- -- /* include setjmp.h for error handling */ --# include -- --# ifdef __linux__ --# ifdef PNG_SAVE_BSD_SOURCE --# define _BSD_SOURCE --# undef PNG_SAVE_BSD_SOURCE --# endif --# endif /* __linux__ */ --#endif /* PNG_SETJMP_SUPPORTED */ -- --#ifdef BSD --# include --#else --# include --#endif -- --/* Other defines for things like memory and the like can go here. */ --#ifdef PNG_INTERNAL -- --#include -- --/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which -- * aren't usually used outside the library (as far as I know), so it is -- * debatable if they should be exported at all. In the future, when it is -- * possible to have run-time registry of chunk-handling functions, some of -- * these will be made available again. --#define PNG_EXTERN extern -- */ --#define PNG_EXTERN -- --/* Other defines specific to compilers can go here. Try to keep -- * them inside an appropriate ifdef/endif pair for portability. -- */ -- --#if defined(PNG_FLOATING_POINT_SUPPORTED) --# if defined(MACOS) -- /* We need to check that hasn't already been included earlier -- * as it seems it doesn't agree with , yet we should really use -- * if possible. -- */ --# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__) --# include --# endif --# else --# include --# endif --# if defined(_AMIGA) && defined(__SASC) && defined(_M68881) -- /* Amiga SAS/C: We must include builtin FPU functions when compiling using -- * MATH=68881 -- */ --# include --# endif --#endif -- --/* Codewarrior on NT has linking problems without this. */ --#if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__) --# define PNG_ALWAYS_EXTERN --#endif -- --/* This provides the non-ANSI (far) memory allocation routines. */ --#if defined(__TURBOC__) && defined(__MSDOS__) --# include --# include --#endif -- --/* I have no idea why is this necessary... */ --#if defined(_MSC_VER) && (defined(WIN32) || defined(_Windows) || \ -- defined(_WINDOWS) || defined(_WIN32) || defined(__WIN32__)) --# include --#endif -- --/* This controls how fine the dithering gets. As this allocates -- * a largish chunk of memory (32K), those who are not as concerned -- * with dithering quality can decrease some or all of these. -- */ --#ifndef PNG_DITHER_RED_BITS --# define PNG_DITHER_RED_BITS 5 --#endif --#ifndef PNG_DITHER_GREEN_BITS --# define PNG_DITHER_GREEN_BITS 5 --#endif --#ifndef PNG_DITHER_BLUE_BITS --# define PNG_DITHER_BLUE_BITS 5 --#endif -- --/* This controls how fine the gamma correction becomes when you -- * are only interested in 8 bits anyway. Increasing this value -- * results in more memory being used, and more pow() functions -- * being called to fill in the gamma tables. Don't set this value -- * less then 8, and even that may not work (I haven't tested it). -- */ -- --#ifndef PNG_MAX_GAMMA_8 --# define PNG_MAX_GAMMA_8 11 --#endif -- --/* This controls how much a difference in gamma we can tolerate before -- * we actually start doing gamma conversion. -- */ --#ifndef PNG_GAMMA_THRESHOLD --# define PNG_GAMMA_THRESHOLD 0.05 --#endif -- --#endif /* PNG_INTERNAL */ -- --/* The following uses const char * instead of char * for error -- * and warning message functions, so some compilers won't complain. -- * If you do not want to use const, define PNG_NO_CONST here. -- */ -- --#ifndef PNG_NO_CONST --# define PNG_CONST const --#else --# define PNG_CONST --#endif -- --/* The following defines give you the ability to remove code from the -- * library that you will not be using. I wish I could figure out how to -- * automate this, but I can't do that without making it seriously hard -- * on the users. So if you are not using an ability, change the #define -- * to and #undef, and that part of the library will not be compiled. If -- * your linker can't find a function, you may want to make sure the -- * ability is defined here. Some of these depend upon some others being -- * defined. I haven't figured out all the interactions here, so you may -- * have to experiment awhile to get everything to compile. If you are -- * creating or using a shared library, you probably shouldn't touch this, -- * as it will affect the size of the structures, and this will cause bad -- * things to happen if the library and/or application ever change. -- */ -- --/* Any features you will not be using can be undef'ed here */ -- --/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user -- * to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS -- * on the compile line, then pick and choose which ones to define without -- * having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED -- * if you only want to have a png-compliant reader/writer but don't need -- * any of the extra transformations. This saves about 80 kbytes in a -- * typical installation of the library. (PNG_NO_* form added in version -- * 1.0.1c, for consistency) -- */ -- --/* The size of the png_text structure changed in libpng-1.0.6 when -- * iTXt is supported. It is turned off by default, to support old apps -- * that malloc the png_text structure instead of calling png_set_text() -- * and letting libpng malloc it. It will be turned on by default in -- * libpng-1.3.0. -- */ -- --#ifndef PNG_iTXt_SUPPORTED --# if !defined(PNG_READ_iTXt_SUPPORTED) && !defined(PNG_NO_READ_iTXt) --# define PNG_NO_READ_iTXt --# endif --# if !defined(PNG_WRITE_iTXt_SUPPORTED) && !defined(PNG_NO_WRITE_iTXt) --# define PNG_NO_WRITE_iTXt --# endif --#endif -- --/* The following support, added after version 1.0.0, can be turned off here en -- * masse by defining PNG_LEGACY_SUPPORTED in case you need binary compatibility -- * with old applications that require the length of png_struct and png_info -- * to remain unchanged. -- */ -- --#ifdef PNG_LEGACY_SUPPORTED --# define PNG_NO_FREE_ME --# define PNG_NO_READ_UNKNOWN_CHUNKS --# define PNG_NO_WRITE_UNKNOWN_CHUNKS --# define PNG_NO_READ_USER_CHUNKS --# define PNG_NO_READ_iCCP --# define PNG_NO_WRITE_iCCP --# define PNG_NO_READ_iTXt --# define PNG_NO_WRITE_iTXt --# define PNG_NO_READ_sCAL --# define PNG_NO_WRITE_sCAL --# define PNG_NO_READ_sPLT --# define PNG_NO_WRITE_sPLT --# define PNG_NO_INFO_IMAGE --# define PNG_NO_READ_RGB_TO_GRAY --# define PNG_NO_READ_USER_TRANSFORM --# define PNG_NO_WRITE_USER_TRANSFORM --# define PNG_NO_USER_MEM --# define PNG_NO_READ_EMPTY_PLTE --# define PNG_NO_MNG_FEATURES --# define PNG_NO_FIXED_POINT_SUPPORTED --#endif -- --/* Ignore attempt to turn off both floating and fixed point support */ --#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \ -- !defined(PNG_NO_FIXED_POINT_SUPPORTED) --# define PNG_FIXED_POINT_SUPPORTED --#endif -- --#ifndef PNG_NO_FREE_ME --# define PNG_FREE_ME_SUPPORTED --#endif -- --#if defined(PNG_READ_SUPPORTED) -- --#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \ -- !defined(PNG_NO_READ_TRANSFORMS) --# define PNG_READ_TRANSFORMS_SUPPORTED --#endif -- --#ifdef PNG_READ_TRANSFORMS_SUPPORTED --# ifndef PNG_NO_READ_EXPAND --# define PNG_READ_EXPAND_SUPPORTED --# endif --# ifndef PNG_NO_READ_SHIFT --# define PNG_READ_SHIFT_SUPPORTED --# endif --# ifndef PNG_NO_READ_PACK --# define PNG_READ_PACK_SUPPORTED --# endif --# ifndef PNG_NO_READ_BGR --# define PNG_READ_BGR_SUPPORTED --# endif --# ifndef PNG_NO_READ_SWAP --# define PNG_READ_SWAP_SUPPORTED --# endif --# ifndef PNG_NO_READ_PACKSWAP --# define PNG_READ_PACKSWAP_SUPPORTED --# endif --# ifndef PNG_NO_READ_INVERT --# define PNG_READ_INVERT_SUPPORTED --# endif --# ifndef PNG_NO_READ_DITHER --# define PNG_READ_DITHER_SUPPORTED --# endif --# ifndef PNG_NO_READ_BACKGROUND --# define PNG_READ_BACKGROUND_SUPPORTED --# endif --# ifndef PNG_NO_READ_16_TO_8 --# define PNG_READ_16_TO_8_SUPPORTED --# endif --# ifndef PNG_NO_READ_FILLER --# define PNG_READ_FILLER_SUPPORTED --# endif --# ifndef PNG_NO_READ_GAMMA --# define PNG_READ_GAMMA_SUPPORTED --# endif --# ifndef PNG_NO_READ_GRAY_TO_RGB --# define PNG_READ_GRAY_TO_RGB_SUPPORTED --# endif --# ifndef PNG_NO_READ_SWAP_ALPHA --# define PNG_READ_SWAP_ALPHA_SUPPORTED --# endif --# ifndef PNG_NO_READ_INVERT_ALPHA --# define PNG_READ_INVERT_ALPHA_SUPPORTED --# endif --# ifndef PNG_NO_READ_STRIP_ALPHA --# define PNG_READ_STRIP_ALPHA_SUPPORTED --# endif --# ifndef PNG_NO_READ_USER_TRANSFORM --# define PNG_READ_USER_TRANSFORM_SUPPORTED --# endif --# ifndef PNG_NO_READ_RGB_TO_GRAY --# define PNG_READ_RGB_TO_GRAY_SUPPORTED --# endif --#endif /* PNG_READ_TRANSFORMS_SUPPORTED */ -- --#if !defined(PNG_NO_PROGRESSIVE_READ) && \ -- !defined(PNG_PROGRESSIVE_READ_NOT_SUPPORTED) /* if you don't do progressive */ --# define PNG_PROGRESSIVE_READ_SUPPORTED /* reading. This is not talking */ --#endif /* about interlacing capability! You'll */ -- /* still have interlacing unless you change the following line: */ -- --#define PNG_READ_INTERLACING_SUPPORTED /* required for PNG-compliant decoders */ -- --#ifndef PNG_NO_READ_COMPOSITE_NODIV --# ifndef PNG_NO_READ_COMPOSITED_NODIV /* libpng-1.0.x misspelling */ --# define PNG_READ_COMPOSITE_NODIV_SUPPORTED /* well tested on Intel, SGI */ --# endif --#endif -- --/* Deprecated, will be removed from version 2.0.0. -- Use PNG_MNG_FEATURES_SUPPORTED instead. */ --#ifndef PNG_NO_READ_EMPTY_PLTE --# define PNG_READ_EMPTY_PLTE_SUPPORTED --#endif -- --#endif /* PNG_READ_SUPPORTED */ -- --#if defined(PNG_WRITE_SUPPORTED) -- --# if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \ -- !defined(PNG_NO_WRITE_TRANSFORMS) --# define PNG_WRITE_TRANSFORMS_SUPPORTED --#endif -- --#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED --# ifndef PNG_NO_WRITE_SHIFT --# define PNG_WRITE_SHIFT_SUPPORTED --# endif --# ifndef PNG_NO_WRITE_PACK --# define PNG_WRITE_PACK_SUPPORTED --# endif --# ifndef PNG_NO_WRITE_BGR --# define PNG_WRITE_BGR_SUPPORTED --# endif --# ifndef PNG_NO_WRITE_SWAP --# define PNG_WRITE_SWAP_SUPPORTED --# endif --# ifndef PNG_NO_WRITE_PACKSWAP --# define PNG_WRITE_PACKSWAP_SUPPORTED --# endif --# ifndef PNG_NO_WRITE_INVERT --# define PNG_WRITE_INVERT_SUPPORTED --# endif --# ifndef PNG_NO_WRITE_FILLER --# define PNG_WRITE_FILLER_SUPPORTED /* same as WRITE_STRIP_ALPHA */ --# endif --# ifndef PNG_NO_WRITE_SWAP_ALPHA --# define PNG_WRITE_SWAP_ALPHA_SUPPORTED --# endif --# ifndef PNG_NO_WRITE_INVERT_ALPHA --# define PNG_WRITE_INVERT_ALPHA_SUPPORTED --# endif --# ifndef PNG_NO_WRITE_USER_TRANSFORM --# define PNG_WRITE_USER_TRANSFORM_SUPPORTED --# endif --#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */ -- --#define PNG_WRITE_INTERLACING_SUPPORTED /* not required for PNG-compliant -- encoders, but can cause trouble -- if left undefined */ -- --#if !defined(PNG_NO_WRITE_WEIGHTED_FILTER) && \ -- defined(PNG_FLOATING_POINT_SUPPORTED) --# define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED --#endif -- --#ifndef PNG_NO_WRITE_FLUSH --# define PNG_WRITE_FLUSH_SUPPORTED --#endif -- --/* Deprecated, see PNG_MNG_FEATURES_SUPPORTED, above */ --#ifndef PNG_NO_WRITE_EMPTY_PLTE --# define PNG_WRITE_EMPTY_PLTE_SUPPORTED --#endif -- --#endif /* PNG_WRITE_SUPPORTED */ -- --#ifndef PNG_1_0_X --# ifndef PNG_NO_ERROR_NUMBERS --# define PNG_ERROR_NUMBERS_SUPPORTED --# endif --#endif /* PNG_1_0_X */ -- --#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ -- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) --# ifndef PNG_NO_USER_TRANSFORM_PTR --# define PNG_USER_TRANSFORM_PTR_SUPPORTED --# endif --#endif -- --#ifndef PNG_NO_STDIO --# define PNG_TIME_RFC1123_SUPPORTED --#endif -- --/* This adds extra functions in pngget.c for accessing data from the -- * info pointer (added in version 0.99) -- * png_get_image_width() -- * png_get_image_height() -- * png_get_bit_depth() -- * png_get_color_type() -- * png_get_compression_type() -- * png_get_filter_type() -- * png_get_interlace_type() -- * png_get_pixel_aspect_ratio() -- * png_get_pixels_per_meter() -- * png_get_x_offset_pixels() -- * png_get_y_offset_pixels() -- * png_get_x_offset_microns() -- * png_get_y_offset_microns() -- */ --#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED) --# define PNG_EASY_ACCESS_SUPPORTED --#endif -- --/* PNG_ASSEMBLER_CODE was enabled by default in version 1.2.0 -- even when PNG_USE_PNGVCRD or PNG_USE_PNGGCCRD is not defined */ --#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_ASSEMBLER_CODE) --# ifndef PNG_ASSEMBLER_CODE_SUPPORTED --# define PNG_ASSEMBLER_CODE_SUPPORTED --# endif --# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) --# define PNG_MMX_CODE_SUPPORTED --# endif --#endif -- --/* If you are sure that you don't need thread safety and you are compiling -- with PNG_USE_PNGCCRD for an MMX application, you can define this for -- faster execution. See pnggccrd.c. --#define PNG_THREAD_UNSAFE_OK --*/ -- --#if !defined(PNG_1_0_X) --#if !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED) --# define PNG_USER_MEM_SUPPORTED --#endif --#endif /* PNG_1_0_X */ -- --/* Added at libpng-1.2.6 */ --#if !defined(PNG_1_0_X) --#ifndef PNG_SET_USER_LIMITS_SUPPORTED --#if !defined(PNG_NO_SET_USER_LIMITS) && !defined(PNG_SET_USER_LIMITS_SUPPORTED) --# define PNG_SET_USER_LIMITS_SUPPORTED --#endif --#endif --#endif /* PNG_1_0_X */ -- --/* Added at libpng-1.0.16 and 1.2.6. To accept all valid PNGS no matter -- * how large, set these limits to 0x7fffffffL -- */ --#ifndef PNG_USER_WIDTH_MAX --# define PNG_USER_WIDTH_MAX 1000000L --#endif --#ifndef PNG_USER_HEIGHT_MAX --# define PNG_USER_HEIGHT_MAX 1000000L --#endif -- --/* These are currently experimental features, define them if you want */ -- --/* very little testing */ --/* --#ifdef PNG_READ_SUPPORTED --# ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED --# define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED --# endif --#endif --*/ -- --/* This is only for PowerPC big-endian and 680x0 systems */ --/* some testing */ --/* --#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED --# define PNG_READ_BIG_ENDIAN_SUPPORTED --#endif --*/ -- --/* Buggy compilers (e.g., gcc 2.7.2.2) need this */ --/* --#define PNG_NO_POINTER_INDEXING --*/ -- --/* These functions are turned off by default, as they will be phased out. */ --/* --#define PNG_USELESS_TESTS_SUPPORTED --#define PNG_CORRECT_PALETTE_SUPPORTED --*/ -- --/* Any chunks you are not interested in, you can undef here. The -- * ones that allocate memory may be expecially important (hIST, -- * tEXt, zTXt, tRNS, pCAL). Others will just save time and make png_info -- * a bit smaller. -- */ -- --#if defined(PNG_READ_SUPPORTED) && \ -- !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ -- !defined(PNG_NO_READ_ANCILLARY_CHUNKS) --# define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED --#endif -- --#if defined(PNG_WRITE_SUPPORTED) && \ -- !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ -- !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS) --# define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED --#endif -- --#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED -- --#ifdef PNG_NO_READ_TEXT --# define PNG_NO_READ_iTXt --# define PNG_NO_READ_tEXt --# define PNG_NO_READ_zTXt --#endif --#ifndef PNG_NO_READ_bKGD --# define PNG_READ_bKGD_SUPPORTED --# define PNG_bKGD_SUPPORTED --#endif --#ifndef PNG_NO_READ_cHRM --# define PNG_READ_cHRM_SUPPORTED --# define PNG_cHRM_SUPPORTED --#endif --#ifndef PNG_NO_READ_gAMA --# define PNG_READ_gAMA_SUPPORTED --# define PNG_gAMA_SUPPORTED --#endif --#ifndef PNG_NO_READ_hIST --# define PNG_READ_hIST_SUPPORTED --# define PNG_hIST_SUPPORTED --#endif --#ifndef PNG_NO_READ_iCCP --# define PNG_READ_iCCP_SUPPORTED --# define PNG_iCCP_SUPPORTED --#endif --#ifndef PNG_NO_READ_iTXt --# ifndef PNG_READ_iTXt_SUPPORTED --# define PNG_READ_iTXt_SUPPORTED --# endif --# ifndef PNG_iTXt_SUPPORTED --# define PNG_iTXt_SUPPORTED --# endif --#endif --#ifndef PNG_NO_READ_oFFs --# define PNG_READ_oFFs_SUPPORTED --# define PNG_oFFs_SUPPORTED --#endif --#ifndef PNG_NO_READ_pCAL --# define PNG_READ_pCAL_SUPPORTED --# define PNG_pCAL_SUPPORTED --#endif --#ifndef PNG_NO_READ_sCAL --# define PNG_READ_sCAL_SUPPORTED --# define PNG_sCAL_SUPPORTED --#endif --#ifndef PNG_NO_READ_pHYs --# define PNG_READ_pHYs_SUPPORTED --# define PNG_pHYs_SUPPORTED --#endif --#ifndef PNG_NO_READ_sBIT --# define PNG_READ_sBIT_SUPPORTED --# define PNG_sBIT_SUPPORTED --#endif --#ifndef PNG_NO_READ_sPLT --# define PNG_READ_sPLT_SUPPORTED --# define PNG_sPLT_SUPPORTED --#endif --#ifndef PNG_NO_READ_sRGB --# define PNG_READ_sRGB_SUPPORTED --# define PNG_sRGB_SUPPORTED --#endif --#ifndef PNG_NO_READ_tEXt --# define PNG_READ_tEXt_SUPPORTED --# define PNG_tEXt_SUPPORTED --#endif --#ifndef PNG_NO_READ_tIME --# define PNG_READ_tIME_SUPPORTED --# define PNG_tIME_SUPPORTED --#endif --#ifndef PNG_NO_READ_tRNS --# define PNG_READ_tRNS_SUPPORTED --# define PNG_tRNS_SUPPORTED --#endif --#ifndef PNG_NO_READ_zTXt --# define PNG_READ_zTXt_SUPPORTED --# define PNG_zTXt_SUPPORTED --#endif --#ifndef PNG_NO_READ_UNKNOWN_CHUNKS --# define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED --# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED --# define PNG_UNKNOWN_CHUNKS_SUPPORTED --# endif --# ifndef PNG_NO_HANDLE_AS_UNKNOWN --# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED --# endif --#endif --#if !defined(PNG_NO_READ_USER_CHUNKS) && \ -- defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) --# define PNG_READ_USER_CHUNKS_SUPPORTED --# define PNG_USER_CHUNKS_SUPPORTED --# ifdef PNG_NO_READ_UNKNOWN_CHUNKS --# undef PNG_NO_READ_UNKNOWN_CHUNKS --# endif --# ifdef PNG_NO_HANDLE_AS_UNKNOWN --# undef PNG_NO_HANDLE_AS_UNKNOWN --# endif --#endif --#ifndef PNG_NO_READ_OPT_PLTE --# define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the */ --#endif /* optional PLTE chunk in RGB and RGBA images */ --#if defined(PNG_READ_iTXt_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) || \ -- defined(PNG_READ_zTXt_SUPPORTED) --# define PNG_READ_TEXT_SUPPORTED --# define PNG_TEXT_SUPPORTED --#endif -- --#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */ -- --#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED -- --#ifdef PNG_NO_WRITE_TEXT --# define PNG_NO_WRITE_iTXt --# define PNG_NO_WRITE_tEXt --# define PNG_NO_WRITE_zTXt --#endif --#ifndef PNG_NO_WRITE_bKGD --# define PNG_WRITE_bKGD_SUPPORTED --# ifndef PNG_bKGD_SUPPORTED --# define PNG_bKGD_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_cHRM --# define PNG_WRITE_cHRM_SUPPORTED --# ifndef PNG_cHRM_SUPPORTED --# define PNG_cHRM_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_gAMA --# define PNG_WRITE_gAMA_SUPPORTED --# ifndef PNG_gAMA_SUPPORTED --# define PNG_gAMA_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_hIST --# define PNG_WRITE_hIST_SUPPORTED --# ifndef PNG_hIST_SUPPORTED --# define PNG_hIST_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_iCCP --# define PNG_WRITE_iCCP_SUPPORTED --# ifndef PNG_iCCP_SUPPORTED --# define PNG_iCCP_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_iTXt --# ifndef PNG_WRITE_iTXt_SUPPORTED --# define PNG_WRITE_iTXt_SUPPORTED --# endif --# ifndef PNG_iTXt_SUPPORTED --# define PNG_iTXt_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_oFFs --# define PNG_WRITE_oFFs_SUPPORTED --# ifndef PNG_oFFs_SUPPORTED --# define PNG_oFFs_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_pCAL --# define PNG_WRITE_pCAL_SUPPORTED --# ifndef PNG_pCAL_SUPPORTED --# define PNG_pCAL_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_sCAL --# define PNG_WRITE_sCAL_SUPPORTED --# ifndef PNG_sCAL_SUPPORTED --# define PNG_sCAL_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_pHYs --# define PNG_WRITE_pHYs_SUPPORTED --# ifndef PNG_pHYs_SUPPORTED --# define PNG_pHYs_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_sBIT --# define PNG_WRITE_sBIT_SUPPORTED --# ifndef PNG_sBIT_SUPPORTED --# define PNG_sBIT_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_sPLT --# define PNG_WRITE_sPLT_SUPPORTED --# ifndef PNG_sPLT_SUPPORTED --# define PNG_sPLT_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_sRGB --# define PNG_WRITE_sRGB_SUPPORTED --# ifndef PNG_sRGB_SUPPORTED --# define PNG_sRGB_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_tEXt --# define PNG_WRITE_tEXt_SUPPORTED --# ifndef PNG_tEXt_SUPPORTED --# define PNG_tEXt_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_tIME --# define PNG_WRITE_tIME_SUPPORTED --# ifndef PNG_tIME_SUPPORTED --# define PNG_tIME_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_tRNS --# define PNG_WRITE_tRNS_SUPPORTED --# ifndef PNG_tRNS_SUPPORTED --# define PNG_tRNS_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_zTXt --# define PNG_WRITE_zTXt_SUPPORTED --# ifndef PNG_zTXt_SUPPORTED --# define PNG_zTXt_SUPPORTED --# endif --#endif --#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS --# define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED --# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED --# define PNG_UNKNOWN_CHUNKS_SUPPORTED --# endif --# ifndef PNG_NO_HANDLE_AS_UNKNOWN --# ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED --# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED --# endif --# endif --#endif --#if defined(PNG_WRITE_iTXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \ -- defined(PNG_WRITE_zTXt_SUPPORTED) --# define PNG_WRITE_TEXT_SUPPORTED --# ifndef PNG_TEXT_SUPPORTED --# define PNG_TEXT_SUPPORTED --# endif --#endif -- --#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */ -- --/* Turn this off to disable png_read_png() and -- * png_write_png() and leave the row_pointers member -- * out of the info structure. -- */ --#ifndef PNG_NO_INFO_IMAGE --# define PNG_INFO_IMAGE_SUPPORTED --#endif -- --/* need the time information for reading tIME chunks */ --#if defined(PNG_tIME_SUPPORTED) --# if !defined(_WIN32_WCE) -- /* "time.h" functions are not supported on WindowsCE */ --# include --# endif --#endif -- --/* Some typedefs to get us started. These should be safe on most of the -- * common platforms. The typedefs should be at least as large as the -- * numbers suggest (a png_uint_32 must be at least 32 bits long), but they -- * don't have to be exactly that size. Some compilers dislike passing -- * unsigned shorts as function parameters, so you may be better off using -- * unsigned int for png_uint_16. Likewise, for 64-bit systems, you may -- * want to have unsigned int for png_uint_32 instead of unsigned long. -- */ -- --typedef unsigned long png_uint_32; --typedef long png_int_32; --typedef unsigned short png_uint_16; --typedef short png_int_16; --typedef unsigned char png_byte; -- --/* This is usually size_t. It is typedef'ed just in case you need it to -- change (I'm not sure if you will or not, so I thought I'd be safe) */ --#ifdef PNG_SIZE_T -- typedef PNG_SIZE_T png_size_t; --# define png_sizeof(x) png_convert_size(sizeof (x)) --#else -- typedef size_t png_size_t; --# define png_sizeof(x) sizeof (x) --#endif -- --/* The following is needed for medium model support. It cannot be in the -- * PNG_INTERNAL section. Needs modification for other compilers besides -- * MSC. Model independent support declares all arrays and pointers to be -- * large using the far keyword. The zlib version used must also support -- * model independent data. As of version zlib 1.0.4, the necessary changes -- * have been made in zlib. The USE_FAR_KEYWORD define triggers other -- * changes that are needed. (Tim Wegner) -- */ -- --/* Separate compiler dependencies (problem here is that zlib.h always -- defines FAR. (SJT) */ --#ifdef __BORLANDC__ --# if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__) --# define LDATA 1 --# else --# define LDATA 0 --# endif -- /* GRR: why is Cygwin in here? Cygwin is not Borland C... */ --# if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__) --# define PNG_MAX_MALLOC_64K --# if (LDATA != 1) --# ifndef FAR --# define FAR __far --# endif --# define USE_FAR_KEYWORD --# endif /* LDATA != 1 */ -- /* Possibly useful for moving data out of default segment. -- * Uncomment it if you want. Could also define FARDATA as -- * const if your compiler supports it. (SJT) --# define FARDATA FAR -- */ --# endif /* __WIN32__, __FLAT__, __CYGWIN__ */ --#endif /* __BORLANDC__ */ -- -- --/* Suggest testing for specific compiler first before testing for -- * FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM, -- * making reliance oncertain keywords suspect. (SJT) -- */ -- --/* MSC Medium model */ --#if defined(FAR) --# if defined(M_I86MM) --# define USE_FAR_KEYWORD --# define FARDATA FAR --# include --# endif --#endif -- --/* SJT: default case */ --#ifndef FAR --# define FAR --#endif -- --/* At this point FAR is always defined */ --#ifndef FARDATA --# define FARDATA --#endif -- --/* Typedef for floating-point numbers that are converted -- to fixed-point with a multiple of 100,000, e.g., int_gamma */ --typedef png_int_32 png_fixed_point; -- --/* Add typedefs for pointers */ --typedef void FAR * png_voidp; --typedef png_byte FAR * png_bytep; --typedef png_uint_32 FAR * png_uint_32p; --typedef png_int_32 FAR * png_int_32p; --typedef png_uint_16 FAR * png_uint_16p; --typedef png_int_16 FAR * png_int_16p; --typedef PNG_CONST char FAR * png_const_charp; --typedef char FAR * png_charp; --typedef png_fixed_point FAR * png_fixed_point_p; -- --#ifndef PNG_NO_STDIO --#if defined(_WIN32_WCE) --typedef HANDLE png_FILE_p; --#else --typedef FILE * png_FILE_p; --#endif --#endif -- --#ifdef PNG_FLOATING_POINT_SUPPORTED --typedef double FAR * png_doublep; --#endif -- --/* Pointers to pointers; i.e. arrays */ --typedef png_byte FAR * FAR * png_bytepp; --typedef png_uint_32 FAR * FAR * png_uint_32pp; --typedef png_int_32 FAR * FAR * png_int_32pp; --typedef png_uint_16 FAR * FAR * png_uint_16pp; --typedef png_int_16 FAR * FAR * png_int_16pp; --typedef PNG_CONST char FAR * FAR * png_const_charpp; --typedef char FAR * FAR * png_charpp; --typedef png_fixed_point FAR * FAR * png_fixed_point_pp; --#ifdef PNG_FLOATING_POINT_SUPPORTED --typedef double FAR * FAR * png_doublepp; --#endif -- --/* Pointers to pointers to pointers; i.e., pointer to array */ --typedef char FAR * FAR * FAR * png_charppp; -- --/* libpng typedefs for types in zlib. If zlib changes -- * or another compression library is used, then change these. -- * Eliminates need to change all the source files. -- */ --typedef charf * png_zcharp; --typedef charf * FAR * png_zcharpp; --typedef z_stream FAR * png_zstreamp; -- --/* -- * Define PNG_BUILD_DLL if the module being built is a Windows -- * LIBPNG DLL. -- * -- * Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL. -- * It is equivalent to Microsoft predefined macro _DLL that is -- * automatically defined when you compile using the share -- * version of the CRT (C Run-Time library) -- * -- * The cygwin mods make this behavior a little different: -- * Define PNG_BUILD_DLL if you are building a dll for use with cygwin -- * Define PNG_STATIC if you are building a static library for use with cygwin, -- * -or- if you are building an application that you want to link to the -- * static library. -- * PNG_USE_DLL is defined by default (no user action needed) unless one of -- * the other flags is defined. -- */ -- --#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL)) --# define PNG_DLL --#endif --/* If CYGWIN, then disallow GLOBAL ARRAYS unless building a static lib. -- * When building a static lib, default to no GLOBAL ARRAYS, but allow -- * command-line override -- */ --#if defined(__CYGWIN__) --# if !defined(PNG_STATIC) --# if defined(PNG_USE_GLOBAL_ARRAYS) --# undef PNG_USE_GLOBAL_ARRAYS --# endif --# if !defined(PNG_USE_LOCAL_ARRAYS) --# define PNG_USE_LOCAL_ARRAYS --# endif --# else --# if defined(PNG_USE_LOCAL_ARRAYS) || defined(PNG_NO_GLOBAL_ARRAYS) --# if defined(PNG_USE_GLOBAL_ARRAYS) --# undef PNG_USE_GLOBAL_ARRAYS --# endif --# endif --# endif --# if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) --# define PNG_USE_LOCAL_ARRAYS --# endif --#endif -- --/* Do not use global arrays (helps with building DLL's) -- * They are no longer used in libpng itself, since version 1.0.5c, -- * but might be required for some pre-1.0.5c applications. -- */ --#if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) --# if defined(PNG_NO_GLOBAL_ARRAYS) || (defined(__GNUC__) && defined(PNG_DLL)) --# define PNG_USE_LOCAL_ARRAYS --# else --# define PNG_USE_GLOBAL_ARRAYS --# endif --#endif -- --#if defined(__CYGWIN__) --# undef PNGAPI --# define PNGAPI __cdecl --# undef PNG_IMPEXP --# define PNG_IMPEXP --#endif -- --/* If you define PNGAPI, e.g., with compiler option "-DPNGAPI=__stdcall", -- * you may get warnings regarding the linkage of png_zalloc and png_zfree. -- * Don't ignore those warnings; you must also reset the default calling -- * convention in your compiler to match your PNGAPI, and you must build -- * zlib and your applications the same way you build libpng. -- */ -- --#if defined(__MINGW32__) && !defined(PNG_MODULEDEF) --# ifndef PNG_NO_MODULEDEF --# define PNG_NO_MODULEDEF --# endif --#endif -- --#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF) --# define PNG_IMPEXP --#endif -- --#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \ -- (( defined(_Windows) || defined(_WINDOWS) || \ -- defined(WIN32) || defined(_WIN32) || defined(__WIN32__) )) -- --# ifndef PNGAPI --# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800)) --# define PNGAPI __cdecl --# else --# define PNGAPI _cdecl --# endif --# endif -- --# if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \ -- 0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */) --# define PNG_IMPEXP --# endif -- --# if !defined(PNG_IMPEXP) -- --# define PNG_EXPORT_TYPE1(type,symbol) PNG_IMPEXP type PNGAPI symbol --# define PNG_EXPORT_TYPE2(type,symbol) type PNG_IMPEXP PNGAPI symbol -- -- /* Borland/Microsoft */ --# if defined(_MSC_VER) || defined(__BORLANDC__) --# if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500) --# define PNG_EXPORT PNG_EXPORT_TYPE1 --# else --# define PNG_EXPORT PNG_EXPORT_TYPE2 --# if defined(PNG_BUILD_DLL) --# define PNG_IMPEXP __export --# else --# define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in -- VC++ */ --# endif /* Exists in Borland C++ for -- C++ classes (== huge) */ --# endif --# endif -- --# if !defined(PNG_IMPEXP) --# if defined(PNG_BUILD_DLL) --# define PNG_IMPEXP __declspec(dllexport) --# else --# define PNG_IMPEXP __declspec(dllimport) --# endif --# endif --# endif /* PNG_IMPEXP */ --#else /* !(DLL || non-cygwin WINDOWS) */ --# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__) --# ifndef PNGAPI --# define PNGAPI _System --# endif --# else --# if 0 /* ... other platforms, with other meanings */ --# endif --# endif --#endif -- --#ifndef PNGAPI --# define PNGAPI --#endif --#ifndef PNG_IMPEXP --# define PNG_IMPEXP --#endif -- --#ifndef PNG_EXPORT --# define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol --#endif -- --#ifdef PNG_USE_GLOBAL_ARRAYS --# ifndef PNG_EXPORT_VAR --# define PNG_EXPORT_VAR(type) extern PNG_IMPEXP type --# endif --#endif -- --/* User may want to use these so they are not in PNG_INTERNAL. Any library -- * functions that are passed far data must be model independent. -- */ -- --#ifndef PNG_ABORT --# define PNG_ABORT() abort() --#endif -- --#ifdef PNG_SETJMP_SUPPORTED --# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf) --#else --# define png_jmpbuf(png_ptr) \ -- (LIBPNG_WAS_COMPILED_WITH__PNG_SETJMP_NOT_SUPPORTED) --#endif -- --#if defined(USE_FAR_KEYWORD) /* memory model independent fns */ --/* use this to make far-to-near assignments */ --# define CHECK 1 --# define NOCHECK 0 --# define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK)) --# define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK)) --# define png_strcpy _fstrcpy --# define png_strncpy _fstrncpy /* Added to v 1.2.6 */ --# define png_strlen _fstrlen --# define png_memcmp _fmemcmp /* SJT: added */ --# define png_memcpy _fmemcpy --# define png_memset _fmemset --#else /* use the usual functions */ --# define CVT_PTR(ptr) (ptr) --# define CVT_PTR_NOCHECK(ptr) (ptr) --# define png_strcpy strcpy --# define png_strncpy strncpy /* Added to v 1.2.6 */ --# define png_strlen strlen --# define png_memcmp memcmp /* SJT: added */ --# define png_memcpy memcpy --# define png_memset memset --#endif --/* End of memory model independent support */ -- --/* Just a little check that someone hasn't tried to define something -- * contradictory. -- */ --#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K) --# undef PNG_ZBUF_SIZE --# define PNG_ZBUF_SIZE 65536L --#endif -- --#ifdef PNG_READ_SUPPORTED --/* Prior to libpng-1.0.9, this block was in pngasmrd.h */ --#if defined(PNG_INTERNAL) -- --/* These are the default thresholds before the MMX code kicks in; if either -- * rowbytes or bitdepth is below the threshold, plain C code is used. These -- * can be overridden at runtime via the png_set_mmx_thresholds() call in -- * libpng 1.2.0 and later. The values below were chosen by Intel. -- */ -- --#ifndef PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT --# define PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT 128 /* >= */ --#endif --#ifndef PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT --# define PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT 9 /* >= */ --#endif -- --/* Set this in the makefile for VC++ on Pentium, not here. */ --/* Platform must be Pentium. Makefile must assemble and load pngvcrd.c . -- * MMX will be detected at run time and used if present. -- */ --#ifdef PNG_USE_PNGVCRD --# define PNG_HAVE_ASSEMBLER_COMBINE_ROW --# define PNG_HAVE_ASSEMBLER_READ_INTERLACE --# define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW --#endif -- --/* Set this in the makefile for gcc/as on Pentium, not here. */ --/* Platform must be Pentium. Makefile must assemble and load pnggccrd.c . -- * MMX will be detected at run time and used if present. -- */ --#ifdef PNG_USE_PNGGCCRD --# define PNG_HAVE_ASSEMBLER_COMBINE_ROW --# define PNG_HAVE_ASSEMBLER_READ_INTERLACE --# define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW --#endif --/* - see pnggccrd.c for info about what is currently enabled */ -- --#endif /* PNG_INTERNAL */ --#endif /* PNG_READ_SUPPORTED */ -- --#endif /* PNGCONF_H */ -- -diff --git a/thirdparty/libpng/pngerror.c b/thirdparty/libpng/pngerror.c -deleted file mode 100644 -index 4ba395b..0000000 ---- a/thirdparty/libpng/pngerror.c -+++ /dev/null -@@ -1,295 +0,0 @@ -- --/* pngerror.c - stub functions for i/o and memory allocation -- * -- * libpng version 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- * -- * This file provides a location for all error handling. Users who -- * need special error handling are expected to write replacement functions -- * and use png_set_error_fn() to use those functions. See the instructions -- * at each function. -- */ -- --#define PNG_INTERNAL --#include "png.h" -- --static void /* PRIVATE */ --png_default_error PNGARG((png_structp png_ptr, -- png_const_charp error_message)); --static void /* PRIVATE */ --png_default_warning PNGARG((png_structp png_ptr, -- png_const_charp warning_message)); -- --/* This function is called whenever there is a fatal error. This function -- * should not be changed. If there is a need to handle errors differently, -- * you should supply a replacement error function and use png_set_error_fn() -- * to replace the error function at run-time. -- */ --void PNGAPI --png_error(png_structp png_ptr, png_const_charp error_message) --{ --#ifdef PNG_ERROR_NUMBERS_SUPPORTED -- char msg[16]; -- if (png_ptr->flags&(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) -- { -- if (*error_message == '#') -- { -- int offset; -- for (offset=1; offset<15; offset++) -- if (*(error_message+offset) == ' ') -- break; -- if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT) -- { -- int i; -- for (i=0; iflags&PNG_FLAG_STRIP_ERROR_TEXT) -- { -- msg[0]='0'; -- msg[1]='\0'; -- error_message=msg; -- } -- } -- } --#endif -- if (png_ptr != NULL && png_ptr->error_fn != NULL) -- (*(png_ptr->error_fn))(png_ptr, error_message); -- -- /* If the custom handler doesn't exist, or if it returns, -- use the default handler, which will not return. */ -- png_default_error(png_ptr, error_message); --} -- --/* This function is called whenever there is a non-fatal error. This function -- * should not be changed. If there is a need to handle warnings differently, -- * you should supply a replacement warning function and use -- * png_set_error_fn() to replace the warning function at run-time. -- */ --void PNGAPI --png_warning(png_structp png_ptr, png_const_charp warning_message) --{ -- int offset = 0; --#ifdef PNG_ERROR_NUMBERS_SUPPORTED -- if (png_ptr->flags&(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) --#endif -- { -- if (*warning_message == '#') -- { -- for (offset=1; offset<15; offset++) -- if (*(warning_message+offset) == ' ') -- break; -- } -- } -- if (png_ptr != NULL && png_ptr->warning_fn != NULL) -- (*(png_ptr->warning_fn))(png_ptr, warning_message+offset); -- else -- png_default_warning(png_ptr, warning_message+offset); --} -- --/* These utilities are used internally to build an error message that relates -- * to the current chunk. The chunk name comes from png_ptr->chunk_name, -- * this is used to prefix the message. The message is limited in length -- * to 63 bytes, the name characters are output as hex digits wrapped in [] -- * if the character is invalid. -- */ --#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97)) --static PNG_CONST char png_digit[16] = { -- '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', -- 'A', 'B', 'C', 'D', 'E', 'F' --}; -- --static void /* PRIVATE */ --png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp -- error_message) --{ -- int iout = 0, iin = 0; -- -- while (iin < 4) -- { -- int c = png_ptr->chunk_name[iin++]; -- if (isnonalpha(c)) -- { -- buffer[iout++] = '['; -- buffer[iout++] = png_digit[(c & 0xf0) >> 4]; -- buffer[iout++] = png_digit[c & 0x0f]; -- buffer[iout++] = ']'; -- } -- else -- { -- buffer[iout++] = (png_byte)c; -- } -- } -- -- if (error_message == NULL) -- buffer[iout] = 0; -- else -- { -- buffer[iout++] = ':'; -- buffer[iout++] = ' '; -- png_strncpy(buffer+iout, error_message, 63); -- buffer[iout+63] = 0; -- } --} -- --void PNGAPI --png_chunk_error(png_structp png_ptr, png_const_charp error_message) --{ -- char msg[18+64]; -- png_format_buffer(png_ptr, msg, error_message); -- png_error(png_ptr, msg); --} -- --void PNGAPI --png_chunk_warning(png_structp png_ptr, png_const_charp warning_message) --{ -- char msg[18+64]; -- png_format_buffer(png_ptr, msg, warning_message); -- png_warning(png_ptr, msg); --} -- --/* This is the default error handling function. Note that replacements for -- * this function MUST NOT RETURN, or the program will likely crash. This -- * function is used by default, or if the program supplies NULL for the -- * error function pointer in png_set_error_fn(). -- */ --static void /* PRIVATE */ --png_default_error(png_structp png_ptr, png_const_charp error_message) --{ --#ifndef PNG_NO_CONSOLE_IO --#ifdef PNG_ERROR_NUMBERS_SUPPORTED -- if (*error_message == '#') -- { -- int offset; -- char error_number[16]; -- for (offset=0; offset<15; offset++) -- { -- error_number[offset] = *(error_message+offset+1); -- if (*(error_message+offset) == ' ') -- break; -- } -- if((offset > 1) && (offset < 15)) -- { -- error_number[offset-1]='\0'; -- fprintf(stderr, "libpng error no. %s: %s\n", error_number, -- error_message+offset); -- } -- else -- fprintf(stderr, "libpng error: %s, offset=%d\n", error_message,offset); -- } -- else --#endif -- fprintf(stderr, "libpng error: %s\n", error_message); --#endif -- --#ifdef PNG_SETJMP_SUPPORTED --# ifdef USE_FAR_KEYWORD -- { -- jmp_buf jmpbuf; -- png_memcpy(jmpbuf,png_ptr->jmpbuf,png_sizeof(jmp_buf)); -- longjmp(jmpbuf, 1); -- } --# else -- longjmp(png_ptr->jmpbuf, 1); --# endif --#else -- /* make compiler happy */ ; -- if (png_ptr) -- PNG_ABORT(); --#endif --#ifdef PNG_NO_CONSOLE_IO -- /* make compiler happy */ ; -- if (&error_message != NULL) -- return; --#endif --} -- --/* This function is called when there is a warning, but the library thinks -- * it can continue anyway. Replacement functions don't have to do anything -- * here if you don't want them to. In the default configuration, png_ptr is -- * not used, but it is passed in case it may be useful. -- */ --static void /* PRIVATE */ --png_default_warning(png_structp png_ptr, png_const_charp warning_message) --{ --#ifndef PNG_NO_CONSOLE_IO --# ifdef PNG_ERROR_NUMBERS_SUPPORTED -- if (*warning_message == '#') -- { -- int offset; -- char warning_number[16]; -- for (offset=0; offset<15; offset++) -- { -- warning_number[offset]=*(warning_message+offset+1); -- if (*(warning_message+offset) == ' ') -- break; -- } -- if((offset > 1) && (offset < 15)) -- { -- warning_number[offset-1]='\0'; -- fprintf(stderr, "libpng warning no. %s: %s\n", warning_number, -- warning_message+offset); -- } -- else -- fprintf(stderr, "libpng warning: %s\n", warning_message); -- } -- else --# endif -- fprintf(stderr, "libpng warning: %s\n", warning_message); --#else -- /* make compiler happy */ ; -- if (warning_message) -- return; --#endif -- /* make compiler happy */ ; -- if (png_ptr) -- return; --} -- --/* This function is called when the application wants to use another method -- * of handling errors and warnings. Note that the error function MUST NOT -- * return to the calling routine or serious problems will occur. The return -- * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1) -- */ --void PNGAPI --png_set_error_fn(png_structp png_ptr, png_voidp error_ptr, -- png_error_ptr error_fn, png_error_ptr warning_fn) --{ -- png_ptr->error_ptr = error_ptr; -- png_ptr->error_fn = error_fn; -- png_ptr->warning_fn = warning_fn; --} -- -- --/* This function returns a pointer to the error_ptr associated with the user -- * functions. The application should free any memory associated with this -- * pointer before png_write_destroy and png_read_destroy are called. -- */ --png_voidp PNGAPI --png_get_error_ptr(png_structp png_ptr) --{ -- return ((png_voidp)png_ptr->error_ptr); --} -- -- --#ifdef PNG_ERROR_NUMBERS_SUPPORTED --void PNGAPI --png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode) --{ -- if(png_ptr != NULL) -- { -- png_ptr->flags &= -- ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode); -- } --} --#endif -diff --git a/thirdparty/libpng/pnggccrd.c b/thirdparty/libpng/pnggccrd.c -deleted file mode 100644 -index 73d3bd8..0000000 ---- a/thirdparty/libpng/pnggccrd.c -+++ /dev/null -@@ -1,5408 +0,0 @@ --/* pnggccrd.c - mixed C/assembler version of utilities to read a PNG file -- * -- * For Intel x86 CPU (Pentium-MMX or later) and GNU C compiler. -- * -- * See http://www.intel.com/drg/pentiumII/appnotes/916/916.htm -- * and http://www.intel.com/drg/pentiumII/appnotes/923/923.htm -- * for Intel's performance analysis of the MMX vs. non-MMX code. -- * -- * libpng version 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * Copyright (c) 1998, Intel Corporation -- * -- * Based on MSVC code contributed by Nirav Chhatrapati, Intel Corp., 1998. -- * Interface to libpng contributed by Gilles Vollant, 1999. -- * GNU C port by Greg Roelofs, 1999-2001. -- * -- * Lines 2350-4300 converted in place with intel2gas 1.3.1: -- * -- * intel2gas -mdI pnggccrd.c.partially-msvc -o pnggccrd.c -- * -- * and then cleaned up by hand. See http://hermes.terminal.at/intel2gas/ . -- * -- * NOTE: A sufficiently recent version of GNU as (or as.exe under DOS/Windows) -- * is required to assemble the newer MMX instructions such as movq. -- * For djgpp, see -- * -- * ftp://ftp.simtel.net/pub/simtelnet/gnu/djgpp/v2gnu/bnu281b.zip -- * -- * (or a later version in the same directory). For Linux, check your -- * distribution's web site(s) or try these links: -- * -- * http://rufus.w3.org/linux/RPM/binutils.html -- * http://www.debian.org/Packages/stable/devel/binutils.html -- * ftp://ftp.slackware.com/pub/linux/slackware/slackware/slakware/d1/ -- * binutils.tgz -- * -- * For other platforms, see the main GNU site: -- * -- * ftp://ftp.gnu.org/pub/gnu/binutils/ -- * -- * Version 2.5.2l.15 is definitely too old... -- */ -- --/* -- * TEMPORARY PORTING NOTES AND CHANGELOG (mostly by Greg Roelofs) -- * ===================================== -- * -- * 19991006: -- * - fixed sign error in post-MMX cleanup code (16- & 32-bit cases) -- * -- * 19991007: -- * - additional optimizations (possible or definite): -- * x [DONE] write MMX code for 64-bit case (pixel_bytes == 8) [not tested] -- * - write MMX code for 48-bit case (pixel_bytes == 6) -- * - figure out what's up with 24-bit case (pixel_bytes == 3): -- * why subtract 8 from width_mmx in the pass 4/5 case? -- * (only width_mmx case) (near line 1606) -- * x [DONE] replace pixel_bytes within each block with the true -- * constant value (or are compilers smart enough to do that?) -- * - rewrite all MMX interlacing code so it's aligned with -- * the *beginning* of the row buffer, not the end. This -- * would not only allow one to eliminate half of the memory -- * writes for odd passes (that is, pass == odd), it may also -- * eliminate some unaligned-data-access exceptions (assuming -- * there's a penalty for not aligning 64-bit accesses on -- * 64-bit boundaries). The only catch is that the "leftover" -- * pixel(s) at the end of the row would have to be saved, -- * but there are enough unused MMX registers in every case, -- * so this is not a problem. A further benefit is that the -- * post-MMX cleanup code (C code) in at least some of the -- * cases could be done within the assembler block. -- * x [DONE] the "v3 v2 v1 v0 v7 v6 v5 v4" comments are confusing, -- * inconsistent, and don't match the MMX Programmer's Reference -- * Manual conventions anyway. They should be changed to -- * "b7 b6 b5 b4 b3 b2 b1 b0," where b0 indicates the byte that -- * was lowest in memory (e.g., corresponding to a left pixel) -- * and b7 is the byte that was highest (e.g., a right pixel). -- * -- * 19991016: -- * - Brennan's Guide notwithstanding, gcc under Linux does *not* -- * want globals prefixed by underscores when referencing them-- -- * i.e., if the variable is const4, then refer to it as const4, -- * not _const4. This seems to be a djgpp-specific requirement. -- * Also, such variables apparently *must* be declared outside -- * of functions; neither static nor automatic variables work if -- * defined within the scope of a single function, but both -- * static and truly global (multi-module) variables work fine. -- * -- * 19991023: -- * - fixed png_combine_row() non-MMX replication bug (odd passes only?) -- * - switched from string-concatenation-with-macros to cleaner method of -- * renaming global variables for djgpp--i.e., always use prefixes in -- * inlined assembler code (== strings) and conditionally rename the -- * variables, not the other way around. Hence _const4, _mask8_0, etc. -- * -- * 19991024: -- * - fixed mmxsupport()/png_do_read_interlace() first-row bug -- * This one was severely weird: even though mmxsupport() doesn't touch -- * ebx (where "row" pointer was stored), it nevertheless managed to zero -- * the register (even in static/non-fPIC code--see below), which in turn -- * caused png_do_read_interlace() to return prematurely on the first row of -- * interlaced images (i.e., without expanding the interlaced pixels). -- * Inspection of the generated assembly code didn't turn up any clues, -- * although it did point at a minor optimization (i.e., get rid of -- * mmx_supported_local variable and just use eax). Possibly the CPUID -- * instruction is more destructive than it looks? (Not yet checked.) -- * - "info gcc" was next to useless, so compared fPIC and non-fPIC assembly -- * listings... Apparently register spillage has to do with ebx, since -- * it's used to index the global offset table. Commenting it out of the -- * input-reg lists in png_combine_row() eliminated compiler barfage, so -- * ifdef'd with __PIC__ macro: if defined, use a global for unmask -- * -- * 19991107: -- * - verified CPUID clobberage: 12-char string constant ("GenuineIntel", -- * "AuthenticAMD", etc.) placed in ebx:ecx:edx. Still need to polish. -- * -- * 19991120: -- * - made "diff" variable (now "_dif") global to simplify conversion of -- * filtering routines (running out of regs, sigh). "diff" is still used -- * in interlacing routines, however. -- * - fixed up both versions of mmxsupport() (ORIG_THAT_USED_TO_CLOBBER_EBX -- * macro determines which is used); original not yet tested. -- * -- * 20000213: -- * - when compiling with gcc, be sure to use -fomit-frame-pointer -- * -- * 20000319: -- * - fixed a register-name typo in png_do_read_interlace(), default (MMX) case, -- * pass == 4 or 5, that caused visible corruption of interlaced images -- * -- * 20000623: -- * - Various problems were reported with gcc 2.95.2 in the Cygwin environment, -- * many of the form "forbidden register 0 (ax) was spilled for class AREG." -- * This is explained at http://gcc.gnu.org/fom_serv/cache/23.html, and -- * Chuck Wilson supplied a patch involving dummy output registers. See -- * http://sourceforge.net/bugs/?func=detailbug&bug_id=108741&group_id=5624 -- * for the original (anonymous) SourceForge bug report. -- * -- * 20000706: -- * - Chuck Wilson passed along these remaining gcc 2.95.2 errors: -- * pnggccrd.c: In function `png_combine_row': -- * pnggccrd.c:525: more than 10 operands in `asm' -- * pnggccrd.c:669: more than 10 operands in `asm' -- * pnggccrd.c:828: more than 10 operands in `asm' -- * pnggccrd.c:994: more than 10 operands in `asm' -- * pnggccrd.c:1177: more than 10 operands in `asm' -- * They are all the same problem and can be worked around by using the -- * global _unmask variable unconditionally, not just in the -fPIC case. -- * Reportedly earlier versions of gcc also have the problem with more than -- * 10 operands; they just don't report it. Much strangeness ensues, etc. -- * -- * 20000729: -- * - enabled png_read_filter_row_mmx_up() (shortest remaining unconverted -- * MMX routine); began converting png_read_filter_row_mmx_sub() -- * - to finish remaining sections: -- * - clean up indentation and comments -- * - preload local variables -- * - add output and input regs (order of former determines numerical -- * mapping of latter) -- * - avoid all usage of ebx (including bx, bh, bl) register [20000823] -- * - remove "$" from addressing of Shift and Mask variables [20000823] -- * -- * 20000731: -- * - global union vars causing segfaults in png_read_filter_row_mmx_sub()? -- * -- * 20000822: -- * - ARGH, stupid png_read_filter_row_mmx_sub() segfault only happens with -- * shared-library (-fPIC) version! Code works just fine as part of static -- * library. Damn damn damn damn damn, should have tested that sooner. -- * ebx is getting clobbered again (explicitly this time); need to save it -- * on stack or rewrite asm code to avoid using it altogether. Blargh! -- * -- * 20000823: -- * - first section was trickiest; all remaining sections have ebx -> edx now. -- * (-fPIC works again.) Also added missing underscores to various Shift* -- * and *Mask* globals and got rid of leading "$" signs. -- * -- * 20000826: -- * - added visual separators to help navigate microscopic printed copies -- * (http://pobox.com/~newt/code/gpr-latest.zip, mode 10); started working -- * on png_read_filter_row_mmx_avg() -- * -- * 20000828: -- * - finished png_read_filter_row_mmx_avg(): only Paeth left! (930 lines...) -- * What the hell, did png_read_filter_row_mmx_paeth(), too. Comments not -- * cleaned up/shortened in either routine, but functionality is complete -- * and seems to be working fine. -- * -- * 20000829: -- * - ahhh, figured out last(?) bit of gcc/gas asm-fu: if register is listed -- * as an input reg (with dummy output variables, etc.), then it *cannot* -- * also appear in the clobber list or gcc 2.95.2 will barf. The solution -- * is simple enough... -- * -- * 20000914: -- * - bug in png_read_filter_row_mmx_avg(): 16-bit grayscale not handled -- * correctly (but 48-bit RGB just fine) -- * -- * 20000916: -- * - fixed bug in png_read_filter_row_mmx_avg(), bpp == 2 case; three errors: -- * - "_ShiftBpp.use = 24;" should have been "_ShiftBpp.use = 16;" -- * - "_ShiftRem.use = 40;" should have been "_ShiftRem.use = 48;" -- * - "psllq _ShiftRem, %%mm2" should have been "psrlq _ShiftRem, %%mm2" -- * -- * 20010101: -- * - added new png_init_mmx_flags() function (here only because it needs to -- * call mmxsupport(), which should probably become global png_mmxsupport()); -- * modified other MMX routines to run conditionally (png_ptr->asm_flags) -- * -- * 20010103: -- * - renamed mmxsupport() to png_mmx_support(), with auto-set of mmx_supported, -- * and made it public; moved png_init_mmx_flags() to png.c as internal func -- * -- * 20010104: -- * - removed dependency on png_read_filter_row_c() (C code already duplicated -- * within MMX version of png_read_filter_row()) so no longer necessary to -- * compile it into pngrutil.o -- * -- * 20010310: -- * - fixed buffer-overrun bug in png_combine_row() C code (non-MMX) -- * -- * 20020304: -- * - eliminated incorrect use of width_mmx in pixel_bytes == 8 case -- * -- * 20040724: -- * - more tinkering with clobber list at lines 4529 and 5033, to get -- * it to compile on gcc-3.4. -- * -- * STILL TO DO: -- * - test png_do_read_interlace() 64-bit case (pixel_bytes == 8) -- * - write MMX code for 48-bit case (pixel_bytes == 6) -- * - figure out what's up with 24-bit case (pixel_bytes == 3): -- * why subtract 8 from width_mmx in the pass 4/5 case? -- * (only width_mmx case) (near line 1606) -- * - rewrite all MMX interlacing code so it's aligned with beginning -- * of the row buffer, not the end (see 19991007 for details) -- * x pick one version of mmxsupport() and get rid of the other -- * - add error messages to any remaining bogus default cases -- * - enable pixel_depth == 8 cases in png_read_filter_row()? (test speed) -- * x add support for runtime enable/disable/query of various MMX routines -- */ -- --#define PNG_INTERNAL --#include "png.h" -- --#if defined(PNG_USE_PNGGCCRD) -- --int PNGAPI png_mmx_support(void); -- --#ifdef PNG_USE_LOCAL_ARRAYS --static const int FARDATA png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; --static const int FARDATA png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; --static const int FARDATA png_pass_width[7] = {8, 4, 4, 2, 2, 1, 1}; --#endif -- --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) --/* djgpp, Win32, and Cygwin add their own underscores to global variables, -- * so define them without: */ --#if defined(__DJGPP__) || defined(WIN32) || defined(__CYGWIN__) --# define _mmx_supported mmx_supported --# define _const4 const4 --# define _const6 const6 --# define _mask8_0 mask8_0 --# define _mask16_1 mask16_1 --# define _mask16_0 mask16_0 --# define _mask24_2 mask24_2 --# define _mask24_1 mask24_1 --# define _mask24_0 mask24_0 --# define _mask32_3 mask32_3 --# define _mask32_2 mask32_2 --# define _mask32_1 mask32_1 --# define _mask32_0 mask32_0 --# define _mask48_5 mask48_5 --# define _mask48_4 mask48_4 --# define _mask48_3 mask48_3 --# define _mask48_2 mask48_2 --# define _mask48_1 mask48_1 --# define _mask48_0 mask48_0 --# define _LBCarryMask LBCarryMask --# define _HBClearMask HBClearMask --# define _ActiveMask ActiveMask --# define _ActiveMask2 ActiveMask2 --# define _ActiveMaskEnd ActiveMaskEnd --# define _ShiftBpp ShiftBpp --# define _ShiftRem ShiftRem --#ifdef PNG_THREAD_UNSAFE_OK --# define _unmask unmask --# define _FullLength FullLength --# define _MMXLength MMXLength --# define _dif dif --# define _patemp patemp --# define _pbtemp pbtemp --# define _pctemp pctemp --#endif --#endif -- -- --/* These constants are used in the inlined MMX assembly code. -- Ignore gcc's "At top level: defined but not used" warnings. */ -- --/* GRR 20000706: originally _unmask was needed only when compiling with -fPIC, -- * since that case uses the %ebx register for indexing the Global Offset Table -- * and there were no other registers available. But gcc 2.95 and later emit -- * "more than 10 operands in `asm'" errors when %ebx is used to preload unmask -- * in the non-PIC case, so we'll just use the global unconditionally now. -- */ --#ifdef PNG_THREAD_UNSAFE_OK --static int _unmask; --#endif -- --static unsigned long long _mask8_0 = 0x0102040810204080LL; -- --static unsigned long long _mask16_1 = 0x0101020204040808LL; --static unsigned long long _mask16_0 = 0x1010202040408080LL; -- --static unsigned long long _mask24_2 = 0x0101010202020404LL; --static unsigned long long _mask24_1 = 0x0408080810101020LL; --static unsigned long long _mask24_0 = 0x2020404040808080LL; -- --static unsigned long long _mask32_3 = 0x0101010102020202LL; --static unsigned long long _mask32_2 = 0x0404040408080808LL; --static unsigned long long _mask32_1 = 0x1010101020202020LL; --static unsigned long long _mask32_0 = 0x4040404080808080LL; -- --static unsigned long long _mask48_5 = 0x0101010101010202LL; --static unsigned long long _mask48_4 = 0x0202020204040404LL; --static unsigned long long _mask48_3 = 0x0404080808080808LL; --static unsigned long long _mask48_2 = 0x1010101010102020LL; --static unsigned long long _mask48_1 = 0x2020202040404040LL; --static unsigned long long _mask48_0 = 0x4040808080808080LL; -- --static unsigned long long _const4 = 0x0000000000FFFFFFLL; --//static unsigned long long _const5 = 0x000000FFFFFF0000LL; // NOT USED --static unsigned long long _const6 = 0x00000000000000FFLL; -- --// These are used in the row-filter routines and should/would be local --// variables if not for gcc addressing limitations. --// WARNING: Their presence probably defeats the thread safety of libpng. -- --#ifdef PNG_THREAD_UNSAFE_OK --static png_uint_32 _FullLength; --static png_uint_32 _MMXLength; --static int _dif; --static int _patemp; // temp variables for Paeth routine --static int _pbtemp; --static int _pctemp; --#endif -- --void /* PRIVATE */ --png_squelch_warnings(void) --{ --#ifdef PNG_THREAD_UNSAFE_OK -- _dif = _dif; -- _patemp = _patemp; -- _pbtemp = _pbtemp; -- _pctemp = _pctemp; -- _MMXLength = _MMXLength; --#endif -- _const4 = _const4; -- _const6 = _const6; -- _mask8_0 = _mask8_0; -- _mask16_1 = _mask16_1; -- _mask16_0 = _mask16_0; -- _mask24_2 = _mask24_2; -- _mask24_1 = _mask24_1; -- _mask24_0 = _mask24_0; -- _mask32_3 = _mask32_3; -- _mask32_2 = _mask32_2; -- _mask32_1 = _mask32_1; -- _mask32_0 = _mask32_0; -- _mask48_5 = _mask48_5; -- _mask48_4 = _mask48_4; -- _mask48_3 = _mask48_3; -- _mask48_2 = _mask48_2; -- _mask48_1 = _mask48_1; -- _mask48_0 = _mask48_0; --} --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ -- -- --static int _mmx_supported = 2; -- --/*===========================================================================*/ --/* */ --/* P N G _ C O M B I N E _ R O W */ --/* */ --/*===========================================================================*/ -- --#if defined(PNG_HAVE_ASSEMBLER_COMBINE_ROW) -- --#define BPP2 2 --#define BPP3 3 /* bytes per pixel (a.k.a. pixel_bytes) */ --#define BPP4 4 --#define BPP6 6 /* (defined only to help avoid cut-and-paste errors) */ --#define BPP8 8 -- --/* Combines the row recently read in with the previous row. -- This routine takes care of alpha and transparency if requested. -- This routine also handles the two methods of progressive display -- of interlaced images, depending on the mask value. -- The mask value describes which pixels are to be combined with -- the row. The pattern always repeats every 8 pixels, so just 8 -- bits are needed. A one indicates the pixel is to be combined; a -- zero indicates the pixel is to be skipped. This is in addition -- to any alpha or transparency value associated with the pixel. -- If you want all pixels to be combined, pass 0xff (255) in mask. */ -- --/* Use this routine for the x86 platform - it uses a faster MMX routine -- if the machine supports MMX. */ -- --void /* PRIVATE */ --png_combine_row(png_structp png_ptr, png_bytep row, int mask) --{ -- png_debug(1, "in png_combine_row (pnggccrd.c)\n"); -- --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) -- if (_mmx_supported == 2) { --#if !defined(PNG_1_0_X) -- /* this should have happened in png_init_mmx_flags() already */ -- png_warning(png_ptr, "asm_flags may not have been initialized"); --#endif -- png_mmx_support(); -- } --#endif -- -- if (mask == 0xff) -- { -- png_debug(2,"mask == 0xff: doing single png_memcpy()\n"); -- png_memcpy(row, png_ptr->row_buf + 1, -- (png_size_t)PNG_ROWBYTES(png_ptr->row_info.pixel_depth,png_ptr->width)); -- } -- else /* (png_combine_row() is never called with mask == 0) */ -- { -- switch (png_ptr->row_info.pixel_depth) -- { -- case 1: /* png_ptr->row_info.pixel_depth */ -- { -- png_bytep sp; -- png_bytep dp; -- int s_inc, s_start, s_end; -- int m; -- int shift; -- png_uint_32 i; -- -- sp = png_ptr->row_buf + 1; -- dp = row; -- m = 0x80; --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_PACKSWAP) -- { -- s_start = 0; -- s_end = 7; -- s_inc = 1; -- } -- else --#endif -- { -- s_start = 7; -- s_end = 0; -- s_inc = -1; -- } -- -- shift = s_start; -- -- for (i = 0; i < png_ptr->width; i++) -- { -- if (m & mask) -- { -- int value; -- -- value = (*sp >> shift) & 0x1; -- *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); -- *dp |= (png_byte)(value << shift); -- } -- -- if (shift == s_end) -- { -- shift = s_start; -- sp++; -- dp++; -- } -- else -- shift += s_inc; -- -- if (m == 1) -- m = 0x80; -- else -- m >>= 1; -- } -- break; -- } -- -- case 2: /* png_ptr->row_info.pixel_depth */ -- { -- png_bytep sp; -- png_bytep dp; -- int s_start, s_end, s_inc; -- int m; -- int shift; -- png_uint_32 i; -- int value; -- -- sp = png_ptr->row_buf + 1; -- dp = row; -- m = 0x80; --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_PACKSWAP) -- { -- s_start = 0; -- s_end = 6; -- s_inc = 2; -- } -- else --#endif -- { -- s_start = 6; -- s_end = 0; -- s_inc = -2; -- } -- -- shift = s_start; -- -- for (i = 0; i < png_ptr->width; i++) -- { -- if (m & mask) -- { -- value = (*sp >> shift) & 0x3; -- *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); -- *dp |= (png_byte)(value << shift); -- } -- -- if (shift == s_end) -- { -- shift = s_start; -- sp++; -- dp++; -- } -- else -- shift += s_inc; -- if (m == 1) -- m = 0x80; -- else -- m >>= 1; -- } -- break; -- } -- -- case 4: /* png_ptr->row_info.pixel_depth */ -- { -- png_bytep sp; -- png_bytep dp; -- int s_start, s_end, s_inc; -- int m; -- int shift; -- png_uint_32 i; -- int value; -- -- sp = png_ptr->row_buf + 1; -- dp = row; -- m = 0x80; --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_PACKSWAP) -- { -- s_start = 0; -- s_end = 4; -- s_inc = 4; -- } -- else --#endif -- { -- s_start = 4; -- s_end = 0; -- s_inc = -4; -- } -- shift = s_start; -- -- for (i = 0; i < png_ptr->width; i++) -- { -- if (m & mask) -- { -- value = (*sp >> shift) & 0xf; -- *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); -- *dp |= (png_byte)(value << shift); -- } -- -- if (shift == s_end) -- { -- shift = s_start; -- sp++; -- dp++; -- } -- else -- shift += s_inc; -- if (m == 1) -- m = 0x80; -- else -- m >>= 1; -- } -- break; -- } -- -- case 8: /* png_ptr->row_info.pixel_depth */ -- { -- png_bytep srcptr; -- png_bytep dstptr; -- --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) -- /* && _mmx_supported */ ) --#else -- if (_mmx_supported) --#endif -- { -- png_uint_32 len; -- int diff; -- int dummy_value_a; // fix 'forbidden register spilled' error -- int dummy_value_d; -- int dummy_value_c; -- int dummy_value_S; -- int dummy_value_D; -- _unmask = ~mask; // global variable for -fPIC version -- srcptr = png_ptr->row_buf + 1; -- dstptr = row; -- len = png_ptr->width &~7; // reduce to multiple of 8 -- diff = (int) (png_ptr->width & 7); // amount lost -- -- __asm__ __volatile__ ( -- "movd _unmask, %%mm7 \n\t" // load bit pattern -- "psubb %%mm6, %%mm6 \n\t" // zero mm6 -- "punpcklbw %%mm7, %%mm7 \n\t" -- "punpcklwd %%mm7, %%mm7 \n\t" -- "punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks -- -- "movq _mask8_0, %%mm0 \n\t" -- "pand %%mm7, %%mm0 \n\t" // nonzero if keep byte -- "pcmpeqb %%mm6, %%mm0 \n\t" // zeros->1s, v versa -- --// preload "movl len, %%ecx \n\t" // load length of line --// preload "movl srcptr, %%esi \n\t" // load source --// preload "movl dstptr, %%edi \n\t" // load dest -- -- "cmpl $0, %%ecx \n\t" // len == 0 ? -- "je mainloop8end \n\t" -- -- "mainloop8: \n\t" -- "movq (%%esi), %%mm4 \n\t" // *srcptr -- "pand %%mm0, %%mm4 \n\t" -- "movq %%mm0, %%mm6 \n\t" -- "pandn (%%edi), %%mm6 \n\t" // *dstptr -- "por %%mm6, %%mm4 \n\t" -- "movq %%mm4, (%%edi) \n\t" -- "addl $8, %%esi \n\t" // inc by 8 bytes processed -- "addl $8, %%edi \n\t" -- "subl $8, %%ecx \n\t" // dec by 8 pixels processed -- "ja mainloop8 \n\t" -- -- "mainloop8end: \n\t" --// preload "movl diff, %%ecx \n\t" // (diff is in eax) -- "movl %%eax, %%ecx \n\t" -- "cmpl $0, %%ecx \n\t" -- "jz end8 \n\t" --// preload "movl mask, %%edx \n\t" -- "sall $24, %%edx \n\t" // make low byte, high byte -- -- "secondloop8: \n\t" -- "sall %%edx \n\t" // move high bit to CF -- "jnc skip8 \n\t" // if CF = 0 -- "movb (%%esi), %%al \n\t" -- "movb %%al, (%%edi) \n\t" -- -- "skip8: \n\t" -- "incl %%esi \n\t" -- "incl %%edi \n\t" -- "decl %%ecx \n\t" -- "jnz secondloop8 \n\t" -- -- "end8: \n\t" -- "EMMS \n\t" // DONE -- -- : "=a" (dummy_value_a), // output regs (dummy) -- "=d" (dummy_value_d), -- "=c" (dummy_value_c), -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "3" (srcptr), // esi // input regs -- "4" (dstptr), // edi -- "0" (diff), // eax --// was (unmask) "b" RESERVED // ebx // Global Offset Table idx -- "2" (len), // ecx -- "1" (mask) // edx -- --#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm4", "%mm6", "%mm7" // clobber list --#endif -- ); -- } -- else /* mmx _not supported - Use modified C routine */ --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ -- { -- register png_uint_32 i; -- png_uint_32 initial_val = png_pass_start[png_ptr->pass]; -- /* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ -- register int stride = png_pass_inc[png_ptr->pass]; -- /* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ -- register int rep_bytes = png_pass_width[png_ptr->pass]; -- /* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ -- png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ -- int diff = (int) (png_ptr->width & 7); /* amount lost */ -- register png_uint_32 final_val = len; /* GRR bugfix */ -- -- srcptr = png_ptr->row_buf + 1 + initial_val; -- dstptr = row + initial_val; -- -- for (i = initial_val; i < final_val; i += stride) -- { -- png_memcpy(dstptr, srcptr, rep_bytes); -- srcptr += stride; -- dstptr += stride; -- } -- if (diff) /* number of leftover pixels: 3 for pngtest */ -- { -- final_val+=diff /* *BPP1 */ ; -- for (; i < final_val; i += stride) -- { -- if (rep_bytes > (int)(final_val-i)) -- rep_bytes = (int)(final_val-i); -- png_memcpy(dstptr, srcptr, rep_bytes); -- srcptr += stride; -- dstptr += stride; -- } -- } -- -- } /* end of else (_mmx_supported) */ -- -- break; -- } /* end 8 bpp */ -- -- case 16: /* png_ptr->row_info.pixel_depth */ -- { -- png_bytep srcptr; -- png_bytep dstptr; -- --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) -- /* && _mmx_supported */ ) --#else -- if (_mmx_supported) --#endif -- { -- png_uint_32 len; -- int diff; -- int dummy_value_a; // fix 'forbidden register spilled' error -- int dummy_value_d; -- int dummy_value_c; -- int dummy_value_S; -- int dummy_value_D; -- _unmask = ~mask; // global variable for -fPIC version -- srcptr = png_ptr->row_buf + 1; -- dstptr = row; -- len = png_ptr->width &~7; // reduce to multiple of 8 -- diff = (int) (png_ptr->width & 7); // amount lost // -- -- __asm__ __volatile__ ( -- "movd _unmask, %%mm7 \n\t" // load bit pattern -- "psubb %%mm6, %%mm6 \n\t" // zero mm6 -- "punpcklbw %%mm7, %%mm7 \n\t" -- "punpcklwd %%mm7, %%mm7 \n\t" -- "punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks -- -- "movq _mask16_0, %%mm0 \n\t" -- "movq _mask16_1, %%mm1 \n\t" -- -- "pand %%mm7, %%mm0 \n\t" -- "pand %%mm7, %%mm1 \n\t" -- -- "pcmpeqb %%mm6, %%mm0 \n\t" -- "pcmpeqb %%mm6, %%mm1 \n\t" -- --// preload "movl len, %%ecx \n\t" // load length of line --// preload "movl srcptr, %%esi \n\t" // load source --// preload "movl dstptr, %%edi \n\t" // load dest -- -- "cmpl $0, %%ecx \n\t" -- "jz mainloop16end \n\t" -- -- "mainloop16: \n\t" -- "movq (%%esi), %%mm4 \n\t" -- "pand %%mm0, %%mm4 \n\t" -- "movq %%mm0, %%mm6 \n\t" -- "movq (%%edi), %%mm7 \n\t" -- "pandn %%mm7, %%mm6 \n\t" -- "por %%mm6, %%mm4 \n\t" -- "movq %%mm4, (%%edi) \n\t" -- -- "movq 8(%%esi), %%mm5 \n\t" -- "pand %%mm1, %%mm5 \n\t" -- "movq %%mm1, %%mm7 \n\t" -- "movq 8(%%edi), %%mm6 \n\t" -- "pandn %%mm6, %%mm7 \n\t" -- "por %%mm7, %%mm5 \n\t" -- "movq %%mm5, 8(%%edi) \n\t" -- -- "addl $16, %%esi \n\t" // inc by 16 bytes processed -- "addl $16, %%edi \n\t" -- "subl $8, %%ecx \n\t" // dec by 8 pixels processed -- "ja mainloop16 \n\t" -- -- "mainloop16end: \n\t" --// preload "movl diff, %%ecx \n\t" // (diff is in eax) -- "movl %%eax, %%ecx \n\t" -- "cmpl $0, %%ecx \n\t" -- "jz end16 \n\t" --// preload "movl mask, %%edx \n\t" -- "sall $24, %%edx \n\t" // make low byte, high byte -- -- "secondloop16: \n\t" -- "sall %%edx \n\t" // move high bit to CF -- "jnc skip16 \n\t" // if CF = 0 -- "movw (%%esi), %%ax \n\t" -- "movw %%ax, (%%edi) \n\t" -- -- "skip16: \n\t" -- "addl $2, %%esi \n\t" -- "addl $2, %%edi \n\t" -- "decl %%ecx \n\t" -- "jnz secondloop16 \n\t" -- -- "end16: \n\t" -- "EMMS \n\t" // DONE -- -- : "=a" (dummy_value_a), // output regs (dummy) -- "=c" (dummy_value_c), -- "=d" (dummy_value_d), -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "0" (diff), // eax // input regs --// was (unmask) " " RESERVED // ebx // Global Offset Table idx -- "1" (len), // ecx -- "2" (mask), // edx -- "3" (srcptr), // esi -- "4" (dstptr) // edi -- --#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm1", "%mm4" // clobber list -- , "%mm5", "%mm6", "%mm7" --#endif -- ); -- } -- else /* mmx _not supported - Use modified C routine */ --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ -- { -- register png_uint_32 i; -- png_uint_32 initial_val = BPP2 * png_pass_start[png_ptr->pass]; -- /* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ -- register int stride = BPP2 * png_pass_inc[png_ptr->pass]; -- /* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ -- register int rep_bytes = BPP2 * png_pass_width[png_ptr->pass]; -- /* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ -- png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ -- int diff = (int) (png_ptr->width & 7); /* amount lost */ -- register png_uint_32 final_val = BPP2 * len; /* GRR bugfix */ -- -- srcptr = png_ptr->row_buf + 1 + initial_val; -- dstptr = row + initial_val; -- -- for (i = initial_val; i < final_val; i += stride) -- { -- png_memcpy(dstptr, srcptr, rep_bytes); -- srcptr += stride; -- dstptr += stride; -- } -- if (diff) /* number of leftover pixels: 3 for pngtest */ -- { -- final_val+=diff*BPP2; -- for (; i < final_val; i += stride) -- { -- if (rep_bytes > (int)(final_val-i)) -- rep_bytes = (int)(final_val-i); -- png_memcpy(dstptr, srcptr, rep_bytes); -- srcptr += stride; -- dstptr += stride; -- } -- } -- } /* end of else (_mmx_supported) */ -- -- break; -- } /* end 16 bpp */ -- -- case 24: /* png_ptr->row_info.pixel_depth */ -- { -- png_bytep srcptr; -- png_bytep dstptr; -- --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) -- /* && _mmx_supported */ ) --#else -- if (_mmx_supported) --#endif -- { -- png_uint_32 len; -- int diff; -- int dummy_value_a; // fix 'forbidden register spilled' error -- int dummy_value_d; -- int dummy_value_c; -- int dummy_value_S; -- int dummy_value_D; -- _unmask = ~mask; // global variable for -fPIC version -- srcptr = png_ptr->row_buf + 1; -- dstptr = row; -- len = png_ptr->width &~7; // reduce to multiple of 8 -- diff = (int) (png_ptr->width & 7); // amount lost // -- -- __asm__ __volatile__ ( -- "movd _unmask, %%mm7 \n\t" // load bit pattern -- "psubb %%mm6, %%mm6 \n\t" // zero mm6 -- "punpcklbw %%mm7, %%mm7 \n\t" -- "punpcklwd %%mm7, %%mm7 \n\t" -- "punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks -- -- "movq _mask24_0, %%mm0 \n\t" -- "movq _mask24_1, %%mm1 \n\t" -- "movq _mask24_2, %%mm2 \n\t" -- -- "pand %%mm7, %%mm0 \n\t" -- "pand %%mm7, %%mm1 \n\t" -- "pand %%mm7, %%mm2 \n\t" -- -- "pcmpeqb %%mm6, %%mm0 \n\t" -- "pcmpeqb %%mm6, %%mm1 \n\t" -- "pcmpeqb %%mm6, %%mm2 \n\t" -- --// preload "movl len, %%ecx \n\t" // load length of line --// preload "movl srcptr, %%esi \n\t" // load source --// preload "movl dstptr, %%edi \n\t" // load dest -- -- "cmpl $0, %%ecx \n\t" -- "jz mainloop24end \n\t" -- -- "mainloop24: \n\t" -- "movq (%%esi), %%mm4 \n\t" -- "pand %%mm0, %%mm4 \n\t" -- "movq %%mm0, %%mm6 \n\t" -- "movq (%%edi), %%mm7 \n\t" -- "pandn %%mm7, %%mm6 \n\t" -- "por %%mm6, %%mm4 \n\t" -- "movq %%mm4, (%%edi) \n\t" -- -- "movq 8(%%esi), %%mm5 \n\t" -- "pand %%mm1, %%mm5 \n\t" -- "movq %%mm1, %%mm7 \n\t" -- "movq 8(%%edi), %%mm6 \n\t" -- "pandn %%mm6, %%mm7 \n\t" -- "por %%mm7, %%mm5 \n\t" -- "movq %%mm5, 8(%%edi) \n\t" -- -- "movq 16(%%esi), %%mm6 \n\t" -- "pand %%mm2, %%mm6 \n\t" -- "movq %%mm2, %%mm4 \n\t" -- "movq 16(%%edi), %%mm7 \n\t" -- "pandn %%mm7, %%mm4 \n\t" -- "por %%mm4, %%mm6 \n\t" -- "movq %%mm6, 16(%%edi) \n\t" -- -- "addl $24, %%esi \n\t" // inc by 24 bytes processed -- "addl $24, %%edi \n\t" -- "subl $8, %%ecx \n\t" // dec by 8 pixels processed -- -- "ja mainloop24 \n\t" -- -- "mainloop24end: \n\t" --// preload "movl diff, %%ecx \n\t" // (diff is in eax) -- "movl %%eax, %%ecx \n\t" -- "cmpl $0, %%ecx \n\t" -- "jz end24 \n\t" --// preload "movl mask, %%edx \n\t" -- "sall $24, %%edx \n\t" // make low byte, high byte -- -- "secondloop24: \n\t" -- "sall %%edx \n\t" // move high bit to CF -- "jnc skip24 \n\t" // if CF = 0 -- "movw (%%esi), %%ax \n\t" -- "movw %%ax, (%%edi) \n\t" -- "xorl %%eax, %%eax \n\t" -- "movb 2(%%esi), %%al \n\t" -- "movb %%al, 2(%%edi) \n\t" -- -- "skip24: \n\t" -- "addl $3, %%esi \n\t" -- "addl $3, %%edi \n\t" -- "decl %%ecx \n\t" -- "jnz secondloop24 \n\t" -- -- "end24: \n\t" -- "EMMS \n\t" // DONE -- -- : "=a" (dummy_value_a), // output regs (dummy) -- "=d" (dummy_value_d), -- "=c" (dummy_value_c), -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "3" (srcptr), // esi // input regs -- "4" (dstptr), // edi -- "0" (diff), // eax --// was (unmask) "b" RESERVED // ebx // Global Offset Table idx -- "2" (len), // ecx -- "1" (mask) // edx -- --#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm1", "%mm2" // clobber list -- , "%mm4", "%mm5", "%mm6", "%mm7" --#endif -- ); -- } -- else /* mmx _not supported - Use modified C routine */ --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ -- { -- register png_uint_32 i; -- png_uint_32 initial_val = BPP3 * png_pass_start[png_ptr->pass]; -- /* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ -- register int stride = BPP3 * png_pass_inc[png_ptr->pass]; -- /* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ -- register int rep_bytes = BPP3 * png_pass_width[png_ptr->pass]; -- /* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ -- png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ -- int diff = (int) (png_ptr->width & 7); /* amount lost */ -- register png_uint_32 final_val = BPP3 * len; /* GRR bugfix */ -- -- srcptr = png_ptr->row_buf + 1 + initial_val; -- dstptr = row + initial_val; -- -- for (i = initial_val; i < final_val; i += stride) -- { -- png_memcpy(dstptr, srcptr, rep_bytes); -- srcptr += stride; -- dstptr += stride; -- } -- if (diff) /* number of leftover pixels: 3 for pngtest */ -- { -- final_val+=diff*BPP3; -- for (; i < final_val; i += stride) -- { -- if (rep_bytes > (int)(final_val-i)) -- rep_bytes = (int)(final_val-i); -- png_memcpy(dstptr, srcptr, rep_bytes); -- srcptr += stride; -- dstptr += stride; -- } -- } -- } /* end of else (_mmx_supported) */ -- -- break; -- } /* end 24 bpp */ -- -- case 32: /* png_ptr->row_info.pixel_depth */ -- { -- png_bytep srcptr; -- png_bytep dstptr; -- --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) -- /* && _mmx_supported */ ) --#else -- if (_mmx_supported) --#endif -- { -- png_uint_32 len; -- int diff; -- int dummy_value_a; // fix 'forbidden register spilled' error -- int dummy_value_d; -- int dummy_value_c; -- int dummy_value_S; -- int dummy_value_D; -- _unmask = ~mask; // global variable for -fPIC version -- srcptr = png_ptr->row_buf + 1; -- dstptr = row; -- len = png_ptr->width &~7; // reduce to multiple of 8 -- diff = (int) (png_ptr->width & 7); // amount lost // -- -- __asm__ __volatile__ ( -- "movd _unmask, %%mm7 \n\t" // load bit pattern -- "psubb %%mm6, %%mm6 \n\t" // zero mm6 -- "punpcklbw %%mm7, %%mm7 \n\t" -- "punpcklwd %%mm7, %%mm7 \n\t" -- "punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks -- -- "movq _mask32_0, %%mm0 \n\t" -- "movq _mask32_1, %%mm1 \n\t" -- "movq _mask32_2, %%mm2 \n\t" -- "movq _mask32_3, %%mm3 \n\t" -- -- "pand %%mm7, %%mm0 \n\t" -- "pand %%mm7, %%mm1 \n\t" -- "pand %%mm7, %%mm2 \n\t" -- "pand %%mm7, %%mm3 \n\t" -- -- "pcmpeqb %%mm6, %%mm0 \n\t" -- "pcmpeqb %%mm6, %%mm1 \n\t" -- "pcmpeqb %%mm6, %%mm2 \n\t" -- "pcmpeqb %%mm6, %%mm3 \n\t" -- --// preload "movl len, %%ecx \n\t" // load length of line --// preload "movl srcptr, %%esi \n\t" // load source --// preload "movl dstptr, %%edi \n\t" // load dest -- -- "cmpl $0, %%ecx \n\t" // lcr -- "jz mainloop32end \n\t" -- -- "mainloop32: \n\t" -- "movq (%%esi), %%mm4 \n\t" -- "pand %%mm0, %%mm4 \n\t" -- "movq %%mm0, %%mm6 \n\t" -- "movq (%%edi), %%mm7 \n\t" -- "pandn %%mm7, %%mm6 \n\t" -- "por %%mm6, %%mm4 \n\t" -- "movq %%mm4, (%%edi) \n\t" -- -- "movq 8(%%esi), %%mm5 \n\t" -- "pand %%mm1, %%mm5 \n\t" -- "movq %%mm1, %%mm7 \n\t" -- "movq 8(%%edi), %%mm6 \n\t" -- "pandn %%mm6, %%mm7 \n\t" -- "por %%mm7, %%mm5 \n\t" -- "movq %%mm5, 8(%%edi) \n\t" -- -- "movq 16(%%esi), %%mm6 \n\t" -- "pand %%mm2, %%mm6 \n\t" -- "movq %%mm2, %%mm4 \n\t" -- "movq 16(%%edi), %%mm7 \n\t" -- "pandn %%mm7, %%mm4 \n\t" -- "por %%mm4, %%mm6 \n\t" -- "movq %%mm6, 16(%%edi) \n\t" -- -- "movq 24(%%esi), %%mm7 \n\t" -- "pand %%mm3, %%mm7 \n\t" -- "movq %%mm3, %%mm5 \n\t" -- "movq 24(%%edi), %%mm4 \n\t" -- "pandn %%mm4, %%mm5 \n\t" -- "por %%mm5, %%mm7 \n\t" -- "movq %%mm7, 24(%%edi) \n\t" -- -- "addl $32, %%esi \n\t" // inc by 32 bytes processed -- "addl $32, %%edi \n\t" -- "subl $8, %%ecx \n\t" // dec by 8 pixels processed -- "ja mainloop32 \n\t" -- -- "mainloop32end: \n\t" --// preload "movl diff, %%ecx \n\t" // (diff is in eax) -- "movl %%eax, %%ecx \n\t" -- "cmpl $0, %%ecx \n\t" -- "jz end32 \n\t" --// preload "movl mask, %%edx \n\t" -- "sall $24, %%edx \n\t" // low byte => high byte -- -- "secondloop32: \n\t" -- "sall %%edx \n\t" // move high bit to CF -- "jnc skip32 \n\t" // if CF = 0 -- "movl (%%esi), %%eax \n\t" -- "movl %%eax, (%%edi) \n\t" -- -- "skip32: \n\t" -- "addl $4, %%esi \n\t" -- "addl $4, %%edi \n\t" -- "decl %%ecx \n\t" -- "jnz secondloop32 \n\t" -- -- "end32: \n\t" -- "EMMS \n\t" // DONE -- -- : "=a" (dummy_value_a), // output regs (dummy) -- "=d" (dummy_value_d), -- "=c" (dummy_value_c), -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "3" (srcptr), // esi // input regs -- "4" (dstptr), // edi -- "0" (diff), // eax --// was (unmask) "b" RESERVED // ebx // Global Offset Table idx -- "2" (len), // ecx -- "1" (mask) // edx -- --#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm1", "%mm2", "%mm3" // clobber list -- , "%mm4", "%mm5", "%mm6", "%mm7" --#endif -- ); -- } -- else /* mmx _not supported - Use modified C routine */ --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ -- { -- register png_uint_32 i; -- png_uint_32 initial_val = BPP4 * png_pass_start[png_ptr->pass]; -- /* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ -- register int stride = BPP4 * png_pass_inc[png_ptr->pass]; -- /* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ -- register int rep_bytes = BPP4 * png_pass_width[png_ptr->pass]; -- /* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ -- png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ -- int diff = (int) (png_ptr->width & 7); /* amount lost */ -- register png_uint_32 final_val = BPP4 * len; /* GRR bugfix */ -- -- srcptr = png_ptr->row_buf + 1 + initial_val; -- dstptr = row + initial_val; -- -- for (i = initial_val; i < final_val; i += stride) -- { -- png_memcpy(dstptr, srcptr, rep_bytes); -- srcptr += stride; -- dstptr += stride; -- } -- if (diff) /* number of leftover pixels: 3 for pngtest */ -- { -- final_val+=diff*BPP4; -- for (; i < final_val; i += stride) -- { -- if (rep_bytes > (int)(final_val-i)) -- rep_bytes = (int)(final_val-i); -- png_memcpy(dstptr, srcptr, rep_bytes); -- srcptr += stride; -- dstptr += stride; -- } -- } -- } /* end of else (_mmx_supported) */ -- -- break; -- } /* end 32 bpp */ -- -- case 48: /* png_ptr->row_info.pixel_depth */ -- { -- png_bytep srcptr; -- png_bytep dstptr; -- --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) -- /* && _mmx_supported */ ) --#else -- if (_mmx_supported) --#endif -- { -- png_uint_32 len; -- int diff; -- int dummy_value_a; // fix 'forbidden register spilled' error -- int dummy_value_d; -- int dummy_value_c; -- int dummy_value_S; -- int dummy_value_D; -- _unmask = ~mask; // global variable for -fPIC version -- srcptr = png_ptr->row_buf + 1; -- dstptr = row; -- len = png_ptr->width &~7; // reduce to multiple of 8 -- diff = (int) (png_ptr->width & 7); // amount lost // -- -- __asm__ __volatile__ ( -- "movd _unmask, %%mm7 \n\t" // load bit pattern -- "psubb %%mm6, %%mm6 \n\t" // zero mm6 -- "punpcklbw %%mm7, %%mm7 \n\t" -- "punpcklwd %%mm7, %%mm7 \n\t" -- "punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks -- -- "movq _mask48_0, %%mm0 \n\t" -- "movq _mask48_1, %%mm1 \n\t" -- "movq _mask48_2, %%mm2 \n\t" -- "movq _mask48_3, %%mm3 \n\t" -- "movq _mask48_4, %%mm4 \n\t" -- "movq _mask48_5, %%mm5 \n\t" -- -- "pand %%mm7, %%mm0 \n\t" -- "pand %%mm7, %%mm1 \n\t" -- "pand %%mm7, %%mm2 \n\t" -- "pand %%mm7, %%mm3 \n\t" -- "pand %%mm7, %%mm4 \n\t" -- "pand %%mm7, %%mm5 \n\t" -- -- "pcmpeqb %%mm6, %%mm0 \n\t" -- "pcmpeqb %%mm6, %%mm1 \n\t" -- "pcmpeqb %%mm6, %%mm2 \n\t" -- "pcmpeqb %%mm6, %%mm3 \n\t" -- "pcmpeqb %%mm6, %%mm4 \n\t" -- "pcmpeqb %%mm6, %%mm5 \n\t" -- --// preload "movl len, %%ecx \n\t" // load length of line --// preload "movl srcptr, %%esi \n\t" // load source --// preload "movl dstptr, %%edi \n\t" // load dest -- -- "cmpl $0, %%ecx \n\t" -- "jz mainloop48end \n\t" -- -- "mainloop48: \n\t" -- "movq (%%esi), %%mm7 \n\t" -- "pand %%mm0, %%mm7 \n\t" -- "movq %%mm0, %%mm6 \n\t" -- "pandn (%%edi), %%mm6 \n\t" -- "por %%mm6, %%mm7 \n\t" -- "movq %%mm7, (%%edi) \n\t" -- -- "movq 8(%%esi), %%mm6 \n\t" -- "pand %%mm1, %%mm6 \n\t" -- "movq %%mm1, %%mm7 \n\t" -- "pandn 8(%%edi), %%mm7 \n\t" -- "por %%mm7, %%mm6 \n\t" -- "movq %%mm6, 8(%%edi) \n\t" -- -- "movq 16(%%esi), %%mm6 \n\t" -- "pand %%mm2, %%mm6 \n\t" -- "movq %%mm2, %%mm7 \n\t" -- "pandn 16(%%edi), %%mm7 \n\t" -- "por %%mm7, %%mm6 \n\t" -- "movq %%mm6, 16(%%edi) \n\t" -- -- "movq 24(%%esi), %%mm7 \n\t" -- "pand %%mm3, %%mm7 \n\t" -- "movq %%mm3, %%mm6 \n\t" -- "pandn 24(%%edi), %%mm6 \n\t" -- "por %%mm6, %%mm7 \n\t" -- "movq %%mm7, 24(%%edi) \n\t" -- -- "movq 32(%%esi), %%mm6 \n\t" -- "pand %%mm4, %%mm6 \n\t" -- "movq %%mm4, %%mm7 \n\t" -- "pandn 32(%%edi), %%mm7 \n\t" -- "por %%mm7, %%mm6 \n\t" -- "movq %%mm6, 32(%%edi) \n\t" -- -- "movq 40(%%esi), %%mm7 \n\t" -- "pand %%mm5, %%mm7 \n\t" -- "movq %%mm5, %%mm6 \n\t" -- "pandn 40(%%edi), %%mm6 \n\t" -- "por %%mm6, %%mm7 \n\t" -- "movq %%mm7, 40(%%edi) \n\t" -- -- "addl $48, %%esi \n\t" // inc by 48 bytes processed -- "addl $48, %%edi \n\t" -- "subl $8, %%ecx \n\t" // dec by 8 pixels processed -- -- "ja mainloop48 \n\t" -- -- "mainloop48end: \n\t" --// preload "movl diff, %%ecx \n\t" // (diff is in eax) -- "movl %%eax, %%ecx \n\t" -- "cmpl $0, %%ecx \n\t" -- "jz end48 \n\t" --// preload "movl mask, %%edx \n\t" -- "sall $24, %%edx \n\t" // make low byte, high byte -- -- "secondloop48: \n\t" -- "sall %%edx \n\t" // move high bit to CF -- "jnc skip48 \n\t" // if CF = 0 -- "movl (%%esi), %%eax \n\t" -- "movl %%eax, (%%edi) \n\t" -- -- "skip48: \n\t" -- "addl $4, %%esi \n\t" -- "addl $4, %%edi \n\t" -- "decl %%ecx \n\t" -- "jnz secondloop48 \n\t" -- -- "end48: \n\t" -- "EMMS \n\t" // DONE -- -- : "=a" (dummy_value_a), // output regs (dummy) -- "=d" (dummy_value_d), -- "=c" (dummy_value_c), -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "3" (srcptr), // esi // input regs -- "4" (dstptr), // edi -- "0" (diff), // eax --// was (unmask) "b" RESERVED // ebx // Global Offset Table idx -- "2" (len), // ecx -- "1" (mask) // edx -- --#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm1", "%mm2", "%mm3" // clobber list -- , "%mm4", "%mm5", "%mm6", "%mm7" --#endif -- ); -- } -- else /* mmx _not supported - Use modified C routine */ --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ -- { -- register png_uint_32 i; -- png_uint_32 initial_val = BPP6 * png_pass_start[png_ptr->pass]; -- /* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ -- register int stride = BPP6 * png_pass_inc[png_ptr->pass]; -- /* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ -- register int rep_bytes = BPP6 * png_pass_width[png_ptr->pass]; -- /* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ -- png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ -- int diff = (int) (png_ptr->width & 7); /* amount lost */ -- register png_uint_32 final_val = BPP6 * len; /* GRR bugfix */ -- -- srcptr = png_ptr->row_buf + 1 + initial_val; -- dstptr = row + initial_val; -- -- for (i = initial_val; i < final_val; i += stride) -- { -- png_memcpy(dstptr, srcptr, rep_bytes); -- srcptr += stride; -- dstptr += stride; -- } -- if (diff) /* number of leftover pixels: 3 for pngtest */ -- { -- final_val+=diff*BPP6; -- for (; i < final_val; i += stride) -- { -- if (rep_bytes > (int)(final_val-i)) -- rep_bytes = (int)(final_val-i); -- png_memcpy(dstptr, srcptr, rep_bytes); -- srcptr += stride; -- dstptr += stride; -- } -- } -- } /* end of else (_mmx_supported) */ -- -- break; -- } /* end 48 bpp */ -- -- case 64: /* png_ptr->row_info.pixel_depth */ -- { -- png_bytep srcptr; -- png_bytep dstptr; -- register png_uint_32 i; -- png_uint_32 initial_val = BPP8 * png_pass_start[png_ptr->pass]; -- /* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ -- register int stride = BPP8 * png_pass_inc[png_ptr->pass]; -- /* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ -- register int rep_bytes = BPP8 * png_pass_width[png_ptr->pass]; -- /* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ -- png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ -- int diff = (int) (png_ptr->width & 7); /* amount lost */ -- register png_uint_32 final_val = BPP8 * len; /* GRR bugfix */ -- -- srcptr = png_ptr->row_buf + 1 + initial_val; -- dstptr = row + initial_val; -- -- for (i = initial_val; i < final_val; i += stride) -- { -- png_memcpy(dstptr, srcptr, rep_bytes); -- srcptr += stride; -- dstptr += stride; -- } -- if (diff) /* number of leftover pixels: 3 for pngtest */ -- { -- final_val+=diff*BPP8; -- for (; i < final_val; i += stride) -- { -- if (rep_bytes > (int)(final_val-i)) -- rep_bytes = (int)(final_val-i); -- png_memcpy(dstptr, srcptr, rep_bytes); -- srcptr += stride; -- dstptr += stride; -- } -- } -- -- break; -- } /* end 64 bpp */ -- -- default: /* png_ptr->row_info.pixel_depth != 1,2,4,8,16,24,32,48,64 */ -- { -- /* this should never happen */ -- png_warning(png_ptr, "Invalid row_info.pixel_depth in pnggccrd"); -- break; -- } -- } /* end switch (png_ptr->row_info.pixel_depth) */ -- -- } /* end if (non-trivial mask) */ -- --} /* end png_combine_row() */ -- --#endif /* PNG_HAVE_ASSEMBLER_COMBINE_ROW */ -- -- -- -- --/*===========================================================================*/ --/* */ --/* P N G _ D O _ R E A D _ I N T E R L A C E */ --/* */ --/*===========================================================================*/ -- --#if defined(PNG_READ_INTERLACING_SUPPORTED) --#if defined(PNG_HAVE_ASSEMBLER_READ_INTERLACE) -- --/* png_do_read_interlace() is called after any 16-bit to 8-bit conversion -- * has taken place. [GRR: what other steps come before and/or after?] -- */ -- --void /* PRIVATE */ --png_do_read_interlace(png_structp png_ptr) --{ -- png_row_infop row_info = &(png_ptr->row_info); -- png_bytep row = png_ptr->row_buf + 1; -- int pass = png_ptr->pass; --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- png_uint_32 transformations = png_ptr->transformations; --#endif -- -- png_debug(1, "in png_do_read_interlace (pnggccrd.c)\n"); -- --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) -- if (_mmx_supported == 2) { --#if !defined(PNG_1_0_X) -- /* this should have happened in png_init_mmx_flags() already */ -- png_warning(png_ptr, "asm_flags may not have been initialized"); --#endif -- png_mmx_support(); -- } --#endif -- -- if (row != NULL && row_info != NULL) -- { -- png_uint_32 final_width; -- -- final_width = row_info->width * png_pass_inc[pass]; -- -- switch (row_info->pixel_depth) -- { -- case 1: -- { -- png_bytep sp, dp; -- int sshift, dshift; -- int s_start, s_end, s_inc; -- png_byte v; -- png_uint_32 i; -- int j; -- -- sp = row + (png_size_t)((row_info->width - 1) >> 3); -- dp = row + (png_size_t)((final_width - 1) >> 3); --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (transformations & PNG_PACKSWAP) -- { -- sshift = (int)((row_info->width + 7) & 7); -- dshift = (int)((final_width + 7) & 7); -- s_start = 7; -- s_end = 0; -- s_inc = -1; -- } -- else --#endif -- { -- sshift = 7 - (int)((row_info->width + 7) & 7); -- dshift = 7 - (int)((final_width + 7) & 7); -- s_start = 0; -- s_end = 7; -- s_inc = 1; -- } -- -- for (i = row_info->width; i; i--) -- { -- v = (png_byte)((*sp >> sshift) & 0x1); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff); -- *dp |= (png_byte)(v << dshift); -- if (dshift == s_end) -- { -- dshift = s_start; -- dp--; -- } -- else -- dshift += s_inc; -- } -- if (sshift == s_end) -- { -- sshift = s_start; -- sp--; -- } -- else -- sshift += s_inc; -- } -- break; -- } -- -- case 2: -- { -- png_bytep sp, dp; -- int sshift, dshift; -- int s_start, s_end, s_inc; -- png_uint_32 i; -- -- sp = row + (png_size_t)((row_info->width - 1) >> 2); -- dp = row + (png_size_t)((final_width - 1) >> 2); --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (transformations & PNG_PACKSWAP) -- { -- sshift = (png_size_t)(((row_info->width + 3) & 3) << 1); -- dshift = (png_size_t)(((final_width + 3) & 3) << 1); -- s_start = 6; -- s_end = 0; -- s_inc = -2; -- } -- else --#endif -- { -- sshift = (png_size_t)((3 - ((row_info->width + 3) & 3)) << 1); -- dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1); -- s_start = 0; -- s_end = 6; -- s_inc = 2; -- } -- -- for (i = row_info->width; i; i--) -- { -- png_byte v; -- int j; -- -- v = (png_byte)((*sp >> sshift) & 0x3); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff); -- *dp |= (png_byte)(v << dshift); -- if (dshift == s_end) -- { -- dshift = s_start; -- dp--; -- } -- else -- dshift += s_inc; -- } -- if (sshift == s_end) -- { -- sshift = s_start; -- sp--; -- } -- else -- sshift += s_inc; -- } -- break; -- } -- -- case 4: -- { -- png_bytep sp, dp; -- int sshift, dshift; -- int s_start, s_end, s_inc; -- png_uint_32 i; -- -- sp = row + (png_size_t)((row_info->width - 1) >> 1); -- dp = row + (png_size_t)((final_width - 1) >> 1); --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (transformations & PNG_PACKSWAP) -- { -- sshift = (png_size_t)(((row_info->width + 1) & 1) << 2); -- dshift = (png_size_t)(((final_width + 1) & 1) << 2); -- s_start = 4; -- s_end = 0; -- s_inc = -4; -- } -- else --#endif -- { -- sshift = (png_size_t)((1 - ((row_info->width + 1) & 1)) << 2); -- dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2); -- s_start = 0; -- s_end = 4; -- s_inc = 4; -- } -- -- for (i = row_info->width; i; i--) -- { -- png_byte v; -- int j; -- -- v = (png_byte)((*sp >> sshift) & 0xf); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff); -- *dp |= (png_byte)(v << dshift); -- if (dshift == s_end) -- { -- dshift = s_start; -- dp--; -- } -- else -- dshift += s_inc; -- } -- if (sshift == s_end) -- { -- sshift = s_start; -- sp--; -- } -- else -- sshift += s_inc; -- } -- break; -- } -- -- /*====================================================================*/ -- -- default: /* 8-bit or larger (this is where the routine is modified) */ -- { --#if 0 --// static unsigned long long _const4 = 0x0000000000FFFFFFLL; no good --// static unsigned long long const4 = 0x0000000000FFFFFFLL; no good --// unsigned long long _const4 = 0x0000000000FFFFFFLL; no good --// unsigned long long const4 = 0x0000000000FFFFFFLL; no good --#endif -- png_bytep sptr, dp; -- png_uint_32 i; -- png_size_t pixel_bytes; -- int width = (int)row_info->width; -- -- pixel_bytes = (row_info->pixel_depth >> 3); -- -- /* point sptr at the last pixel in the pre-expanded row: */ -- sptr = row + (width - 1) * pixel_bytes; -- -- /* point dp at the last pixel position in the expanded row: */ -- dp = row + (final_width - 1) * pixel_bytes; -- -- /* New code by Nirav Chhatrapati - Intel Corporation */ -- --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE) -- /* && _mmx_supported */ ) --#else -- if (_mmx_supported) --#endif -- { -- //-------------------------------------------------------------- -- if (pixel_bytes == 3) -- { -- if (((pass == 0) || (pass == 1)) && width) -- { -- int dummy_value_c; // fix 'forbidden register spilled' -- int dummy_value_S; -- int dummy_value_D; -- -- __asm__ __volatile__ ( -- "subl $21, %%edi \n\t" -- // (png_pass_inc[pass] - 1)*pixel_bytes -- -- ".loop3_pass0: \n\t" -- "movd (%%esi), %%mm0 \n\t" // x x x x x 2 1 0 -- "pand _const4, %%mm0 \n\t" // z z z z z 2 1 0 -- "movq %%mm0, %%mm1 \n\t" // z z z z z 2 1 0 -- "psllq $16, %%mm0 \n\t" // z z z 2 1 0 z z -- "movq %%mm0, %%mm2 \n\t" // z z z 2 1 0 z z -- "psllq $24, %%mm0 \n\t" // 2 1 0 z z z z z -- "psrlq $8, %%mm1 \n\t" // z z z z z z 2 1 -- "por %%mm2, %%mm0 \n\t" // 2 1 0 2 1 0 z z -- "por %%mm1, %%mm0 \n\t" // 2 1 0 2 1 0 2 1 -- "movq %%mm0, %%mm3 \n\t" // 2 1 0 2 1 0 2 1 -- "psllq $16, %%mm0 \n\t" // 0 2 1 0 2 1 z z -- "movq %%mm3, %%mm4 \n\t" // 2 1 0 2 1 0 2 1 -- "punpckhdq %%mm0, %%mm3 \n\t" // 0 2 1 0 2 1 0 2 -- "movq %%mm4, 16(%%edi) \n\t" -- "psrlq $32, %%mm0 \n\t" // z z z z 0 2 1 0 -- "movq %%mm3, 8(%%edi) \n\t" -- "punpckldq %%mm4, %%mm0 \n\t" // 1 0 2 1 0 2 1 0 -- "subl $3, %%esi \n\t" -- "movq %%mm0, (%%edi) \n\t" -- "subl $24, %%edi \n\t" -- "decl %%ecx \n\t" -- "jnz .loop3_pass0 \n\t" -- "EMMS \n\t" // DONE -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "1" (sptr), // esi // input regs -- "2" (dp), // edi -- "0" (width), // ecx -- "rim" (_const4) // %1(?) (0x0000000000FFFFFFLL) -- --#if 0 /* %mm0, ..., %mm4 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm1", "%mm2" // clobber list -- , "%mm3", "%mm4" --#endif -- ); -- } -- else if (((pass == 2) || (pass == 3)) && width) -- { -- int dummy_value_c; // fix 'forbidden register spilled' -- int dummy_value_S; -- int dummy_value_D; -- -- __asm__ __volatile__ ( -- "subl $9, %%edi \n\t" -- // (png_pass_inc[pass] - 1)*pixel_bytes -- -- ".loop3_pass2: \n\t" -- "movd (%%esi), %%mm0 \n\t" // x x x x x 2 1 0 -- "pand _const4, %%mm0 \n\t" // z z z z z 2 1 0 -- "movq %%mm0, %%mm1 \n\t" // z z z z z 2 1 0 -- "psllq $16, %%mm0 \n\t" // z z z 2 1 0 z z -- "movq %%mm0, %%mm2 \n\t" // z z z 2 1 0 z z -- "psllq $24, %%mm0 \n\t" // 2 1 0 z z z z z -- "psrlq $8, %%mm1 \n\t" // z z z z z z 2 1 -- "por %%mm2, %%mm0 \n\t" // 2 1 0 2 1 0 z z -- "por %%mm1, %%mm0 \n\t" // 2 1 0 2 1 0 2 1 -- "movq %%mm0, 4(%%edi) \n\t" -- "psrlq $16, %%mm0 \n\t" // z z 2 1 0 2 1 0 -- "subl $3, %%esi \n\t" -- "movd %%mm0, (%%edi) \n\t" -- "subl $12, %%edi \n\t" -- "decl %%ecx \n\t" -- "jnz .loop3_pass2 \n\t" -- "EMMS \n\t" // DONE -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "1" (sptr), // esi // input regs -- "2" (dp), // edi -- "0" (width), // ecx -- "rim" (_const4) // (0x0000000000FFFFFFLL) -- --#if 0 /* %mm0, ..., %mm2 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm1", "%mm2" // clobber list --#endif -- ); -- } -- else if (width) /* && ((pass == 4) || (pass == 5)) */ -- { -- int width_mmx = ((width >> 1) << 1) - 8; // GRR: huh? -- if (width_mmx < 0) -- width_mmx = 0; -- width -= width_mmx; // 8 or 9 pix, 24 or 27 bytes -- if (width_mmx) -- { -- // png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; -- // sptr points at last pixel in pre-expanded row -- // dp points at last pixel position in expanded row -- int dummy_value_c; // fix 'forbidden register spilled' -- int dummy_value_S; -- int dummy_value_D; -- -- __asm__ __volatile__ ( -- "subl $3, %%esi \n\t" -- "subl $9, %%edi \n\t" -- // (png_pass_inc[pass] + 1)*pixel_bytes -- -- ".loop3_pass4: \n\t" -- "movq (%%esi), %%mm0 \n\t" // x x 5 4 3 2 1 0 -- "movq %%mm0, %%mm1 \n\t" // x x 5 4 3 2 1 0 -- "movq %%mm0, %%mm2 \n\t" // x x 5 4 3 2 1 0 -- "psllq $24, %%mm0 \n\t" // 4 3 2 1 0 z z z -- "pand _const4, %%mm1 \n\t" // z z z z z 2 1 0 -- "psrlq $24, %%mm2 \n\t" // z z z x x 5 4 3 -- "por %%mm1, %%mm0 \n\t" // 4 3 2 1 0 2 1 0 -- "movq %%mm2, %%mm3 \n\t" // z z z x x 5 4 3 -- "psllq $8, %%mm2 \n\t" // z z x x 5 4 3 z -- "movq %%mm0, (%%edi) \n\t" -- "psrlq $16, %%mm3 \n\t" // z z z z z x x 5 -- "pand _const6, %%mm3 \n\t" // z z z z z z z 5 -- "por %%mm3, %%mm2 \n\t" // z z x x 5 4 3 5 -- "subl $6, %%esi \n\t" -- "movd %%mm2, 8(%%edi) \n\t" -- "subl $12, %%edi \n\t" -- "subl $2, %%ecx \n\t" -- "jnz .loop3_pass4 \n\t" -- "EMMS \n\t" // DONE -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "1" (sptr), // esi // input regs -- "2" (dp), // edi -- "0" (width_mmx), // ecx -- "rim" (_const4), // 0x0000000000FFFFFFLL -- "rim" (_const6) // 0x00000000000000FFLL -- --#if 0 /* %mm0, ..., %mm3 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm1" // clobber list -- , "%mm2", "%mm3" --#endif -- ); -- } -- -- sptr -= width_mmx*3; -- dp -= width_mmx*6; -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- -- png_memcpy(v, sptr, 3); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, 3); -- dp -= 3; -- } -- sptr -= 3; -- } -- } -- } /* end of pixel_bytes == 3 */ -- -- //-------------------------------------------------------------- -- else if (pixel_bytes == 1) -- { -- if (((pass == 0) || (pass == 1)) && width) -- { -- int width_mmx = ((width >> 2) << 2); -- width -= width_mmx; // 0-3 pixels => 0-3 bytes -- if (width_mmx) -- { -- int dummy_value_c; // fix 'forbidden register spilled' -- int dummy_value_S; -- int dummy_value_D; -- -- __asm__ __volatile__ ( -- "subl $3, %%esi \n\t" -- "subl $31, %%edi \n\t" -- -- ".loop1_pass0: \n\t" -- "movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 -- "movq %%mm0, %%mm1 \n\t" // x x x x 3 2 1 0 -- "punpcklbw %%mm0, %%mm0 \n\t" // 3 3 2 2 1 1 0 0 -- "movq %%mm0, %%mm2 \n\t" // 3 3 2 2 1 1 0 0 -- "punpcklwd %%mm0, %%mm0 \n\t" // 1 1 1 1 0 0 0 0 -- "movq %%mm0, %%mm3 \n\t" // 1 1 1 1 0 0 0 0 -- "punpckldq %%mm0, %%mm0 \n\t" // 0 0 0 0 0 0 0 0 -- "punpckhdq %%mm3, %%mm3 \n\t" // 1 1 1 1 1 1 1 1 -- "movq %%mm0, (%%edi) \n\t" -- "punpckhwd %%mm2, %%mm2 \n\t" // 3 3 3 3 2 2 2 2 -- "movq %%mm3, 8(%%edi) \n\t" -- "movq %%mm2, %%mm4 \n\t" // 3 3 3 3 2 2 2 2 -- "punpckldq %%mm2, %%mm2 \n\t" // 2 2 2 2 2 2 2 2 -- "punpckhdq %%mm4, %%mm4 \n\t" // 3 3 3 3 3 3 3 3 -- "movq %%mm2, 16(%%edi) \n\t" -- "subl $4, %%esi \n\t" -- "movq %%mm4, 24(%%edi) \n\t" -- "subl $32, %%edi \n\t" -- "subl $4, %%ecx \n\t" -- "jnz .loop1_pass0 \n\t" -- "EMMS \n\t" // DONE -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "1" (sptr), // esi // input regs -- "2" (dp), // edi -- "0" (width_mmx) // ecx -- --#if 0 /* %mm0, ..., %mm4 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm1", "%mm2" // clobber list -- , "%mm3", "%mm4" --#endif -- ); -- } -- -- sptr -= width_mmx; -- dp -= width_mmx*8; -- for (i = width; i; i--) -- { -- int j; -- -- /* I simplified this part in version 1.0.4e -- * here and in several other instances where -- * pixel_bytes == 1 -- GR-P -- * -- * Original code: -- * -- * png_byte v[8]; -- * png_memcpy(v, sptr, pixel_bytes); -- * for (j = 0; j < png_pass_inc[pass]; j++) -- * { -- * png_memcpy(dp, v, pixel_bytes); -- * dp -= pixel_bytes; -- * } -- * sptr -= pixel_bytes; -- * -- * Replacement code is in the next three lines: -- */ -- -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- *dp-- = *sptr; -- } -- --sptr; -- } -- } -- else if (((pass == 2) || (pass == 3)) && width) -- { -- int width_mmx = ((width >> 2) << 2); -- width -= width_mmx; // 0-3 pixels => 0-3 bytes -- if (width_mmx) -- { -- int dummy_value_c; // fix 'forbidden register spilled' -- int dummy_value_S; -- int dummy_value_D; -- -- __asm__ __volatile__ ( -- "subl $3, %%esi \n\t" -- "subl $15, %%edi \n\t" -- -- ".loop1_pass2: \n\t" -- "movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 -- "punpcklbw %%mm0, %%mm0 \n\t" // 3 3 2 2 1 1 0 0 -- "movq %%mm0, %%mm1 \n\t" // 3 3 2 2 1 1 0 0 -- "punpcklwd %%mm0, %%mm0 \n\t" // 1 1 1 1 0 0 0 0 -- "punpckhwd %%mm1, %%mm1 \n\t" // 3 3 3 3 2 2 2 2 -- "movq %%mm0, (%%edi) \n\t" -- "subl $4, %%esi \n\t" -- "movq %%mm1, 8(%%edi) \n\t" -- "subl $16, %%edi \n\t" -- "subl $4, %%ecx \n\t" -- "jnz .loop1_pass2 \n\t" -- "EMMS \n\t" // DONE -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "1" (sptr), // esi // input regs -- "2" (dp), // edi -- "0" (width_mmx) // ecx -- --#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm1" // clobber list --#endif -- ); -- } -- -- sptr -= width_mmx; -- dp -= width_mmx*4; -- for (i = width; i; i--) -- { -- int j; -- -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- *dp-- = *sptr; -- } -- --sptr; -- } -- } -- else if (width) /* && ((pass == 4) || (pass == 5)) */ -- { -- int width_mmx = ((width >> 3) << 3); -- width -= width_mmx; // 0-3 pixels => 0-3 bytes -- if (width_mmx) -- { -- int dummy_value_c; // fix 'forbidden register spilled' -- int dummy_value_S; -- int dummy_value_D; -- -- __asm__ __volatile__ ( -- "subl $7, %%esi \n\t" -- "subl $15, %%edi \n\t" -- -- ".loop1_pass4: \n\t" -- "movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 -- "movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 -- "punpcklbw %%mm0, %%mm0 \n\t" // 3 3 2 2 1 1 0 0 -- "punpckhbw %%mm1, %%mm1 \n\t" // 7 7 6 6 5 5 4 4 -- "movq %%mm1, 8(%%edi) \n\t" -- "subl $8, %%esi \n\t" -- "movq %%mm0, (%%edi) \n\t" -- "subl $16, %%edi \n\t" -- "subl $8, %%ecx \n\t" -- "jnz .loop1_pass4 \n\t" -- "EMMS \n\t" // DONE -- -- : "=c" (dummy_value_c), // output regs (none) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "1" (sptr), // esi // input regs -- "2" (dp), // edi -- "0" (width_mmx) // ecx -- --#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm1" // clobber list --#endif -- ); -- } -- -- sptr -= width_mmx; -- dp -= width_mmx*2; -- for (i = width; i; i--) -- { -- int j; -- -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- *dp-- = *sptr; -- } -- --sptr; -- } -- } -- } /* end of pixel_bytes == 1 */ -- -- //-------------------------------------------------------------- -- else if (pixel_bytes == 2) -- { -- if (((pass == 0) || (pass == 1)) && width) -- { -- int width_mmx = ((width >> 1) << 1); -- width -= width_mmx; // 0,1 pixels => 0,2 bytes -- if (width_mmx) -- { -- int dummy_value_c; // fix 'forbidden register spilled' -- int dummy_value_S; -- int dummy_value_D; -- -- __asm__ __volatile__ ( -- "subl $2, %%esi \n\t" -- "subl $30, %%edi \n\t" -- -- ".loop2_pass0: \n\t" -- "movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 -- "punpcklwd %%mm0, %%mm0 \n\t" // 3 2 3 2 1 0 1 0 -- "movq %%mm0, %%mm1 \n\t" // 3 2 3 2 1 0 1 0 -- "punpckldq %%mm0, %%mm0 \n\t" // 1 0 1 0 1 0 1 0 -- "punpckhdq %%mm1, %%mm1 \n\t" // 3 2 3 2 3 2 3 2 -- "movq %%mm0, (%%edi) \n\t" -- "movq %%mm0, 8(%%edi) \n\t" -- "movq %%mm1, 16(%%edi) \n\t" -- "subl $4, %%esi \n\t" -- "movq %%mm1, 24(%%edi) \n\t" -- "subl $32, %%edi \n\t" -- "subl $2, %%ecx \n\t" -- "jnz .loop2_pass0 \n\t" -- "EMMS \n\t" // DONE -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "1" (sptr), // esi // input regs -- "2" (dp), // edi -- "0" (width_mmx) // ecx -- --#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm1" // clobber list --#endif -- ); -- } -- -- sptr -= (width_mmx*2 - 2); // sign fixed -- dp -= (width_mmx*16 - 2); // sign fixed -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- sptr -= 2; -- png_memcpy(v, sptr, 2); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- dp -= 2; -- png_memcpy(dp, v, 2); -- } -- } -- } -- else if (((pass == 2) || (pass == 3)) && width) -- { -- int width_mmx = ((width >> 1) << 1) ; -- width -= width_mmx; // 0,1 pixels => 0,2 bytes -- if (width_mmx) -- { -- int dummy_value_c; // fix 'forbidden register spilled' -- int dummy_value_S; -- int dummy_value_D; -- -- __asm__ __volatile__ ( -- "subl $2, %%esi \n\t" -- "subl $14, %%edi \n\t" -- -- ".loop2_pass2: \n\t" -- "movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 -- "punpcklwd %%mm0, %%mm0 \n\t" // 3 2 3 2 1 0 1 0 -- "movq %%mm0, %%mm1 \n\t" // 3 2 3 2 1 0 1 0 -- "punpckldq %%mm0, %%mm0 \n\t" // 1 0 1 0 1 0 1 0 -- "punpckhdq %%mm1, %%mm1 \n\t" // 3 2 3 2 3 2 3 2 -- "movq %%mm0, (%%edi) \n\t" -- "subl $4, %%esi \n\t" -- "movq %%mm1, 8(%%edi) \n\t" -- "subl $16, %%edi \n\t" -- "subl $2, %%ecx \n\t" -- "jnz .loop2_pass2 \n\t" -- "EMMS \n\t" // DONE -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "1" (sptr), // esi // input regs -- "2" (dp), // edi -- "0" (width_mmx) // ecx -- --#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm1" // clobber list --#endif -- ); -- } -- -- sptr -= (width_mmx*2 - 2); // sign fixed -- dp -= (width_mmx*8 - 2); // sign fixed -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- sptr -= 2; -- png_memcpy(v, sptr, 2); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- dp -= 2; -- png_memcpy(dp, v, 2); -- } -- } -- } -- else if (width) // pass == 4 or 5 -- { -- int width_mmx = ((width >> 1) << 1) ; -- width -= width_mmx; // 0,1 pixels => 0,2 bytes -- if (width_mmx) -- { -- int dummy_value_c; // fix 'forbidden register spilled' -- int dummy_value_S; -- int dummy_value_D; -- -- __asm__ __volatile__ ( -- "subl $2, %%esi \n\t" -- "subl $6, %%edi \n\t" -- -- ".loop2_pass4: \n\t" -- "movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 -- "punpcklwd %%mm0, %%mm0 \n\t" // 3 2 3 2 1 0 1 0 -- "subl $4, %%esi \n\t" -- "movq %%mm0, (%%edi) \n\t" -- "subl $8, %%edi \n\t" -- "subl $2, %%ecx \n\t" -- "jnz .loop2_pass4 \n\t" -- "EMMS \n\t" // DONE -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "1" (sptr), // esi // input regs -- "2" (dp), // edi -- "0" (width_mmx) // ecx -- --#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0" // clobber list --#endif -- ); -- } -- -- sptr -= (width_mmx*2 - 2); // sign fixed -- dp -= (width_mmx*4 - 2); // sign fixed -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- sptr -= 2; -- png_memcpy(v, sptr, 2); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- dp -= 2; -- png_memcpy(dp, v, 2); -- } -- } -- } -- } /* end of pixel_bytes == 2 */ -- -- //-------------------------------------------------------------- -- else if (pixel_bytes == 4) -- { -- if (((pass == 0) || (pass == 1)) && width) -- { -- int width_mmx = ((width >> 1) << 1); -- width -= width_mmx; // 0,1 pixels => 0,4 bytes -- if (width_mmx) -- { -- int dummy_value_c; // fix 'forbidden register spilled' -- int dummy_value_S; -- int dummy_value_D; -- -- __asm__ __volatile__ ( -- "subl $4, %%esi \n\t" -- "subl $60, %%edi \n\t" -- -- ".loop4_pass0: \n\t" -- "movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 -- "movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 -- "punpckldq %%mm0, %%mm0 \n\t" // 3 2 1 0 3 2 1 0 -- "punpckhdq %%mm1, %%mm1 \n\t" // 7 6 5 4 7 6 5 4 -- "movq %%mm0, (%%edi) \n\t" -- "movq %%mm0, 8(%%edi) \n\t" -- "movq %%mm0, 16(%%edi) \n\t" -- "movq %%mm0, 24(%%edi) \n\t" -- "movq %%mm1, 32(%%edi) \n\t" -- "movq %%mm1, 40(%%edi) \n\t" -- "movq %%mm1, 48(%%edi) \n\t" -- "subl $8, %%esi \n\t" -- "movq %%mm1, 56(%%edi) \n\t" -- "subl $64, %%edi \n\t" -- "subl $2, %%ecx \n\t" -- "jnz .loop4_pass0 \n\t" -- "EMMS \n\t" // DONE -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "1" (sptr), // esi // input regs -- "2" (dp), // edi -- "0" (width_mmx) // ecx -- --#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm1" // clobber list --#endif -- ); -- } -- -- sptr -= (width_mmx*4 - 4); // sign fixed -- dp -= (width_mmx*32 - 4); // sign fixed -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- sptr -= 4; -- png_memcpy(v, sptr, 4); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- dp -= 4; -- png_memcpy(dp, v, 4); -- } -- } -- } -- else if (((pass == 2) || (pass == 3)) && width) -- { -- int width_mmx = ((width >> 1) << 1); -- width -= width_mmx; // 0,1 pixels => 0,4 bytes -- if (width_mmx) -- { -- int dummy_value_c; // fix 'forbidden register spilled' -- int dummy_value_S; -- int dummy_value_D; -- -- __asm__ __volatile__ ( -- "subl $4, %%esi \n\t" -- "subl $28, %%edi \n\t" -- -- ".loop4_pass2: \n\t" -- "movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 -- "movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 -- "punpckldq %%mm0, %%mm0 \n\t" // 3 2 1 0 3 2 1 0 -- "punpckhdq %%mm1, %%mm1 \n\t" // 7 6 5 4 7 6 5 4 -- "movq %%mm0, (%%edi) \n\t" -- "movq %%mm0, 8(%%edi) \n\t" -- "movq %%mm1, 16(%%edi) \n\t" -- "movq %%mm1, 24(%%edi) \n\t" -- "subl $8, %%esi \n\t" -- "subl $32, %%edi \n\t" -- "subl $2, %%ecx \n\t" -- "jnz .loop4_pass2 \n\t" -- "EMMS \n\t" // DONE -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "1" (sptr), // esi // input regs -- "2" (dp), // edi -- "0" (width_mmx) // ecx -- --#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm1" // clobber list --#endif -- ); -- } -- -- sptr -= (width_mmx*4 - 4); // sign fixed -- dp -= (width_mmx*16 - 4); // sign fixed -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- sptr -= 4; -- png_memcpy(v, sptr, 4); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- dp -= 4; -- png_memcpy(dp, v, 4); -- } -- } -- } -- else if (width) // pass == 4 or 5 -- { -- int width_mmx = ((width >> 1) << 1) ; -- width -= width_mmx; // 0,1 pixels => 0,4 bytes -- if (width_mmx) -- { -- int dummy_value_c; // fix 'forbidden register spilled' -- int dummy_value_S; -- int dummy_value_D; -- -- __asm__ __volatile__ ( -- "subl $4, %%esi \n\t" -- "subl $12, %%edi \n\t" -- -- ".loop4_pass4: \n\t" -- "movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 -- "movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 -- "punpckldq %%mm0, %%mm0 \n\t" // 3 2 1 0 3 2 1 0 -- "punpckhdq %%mm1, %%mm1 \n\t" // 7 6 5 4 7 6 5 4 -- "movq %%mm0, (%%edi) \n\t" -- "subl $8, %%esi \n\t" -- "movq %%mm1, 8(%%edi) \n\t" -- "subl $16, %%edi \n\t" -- "subl $2, %%ecx \n\t" -- "jnz .loop4_pass4 \n\t" -- "EMMS \n\t" // DONE -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "1" (sptr), // esi // input regs -- "2" (dp), // edi -- "0" (width_mmx) // ecx -- --#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0", "%mm1" // clobber list --#endif -- ); -- } -- -- sptr -= (width_mmx*4 - 4); // sign fixed -- dp -= (width_mmx*8 - 4); // sign fixed -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- sptr -= 4; -- png_memcpy(v, sptr, 4); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- dp -= 4; -- png_memcpy(dp, v, 4); -- } -- } -- } -- } /* end of pixel_bytes == 4 */ -- -- //-------------------------------------------------------------- -- else if (pixel_bytes == 8) -- { --// GRR TEST: should work, but needs testing (special 64-bit version of rpng2?) -- // GRR NOTE: no need to combine passes here! -- if (((pass == 0) || (pass == 1)) && width) -- { -- int dummy_value_c; // fix 'forbidden register spilled' -- int dummy_value_S; -- int dummy_value_D; -- -- // source is 8-byte RRGGBBAA -- // dest is 64-byte RRGGBBAA RRGGBBAA RRGGBBAA RRGGBBAA ... -- __asm__ __volatile__ ( -- "subl $56, %%edi \n\t" // start of last block -- -- ".loop8_pass0: \n\t" -- "movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 -- "movq %%mm0, (%%edi) \n\t" -- "movq %%mm0, 8(%%edi) \n\t" -- "movq %%mm0, 16(%%edi) \n\t" -- "movq %%mm0, 24(%%edi) \n\t" -- "movq %%mm0, 32(%%edi) \n\t" -- "movq %%mm0, 40(%%edi) \n\t" -- "movq %%mm0, 48(%%edi) \n\t" -- "subl $8, %%esi \n\t" -- "movq %%mm0, 56(%%edi) \n\t" -- "subl $64, %%edi \n\t" -- "decl %%ecx \n\t" -- "jnz .loop8_pass0 \n\t" -- "EMMS \n\t" // DONE -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "1" (sptr), // esi // input regs -- "2" (dp), // edi -- "0" (width) // ecx -- --#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0" // clobber list --#endif -- ); -- } -- else if (((pass == 2) || (pass == 3)) && width) -- { -- // source is 8-byte RRGGBBAA -- // dest is 32-byte RRGGBBAA RRGGBBAA RRGGBBAA RRGGBBAA -- // (recall that expansion is _in place_: sptr and dp -- // both point at locations within same row buffer) -- { -- int dummy_value_c; // fix 'forbidden register spilled' -- int dummy_value_S; -- int dummy_value_D; -- -- __asm__ __volatile__ ( -- "subl $24, %%edi \n\t" // start of last block -- -- ".loop8_pass2: \n\t" -- "movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 -- "movq %%mm0, (%%edi) \n\t" -- "movq %%mm0, 8(%%edi) \n\t" -- "movq %%mm0, 16(%%edi) \n\t" -- "subl $8, %%esi \n\t" -- "movq %%mm0, 24(%%edi) \n\t" -- "subl $32, %%edi \n\t" -- "decl %%ecx \n\t" -- "jnz .loop8_pass2 \n\t" -- "EMMS \n\t" // DONE -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "1" (sptr), // esi // input regs -- "2" (dp), // edi -- "0" (width) // ecx -- --#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0" // clobber list --#endif -- ); -- } -- } -- else if (width) // pass == 4 or 5 -- { -- // source is 8-byte RRGGBBAA -- // dest is 16-byte RRGGBBAA RRGGBBAA -- { -- int dummy_value_c; // fix 'forbidden register spilled' -- int dummy_value_S; -- int dummy_value_D; -- -- __asm__ __volatile__ ( -- "subl $8, %%edi \n\t" // start of last block -- -- ".loop8_pass4: \n\t" -- "movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 -- "movq %%mm0, (%%edi) \n\t" -- "subl $8, %%esi \n\t" -- "movq %%mm0, 8(%%edi) \n\t" -- "subl $16, %%edi \n\t" -- "decl %%ecx \n\t" -- "jnz .loop8_pass4 \n\t" -- "EMMS \n\t" // DONE -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "1" (sptr), // esi // input regs -- "2" (dp), // edi -- "0" (width) // ecx -- --#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- : "%mm0" // clobber list --#endif -- ); -- } -- } -- -- } /* end of pixel_bytes == 8 */ -- -- //-------------------------------------------------------------- -- else if (pixel_bytes == 6) -- { -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- png_memcpy(v, sptr, 6); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, 6); -- dp -= 6; -- } -- sptr -= 6; -- } -- } /* end of pixel_bytes == 6 */ -- -- //-------------------------------------------------------------- -- else -- { -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- png_memcpy(v, sptr, pixel_bytes); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, pixel_bytes); -- dp -= pixel_bytes; -- } -- sptr-= pixel_bytes; -- } -- } -- } // end of _mmx_supported ======================================== -- -- else /* MMX not supported: use modified C code - takes advantage -- * of inlining of png_memcpy for a constant */ -- /* GRR 19991007: does it? or should pixel_bytes in each -- * block be replaced with immediate value (e.g., 1)? */ -- /* GRR 19991017: replaced with constants in each case */ --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ -- { -- if (pixel_bytes == 1) -- { -- for (i = width; i; i--) -- { -- int j; -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- *dp-- = *sptr; -- } -- --sptr; -- } -- } -- else if (pixel_bytes == 3) -- { -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- png_memcpy(v, sptr, 3); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, 3); -- dp -= 3; -- } -- sptr -= 3; -- } -- } -- else if (pixel_bytes == 2) -- { -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- png_memcpy(v, sptr, 2); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, 2); -- dp -= 2; -- } -- sptr -= 2; -- } -- } -- else if (pixel_bytes == 4) -- { -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- png_memcpy(v, sptr, 4); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { --#ifdef PNG_DEBUG -- if (dp < row || dp+3 > row+png_ptr->row_buf_size) -- { -- printf("dp out of bounds: row=%d, dp=%d, rp=%d\n", -- row, dp, row+png_ptr->row_buf_size); -- printf("row_buf=%d\n",png_ptr->row_buf_size); -- } --#endif -- png_memcpy(dp, v, 4); -- dp -= 4; -- } -- sptr -= 4; -- } -- } -- else if (pixel_bytes == 6) -- { -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- png_memcpy(v, sptr, 6); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, 6); -- dp -= 6; -- } -- sptr -= 6; -- } -- } -- else if (pixel_bytes == 8) -- { -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- png_memcpy(v, sptr, 8); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, 8); -- dp -= 8; -- } -- sptr -= 8; -- } -- } -- else /* GRR: should never be reached */ -- { -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- png_memcpy(v, sptr, pixel_bytes); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, pixel_bytes); -- dp -= pixel_bytes; -- } -- sptr -= pixel_bytes; -- } -- } -- -- } /* end if (MMX not supported) */ -- break; -- } -- } /* end switch (row_info->pixel_depth) */ -- -- row_info->width = final_width; -- -- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,final_width); -- } -- --} /* end png_do_read_interlace() */ -- --#endif /* PNG_HAVE_ASSEMBLER_READ_INTERLACE */ --#endif /* PNG_READ_INTERLACING_SUPPORTED */ -- -- -- --#if defined(PNG_HAVE_ASSEMBLER_READ_FILTER_ROW) --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) -- --// These variables are utilized in the functions below. They are declared --// globally here to ensure alignment on 8-byte boundaries. -- --union uAll { -- long long use; -- double align; --} _LBCarryMask = {0x0101010101010101LL}, -- _HBClearMask = {0x7f7f7f7f7f7f7f7fLL}, -- _ActiveMask, _ActiveMask2, _ActiveMaskEnd, _ShiftBpp, _ShiftRem; -- --#ifdef PNG_THREAD_UNSAFE_OK --//===========================================================================// --// // --// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ A V G // --// // --//===========================================================================// -- --// Optimized code for PNG Average filter decoder -- --static void /* PRIVATE */ --png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row, -- png_bytep prev_row) --{ -- int bpp; -- int dummy_value_c; // fix 'forbidden register 2 (cx) was spilled' error -- int dummy_value_S; -- int dummy_value_D; -- -- bpp = (row_info->pixel_depth + 7) >> 3; // get # bytes per pixel -- _FullLength = row_info->rowbytes; // # of bytes to filter -- -- __asm__ __volatile__ ( -- // initialize address pointers and offset --#ifdef __PIC__ -- "pushl %%ebx \n\t" // save index to Global Offset Table --#endif --//pre "movl row, %%edi \n\t" // edi: Avg(x) -- "xorl %%ebx, %%ebx \n\t" // ebx: x -- "movl %%edi, %%edx \n\t" --//pre "movl prev_row, %%esi \n\t" // esi: Prior(x) --//pre "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) -- "subl %%ecx, %%edx \n\t" // edx: Raw(x-bpp) -- -- "xorl %%eax,%%eax \n\t" -- -- // Compute the Raw value for the first bpp bytes -- // Raw(x) = Avg(x) + (Prior(x)/2) -- "avg_rlp: \n\t" -- "movb (%%esi,%%ebx,),%%al \n\t" // load al with Prior(x) -- "incl %%ebx \n\t" -- "shrb %%al \n\t" // divide by 2 -- "addb -1(%%edi,%%ebx,),%%al \n\t" // add Avg(x); -1 to offset inc ebx --//pre "cmpl bpp, %%ebx \n\t" // (bpp is preloaded into ecx) -- "cmpl %%ecx, %%ebx \n\t" -- "movb %%al,-1(%%edi,%%ebx,) \n\t" // write Raw(x); -1 to offset inc ebx -- "jb avg_rlp \n\t" // mov does not affect flags -- -- // get # of bytes to alignment -- "movl %%edi, _dif \n\t" // take start of row -- "addl %%ebx, _dif \n\t" // add bpp -- "addl $0xf, _dif \n\t" // add 7+8 to incr past alignment bdry -- "andl $0xfffffff8, _dif \n\t" // mask to alignment boundary -- "subl %%edi, _dif \n\t" // subtract from start => value ebx at -- "jz avg_go \n\t" // alignment -- -- // fix alignment -- // Compute the Raw value for the bytes up to the alignment boundary -- // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) -- "xorl %%ecx, %%ecx \n\t" -- -- "avg_lp1: \n\t" -- "xorl %%eax, %%eax \n\t" -- "movb (%%esi,%%ebx,), %%cl \n\t" // load cl with Prior(x) -- "movb (%%edx,%%ebx,), %%al \n\t" // load al with Raw(x-bpp) -- "addw %%cx, %%ax \n\t" -- "incl %%ebx \n\t" -- "shrw %%ax \n\t" // divide by 2 -- "addb -1(%%edi,%%ebx,), %%al \n\t" // add Avg(x); -1 to offset inc ebx -- "cmpl _dif, %%ebx \n\t" // check if at alignment boundary -- "movb %%al, -1(%%edi,%%ebx,) \n\t" // write Raw(x); -1 to offset inc ebx -- "jb avg_lp1 \n\t" // repeat until at alignment boundary -- -- "avg_go: \n\t" -- "movl _FullLength, %%eax \n\t" -- "movl %%eax, %%ecx \n\t" -- "subl %%ebx, %%eax \n\t" // subtract alignment fix -- "andl $0x00000007, %%eax \n\t" // calc bytes over mult of 8 -- "subl %%eax, %%ecx \n\t" // drop over bytes from original length -- "movl %%ecx, _MMXLength \n\t" --#ifdef __PIC__ -- "popl %%ebx \n\t" // restore index to Global Offset Table --#endif -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "0" (bpp), // ecx // input regs -- "1" (prev_row), // esi -- "2" (row) // edi -- -- : "%eax", "%edx" // clobber list --#ifndef __PIC__ -- , "%ebx" --#endif -- // GRR: INCLUDE "memory" as clobbered? (_dif, _MMXLength) -- // (seems to work fine without...) -- ); -- -- // now do the math for the rest of the row -- switch (bpp) -- { -- case 3: -- { -- _ActiveMask.use = 0x0000000000ffffffLL; -- _ShiftBpp.use = 24; // == 3 * 8 -- _ShiftRem.use = 40; // == 64 - 24 -- -- __asm__ __volatile__ ( -- // re-init address pointers and offset -- "movq _ActiveMask, %%mm7 \n\t" -- "movl _dif, %%ecx \n\t" // ecx: x = offset to -- "movq _LBCarryMask, %%mm5 \n\t" // alignment boundary --// preload "movl row, %%edi \n\t" // edi: Avg(x) -- "movq _HBClearMask, %%mm4 \n\t" --// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) -- -- // prime the pump: load the first Raw(x-bpp) data set -- "movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes -- // (correct pos. in loop below) -- "avg_3lp: \n\t" -- "movq (%%edi,%%ecx,), %%mm0 \n\t" // load mm0 with Avg(x) -- "movq %%mm5, %%mm3 \n\t" -- "psrlq _ShiftRem, %%mm2 \n\t" // correct position Raw(x-bpp) -- // data -- "movq (%%esi,%%ecx,), %%mm1 \n\t" // load mm1 with Prior(x) -- "movq %%mm7, %%mm6 \n\t" -- "pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte -- "psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 -- "pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each -- // byte -- "paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for -- // each byte -- // add 1st active group (Raw(x-bpp)/2) to average with LBCarry -- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting -- // LBCarrys -- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte -- // where both -- // lsb's were == 1 (only valid for active group) -- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 -- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each -- // byte -- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) -- // for each byte -- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 1 -- // bytes to add to Avg -- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to -- // Avg for each Active -- // byte -- // add 2nd active group (Raw(x-bpp)/2) to average with _LBCarry -- "psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover -- // bytes 3-5 -- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 -- "psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly -- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting -- // LBCarrys -- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte -- // where both -- // lsb's were == 1 (only valid for active group) -- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 -- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each -- // byte -- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) -- // for each byte -- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 -- // bytes to add to Avg -- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to -- // Avg for each Active -- // byte -- -- // add 3rd active group (Raw(x-bpp)/2) to average with _LBCarry -- "psllq _ShiftBpp, %%mm6 \n\t" // shift mm6 mask to cover last -- // two -- // bytes -- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 -- "psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly -- // Data only needs to be shifted once here to -- // get the correct x-bpp offset. -- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting -- // LBCarrys -- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte -- // where both -- // lsb's were == 1 (only valid for active group) -- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 -- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each -- // byte -- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) -- // for each byte -- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 -- // bytes to add to Avg -- "addl $8, %%ecx \n\t" -- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to -- // Avg for each Active -- // byte -- // now ready to write back to memory -- "movq %%mm0, -8(%%edi,%%ecx,) \n\t" -- // move updated Raw(x) to use as Raw(x-bpp) for next loop -- "cmpl _MMXLength, %%ecx \n\t" -- "movq %%mm0, %%mm2 \n\t" // mov updated Raw(x) to mm2 -- "jb avg_3lp \n\t" -- -- : "=S" (dummy_value_S), // output regs (dummy) -- "=D" (dummy_value_D) -- -- : "0" (prev_row), // esi // input regs -- "1" (row) // edi -- -- : "%ecx" // clobber list --#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- , "%mm0", "%mm1", "%mm2", "%mm3" -- , "%mm4", "%mm5", "%mm6", "%mm7" --#endif -- ); -- } -- break; // end 3 bpp -- -- case 6: -- case 4: -- //case 7: // who wrote this? PNG doesn't support 5 or 7 bytes/pixel -- //case 5: // GRR BOGUS -- { -- _ActiveMask.use = 0xffffffffffffffffLL; // use shift below to clear -- // appropriate inactive bytes -- _ShiftBpp.use = bpp << 3; -- _ShiftRem.use = 64 - _ShiftBpp.use; -- -- __asm__ __volatile__ ( -- "movq _HBClearMask, %%mm4 \n\t" -- -- // re-init address pointers and offset -- "movl _dif, %%ecx \n\t" // ecx: x = offset to -- // alignment boundary -- -- // load _ActiveMask and clear all bytes except for 1st active group -- "movq _ActiveMask, %%mm7 \n\t" --// preload "movl row, %%edi \n\t" // edi: Avg(x) -- "psrlq _ShiftRem, %%mm7 \n\t" --// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) -- "movq %%mm7, %%mm6 \n\t" -- "movq _LBCarryMask, %%mm5 \n\t" -- "psllq _ShiftBpp, %%mm6 \n\t" // create mask for 2nd active -- // group -- -- // prime the pump: load the first Raw(x-bpp) data set -- "movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes -- // (we correct pos. in loop below) -- "avg_4lp: \n\t" -- "movq (%%edi,%%ecx,), %%mm0 \n\t" -- "psrlq _ShiftRem, %%mm2 \n\t" // shift data to pos. correctly -- "movq (%%esi,%%ecx,), %%mm1 \n\t" -- // add (Prev_row/2) to average -- "movq %%mm5, %%mm3 \n\t" -- "pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte -- "psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 -- "pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each -- // byte -- "paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for -- // each byte -- // add 1st active group (Raw(x-bpp)/2) to average with _LBCarry -- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting -- // LBCarrys -- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte -- // where both -- // lsb's were == 1 (only valid for active group) -- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 -- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each -- // byte -- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) -- // for each byte -- "pand %%mm7, %%mm2 \n\t" // leave only Active Group 1 -- // bytes to add to Avg -- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to Avg -- // for each Active -- // byte -- // add 2nd active group (Raw(x-bpp)/2) to average with _LBCarry -- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 -- "psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly -- "addl $8, %%ecx \n\t" -- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting -- // LBCarrys -- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte -- // where both -- // lsb's were == 1 (only valid for active group) -- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 -- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each -- // byte -- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) -- // for each byte -- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 -- // bytes to add to Avg -- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to -- // Avg for each Active -- // byte -- "cmpl _MMXLength, %%ecx \n\t" -- // now ready to write back to memory -- "movq %%mm0, -8(%%edi,%%ecx,) \n\t" -- // prep Raw(x-bpp) for next loop -- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 -- "jb avg_4lp \n\t" -- -- : "=S" (dummy_value_S), // output regs (dummy) -- "=D" (dummy_value_D) -- -- : "0" (prev_row), // esi // input regs -- "1" (row) // edi -- -- : "%ecx" // clobber list --#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- , "%mm0", "%mm1", "%mm2", "%mm3" -- , "%mm4", "%mm5", "%mm6", "%mm7" --#endif -- ); -- } -- break; // end 4,6 bpp -- -- case 2: -- { -- _ActiveMask.use = 0x000000000000ffffLL; -- _ShiftBpp.use = 16; // == 2 * 8 -- _ShiftRem.use = 48; // == 64 - 16 -- -- __asm__ __volatile__ ( -- // load _ActiveMask -- "movq _ActiveMask, %%mm7 \n\t" -- // re-init address pointers and offset -- "movl _dif, %%ecx \n\t" // ecx: x = offset to alignment -- // boundary -- "movq _LBCarryMask, %%mm5 \n\t" --// preload "movl row, %%edi \n\t" // edi: Avg(x) -- "movq _HBClearMask, %%mm4 \n\t" --// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) -- -- // prime the pump: load the first Raw(x-bpp) data set -- "movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes -- // (we correct pos. in loop below) -- "avg_2lp: \n\t" -- "movq (%%edi,%%ecx,), %%mm0 \n\t" -- "psrlq _ShiftRem, %%mm2 \n\t" // shift data to pos. correctly -- "movq (%%esi,%%ecx,), %%mm1 \n\t" // (GRR BUGFIX: was psllq) -- // add (Prev_row/2) to average -- "movq %%mm5, %%mm3 \n\t" -- "pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte -- "psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 -- "pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each -- // byte -- "movq %%mm7, %%mm6 \n\t" -- "paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for -- // each byte -- -- // add 1st active group (Raw(x-bpp)/2) to average with _LBCarry -- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting -- // LBCarrys -- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte -- // where both -- // lsb's were == 1 (only valid -- // for active group) -- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 -- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each -- // byte -- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) -- // for each byte -- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 1 -- // bytes to add to Avg -- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to Avg -- // for each Active byte -- -- // add 2nd active group (Raw(x-bpp)/2) to average with _LBCarry -- "psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover -- // bytes 2 & 3 -- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 -- "psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly -- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting -- // LBCarrys -- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte -- // where both -- // lsb's were == 1 (only valid -- // for active group) -- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 -- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each -- // byte -- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) -- // for each byte -- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 -- // bytes to add to Avg -- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to -- // Avg for each Active byte -- -- // add 3rd active group (Raw(x-bpp)/2) to average with _LBCarry -- "psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover -- // bytes 4 & 5 -- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 -- "psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly -- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting -- // LBCarrys -- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte -- // where both lsb's were == 1 -- // (only valid for active group) -- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 -- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each -- // byte -- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) -- // for each byte -- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 -- // bytes to add to Avg -- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to -- // Avg for each Active byte -- -- // add 4th active group (Raw(x-bpp)/2) to average with _LBCarry -- "psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover -- // bytes 6 & 7 -- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 -- "psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly -- "addl $8, %%ecx \n\t" -- "movq %%mm3, %%mm1 \n\t" // now use mm1 for getting -- // LBCarrys -- "pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte -- // where both -- // lsb's were == 1 (only valid -- // for active group) -- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 -- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each -- // byte -- "paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) -- // for each byte -- "pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 -- // bytes to add to Avg -- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to -- // Avg for each Active byte -- -- "cmpl _MMXLength, %%ecx \n\t" -- // now ready to write back to memory -- "movq %%mm0, -8(%%edi,%%ecx,) \n\t" -- // prep Raw(x-bpp) for next loop -- "movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 -- "jb avg_2lp \n\t" -- -- : "=S" (dummy_value_S), // output regs (dummy) -- "=D" (dummy_value_D) -- -- : "0" (prev_row), // esi // input regs -- "1" (row) // edi -- -- : "%ecx" // clobber list --#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- , "%mm0", "%mm1", "%mm2", "%mm3" -- , "%mm4", "%mm5", "%mm6", "%mm7" --#endif -- ); -- } -- break; // end 2 bpp -- -- case 1: -- { -- __asm__ __volatile__ ( -- // re-init address pointers and offset --#ifdef __PIC__ -- "pushl %%ebx \n\t" // save Global Offset Table index --#endif -- "movl _dif, %%ebx \n\t" // ebx: x = offset to alignment -- // boundary --// preload "movl row, %%edi \n\t" // edi: Avg(x) -- "cmpl _FullLength, %%ebx \n\t" // test if offset at end of array -- "jnb avg_1end \n\t" -- // do Paeth decode for remaining bytes --// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) -- "movl %%edi, %%edx \n\t" --// preload "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) -- "subl %%ecx, %%edx \n\t" // edx: Raw(x-bpp) -- "xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx -- // in loop below -- "avg_1lp: \n\t" -- // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) -- "xorl %%eax, %%eax \n\t" -- "movb (%%esi,%%ebx,), %%cl \n\t" // load cl with Prior(x) -- "movb (%%edx,%%ebx,), %%al \n\t" // load al with Raw(x-bpp) -- "addw %%cx, %%ax \n\t" -- "incl %%ebx \n\t" -- "shrw %%ax \n\t" // divide by 2 -- "addb -1(%%edi,%%ebx,), %%al \n\t" // add Avg(x); -1 to offset -- // inc ebx -- "cmpl _FullLength, %%ebx \n\t" // check if at end of array -- "movb %%al, -1(%%edi,%%ebx,) \n\t" // write back Raw(x); -- // mov does not affect flags; -1 to offset inc ebx -- "jb avg_1lp \n\t" -- -- "avg_1end: \n\t" --#ifdef __PIC__ -- "popl %%ebx \n\t" // Global Offset Table index --#endif -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "0" (bpp), // ecx // input regs -- "1" (prev_row), // esi -- "2" (row) // edi -- -- : "%eax", "%edx" // clobber list --#ifndef __PIC__ -- , "%ebx" --#endif -- ); -- } -- return; // end 1 bpp -- -- case 8: -- { -- __asm__ __volatile__ ( -- // re-init address pointers and offset -- "movl _dif, %%ecx \n\t" // ecx: x == offset to alignment -- "movq _LBCarryMask, %%mm5 \n\t" // boundary --// preload "movl row, %%edi \n\t" // edi: Avg(x) -- "movq _HBClearMask, %%mm4 \n\t" --// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) -- -- // prime the pump: load the first Raw(x-bpp) data set -- "movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes -- // (NO NEED to correct pos. in loop below) -- -- "avg_8lp: \n\t" -- "movq (%%edi,%%ecx,), %%mm0 \n\t" -- "movq %%mm5, %%mm3 \n\t" -- "movq (%%esi,%%ecx,), %%mm1 \n\t" -- "addl $8, %%ecx \n\t" -- "pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte -- "psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 -- "pand %%mm2, %%mm3 \n\t" // get LBCarrys for each byte -- // where both lsb's were == 1 -- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 -- "pand %%mm4, %%mm1 \n\t" // clear invalid bit 7, each byte -- "paddb %%mm3, %%mm0 \n\t" // add LBCarrys to Avg, each byte -- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7, each byte -- "paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg, each -- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) to Avg for each -- "cmpl _MMXLength, %%ecx \n\t" -- "movq %%mm0, -8(%%edi,%%ecx,) \n\t" -- "movq %%mm0, %%mm2 \n\t" // reuse as Raw(x-bpp) -- "jb avg_8lp \n\t" -- -- : "=S" (dummy_value_S), // output regs (dummy) -- "=D" (dummy_value_D) -- -- : "0" (prev_row), // esi // input regs -- "1" (row) // edi -- -- : "%ecx" // clobber list --#if 0 /* %mm0, ..., %mm5 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- , "%mm0", "%mm1", "%mm2" -- , "%mm3", "%mm4", "%mm5" --#endif -- ); -- } -- break; // end 8 bpp -- -- default: // bpp greater than 8 (!= 1,2,3,4,[5],6,[7],8) -- { -- --#ifdef PNG_DEBUG -- // GRR: PRINT ERROR HERE: SHOULD NEVER BE REACHED -- png_debug(1, -- "Internal logic error in pnggccrd (png_read_filter_row_mmx_avg())\n"); --#endif -- --#if 0 -- __asm__ __volatile__ ( -- "movq _LBCarryMask, %%mm5 \n\t" -- // re-init address pointers and offset -- "movl _dif, %%ebx \n\t" // ebx: x = offset to -- // alignment boundary -- "movl row, %%edi \n\t" // edi: Avg(x) -- "movq _HBClearMask, %%mm4 \n\t" -- "movl %%edi, %%edx \n\t" -- "movl prev_row, %%esi \n\t" // esi: Prior(x) -- "subl bpp, %%edx \n\t" // edx: Raw(x-bpp) -- "avg_Alp: \n\t" -- "movq (%%edi,%%ebx,), %%mm0 \n\t" -- "movq %%mm5, %%mm3 \n\t" -- "movq (%%esi,%%ebx,), %%mm1 \n\t" -- "pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte -- "movq (%%edx,%%ebx,), %%mm2 \n\t" -- "psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 -- "pand %%mm2, %%mm3 \n\t" // get LBCarrys for each byte -- // where both lsb's were == 1 -- "psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 -- "pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each -- // byte -- "paddb %%mm3, %%mm0 \n\t" // add LBCarrys to Avg for each -- // byte -- "pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each -- // byte -- "paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for -- // each byte -- "addl $8, %%ebx \n\t" -- "paddb %%mm2, %%mm0 \n\t" // add (Raw/2) to Avg for each -- // byte -- "cmpl _MMXLength, %%ebx \n\t" -- "movq %%mm0, -8(%%edi,%%ebx,) \n\t" -- "jb avg_Alp \n\t" -- -- : // FIXASM: output regs/vars go here, e.g.: "=m" (memory_var) -- -- : // FIXASM: input regs, e.g.: "c" (count), "S" (src), "D" (dest) -- -- : "%ebx", "%edx", "%edi", "%esi" // CHECKASM: clobber list -- ); --#endif /* 0 - NEVER REACHED */ -- } -- break; -- -- } // end switch (bpp) -- -- __asm__ __volatile__ ( -- // MMX acceleration complete; now do clean-up -- // check if any remaining bytes left to decode --#ifdef __PIC__ -- "pushl %%ebx \n\t" // save index to Global Offset Table --#endif -- "movl _MMXLength, %%ebx \n\t" // ebx: x == offset bytes after MMX --//pre "movl row, %%edi \n\t" // edi: Avg(x) -- "cmpl _FullLength, %%ebx \n\t" // test if offset at end of array -- "jnb avg_end \n\t" -- -- // do Avg decode for remaining bytes --//pre "movl prev_row, %%esi \n\t" // esi: Prior(x) -- "movl %%edi, %%edx \n\t" --//pre "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) -- "subl %%ecx, %%edx \n\t" // edx: Raw(x-bpp) -- "xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx below -- -- "avg_lp2: \n\t" -- // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) -- "xorl %%eax, %%eax \n\t" -- "movb (%%esi,%%ebx,), %%cl \n\t" // load cl with Prior(x) -- "movb (%%edx,%%ebx,), %%al \n\t" // load al with Raw(x-bpp) -- "addw %%cx, %%ax \n\t" -- "incl %%ebx \n\t" -- "shrw %%ax \n\t" // divide by 2 -- "addb -1(%%edi,%%ebx,), %%al \n\t" // add Avg(x); -1 to offset inc ebx -- "cmpl _FullLength, %%ebx \n\t" // check if at end of array -- "movb %%al, -1(%%edi,%%ebx,) \n\t" // write back Raw(x) [mov does not -- "jb avg_lp2 \n\t" // affect flags; -1 to offset inc ebx] -- -- "avg_end: \n\t" -- "EMMS \n\t" // end MMX; prep for poss. FP instrs. --#ifdef __PIC__ -- "popl %%ebx \n\t" // restore index to Global Offset Table --#endif -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "0" (bpp), // ecx // input regs -- "1" (prev_row), // esi -- "2" (row) // edi -- -- : "%eax", "%edx" // clobber list --#ifndef __PIC__ -- , "%ebx" --#endif -- ); -- --} /* end png_read_filter_row_mmx_avg() */ --#endif -- -- -- --#ifdef PNG_THREAD_UNSAFE_OK --//===========================================================================// --// // --// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ P A E T H // --// // --//===========================================================================// -- --// Optimized code for PNG Paeth filter decoder -- --static void /* PRIVATE */ --png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row, -- png_bytep prev_row) --{ -- int bpp; -- int dummy_value_c; // fix 'forbidden register 2 (cx) was spilled' error -- int dummy_value_S; -- int dummy_value_D; -- -- bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel -- _FullLength = row_info->rowbytes; // # of bytes to filter -- -- __asm__ __volatile__ ( --#ifdef __PIC__ -- "pushl %%ebx \n\t" // save index to Global Offset Table --#endif -- "xorl %%ebx, %%ebx \n\t" // ebx: x offset --//pre "movl row, %%edi \n\t" -- "xorl %%edx, %%edx \n\t" // edx: x-bpp offset --//pre "movl prev_row, %%esi \n\t" -- "xorl %%eax, %%eax \n\t" -- -- // Compute the Raw value for the first bpp bytes -- // Note: the formula works out to be always -- // Paeth(x) = Raw(x) + Prior(x) where x < bpp -- "paeth_rlp: \n\t" -- "movb (%%edi,%%ebx,), %%al \n\t" -- "addb (%%esi,%%ebx,), %%al \n\t" -- "incl %%ebx \n\t" --//pre "cmpl bpp, %%ebx \n\t" (bpp is preloaded into ecx) -- "cmpl %%ecx, %%ebx \n\t" -- "movb %%al, -1(%%edi,%%ebx,) \n\t" -- "jb paeth_rlp \n\t" -- // get # of bytes to alignment -- "movl %%edi, _dif \n\t" // take start of row -- "addl %%ebx, _dif \n\t" // add bpp -- "xorl %%ecx, %%ecx \n\t" -- "addl $0xf, _dif \n\t" // add 7 + 8 to incr past alignment -- // boundary -- "andl $0xfffffff8, _dif \n\t" // mask to alignment boundary -- "subl %%edi, _dif \n\t" // subtract from start ==> value ebx -- // at alignment -- "jz paeth_go \n\t" -- // fix alignment -- -- "paeth_lp1: \n\t" -- "xorl %%eax, %%eax \n\t" -- // pav = p - a = (a + b - c) - a = b - c -- "movb (%%esi,%%ebx,), %%al \n\t" // load Prior(x) into al -- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl -- "subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) -- "movl %%eax, _patemp \n\t" // Save pav for later use -- "xorl %%eax, %%eax \n\t" -- // pbv = p - b = (a + b - c) - b = a - c -- "movb (%%edi,%%edx,), %%al \n\t" // load Raw(x-bpp) into al -- "subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) -- "movl %%eax, %%ecx \n\t" -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- "addl _patemp, %%eax \n\t" // pcv = pav + pbv -- // pc = abs(pcv) -- "testl $0x80000000, %%eax \n\t" -- "jz paeth_pca \n\t" -- "negl %%eax \n\t" // reverse sign of neg values -- -- "paeth_pca: \n\t" -- "movl %%eax, _pctemp \n\t" // save pc for later use -- // pb = abs(pbv) -- "testl $0x80000000, %%ecx \n\t" -- "jz paeth_pba \n\t" -- "negl %%ecx \n\t" // reverse sign of neg values -- -- "paeth_pba: \n\t" -- "movl %%ecx, _pbtemp \n\t" // save pb for later use -- // pa = abs(pav) -- "movl _patemp, %%eax \n\t" -- "testl $0x80000000, %%eax \n\t" -- "jz paeth_paa \n\t" -- "negl %%eax \n\t" // reverse sign of neg values -- -- "paeth_paa: \n\t" -- "movl %%eax, _patemp \n\t" // save pa for later use -- // test if pa <= pb -- "cmpl %%ecx, %%eax \n\t" -- "jna paeth_abb \n\t" -- // pa > pb; now test if pb <= pc -- "cmpl _pctemp, %%ecx \n\t" -- "jna paeth_bbc \n\t" -- // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) -- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl -- "jmp paeth_paeth \n\t" -- -- "paeth_bbc: \n\t" -- // pb <= pc; Raw(x) = Paeth(x) + Prior(x) -- "movb (%%esi,%%ebx,), %%cl \n\t" // load Prior(x) into cl -- "jmp paeth_paeth \n\t" -- -- "paeth_abb: \n\t" -- // pa <= pb; now test if pa <= pc -- "cmpl _pctemp, %%eax \n\t" -- "jna paeth_abc \n\t" -- // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) -- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl -- "jmp paeth_paeth \n\t" -- -- "paeth_abc: \n\t" -- // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) -- "movb (%%edi,%%edx,), %%cl \n\t" // load Raw(x-bpp) into cl -- -- "paeth_paeth: \n\t" -- "incl %%ebx \n\t" -- "incl %%edx \n\t" -- // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 -- "addb %%cl, -1(%%edi,%%ebx,) \n\t" -- "cmpl _dif, %%ebx \n\t" -- "jb paeth_lp1 \n\t" -- -- "paeth_go: \n\t" -- "movl _FullLength, %%ecx \n\t" -- "movl %%ecx, %%eax \n\t" -- "subl %%ebx, %%eax \n\t" // subtract alignment fix -- "andl $0x00000007, %%eax \n\t" // calc bytes over mult of 8 -- "subl %%eax, %%ecx \n\t" // drop over bytes from original length -- "movl %%ecx, _MMXLength \n\t" --#ifdef __PIC__ -- "popl %%ebx \n\t" // restore index to Global Offset Table --#endif -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "0" (bpp), // ecx // input regs -- "1" (prev_row), // esi -- "2" (row) // edi -- -- : "%eax", "%edx" // clobber list --#ifndef __PIC__ -- , "%ebx" --#endif -- ); -- -- // now do the math for the rest of the row -- switch (bpp) -- { -- case 3: -- { -- _ActiveMask.use = 0x0000000000ffffffLL; -- _ActiveMaskEnd.use = 0xffff000000000000LL; -- _ShiftBpp.use = 24; // == bpp(3) * 8 -- _ShiftRem.use = 40; // == 64 - 24 -- -- __asm__ __volatile__ ( -- "movl _dif, %%ecx \n\t" --// preload "movl row, %%edi \n\t" --// preload "movl prev_row, %%esi \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- // prime the pump: load the first Raw(x-bpp) data set -- "movq -8(%%edi,%%ecx,), %%mm1 \n\t" -- "paeth_3lp: \n\t" -- "psrlq _ShiftRem, %%mm1 \n\t" // shift last 3 bytes to 1st -- // 3 bytes -- "movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) -- "punpcklbw %%mm0, %%mm1 \n\t" // unpack High bytes of a -- "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // prep c=Prior(x-bpp) bytes -- "punpcklbw %%mm0, %%mm2 \n\t" // unpack High bytes of b -- "psrlq _ShiftRem, %%mm3 \n\t" // shift last 3 bytes to 1st -- // 3 bytes -- // pav = p - a = (a + b - c) - a = b - c -- "movq %%mm2, %%mm4 \n\t" -- "punpcklbw %%mm0, %%mm3 \n\t" // unpack High bytes of c -- // pbv = p - b = (a + b - c) - b = a - c -- "movq %%mm1, %%mm5 \n\t" -- "psubw %%mm3, %%mm4 \n\t" -- "pxor %%mm7, %%mm7 \n\t" -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- "movq %%mm4, %%mm6 \n\t" -- "psubw %%mm3, %%mm5 \n\t" -- -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 -- "paddw %%mm5, %%mm6 \n\t" -- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 -- "psubw %%mm0, %%mm4 \n\t" -- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 -- "psubw %%mm0, %%mm4 \n\t" -- "psubw %%mm7, %%mm5 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 -- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "psubw %%mm7, %%mm5 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- // test pa <= pb -- "movq %%mm4, %%mm7 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? -- "movq %%mm7, %%mm0 \n\t" -- // use mm7 mask to merge pa & pb -- "pand %%mm7, %%mm5 \n\t" -- // use mm0 mask copy to merge a & b -- "pand %%mm0, %%mm2 \n\t" -- "pandn %%mm4, %%mm7 \n\t" -- "pandn %%mm1, %%mm0 \n\t" -- "paddw %%mm5, %%mm7 \n\t" -- "paddw %%mm2, %%mm0 \n\t" -- // test ((pa <= pb)? pa:pb) <= pc -- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? -- "pxor %%mm1, %%mm1 \n\t" -- "pand %%mm7, %%mm3 \n\t" -- "pandn %%mm0, %%mm7 \n\t" -- "paddw %%mm3, %%mm7 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- "packuswb %%mm1, %%mm7 \n\t" -- "movq (%%esi,%%ecx,), %%mm3 \n\t" // load c=Prior(x-bpp) -- "pand _ActiveMask, %%mm7 \n\t" -- "movq %%mm3, %%mm2 \n\t" // load b=Prior(x) step 1 -- "paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) -- "punpcklbw %%mm0, %%mm3 \n\t" // unpack High bytes of c -- "movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value -- "movq %%mm7, %%mm1 \n\t" // now mm1 will be used as -- // Raw(x-bpp) -- // now do Paeth for 2nd set of bytes (3-5) -- "psrlq _ShiftBpp, %%mm2 \n\t" // load b=Prior(x) step 2 -- "punpcklbw %%mm0, %%mm1 \n\t" // unpack High bytes of a -- "pxor %%mm7, %%mm7 \n\t" -- "punpcklbw %%mm0, %%mm2 \n\t" // unpack High bytes of b -- // pbv = p - b = (a + b - c) - b = a - c -- "movq %%mm1, %%mm5 \n\t" -- // pav = p - a = (a + b - c) - a = b - c -- "movq %%mm2, %%mm4 \n\t" -- "psubw %%mm3, %%mm5 \n\t" -- "psubw %%mm3, %%mm4 \n\t" -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = -- // pav + pbv = pbv + pav -- "movq %%mm5, %%mm6 \n\t" -- "paddw %%mm4, %%mm6 \n\t" -- -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- "pcmpgtw %%mm5, %%mm0 \n\t" // create mask pbv bytes < 0 -- "pcmpgtw %%mm4, %%mm7 \n\t" // create mask pav bytes < 0 -- "pand %%mm5, %%mm0 \n\t" // only pbv bytes < 0 in mm0 -- "pand %%mm4, %%mm7 \n\t" // only pav bytes < 0 in mm7 -- "psubw %%mm0, %%mm5 \n\t" -- "psubw %%mm7, %%mm4 \n\t" -- "psubw %%mm0, %%mm5 \n\t" -- "psubw %%mm7, %%mm4 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 -- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "psubw %%mm0, %%mm6 \n\t" -- // test pa <= pb -- "movq %%mm4, %%mm7 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? -- "movq %%mm7, %%mm0 \n\t" -- // use mm7 mask to merge pa & pb -- "pand %%mm7, %%mm5 \n\t" -- // use mm0 mask copy to merge a & b -- "pand %%mm0, %%mm2 \n\t" -- "pandn %%mm4, %%mm7 \n\t" -- "pandn %%mm1, %%mm0 \n\t" -- "paddw %%mm5, %%mm7 \n\t" -- "paddw %%mm2, %%mm0 \n\t" -- // test ((pa <= pb)? pa:pb) <= pc -- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? -- "movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) -- "pand %%mm7, %%mm3 \n\t" -- "pandn %%mm0, %%mm7 \n\t" -- "pxor %%mm1, %%mm1 \n\t" -- "paddw %%mm3, %%mm7 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- "packuswb %%mm1, %%mm7 \n\t" -- "movq %%mm2, %%mm3 \n\t" // load c=Prior(x-bpp) step 1 -- "pand _ActiveMask, %%mm7 \n\t" -- "punpckhbw %%mm0, %%mm2 \n\t" // unpack High bytes of b -- "psllq _ShiftBpp, %%mm7 \n\t" // shift bytes to 2nd group of -- // 3 bytes -- // pav = p - a = (a + b - c) - a = b - c -- "movq %%mm2, %%mm4 \n\t" -- "paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) -- "psllq _ShiftBpp, %%mm3 \n\t" // load c=Prior(x-bpp) step 2 -- "movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value -- "movq %%mm7, %%mm1 \n\t" -- "punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c -- "psllq _ShiftBpp, %%mm1 \n\t" // shift bytes -- // now mm1 will be used as Raw(x-bpp) -- // now do Paeth for 3rd, and final, set of bytes (6-7) -- "pxor %%mm7, %%mm7 \n\t" -- "punpckhbw %%mm0, %%mm1 \n\t" // unpack High bytes of a -- "psubw %%mm3, %%mm4 \n\t" -- // pbv = p - b = (a + b - c) - b = a - c -- "movq %%mm1, %%mm5 \n\t" -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- "movq %%mm4, %%mm6 \n\t" -- "psubw %%mm3, %%mm5 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- "paddw %%mm5, %%mm6 \n\t" -- -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 -- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 -- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 -- "psubw %%mm0, %%mm4 \n\t" -- "psubw %%mm7, %%mm5 \n\t" -- "psubw %%mm0, %%mm4 \n\t" -- "psubw %%mm7, %%mm5 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 -- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "psubw %%mm0, %%mm6 \n\t" -- // test pa <= pb -- "movq %%mm4, %%mm7 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? -- "movq %%mm7, %%mm0 \n\t" -- // use mm0 mask copy to merge a & b -- "pand %%mm0, %%mm2 \n\t" -- // use mm7 mask to merge pa & pb -- "pand %%mm7, %%mm5 \n\t" -- "pandn %%mm1, %%mm0 \n\t" -- "pandn %%mm4, %%mm7 \n\t" -- "paddw %%mm2, %%mm0 \n\t" -- "paddw %%mm5, %%mm7 \n\t" -- // test ((pa <= pb)? pa:pb) <= pc -- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? -- "pand %%mm7, %%mm3 \n\t" -- "pandn %%mm0, %%mm7 \n\t" -- "paddw %%mm3, %%mm7 \n\t" -- "pxor %%mm1, %%mm1 \n\t" -- "packuswb %%mm7, %%mm1 \n\t" -- // step ecx to next set of 8 bytes and repeat loop til done -- "addl $8, %%ecx \n\t" -- "pand _ActiveMaskEnd, %%mm1 \n\t" -- "paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add Paeth predictor with -- // Raw(x) -- -- "cmpl _MMXLength, %%ecx \n\t" -- "pxor %%mm0, %%mm0 \n\t" // pxor does not affect flags -- "movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value -- // mm1 will be used as Raw(x-bpp) next loop -- // mm3 ready to be used as Prior(x-bpp) next loop -- "jb paeth_3lp \n\t" -- -- : "=S" (dummy_value_S), // output regs (dummy) -- "=D" (dummy_value_D) -- -- : "0" (prev_row), // esi // input regs -- "1" (row) // edi -- -- : "%ecx" // clobber list --#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- , "%mm0", "%mm1", "%mm2", "%mm3" -- , "%mm4", "%mm5", "%mm6", "%mm7" --#endif -- ); -- } -- break; // end 3 bpp -- -- case 6: -- //case 7: // GRR BOGUS -- //case 5: // GRR BOGUS -- { -- _ActiveMask.use = 0x00000000ffffffffLL; -- _ActiveMask2.use = 0xffffffff00000000LL; -- _ShiftBpp.use = bpp << 3; // == bpp * 8 -- _ShiftRem.use = 64 - _ShiftBpp.use; -- -- __asm__ __volatile__ ( -- "movl _dif, %%ecx \n\t" --// preload "movl row, %%edi \n\t" --// preload "movl prev_row, %%esi \n\t" -- // prime the pump: load the first Raw(x-bpp) data set -- "movq -8(%%edi,%%ecx,), %%mm1 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- -- "paeth_6lp: \n\t" -- // must shift to position Raw(x-bpp) data -- "psrlq _ShiftRem, %%mm1 \n\t" -- // do first set of 4 bytes -- "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes -- "punpcklbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a -- "movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) -- "punpcklbw %%mm0, %%mm2 \n\t" // unpack Low bytes of b -- // must shift to position Prior(x-bpp) data -- "psrlq _ShiftRem, %%mm3 \n\t" -- // pav = p - a = (a + b - c) - a = b - c -- "movq %%mm2, %%mm4 \n\t" -- "punpcklbw %%mm0, %%mm3 \n\t" // unpack Low bytes of c -- // pbv = p - b = (a + b - c) - b = a - c -- "movq %%mm1, %%mm5 \n\t" -- "psubw %%mm3, %%mm4 \n\t" -- "pxor %%mm7, %%mm7 \n\t" -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- "movq %%mm4, %%mm6 \n\t" -- "psubw %%mm3, %%mm5 \n\t" -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 -- "paddw %%mm5, %%mm6 \n\t" -- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 -- "psubw %%mm0, %%mm4 \n\t" -- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 -- "psubw %%mm0, %%mm4 \n\t" -- "psubw %%mm7, %%mm5 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 -- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "psubw %%mm7, %%mm5 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- // test pa <= pb -- "movq %%mm4, %%mm7 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? -- "movq %%mm7, %%mm0 \n\t" -- // use mm7 mask to merge pa & pb -- "pand %%mm7, %%mm5 \n\t" -- // use mm0 mask copy to merge a & b -- "pand %%mm0, %%mm2 \n\t" -- "pandn %%mm4, %%mm7 \n\t" -- "pandn %%mm1, %%mm0 \n\t" -- "paddw %%mm5, %%mm7 \n\t" -- "paddw %%mm2, %%mm0 \n\t" -- // test ((pa <= pb)? pa:pb) <= pc -- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? -- "pxor %%mm1, %%mm1 \n\t" -- "pand %%mm7, %%mm3 \n\t" -- "pandn %%mm0, %%mm7 \n\t" -- "paddw %%mm3, %%mm7 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- "packuswb %%mm1, %%mm7 \n\t" -- "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // load c=Prior(x-bpp) -- "pand _ActiveMask, %%mm7 \n\t" -- "psrlq _ShiftRem, %%mm3 \n\t" -- "movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) step 1 -- "paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor and Raw(x) -- "movq %%mm2, %%mm6 \n\t" -- "movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value -- "movq -8(%%edi,%%ecx,), %%mm1 \n\t" -- "psllq _ShiftBpp, %%mm6 \n\t" -- "movq %%mm7, %%mm5 \n\t" -- "psrlq _ShiftRem, %%mm1 \n\t" -- "por %%mm6, %%mm3 \n\t" -- "psllq _ShiftBpp, %%mm5 \n\t" -- "punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c -- "por %%mm5, %%mm1 \n\t" -- // do second set of 4 bytes -- "punpckhbw %%mm0, %%mm2 \n\t" // unpack High bytes of b -- "punpckhbw %%mm0, %%mm1 \n\t" // unpack High bytes of a -- // pav = p - a = (a + b - c) - a = b - c -- "movq %%mm2, %%mm4 \n\t" -- // pbv = p - b = (a + b - c) - b = a - c -- "movq %%mm1, %%mm5 \n\t" -- "psubw %%mm3, %%mm4 \n\t" -- "pxor %%mm7, %%mm7 \n\t" -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- "movq %%mm4, %%mm6 \n\t" -- "psubw %%mm3, %%mm5 \n\t" -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 -- "paddw %%mm5, %%mm6 \n\t" -- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 -- "psubw %%mm0, %%mm4 \n\t" -- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 -- "psubw %%mm0, %%mm4 \n\t" -- "psubw %%mm7, %%mm5 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 -- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "psubw %%mm7, %%mm5 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- // test pa <= pb -- "movq %%mm4, %%mm7 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? -- "movq %%mm7, %%mm0 \n\t" -- // use mm7 mask to merge pa & pb -- "pand %%mm7, %%mm5 \n\t" -- // use mm0 mask copy to merge a & b -- "pand %%mm0, %%mm2 \n\t" -- "pandn %%mm4, %%mm7 \n\t" -- "pandn %%mm1, %%mm0 \n\t" -- "paddw %%mm5, %%mm7 \n\t" -- "paddw %%mm2, %%mm0 \n\t" -- // test ((pa <= pb)? pa:pb) <= pc -- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? -- "pxor %%mm1, %%mm1 \n\t" -- "pand %%mm7, %%mm3 \n\t" -- "pandn %%mm0, %%mm7 \n\t" -- "pxor %%mm1, %%mm1 \n\t" -- "paddw %%mm3, %%mm7 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- // step ecx to next set of 8 bytes and repeat loop til done -- "addl $8, %%ecx \n\t" -- "packuswb %%mm7, %%mm1 \n\t" -- "paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add Paeth predictor with Raw(x) -- "cmpl _MMXLength, %%ecx \n\t" -- "movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value -- // mm1 will be used as Raw(x-bpp) next loop -- "jb paeth_6lp \n\t" -- -- : "=S" (dummy_value_S), // output regs (dummy) -- "=D" (dummy_value_D) -- -- : "0" (prev_row), // esi // input regs -- "1" (row) // edi -- -- : "%ecx" // clobber list --#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- , "%mm0", "%mm1", "%mm2", "%mm3" -- , "%mm4", "%mm5", "%mm6", "%mm7" --#endif -- ); -- } -- break; // end 6 bpp -- -- case 4: -- { -- _ActiveMask.use = 0x00000000ffffffffLL; -- -- __asm__ __volatile__ ( -- "movl _dif, %%ecx \n\t" --// preload "movl row, %%edi \n\t" --// preload "movl prev_row, %%esi \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- // prime the pump: load the first Raw(x-bpp) data set -- "movq -8(%%edi,%%ecx,), %%mm1 \n\t" // only time should need to read -- // a=Raw(x-bpp) bytes -- "paeth_4lp: \n\t" -- // do first set of 4 bytes -- "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes -- "punpckhbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a -- "movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) -- "punpcklbw %%mm0, %%mm2 \n\t" // unpack High bytes of b -- // pav = p - a = (a + b - c) - a = b - c -- "movq %%mm2, %%mm4 \n\t" -- "punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c -- // pbv = p - b = (a + b - c) - b = a - c -- "movq %%mm1, %%mm5 \n\t" -- "psubw %%mm3, %%mm4 \n\t" -- "pxor %%mm7, %%mm7 \n\t" -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- "movq %%mm4, %%mm6 \n\t" -- "psubw %%mm3, %%mm5 \n\t" -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 -- "paddw %%mm5, %%mm6 \n\t" -- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 -- "psubw %%mm0, %%mm4 \n\t" -- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 -- "psubw %%mm0, %%mm4 \n\t" -- "psubw %%mm7, %%mm5 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 -- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "psubw %%mm7, %%mm5 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- // test pa <= pb -- "movq %%mm4, %%mm7 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? -- "movq %%mm7, %%mm0 \n\t" -- // use mm7 mask to merge pa & pb -- "pand %%mm7, %%mm5 \n\t" -- // use mm0 mask copy to merge a & b -- "pand %%mm0, %%mm2 \n\t" -- "pandn %%mm4, %%mm7 \n\t" -- "pandn %%mm1, %%mm0 \n\t" -- "paddw %%mm5, %%mm7 \n\t" -- "paddw %%mm2, %%mm0 \n\t" -- // test ((pa <= pb)? pa:pb) <= pc -- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? -- "pxor %%mm1, %%mm1 \n\t" -- "pand %%mm7, %%mm3 \n\t" -- "pandn %%mm0, %%mm7 \n\t" -- "paddw %%mm3, %%mm7 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- "packuswb %%mm1, %%mm7 \n\t" -- "movq (%%esi,%%ecx,), %%mm3 \n\t" // load c=Prior(x-bpp) -- "pand _ActiveMask, %%mm7 \n\t" -- "movq %%mm3, %%mm2 \n\t" // load b=Prior(x) step 1 -- "paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) -- "punpcklbw %%mm0, %%mm3 \n\t" // unpack High bytes of c -- "movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value -- "movq %%mm7, %%mm1 \n\t" // now mm1 will be used as Raw(x-bpp) -- // do second set of 4 bytes -- "punpckhbw %%mm0, %%mm2 \n\t" // unpack Low bytes of b -- "punpcklbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a -- // pav = p - a = (a + b - c) - a = b - c -- "movq %%mm2, %%mm4 \n\t" -- // pbv = p - b = (a + b - c) - b = a - c -- "movq %%mm1, %%mm5 \n\t" -- "psubw %%mm3, %%mm4 \n\t" -- "pxor %%mm7, %%mm7 \n\t" -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- "movq %%mm4, %%mm6 \n\t" -- "psubw %%mm3, %%mm5 \n\t" -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 -- "paddw %%mm5, %%mm6 \n\t" -- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 -- "psubw %%mm0, %%mm4 \n\t" -- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 -- "psubw %%mm0, %%mm4 \n\t" -- "psubw %%mm7, %%mm5 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 -- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "psubw %%mm7, %%mm5 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- // test pa <= pb -- "movq %%mm4, %%mm7 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? -- "movq %%mm7, %%mm0 \n\t" -- // use mm7 mask to merge pa & pb -- "pand %%mm7, %%mm5 \n\t" -- // use mm0 mask copy to merge a & b -- "pand %%mm0, %%mm2 \n\t" -- "pandn %%mm4, %%mm7 \n\t" -- "pandn %%mm1, %%mm0 \n\t" -- "paddw %%mm5, %%mm7 \n\t" -- "paddw %%mm2, %%mm0 \n\t" -- // test ((pa <= pb)? pa:pb) <= pc -- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? -- "pxor %%mm1, %%mm1 \n\t" -- "pand %%mm7, %%mm3 \n\t" -- "pandn %%mm0, %%mm7 \n\t" -- "pxor %%mm1, %%mm1 \n\t" -- "paddw %%mm3, %%mm7 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- // step ecx to next set of 8 bytes and repeat loop til done -- "addl $8, %%ecx \n\t" -- "packuswb %%mm7, %%mm1 \n\t" -- "paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add predictor with Raw(x) -- "cmpl _MMXLength, %%ecx \n\t" -- "movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value -- // mm1 will be used as Raw(x-bpp) next loop -- "jb paeth_4lp \n\t" -- -- : "=S" (dummy_value_S), // output regs (dummy) -- "=D" (dummy_value_D) -- -- : "0" (prev_row), // esi // input regs -- "1" (row) // edi -- -- : "%ecx" // clobber list --#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- , "%mm0", "%mm1", "%mm2", "%mm3" -- , "%mm4", "%mm5", "%mm6", "%mm7" --#endif -- ); -- } -- break; // end 4 bpp -- -- case 8: // bpp == 8 -- { -- _ActiveMask.use = 0x00000000ffffffffLL; -- -- __asm__ __volatile__ ( -- "movl _dif, %%ecx \n\t" --// preload "movl row, %%edi \n\t" --// preload "movl prev_row, %%esi \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- // prime the pump: load the first Raw(x-bpp) data set -- "movq -8(%%edi,%%ecx,), %%mm1 \n\t" // only time should need to read -- // a=Raw(x-bpp) bytes -- "paeth_8lp: \n\t" -- // do first set of 4 bytes -- "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes -- "punpcklbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a -- "movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) -- "punpcklbw %%mm0, %%mm2 \n\t" // unpack Low bytes of b -- // pav = p - a = (a + b - c) - a = b - c -- "movq %%mm2, %%mm4 \n\t" -- "punpcklbw %%mm0, %%mm3 \n\t" // unpack Low bytes of c -- // pbv = p - b = (a + b - c) - b = a - c -- "movq %%mm1, %%mm5 \n\t" -- "psubw %%mm3, %%mm4 \n\t" -- "pxor %%mm7, %%mm7 \n\t" -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- "movq %%mm4, %%mm6 \n\t" -- "psubw %%mm3, %%mm5 \n\t" -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 -- "paddw %%mm5, %%mm6 \n\t" -- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 -- "psubw %%mm0, %%mm4 \n\t" -- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 -- "psubw %%mm0, %%mm4 \n\t" -- "psubw %%mm7, %%mm5 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 -- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "psubw %%mm7, %%mm5 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- // test pa <= pb -- "movq %%mm4, %%mm7 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? -- "movq %%mm7, %%mm0 \n\t" -- // use mm7 mask to merge pa & pb -- "pand %%mm7, %%mm5 \n\t" -- // use mm0 mask copy to merge a & b -- "pand %%mm0, %%mm2 \n\t" -- "pandn %%mm4, %%mm7 \n\t" -- "pandn %%mm1, %%mm0 \n\t" -- "paddw %%mm5, %%mm7 \n\t" -- "paddw %%mm2, %%mm0 \n\t" -- // test ((pa <= pb)? pa:pb) <= pc -- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? -- "pxor %%mm1, %%mm1 \n\t" -- "pand %%mm7, %%mm3 \n\t" -- "pandn %%mm0, %%mm7 \n\t" -- "paddw %%mm3, %%mm7 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- "packuswb %%mm1, %%mm7 \n\t" -- "movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes -- "pand _ActiveMask, %%mm7 \n\t" -- "movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) -- "paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) -- "punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c -- "movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value -- "movq -8(%%edi,%%ecx,), %%mm1 \n\t" // read a=Raw(x-bpp) bytes -- -- // do second set of 4 bytes -- "punpckhbw %%mm0, %%mm2 \n\t" // unpack High bytes of b -- "punpckhbw %%mm0, %%mm1 \n\t" // unpack High bytes of a -- // pav = p - a = (a + b - c) - a = b - c -- "movq %%mm2, %%mm4 \n\t" -- // pbv = p - b = (a + b - c) - b = a - c -- "movq %%mm1, %%mm5 \n\t" -- "psubw %%mm3, %%mm4 \n\t" -- "pxor %%mm7, %%mm7 \n\t" -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- "movq %%mm4, %%mm6 \n\t" -- "psubw %%mm3, %%mm5 \n\t" -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- "pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 -- "paddw %%mm5, %%mm6 \n\t" -- "pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 -- "psubw %%mm0, %%mm4 \n\t" -- "pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 -- "psubw %%mm0, %%mm4 \n\t" -- "psubw %%mm7, %%mm5 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- "pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 -- "pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 -- "psubw %%mm7, %%mm5 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- // test pa <= pb -- "movq %%mm4, %%mm7 \n\t" -- "psubw %%mm0, %%mm6 \n\t" -- "pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? -- "movq %%mm7, %%mm0 \n\t" -- // use mm7 mask to merge pa & pb -- "pand %%mm7, %%mm5 \n\t" -- // use mm0 mask copy to merge a & b -- "pand %%mm0, %%mm2 \n\t" -- "pandn %%mm4, %%mm7 \n\t" -- "pandn %%mm1, %%mm0 \n\t" -- "paddw %%mm5, %%mm7 \n\t" -- "paddw %%mm2, %%mm0 \n\t" -- // test ((pa <= pb)? pa:pb) <= pc -- "pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? -- "pxor %%mm1, %%mm1 \n\t" -- "pand %%mm7, %%mm3 \n\t" -- "pandn %%mm0, %%mm7 \n\t" -- "pxor %%mm1, %%mm1 \n\t" -- "paddw %%mm3, %%mm7 \n\t" -- "pxor %%mm0, %%mm0 \n\t" -- // step ecx to next set of 8 bytes and repeat loop til done -- "addl $8, %%ecx \n\t" -- "packuswb %%mm7, %%mm1 \n\t" -- "paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add Paeth predictor with Raw(x) -- "cmpl _MMXLength, %%ecx \n\t" -- "movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value -- // mm1 will be used as Raw(x-bpp) next loop -- "jb paeth_8lp \n\t" -- -- : "=S" (dummy_value_S), // output regs (dummy) -- "=D" (dummy_value_D) -- -- : "0" (prev_row), // esi // input regs -- "1" (row) // edi -- -- : "%ecx" // clobber list --#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ -- , "%mm0", "%mm1", "%mm2", "%mm3" -- , "%mm4", "%mm5", "%mm6", "%mm7" --#endif -- ); -- } -- break; // end 8 bpp -- -- case 1: // bpp = 1 -- case 2: // bpp = 2 -- default: // bpp > 8 -- { -- __asm__ __volatile__ ( --#ifdef __PIC__ -- "pushl %%ebx \n\t" // save Global Offset Table index --#endif -- "movl _dif, %%ebx \n\t" -- "cmpl _FullLength, %%ebx \n\t" -- "jnb paeth_dend \n\t" -- --// preload "movl row, %%edi \n\t" --// preload "movl prev_row, %%esi \n\t" -- // do Paeth decode for remaining bytes -- "movl %%ebx, %%edx \n\t" --// preload "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) -- "subl %%ecx, %%edx \n\t" // edx = ebx - bpp -- "xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx -- -- "paeth_dlp: \n\t" -- "xorl %%eax, %%eax \n\t" -- // pav = p - a = (a + b - c) - a = b - c -- "movb (%%esi,%%ebx,), %%al \n\t" // load Prior(x) into al -- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl -- "subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) -- "movl %%eax, _patemp \n\t" // Save pav for later use -- "xorl %%eax, %%eax \n\t" -- // pbv = p - b = (a + b - c) - b = a - c -- "movb (%%edi,%%edx,), %%al \n\t" // load Raw(x-bpp) into al -- "subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) -- "movl %%eax, %%ecx \n\t" -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- "addl _patemp, %%eax \n\t" // pcv = pav + pbv -- // pc = abs(pcv) -- "testl $0x80000000, %%eax \n\t" -- "jz paeth_dpca \n\t" -- "negl %%eax \n\t" // reverse sign of neg values -- -- "paeth_dpca: \n\t" -- "movl %%eax, _pctemp \n\t" // save pc for later use -- // pb = abs(pbv) -- "testl $0x80000000, %%ecx \n\t" -- "jz paeth_dpba \n\t" -- "negl %%ecx \n\t" // reverse sign of neg values -- -- "paeth_dpba: \n\t" -- "movl %%ecx, _pbtemp \n\t" // save pb for later use -- // pa = abs(pav) -- "movl _patemp, %%eax \n\t" -- "testl $0x80000000, %%eax \n\t" -- "jz paeth_dpaa \n\t" -- "negl %%eax \n\t" // reverse sign of neg values -- -- "paeth_dpaa: \n\t" -- "movl %%eax, _patemp \n\t" // save pa for later use -- // test if pa <= pb -- "cmpl %%ecx, %%eax \n\t" -- "jna paeth_dabb \n\t" -- // pa > pb; now test if pb <= pc -- "cmpl _pctemp, %%ecx \n\t" -- "jna paeth_dbbc \n\t" -- // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) -- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl -- "jmp paeth_dpaeth \n\t" -- -- "paeth_dbbc: \n\t" -- // pb <= pc; Raw(x) = Paeth(x) + Prior(x) -- "movb (%%esi,%%ebx,), %%cl \n\t" // load Prior(x) into cl -- "jmp paeth_dpaeth \n\t" -- -- "paeth_dabb: \n\t" -- // pa <= pb; now test if pa <= pc -- "cmpl _pctemp, %%eax \n\t" -- "jna paeth_dabc \n\t" -- // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) -- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl -- "jmp paeth_dpaeth \n\t" -- -- "paeth_dabc: \n\t" -- // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) -- "movb (%%edi,%%edx,), %%cl \n\t" // load Raw(x-bpp) into cl -- -- "paeth_dpaeth: \n\t" -- "incl %%ebx \n\t" -- "incl %%edx \n\t" -- // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 -- "addb %%cl, -1(%%edi,%%ebx,) \n\t" -- "cmpl _FullLength, %%ebx \n\t" -- "jb paeth_dlp \n\t" -- -- "paeth_dend: \n\t" --#ifdef __PIC__ -- "popl %%ebx \n\t" // index to Global Offset Table --#endif -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "0" (bpp), // ecx // input regs -- "1" (prev_row), // esi -- "2" (row) // edi -- -- : "%eax", "%edx" // clobber list --#ifndef __PIC__ -- , "%ebx" --#endif -- ); -- } -- return; // No need to go further with this one -- -- } // end switch (bpp) -- -- __asm__ __volatile__ ( -- // MMX acceleration complete; now do clean-up -- // check if any remaining bytes left to decode --#ifdef __PIC__ -- "pushl %%ebx \n\t" // save index to Global Offset Table --#endif -- "movl _MMXLength, %%ebx \n\t" -- "cmpl _FullLength, %%ebx \n\t" -- "jnb paeth_end \n\t" --//pre "movl row, %%edi \n\t" --//pre "movl prev_row, %%esi \n\t" -- // do Paeth decode for remaining bytes -- "movl %%ebx, %%edx \n\t" --//pre "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) -- "subl %%ecx, %%edx \n\t" // edx = ebx - bpp -- "xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx below -- -- "paeth_lp2: \n\t" -- "xorl %%eax, %%eax \n\t" -- // pav = p - a = (a + b - c) - a = b - c -- "movb (%%esi,%%ebx,), %%al \n\t" // load Prior(x) into al -- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl -- "subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) -- "movl %%eax, _patemp \n\t" // Save pav for later use -- "xorl %%eax, %%eax \n\t" -- // pbv = p - b = (a + b - c) - b = a - c -- "movb (%%edi,%%edx,), %%al \n\t" // load Raw(x-bpp) into al -- "subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) -- "movl %%eax, %%ecx \n\t" -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- "addl _patemp, %%eax \n\t" // pcv = pav + pbv -- // pc = abs(pcv) -- "testl $0x80000000, %%eax \n\t" -- "jz paeth_pca2 \n\t" -- "negl %%eax \n\t" // reverse sign of neg values -- -- "paeth_pca2: \n\t" -- "movl %%eax, _pctemp \n\t" // save pc for later use -- // pb = abs(pbv) -- "testl $0x80000000, %%ecx \n\t" -- "jz paeth_pba2 \n\t" -- "negl %%ecx \n\t" // reverse sign of neg values -- -- "paeth_pba2: \n\t" -- "movl %%ecx, _pbtemp \n\t" // save pb for later use -- // pa = abs(pav) -- "movl _patemp, %%eax \n\t" -- "testl $0x80000000, %%eax \n\t" -- "jz paeth_paa2 \n\t" -- "negl %%eax \n\t" // reverse sign of neg values -- -- "paeth_paa2: \n\t" -- "movl %%eax, _patemp \n\t" // save pa for later use -- // test if pa <= pb -- "cmpl %%ecx, %%eax \n\t" -- "jna paeth_abb2 \n\t" -- // pa > pb; now test if pb <= pc -- "cmpl _pctemp, %%ecx \n\t" -- "jna paeth_bbc2 \n\t" -- // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) -- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl -- "jmp paeth_paeth2 \n\t" -- -- "paeth_bbc2: \n\t" -- // pb <= pc; Raw(x) = Paeth(x) + Prior(x) -- "movb (%%esi,%%ebx,), %%cl \n\t" // load Prior(x) into cl -- "jmp paeth_paeth2 \n\t" -- -- "paeth_abb2: \n\t" -- // pa <= pb; now test if pa <= pc -- "cmpl _pctemp, %%eax \n\t" -- "jna paeth_abc2 \n\t" -- // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) -- "movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl -- "jmp paeth_paeth2 \n\t" -- -- "paeth_abc2: \n\t" -- // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) -- "movb (%%edi,%%edx,), %%cl \n\t" // load Raw(x-bpp) into cl -- -- "paeth_paeth2: \n\t" -- "incl %%ebx \n\t" -- "incl %%edx \n\t" -- // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 -- "addb %%cl, -1(%%edi,%%ebx,) \n\t" -- "cmpl _FullLength, %%ebx \n\t" -- "jb paeth_lp2 \n\t" -- -- "paeth_end: \n\t" -- "EMMS \n\t" // end MMX; prep for poss. FP instrs. --#ifdef __PIC__ -- "popl %%ebx \n\t" // restore index to Global Offset Table --#endif -- -- : "=c" (dummy_value_c), // output regs (dummy) -- "=S" (dummy_value_S), -- "=D" (dummy_value_D) -- -- : "0" (bpp), // ecx // input regs -- "1" (prev_row), // esi -- "2" (row) // edi -- -- : "%eax", "%edx" // clobber list (no input regs!) --#ifndef __PIC__ -- , "%ebx" --#endif -- ); -- --} /* end png_read_filter_row_mmx_paeth() */ --#endif -- -- -- -- --#ifdef PNG_THREAD_UNSAFE_OK --//===========================================================================// --// // --// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ S U B // --// // --//===========================================================================// -- --// Optimized code for PNG Sub filter decoder -- --static void /* PRIVATE */ --png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row) --{ -- int bpp; -- int dummy_value_a; -- int dummy_value_D; -- -- bpp = (row_info->pixel_depth + 7) >> 3; // calc number of bytes per pixel -- _FullLength = row_info->rowbytes - bpp; // number of bytes to filter -- -- __asm__ __volatile__ ( --//pre "movl row, %%edi \n\t" -- "movl %%edi, %%esi \n\t" // lp = row --//pre "movl bpp, %%eax \n\t" -- "addl %%eax, %%edi \n\t" // rp = row + bpp --//irr "xorl %%eax, %%eax \n\t" -- // get # of bytes to alignment -- "movl %%edi, _dif \n\t" // take start of row -- "addl $0xf, _dif \n\t" // add 7 + 8 to incr past -- // alignment boundary -- "xorl %%ecx, %%ecx \n\t" -- "andl $0xfffffff8, _dif \n\t" // mask to alignment boundary -- "subl %%edi, _dif \n\t" // subtract from start ==> value -- "jz sub_go \n\t" // ecx at alignment -- -- "sub_lp1: \n\t" // fix alignment -- "movb (%%esi,%%ecx,), %%al \n\t" -- "addb %%al, (%%edi,%%ecx,) \n\t" -- "incl %%ecx \n\t" -- "cmpl _dif, %%ecx \n\t" -- "jb sub_lp1 \n\t" -- -- "sub_go: \n\t" -- "movl _FullLength, %%eax \n\t" -- "movl %%eax, %%edx \n\t" -- "subl %%ecx, %%edx \n\t" // subtract alignment fix -- "andl $0x00000007, %%edx \n\t" // calc bytes over mult of 8 -- "subl %%edx, %%eax \n\t" // drop over bytes from length -- "movl %%eax, _MMXLength \n\t" -- -- : "=a" (dummy_value_a), // 0 // output regs (dummy) -- "=D" (dummy_value_D) // 1 -- -- : "0" (bpp), // eax // input regs -- "1" (row) // edi -- -- : "%esi", "%ecx", "%edx" // clobber list -- --#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ -- , "%mm0", "%mm1", "%mm2", "%mm3" -- , "%mm4", "%mm5", "%mm6", "%mm7" --#endif -- ); -- -- // now do the math for the rest of the row -- switch (bpp) -- { -- case 3: -- { -- _ActiveMask.use = 0x0000ffffff000000LL; -- _ShiftBpp.use = 24; // == 3 * 8 -- _ShiftRem.use = 40; // == 64 - 24 -- -- __asm__ __volatile__ ( --// preload "movl row, %%edi \n\t" -- "movq _ActiveMask, %%mm7 \n\t" // load _ActiveMask for 2nd -- // active byte group -- "movl %%edi, %%esi \n\t" // lp = row --// preload "movl bpp, %%eax \n\t" -- "addl %%eax, %%edi \n\t" // rp = row + bpp -- "movq %%mm7, %%mm6 \n\t" -- "movl _dif, %%edx \n\t" -- "psllq _ShiftBpp, %%mm6 \n\t" // move mask in mm6 to cover -- // 3rd active byte group -- // prime the pump: load the first Raw(x-bpp) data set -- "movq -8(%%edi,%%edx,), %%mm1 \n\t" -- -- "sub_3lp: \n\t" // shift data for adding first -- "psrlq _ShiftRem, %%mm1 \n\t" // bpp bytes (no need for mask; -- // shift clears inactive bytes) -- // add 1st active group -- "movq (%%edi,%%edx,), %%mm0 \n\t" -- "paddb %%mm1, %%mm0 \n\t" -- -- // add 2nd active group -- "movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 -- "psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly -- "pand %%mm7, %%mm1 \n\t" // mask to use 2nd active group -- "paddb %%mm1, %%mm0 \n\t" -- -- // add 3rd active group -- "movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 -- "psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly -- "pand %%mm6, %%mm1 \n\t" // mask to use 3rd active group -- "addl $8, %%edx \n\t" -- "paddb %%mm1, %%mm0 \n\t" -- -- "cmpl _MMXLength, %%edx \n\t" -- "movq %%mm0, -8(%%edi,%%edx,) \n\t" // write updated Raws to array -- "movq %%mm0, %%mm1 \n\t" // prep 1st add at top of loop -- "jb sub_3lp \n\t" -- -- : "=a" (dummy_value_a), // 0 // output regs (dummy) -- "=D" (dummy_value_D) // 1 -- -- : "0" (bpp), // eax // input regs -- "1" (row) // edi -- -- : "%edx", "%esi" // clobber list --#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ -- , "%mm0", "%mm1", "%mm6", "%mm7" --#endif -- ); -- } -- break; -- -- case 1: -- { -- __asm__ __volatile__ ( -- "movl _dif, %%edx \n\t" --// preload "movl row, %%edi \n\t" -- "cmpl _FullLength, %%edx \n\t" -- "jnb sub_1end \n\t" -- "movl %%edi, %%esi \n\t" // lp = row -- "xorl %%eax, %%eax \n\t" --// preload "movl bpp, %%eax \n\t" -- "addl %%eax, %%edi \n\t" // rp = row + bpp -- -- "sub_1lp: \n\t" -- "movb (%%esi,%%edx,), %%al \n\t" -- "addb %%al, (%%edi,%%edx,) \n\t" -- "incl %%edx \n\t" -- "cmpl _FullLength, %%edx \n\t" -- "jb sub_1lp \n\t" -- -- "sub_1end: \n\t" -- -- : "=a" (dummy_value_a), // 0 // output regs (dummy) -- "=D" (dummy_value_D) // 1 -- -- : "0" (bpp), // eax // input regs -- "1" (row) // edi -- -- : "%edx", "%esi" // clobber list -- ); -- } -- return; -- -- case 6: -- case 4: -- //case 7: // GRR BOGUS -- //case 5: // GRR BOGUS -- { -- _ShiftBpp.use = bpp << 3; -- _ShiftRem.use = 64 - _ShiftBpp.use; -- -- __asm__ __volatile__ ( --// preload "movl row, %%edi \n\t" -- "movl _dif, %%edx \n\t" -- "movl %%edi, %%esi \n\t" // lp = row --// preload "movl bpp, %%eax \n\t" -- "addl %%eax, %%edi \n\t" // rp = row + bpp -- -- // prime the pump: load the first Raw(x-bpp) data set -- "movq -8(%%edi,%%edx,), %%mm1 \n\t" -- -- "sub_4lp: \n\t" // shift data for adding first -- "psrlq _ShiftRem, %%mm1 \n\t" // bpp bytes (no need for mask; -- // shift clears inactive bytes) -- "movq (%%edi,%%edx,), %%mm0 \n\t" -- "paddb %%mm1, %%mm0 \n\t" -- -- // add 2nd active group -- "movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 -- "psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly -- "addl $8, %%edx \n\t" -- "paddb %%mm1, %%mm0 \n\t" -- -- "cmpl _MMXLength, %%edx \n\t" -- "movq %%mm0, -8(%%edi,%%edx,) \n\t" -- "movq %%mm0, %%mm1 \n\t" // prep 1st add at top of loop -- "jb sub_4lp \n\t" -- -- : "=a" (dummy_value_a), // 0 // output regs (dummy) -- "=D" (dummy_value_D) // 1 -- -- : "0" (bpp), // eax // input regs -- "1" (row) // edi -- -- : "%edx", "%esi" // clobber list --#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ -- , "%mm0", "%mm1" --#endif -- ); -- } -- break; -- -- case 2: -- { -- _ActiveMask.use = 0x00000000ffff0000LL; -- _ShiftBpp.use = 16; // == 2 * 8 -- _ShiftRem.use = 48; // == 64 - 16 -- -- __asm__ __volatile__ ( -- "movq _ActiveMask, %%mm7 \n\t" // load _ActiveMask for 2nd -- // active byte group -- "movl _dif, %%edx \n\t" -- "movq %%mm7, %%mm6 \n\t" --// preload "movl row, %%edi \n\t" -- "psllq _ShiftBpp, %%mm6 \n\t" // move mask in mm6 to cover -- // 3rd active byte group -- "movl %%edi, %%esi \n\t" // lp = row -- "movq %%mm6, %%mm5 \n\t" --// preload "movl bpp, %%eax \n\t" -- "addl %%eax, %%edi \n\t" // rp = row + bpp -- "psllq _ShiftBpp, %%mm5 \n\t" // move mask in mm5 to cover -- // 4th active byte group -- // prime the pump: load the first Raw(x-bpp) data set -- "movq -8(%%edi,%%edx,), %%mm1 \n\t" -- -- "sub_2lp: \n\t" // shift data for adding first -- "psrlq _ShiftRem, %%mm1 \n\t" // bpp bytes (no need for mask; -- // shift clears inactive bytes) -- // add 1st active group -- "movq (%%edi,%%edx,), %%mm0 \n\t" -- "paddb %%mm1, %%mm0 \n\t" -- -- // add 2nd active group -- "movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 -- "psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly -- "pand %%mm7, %%mm1 \n\t" // mask to use 2nd active group -- "paddb %%mm1, %%mm0 \n\t" -- -- // add 3rd active group -- "movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 -- "psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly -- "pand %%mm6, %%mm1 \n\t" // mask to use 3rd active group -- "paddb %%mm1, %%mm0 \n\t" -- -- // add 4th active group -- "movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 -- "psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly -- "pand %%mm5, %%mm1 \n\t" // mask to use 4th active group -- "addl $8, %%edx \n\t" -- "paddb %%mm1, %%mm0 \n\t" -- "cmpl _MMXLength, %%edx \n\t" -- "movq %%mm0, -8(%%edi,%%edx,) \n\t" // write updated Raws to array -- "movq %%mm0, %%mm1 \n\t" // prep 1st add at top of loop -- "jb sub_2lp \n\t" -- -- : "=a" (dummy_value_a), // 0 // output regs (dummy) -- "=D" (dummy_value_D) // 1 -- -- : "0" (bpp), // eax // input regs -- "1" (row) // edi -- -- : "%edx", "%esi" // clobber list --#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ -- , "%mm0", "%mm1", "%mm5", "%mm6", "%mm7" --#endif -- ); -- } -- break; -- -- case 8: -- { -- __asm__ __volatile__ ( --// preload "movl row, %%edi \n\t" -- "movl _dif, %%edx \n\t" -- "movl %%edi, %%esi \n\t" // lp = row --// preload "movl bpp, %%eax \n\t" -- "addl %%eax, %%edi \n\t" // rp = row + bpp -- "movl _MMXLength, %%ecx \n\t" -- -- // prime the pump: load the first Raw(x-bpp) data set -- "movq -8(%%edi,%%edx,), %%mm7 \n\t" -- "andl $0x0000003f, %%ecx \n\t" // calc bytes over mult of 64 -- -- "sub_8lp: \n\t" -- "movq (%%edi,%%edx,), %%mm0 \n\t" // load Sub(x) for 1st 8 bytes -- "paddb %%mm7, %%mm0 \n\t" -- "movq 8(%%edi,%%edx,), %%mm1 \n\t" // load Sub(x) for 2nd 8 bytes -- "movq %%mm0, (%%edi,%%edx,) \n\t" // write Raw(x) for 1st 8 bytes -- -- // Now mm0 will be used as Raw(x-bpp) for the 2nd group of 8 bytes. -- // This will be repeated for each group of 8 bytes with the 8th -- // group being used as the Raw(x-bpp) for the 1st group of the -- // next loop. -- -- "paddb %%mm0, %%mm1 \n\t" -- "movq 16(%%edi,%%edx,), %%mm2 \n\t" // load Sub(x) for 3rd 8 bytes -- "movq %%mm1, 8(%%edi,%%edx,) \n\t" // write Raw(x) for 2nd 8 bytes -- "paddb %%mm1, %%mm2 \n\t" -- "movq 24(%%edi,%%edx,), %%mm3 \n\t" // load Sub(x) for 4th 8 bytes -- "movq %%mm2, 16(%%edi,%%edx,) \n\t" // write Raw(x) for 3rd 8 bytes -- "paddb %%mm2, %%mm3 \n\t" -- "movq 32(%%edi,%%edx,), %%mm4 \n\t" // load Sub(x) for 5th 8 bytes -- "movq %%mm3, 24(%%edi,%%edx,) \n\t" // write Raw(x) for 4th 8 bytes -- "paddb %%mm3, %%mm4 \n\t" -- "movq 40(%%edi,%%edx,), %%mm5 \n\t" // load Sub(x) for 6th 8 bytes -- "movq %%mm4, 32(%%edi,%%edx,) \n\t" // write Raw(x) for 5th 8 bytes -- "paddb %%mm4, %%mm5 \n\t" -- "movq 48(%%edi,%%edx,), %%mm6 \n\t" // load Sub(x) for 7th 8 bytes -- "movq %%mm5, 40(%%edi,%%edx,) \n\t" // write Raw(x) for 6th 8 bytes -- "paddb %%mm5, %%mm6 \n\t" -- "movq 56(%%edi,%%edx,), %%mm7 \n\t" // load Sub(x) for 8th 8 bytes -- "movq %%mm6, 48(%%edi,%%edx,) \n\t" // write Raw(x) for 7th 8 bytes -- "addl $64, %%edx \n\t" -- "paddb %%mm6, %%mm7 \n\t" -- "cmpl %%ecx, %%edx \n\t" -- "movq %%mm7, -8(%%edi,%%edx,) \n\t" // write Raw(x) for 8th 8 bytes -- "jb sub_8lp \n\t" -- -- "cmpl _MMXLength, %%edx \n\t" -- "jnb sub_8lt8 \n\t" -- -- "sub_8lpA: \n\t" -- "movq (%%edi,%%edx,), %%mm0 \n\t" -- "addl $8, %%edx \n\t" -- "paddb %%mm7, %%mm0 \n\t" -- "cmpl _MMXLength, %%edx \n\t" -- "movq %%mm0, -8(%%edi,%%edx,) \n\t" // -8 to offset early addl edx -- "movq %%mm0, %%mm7 \n\t" // move calculated Raw(x) data -- // to mm1 to be new Raw(x-bpp) -- // for next loop -- "jb sub_8lpA \n\t" -- -- "sub_8lt8: \n\t" -- -- : "=a" (dummy_value_a), // 0 // output regs (dummy) -- "=D" (dummy_value_D) // 1 -- -- : "0" (bpp), // eax // input regs -- "1" (row) // edi -- -- : "%ecx", "%edx", "%esi" // clobber list --#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ -- , "%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7" --#endif -- ); -- } -- break; -- -- default: // bpp greater than 8 bytes GRR BOGUS -- { -- __asm__ __volatile__ ( -- "movl _dif, %%edx \n\t" --// preload "movl row, %%edi \n\t" -- "movl %%edi, %%esi \n\t" // lp = row --// preload "movl bpp, %%eax \n\t" -- "addl %%eax, %%edi \n\t" // rp = row + bpp -- -- "sub_Alp: \n\t" -- "movq (%%edi,%%edx,), %%mm0 \n\t" -- "movq (%%esi,%%edx,), %%mm1 \n\t" -- "addl $8, %%edx \n\t" -- "paddb %%mm1, %%mm0 \n\t" -- "cmpl _MMXLength, %%edx \n\t" -- "movq %%mm0, -8(%%edi,%%edx,) \n\t" // mov does not affect flags; -- // -8 to offset addl edx -- "jb sub_Alp \n\t" -- -- : "=a" (dummy_value_a), // 0 // output regs (dummy) -- "=D" (dummy_value_D) // 1 -- -- : "0" (bpp), // eax // input regs -- "1" (row) // edi -- -- : "%edx", "%esi" // clobber list --#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ -- , "%mm0", "%mm1" --#endif -- ); -- } -- break; -- -- } // end switch (bpp) -- -- __asm__ __volatile__ ( -- "movl _MMXLength, %%edx \n\t" --//pre "movl row, %%edi \n\t" -- "cmpl _FullLength, %%edx \n\t" -- "jnb sub_end \n\t" -- -- "movl %%edi, %%esi \n\t" // lp = row --//pre "movl bpp, %%eax \n\t" -- "addl %%eax, %%edi \n\t" // rp = row + bpp -- "xorl %%eax, %%eax \n\t" -- -- "sub_lp2: \n\t" -- "movb (%%esi,%%edx,), %%al \n\t" -- "addb %%al, (%%edi,%%edx,) \n\t" -- "incl %%edx \n\t" -- "cmpl _FullLength, %%edx \n\t" -- "jb sub_lp2 \n\t" -- -- "sub_end: \n\t" -- "EMMS \n\t" // end MMX instructions -- -- : "=a" (dummy_value_a), // 0 // output regs (dummy) -- "=D" (dummy_value_D) // 1 -- -- : "0" (bpp), // eax // input regs -- "1" (row) // edi -- -- : "%edx", "%esi" // clobber list -- ); -- --} // end of png_read_filter_row_mmx_sub() --#endif -- -- -- -- --//===========================================================================// --// // --// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ U P // --// // --//===========================================================================// -- --// Optimized code for PNG Up filter decoder -- --static void /* PRIVATE */ --png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row, -- png_bytep prev_row) --{ -- png_uint_32 len; -- int dummy_value_d; // fix 'forbidden register 3 (dx) was spilled' error -- int dummy_value_S; -- int dummy_value_D; -- -- len = row_info->rowbytes; // number of bytes to filter -- -- __asm__ __volatile__ ( --//pre "movl row, %%edi \n\t" -- // get # of bytes to alignment --#ifdef __PIC__ -- "pushl %%ebx \n\t" --#endif -- "movl %%edi, %%ecx \n\t" -- "xorl %%ebx, %%ebx \n\t" -- "addl $0x7, %%ecx \n\t" -- "xorl %%eax, %%eax \n\t" -- "andl $0xfffffff8, %%ecx \n\t" --//pre "movl prev_row, %%esi \n\t" -- "subl %%edi, %%ecx \n\t" -- "jz up_go \n\t" -- -- "up_lp1: \n\t" // fix alignment -- "movb (%%edi,%%ebx,), %%al \n\t" -- "addb (%%esi,%%ebx,), %%al \n\t" -- "incl %%ebx \n\t" -- "cmpl %%ecx, %%ebx \n\t" -- "movb %%al, -1(%%edi,%%ebx,) \n\t" // mov does not affect flags; -1 to -- "jb up_lp1 \n\t" // offset incl ebx -- -- "up_go: \n\t" --//pre "movl len, %%edx \n\t" -- "movl %%edx, %%ecx \n\t" -- "subl %%ebx, %%edx \n\t" // subtract alignment fix -- "andl $0x0000003f, %%edx \n\t" // calc bytes over mult of 64 -- "subl %%edx, %%ecx \n\t" // drop over bytes from length -- -- // unrolled loop - use all MMX registers and interleave to reduce -- // number of branch instructions (loops) and reduce partial stalls -- "up_loop: \n\t" -- "movq (%%esi,%%ebx,), %%mm1 \n\t" -- "movq (%%edi,%%ebx,), %%mm0 \n\t" -- "movq 8(%%esi,%%ebx,), %%mm3 \n\t" -- "paddb %%mm1, %%mm0 \n\t" -- "movq 8(%%edi,%%ebx,), %%mm2 \n\t" -- "movq %%mm0, (%%edi,%%ebx,) \n\t" -- "paddb %%mm3, %%mm2 \n\t" -- "movq 16(%%esi,%%ebx,), %%mm5 \n\t" -- "movq %%mm2, 8(%%edi,%%ebx,) \n\t" -- "movq 16(%%edi,%%ebx,), %%mm4 \n\t" -- "movq 24(%%esi,%%ebx,), %%mm7 \n\t" -- "paddb %%mm5, %%mm4 \n\t" -- "movq 24(%%edi,%%ebx,), %%mm6 \n\t" -- "movq %%mm4, 16(%%edi,%%ebx,) \n\t" -- "paddb %%mm7, %%mm6 \n\t" -- "movq 32(%%esi,%%ebx,), %%mm1 \n\t" -- "movq %%mm6, 24(%%edi,%%ebx,) \n\t" -- "movq 32(%%edi,%%ebx,), %%mm0 \n\t" -- "movq 40(%%esi,%%ebx,), %%mm3 \n\t" -- "paddb %%mm1, %%mm0 \n\t" -- "movq 40(%%edi,%%ebx,), %%mm2 \n\t" -- "movq %%mm0, 32(%%edi,%%ebx,) \n\t" -- "paddb %%mm3, %%mm2 \n\t" -- "movq 48(%%esi,%%ebx,), %%mm5 \n\t" -- "movq %%mm2, 40(%%edi,%%ebx,) \n\t" -- "movq 48(%%edi,%%ebx,), %%mm4 \n\t" -- "movq 56(%%esi,%%ebx,), %%mm7 \n\t" -- "paddb %%mm5, %%mm4 \n\t" -- "movq 56(%%edi,%%ebx,), %%mm6 \n\t" -- "movq %%mm4, 48(%%edi,%%ebx,) \n\t" -- "addl $64, %%ebx \n\t" -- "paddb %%mm7, %%mm6 \n\t" -- "cmpl %%ecx, %%ebx \n\t" -- "movq %%mm6, -8(%%edi,%%ebx,) \n\t" // (+56)movq does not affect flags; -- "jb up_loop \n\t" // -8 to offset addl ebx -- -- "cmpl $0, %%edx \n\t" // test for bytes over mult of 64 -- "jz up_end \n\t" -- -- "cmpl $8, %%edx \n\t" // test for less than 8 bytes -- "jb up_lt8 \n\t" // [added by lcreeve@netins.net] -- -- "addl %%edx, %%ecx \n\t" -- "andl $0x00000007, %%edx \n\t" // calc bytes over mult of 8 -- "subl %%edx, %%ecx \n\t" // drop over bytes from length -- "jz up_lt8 \n\t" -- -- "up_lpA: \n\t" // use MMX regs to update 8 bytes sim. -- "movq (%%esi,%%ebx,), %%mm1 \n\t" -- "movq (%%edi,%%ebx,), %%mm0 \n\t" -- "addl $8, %%ebx \n\t" -- "paddb %%mm1, %%mm0 \n\t" -- "cmpl %%ecx, %%ebx \n\t" -- "movq %%mm0, -8(%%edi,%%ebx,) \n\t" // movq does not affect flags; -8 to -- "jb up_lpA \n\t" // offset add ebx -- "cmpl $0, %%edx \n\t" // test for bytes over mult of 8 -- "jz up_end \n\t" -- -- "up_lt8: \n\t" -- "xorl %%eax, %%eax \n\t" -- "addl %%edx, %%ecx \n\t" // move over byte count into counter -- -- "up_lp2: \n\t" // use x86 regs for remaining bytes -- "movb (%%edi,%%ebx,), %%al \n\t" -- "addb (%%esi,%%ebx,), %%al \n\t" -- "incl %%ebx \n\t" -- "cmpl %%ecx, %%ebx \n\t" -- "movb %%al, -1(%%edi,%%ebx,) \n\t" // mov does not affect flags; -1 to -- "jb up_lp2 \n\t" // offset inc ebx -- -- "up_end: \n\t" -- "EMMS \n\t" // conversion of filtered row complete --#ifdef __PIC__ -- "popl %%ebx \n\t" --#endif -- -- : "=d" (dummy_value_d), // 0 // output regs (dummy) -- "=S" (dummy_value_S), // 1 -- "=D" (dummy_value_D) // 2 -- -- : "0" (len), // edx // input regs -- "1" (prev_row), // esi -- "2" (row) // edi -- -- : "%eax", "%ecx" // clobber list (no input regs!) --#ifndef __PIC__ -- , "%ebx" --#endif -- --#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ -- , "%mm0", "%mm1", "%mm2", "%mm3" -- , "%mm4", "%mm5", "%mm6", "%mm7" --#endif -- ); -- --} // end of png_read_filter_row_mmx_up() -- --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ -- -- -- -- --/*===========================================================================*/ --/* */ --/* P N G _ R E A D _ F I L T E R _ R O W */ --/* */ --/*===========================================================================*/ -- -- --/* Optimized png_read_filter_row routines */ -- --void /* PRIVATE */ --png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep -- row, png_bytep prev_row, int filter) --{ --#ifdef PNG_DEBUG -- char filnm[10]; --#endif -- --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) --/* GRR: these are superseded by png_ptr->asm_flags: */ --#define UseMMX_sub 1 // GRR: converted 20000730 --#define UseMMX_up 1 // GRR: converted 20000729 --#define UseMMX_avg 1 // GRR: converted 20000828 (+ 16-bit bugfix 20000916) --#define UseMMX_paeth 1 // GRR: converted 20000828 -- -- if (_mmx_supported == 2) { -- /* this should have happened in png_init_mmx_flags() already */ --#if !defined(PNG_1_0_X) -- png_warning(png_ptr, "asm_flags may not have been initialized"); --#endif -- png_mmx_support(); -- } --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ -- --#ifdef PNG_DEBUG -- png_debug(1, "in png_read_filter_row (pnggccrd.c)\n"); -- switch (filter) -- { -- case 0: sprintf(filnm, "none"); -- break; -- case 1: sprintf(filnm, "sub-%s", --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) --#if !defined(PNG_1_0_X) -- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "MMX" : --#endif --#endif --"x86"); -- break; -- case 2: sprintf(filnm, "up-%s", --#ifdef PNG_ASSEMBLER_CODE_SUPPORTED --#if !defined(PNG_1_0_X) -- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "MMX" : --#endif --#endif -- "x86"); -- break; -- case 3: sprintf(filnm, "avg-%s", --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) --#if !defined(PNG_1_0_X) -- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "MMX" : --#endif --#endif -- "x86"); -- break; -- case 4: sprintf(filnm, "Paeth-%s", --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) --#if !defined(PNG_1_0_X) -- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "MMX": --#endif --#endif --"x86"); -- break; -- default: sprintf(filnm, "unknw"); -- break; -- } -- png_debug2(0, "row_number=%5ld, %5s, ", png_ptr->row_number, filnm); -- png_debug1(0, "row=0x%08lx, ", (unsigned long)row); -- png_debug2(0, "pixdepth=%2d, bytes=%d, ", (int)row_info->pixel_depth, -- (int)((row_info->pixel_depth + 7) >> 3)); -- png_debug1(0,"rowbytes=%8ld\n", row_info->rowbytes); --#endif /* PNG_DEBUG */ -- -- switch (filter) -- { -- case PNG_FILTER_VALUE_NONE: -- break; -- -- case PNG_FILTER_VALUE_SUB: --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB) && -- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && -- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) --#else -- if (_mmx_supported) --#endif -- { -- png_read_filter_row_mmx_sub(row_info, row); -- } -- else --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ -- { -- png_uint_32 i; -- png_uint_32 istop = row_info->rowbytes; -- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; -- png_bytep rp = row + bpp; -- png_bytep lp = row; -- -- for (i = bpp; i < istop; i++) -- { -- *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff); -- rp++; -- } -- } /* end !UseMMX_sub */ -- break; -- -- case PNG_FILTER_VALUE_UP: --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP) && -- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && -- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) --#else -- if (_mmx_supported) --#endif -- { -- png_read_filter_row_mmx_up(row_info, row, prev_row); -- } -- else --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ -- { -- png_uint_32 i; -- png_uint_32 istop = row_info->rowbytes; -- png_bytep rp = row; -- png_bytep pp = prev_row; -- -- for (i = 0; i < istop; ++i) -- { -- *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); -- rp++; -- } -- } /* end !UseMMX_up */ -- break; -- -- case PNG_FILTER_VALUE_AVG: --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG) && -- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && -- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) --#else -- if (_mmx_supported) --#endif -- { -- png_read_filter_row_mmx_avg(row_info, row, prev_row); -- } -- else --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ -- { -- png_uint_32 i; -- png_bytep rp = row; -- png_bytep pp = prev_row; -- png_bytep lp = row; -- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; -- png_uint_32 istop = row_info->rowbytes - bpp; -- -- for (i = 0; i < bpp; i++) -- { -- *rp = (png_byte)(((int)(*rp) + -- ((int)(*pp++) >> 1)) & 0xff); -- rp++; -- } -- -- for (i = 0; i < istop; i++) -- { -- *rp = (png_byte)(((int)(*rp) + -- ((int)(*pp++ + *lp++) >> 1)) & 0xff); -- rp++; -- } -- } /* end !UseMMX_avg */ -- break; -- -- case PNG_FILTER_VALUE_PAETH: --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH) && -- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && -- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) --#else -- if (_mmx_supported) --#endif -- { -- png_read_filter_row_mmx_paeth(row_info, row, prev_row); -- } -- else --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ -- { -- png_uint_32 i; -- png_bytep rp = row; -- png_bytep pp = prev_row; -- png_bytep lp = row; -- png_bytep cp = prev_row; -- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; -- png_uint_32 istop = row_info->rowbytes - bpp; -- -- for (i = 0; i < bpp; i++) -- { -- *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); -- rp++; -- } -- -- for (i = 0; i < istop; i++) /* use leftover rp,pp */ -- { -- int a, b, c, pa, pb, pc, p; -- -- a = *lp++; -- b = *pp++; -- c = *cp++; -- -- p = b - c; -- pc = a - c; -- --#ifdef PNG_USE_ABS -- pa = abs(p); -- pb = abs(pc); -- pc = abs(p + pc); --#else -- pa = p < 0 ? -p : p; -- pb = pc < 0 ? -pc : pc; -- pc = (p + pc) < 0 ? -(p + pc) : p + pc; --#endif -- -- /* -- if (pa <= pb && pa <= pc) -- p = a; -- else if (pb <= pc) -- p = b; -- else -- p = c; -- */ -- -- p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c; -- -- *rp = (png_byte)(((int)(*rp) + p) & 0xff); -- rp++; -- } -- } /* end !UseMMX_paeth */ -- break; -- -- default: -- png_warning(png_ptr, "Ignoring bad row-filter type"); -- *row=0; -- break; -- } --} -- --#endif /* PNG_HAVE_ASSEMBLER_READ_FILTER_ROW */ -- -- --/*===========================================================================*/ --/* */ --/* P N G _ M M X _ S U P P O R T */ --/* */ --/*===========================================================================*/ -- --/* GRR NOTES: (1) the following code assumes 386 or better (pushfl/popfl) -- * (2) all instructions compile with gcc 2.7.2.3 and later -- * (3) the function is moved down here to prevent gcc from -- * inlining it in multiple places and then barfing be- -- * cause the ".NOT_SUPPORTED" label is multiply defined -- * [is there a way to signal that a *single* function should -- * not be inlined? is there a way to modify the label for -- * each inlined instance, e.g., by appending _1, _2, etc.? -- * maybe if don't use leading "." in label name? (nope...sigh)] -- */ -- --int PNGAPI --png_mmx_support(void) --{ --#if defined(PNG_MMX_CODE_SUPPORTED) -- __asm__ __volatile__ ( -- "pushl %%ebx \n\t" // ebx gets clobbered by CPUID instruction -- "pushl %%ecx \n\t" // so does ecx... -- "pushl %%edx \n\t" // ...and edx (but ecx & edx safe on Linux) --// ".byte 0x66 \n\t" // convert 16-bit pushf to 32-bit pushfd --// "pushf \n\t" // 16-bit pushf -- "pushfl \n\t" // save Eflag to stack -- "popl %%eax \n\t" // get Eflag from stack into eax -- "movl %%eax, %%ecx \n\t" // make another copy of Eflag in ecx -- "xorl $0x200000, %%eax \n\t" // toggle ID bit in Eflag (i.e., bit 21) -- "pushl %%eax \n\t" // save modified Eflag back to stack --// ".byte 0x66 \n\t" // convert 16-bit popf to 32-bit popfd --// "popf \n\t" // 16-bit popf -- "popfl \n\t" // restore modified value to Eflag reg -- "pushfl \n\t" // save Eflag to stack -- "popl %%eax \n\t" // get Eflag from stack -- "pushl %%ecx \n\t" // save original Eflag to stack -- "popfl \n\t" // restore original Eflag -- "xorl %%ecx, %%eax \n\t" // compare new Eflag with original Eflag -- "jz 0f \n\t" // if same, CPUID instr. is not supported -- -- "xorl %%eax, %%eax \n\t" // set eax to zero --// ".byte 0x0f, 0xa2 \n\t" // CPUID instruction (two-byte opcode) -- "cpuid \n\t" // get the CPU identification info -- "cmpl $1, %%eax \n\t" // make sure eax return non-zero value -- "jl 0f \n\t" // if eax is zero, MMX is not supported -- -- "xorl %%eax, %%eax \n\t" // set eax to zero and... -- "incl %%eax \n\t" // ...increment eax to 1. This pair is -- // faster than the instruction "mov eax, 1" -- "cpuid \n\t" // get the CPU identification info again -- "andl $0x800000, %%edx \n\t" // mask out all bits but MMX bit (23) -- "cmpl $0, %%edx \n\t" // 0 = MMX not supported -- "jz 0f \n\t" // non-zero = yes, MMX IS supported -- -- "movl $1, %%eax \n\t" // set return value to 1 -- "jmp 1f \n\t" // DONE: have MMX support -- -- "0: \n\t" // .NOT_SUPPORTED: target label for jump instructions -- "movl $0, %%eax \n\t" // set return value to 0 -- "1: \n\t" // .RETURN: target label for jump instructions -- "movl %%eax, _mmx_supported \n\t" // save in global static variable, too -- "popl %%edx \n\t" // restore edx -- "popl %%ecx \n\t" // restore ecx -- "popl %%ebx \n\t" // restore ebx -- --// "ret \n\t" // DONE: no MMX support -- // (fall through to standard C "ret") -- -- : // output list (none) -- -- : // any variables used on input (none) -- -- : "%eax" // clobber list --// , "%ebx", "%ecx", "%edx" // GRR: we handle these manually --// , "memory" // if write to a variable gcc thought was in a reg --// , "cc" // "condition codes" (flag bits) -- ); --#else -- _mmx_supported = 0; --#endif /* PNG_MMX_CODE_SUPPORTED */ -- -- return _mmx_supported; --} -- -- --#endif /* PNG_USE_PNGGCCRD */ -diff --git a/thirdparty/libpng/pngget.c b/thirdparty/libpng/pngget.c -deleted file mode 100644 -index 1d1cc21..0000000 ---- a/thirdparty/libpng/pngget.c -+++ /dev/null -@@ -1,934 +0,0 @@ -- --/* pngget.c - retrieval of values from info struct -- * -- * libpng 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- */ -- --#define PNG_INTERNAL --#include "png.h" -- --png_uint_32 PNGAPI --png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag) --{ -- if (png_ptr != NULL && info_ptr != NULL) -- return(info_ptr->valid & flag); -- else -- return(0); --} -- --png_uint_32 PNGAPI --png_get_rowbytes(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) -- return(info_ptr->rowbytes); -- else -- return(0); --} -- --#if defined(PNG_INFO_IMAGE_SUPPORTED) --png_bytepp PNGAPI --png_get_rows(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) -- return(info_ptr->row_pointers); -- else -- return(0); --} --#endif -- --#ifdef PNG_EASY_ACCESS_SUPPORTED --/* easy access to info, added in libpng-0.99 */ --png_uint_32 PNGAPI --png_get_image_width(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) -- { -- return info_ptr->width; -- } -- return (0); --} -- --png_uint_32 PNGAPI --png_get_image_height(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) -- { -- return info_ptr->height; -- } -- return (0); --} -- --png_byte PNGAPI --png_get_bit_depth(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) -- { -- return info_ptr->bit_depth; -- } -- return (0); --} -- --png_byte PNGAPI --png_get_color_type(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) -- { -- return info_ptr->color_type; -- } -- return (0); --} -- --png_byte PNGAPI --png_get_filter_type(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) -- { -- return info_ptr->filter_type; -- } -- return (0); --} -- --png_byte PNGAPI --png_get_interlace_type(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) -- { -- return info_ptr->interlace_type; -- } -- return (0); --} -- --png_byte PNGAPI --png_get_compression_type(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) -- { -- return info_ptr->compression_type; -- } -- return (0); --} -- --png_uint_32 PNGAPI --png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) --#if defined(PNG_pHYs_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_pHYs) -- { -- png_debug1(1, "in %s retrieval function\n", "png_get_x_pixels_per_meter"); -- if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER) -- return (0); -- else return (info_ptr->x_pixels_per_unit); -- } --#else -- return (0); --#endif -- return (0); --} -- --png_uint_32 PNGAPI --png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) --#if defined(PNG_pHYs_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_pHYs) -- { -- png_debug1(1, "in %s retrieval function\n", "png_get_y_pixels_per_meter"); -- if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER) -- return (0); -- else return (info_ptr->y_pixels_per_unit); -- } --#else -- return (0); --#endif -- return (0); --} -- --png_uint_32 PNGAPI --png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) --#if defined(PNG_pHYs_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_pHYs) -- { -- png_debug1(1, "in %s retrieval function\n", "png_get_pixels_per_meter"); -- if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER || -- info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit) -- return (0); -- else return (info_ptr->x_pixels_per_unit); -- } --#else -- return (0); --#endif -- return (0); --} -- --#ifdef PNG_FLOATING_POINT_SUPPORTED --float PNGAPI --png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr) -- { -- if (png_ptr != NULL && info_ptr != NULL) --#if defined(PNG_pHYs_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_pHYs) -- { -- png_debug1(1, "in %s retrieval function\n", "png_get_aspect_ratio"); -- if (info_ptr->x_pixels_per_unit == 0) -- return ((float)0.0); -- else -- return ((float)((float)info_ptr->y_pixels_per_unit -- /(float)info_ptr->x_pixels_per_unit)); -- } --#else -- return (0.0); --#endif -- return ((float)0.0); --} --#endif -- --png_int_32 PNGAPI --png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) --#if defined(PNG_oFFs_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_oFFs) -- { -- png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns"); -- if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER) -- return (0); -- else return (info_ptr->x_offset); -- } --#else -- return (0); --#endif -- return (0); --} -- --png_int_32 PNGAPI --png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) --#if defined(PNG_oFFs_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_oFFs) -- { -- png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns"); -- if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER) -- return (0); -- else return (info_ptr->y_offset); -- } --#else -- return (0); --#endif -- return (0); --} -- --png_int_32 PNGAPI --png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) --#if defined(PNG_oFFs_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_oFFs) -- { -- png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns"); -- if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL) -- return (0); -- else return (info_ptr->x_offset); -- } --#else -- return (0); --#endif -- return (0); --} -- --png_int_32 PNGAPI --png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) --#if defined(PNG_oFFs_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_oFFs) -- { -- png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns"); -- if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL) -- return (0); -- else return (info_ptr->y_offset); -- } --#else -- return (0); --#endif -- return (0); --} -- --#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED) --png_uint_32 PNGAPI --png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) --{ -- return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr) -- *.0254 +.5)); --} -- --png_uint_32 PNGAPI --png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) --{ -- return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr) -- *.0254 +.5)); --} -- --png_uint_32 PNGAPI --png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) --{ -- return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr) -- *.0254 +.5)); --} -- --float PNGAPI --png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr) --{ -- return ((float)png_get_x_offset_microns(png_ptr, info_ptr) -- *.00003937); --} -- --float PNGAPI --png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr) --{ -- return ((float)png_get_y_offset_microns(png_ptr, info_ptr) -- *.00003937); --} -- --#if defined(PNG_pHYs_SUPPORTED) --png_uint_32 PNGAPI --png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr, -- png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) --{ -- png_uint_32 retval = 0; -- -- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) -- { -- png_debug1(1, "in %s retrieval function\n", "pHYs"); -- if (res_x != NULL) -- { -- *res_x = info_ptr->x_pixels_per_unit; -- retval |= PNG_INFO_pHYs; -- } -- if (res_y != NULL) -- { -- *res_y = info_ptr->y_pixels_per_unit; -- retval |= PNG_INFO_pHYs; -- } -- if (unit_type != NULL) -- { -- *unit_type = (int)info_ptr->phys_unit_type; -- retval |= PNG_INFO_pHYs; -- if(*unit_type == 1) -- { -- if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50); -- if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50); -- } -- } -- } -- return (retval); --} --#endif /* PNG_pHYs_SUPPORTED */ --#endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */ -- --/* png_get_channels really belongs in here, too, but it's been around longer */ -- --#endif /* PNG_EASY_ACCESS_SUPPORTED */ -- --png_byte PNGAPI --png_get_channels(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) -- return(info_ptr->channels); -- else -- return (0); --} -- --png_bytep PNGAPI --png_get_signature(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr != NULL && info_ptr != NULL) -- return(info_ptr->signature); -- else -- return (NULL); --} -- --#if defined(PNG_bKGD_SUPPORTED) --png_uint_32 PNGAPI --png_get_bKGD(png_structp png_ptr, png_infop info_ptr, -- png_color_16p *background) --{ -- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD) -- && background != NULL) -- { -- png_debug1(1, "in %s retrieval function\n", "bKGD"); -- *background = &(info_ptr->background); -- return (PNG_INFO_bKGD); -- } -- return (0); --} --#endif -- --#if defined(PNG_cHRM_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED --png_uint_32 PNGAPI --png_get_cHRM(png_structp png_ptr, png_infop info_ptr, -- double *white_x, double *white_y, double *red_x, double *red_y, -- double *green_x, double *green_y, double *blue_x, double *blue_y) --{ -- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) -- { -- png_debug1(1, "in %s retrieval function\n", "cHRM"); -- if (white_x != NULL) -- *white_x = (double)info_ptr->x_white; -- if (white_y != NULL) -- *white_y = (double)info_ptr->y_white; -- if (red_x != NULL) -- *red_x = (double)info_ptr->x_red; -- if (red_y != NULL) -- *red_y = (double)info_ptr->y_red; -- if (green_x != NULL) -- *green_x = (double)info_ptr->x_green; -- if (green_y != NULL) -- *green_y = (double)info_ptr->y_green; -- if (blue_x != NULL) -- *blue_x = (double)info_ptr->x_blue; -- if (blue_y != NULL) -- *blue_y = (double)info_ptr->y_blue; -- return (PNG_INFO_cHRM); -- } -- return (0); --} --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED --png_uint_32 PNGAPI --png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr, -- png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x, -- png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y, -- png_fixed_point *blue_x, png_fixed_point *blue_y) --{ -- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) -- { -- png_debug1(1, "in %s retrieval function\n", "cHRM"); -- if (white_x != NULL) -- *white_x = info_ptr->int_x_white; -- if (white_y != NULL) -- *white_y = info_ptr->int_y_white; -- if (red_x != NULL) -- *red_x = info_ptr->int_x_red; -- if (red_y != NULL) -- *red_y = info_ptr->int_y_red; -- if (green_x != NULL) -- *green_x = info_ptr->int_x_green; -- if (green_y != NULL) -- *green_y = info_ptr->int_y_green; -- if (blue_x != NULL) -- *blue_x = info_ptr->int_x_blue; -- if (blue_y != NULL) -- *blue_y = info_ptr->int_y_blue; -- return (PNG_INFO_cHRM); -- } -- return (0); --} --#endif --#endif -- --#if defined(PNG_gAMA_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED --png_uint_32 PNGAPI --png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma) --{ -- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) -- && file_gamma != NULL) -- { -- png_debug1(1, "in %s retrieval function\n", "gAMA"); -- *file_gamma = (double)info_ptr->gamma; -- return (PNG_INFO_gAMA); -- } -- return (0); --} --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED --png_uint_32 PNGAPI --png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, -- png_fixed_point *int_file_gamma) --{ -- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) -- && int_file_gamma != NULL) -- { -- png_debug1(1, "in %s retrieval function\n", "gAMA"); -- *int_file_gamma = info_ptr->int_gamma; -- return (PNG_INFO_gAMA); -- } -- return (0); --} --#endif --#endif -- --#if defined(PNG_sRGB_SUPPORTED) --png_uint_32 PNGAPI --png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent) --{ -- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB) -- && file_srgb_intent != NULL) -- { -- png_debug1(1, "in %s retrieval function\n", "sRGB"); -- *file_srgb_intent = (int)info_ptr->srgb_intent; -- return (PNG_INFO_sRGB); -- } -- return (0); --} --#endif -- --#if defined(PNG_iCCP_SUPPORTED) --png_uint_32 PNGAPI --png_get_iCCP(png_structp png_ptr, png_infop info_ptr, -- png_charpp name, int *compression_type, -- png_charpp profile, png_uint_32 *proflen) --{ -- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP) -- && name != NULL && profile != NULL && proflen != NULL) -- { -- png_debug1(1, "in %s retrieval function\n", "iCCP"); -- *name = info_ptr->iccp_name; -- *profile = info_ptr->iccp_profile; -- /* compression_type is a dummy so the API won't have to change -- if we introduce multiple compression types later. */ -- *proflen = (int)info_ptr->iccp_proflen; -- *compression_type = (int)info_ptr->iccp_compression; -- return (PNG_INFO_iCCP); -- } -- return (0); --} --#endif -- --#if defined(PNG_sPLT_SUPPORTED) --png_uint_32 PNGAPI --png_get_sPLT(png_structp png_ptr, png_infop info_ptr, -- png_sPLT_tpp spalettes) --{ -- if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL) -- *spalettes = info_ptr->splt_palettes; -- return ((png_uint_32)info_ptr->splt_palettes_num); --} --#endif -- --#if defined(PNG_hIST_SUPPORTED) --png_uint_32 PNGAPI --png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist) --{ -- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST) -- && hist != NULL) -- { -- png_debug1(1, "in %s retrieval function\n", "hIST"); -- *hist = info_ptr->hist; -- return (PNG_INFO_hIST); -- } -- return (0); --} --#endif -- --png_uint_32 PNGAPI --png_get_IHDR(png_structp png_ptr, png_infop info_ptr, -- png_uint_32 *width, png_uint_32 *height, int *bit_depth, -- int *color_type, int *interlace_type, int *compression_type, -- int *filter_type) -- --{ -- if (png_ptr != NULL && info_ptr != NULL && width != NULL && height != NULL && -- bit_depth != NULL && color_type != NULL) -- { -- png_debug1(1, "in %s retrieval function\n", "IHDR"); -- *width = info_ptr->width; -- *height = info_ptr->height; -- *bit_depth = info_ptr->bit_depth; -- if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16) -- png_error(png_ptr, "Invalid bit depth"); -- *color_type = info_ptr->color_type; -- if (info_ptr->color_type > 6) -- png_error(png_ptr, "Invalid color type"); -- if (compression_type != NULL) -- *compression_type = info_ptr->compression_type; -- if (filter_type != NULL) -- *filter_type = info_ptr->filter_type; -- if (interlace_type != NULL) -- *interlace_type = info_ptr->interlace_type; -- -- /* check for potential overflow of rowbytes */ -- if (width == 0 || *width > PNG_UINT_31_MAX) -- png_error(png_ptr, "Invalid image width"); -- if (height == 0 || *height > PNG_UINT_31_MAX) -- png_error(png_ptr, "Invalid image height"); -- if (info_ptr->width > (PNG_UINT_32_MAX -- >> 3) /* 8-byte RGBA pixels */ -- - 64 /* bigrowbuf hack */ -- - 1 /* filter byte */ -- - 7*8 /* rounding of width to multiple of 8 pixels */ -- - 8) /* extra max_pixel_depth pad */ -- { -- png_warning(png_ptr, -- "Width too large for libpng to process image data."); -- } -- return (1); -- } -- return (0); --} -- --#if defined(PNG_oFFs_SUPPORTED) --png_uint_32 PNGAPI --png_get_oFFs(png_structp png_ptr, png_infop info_ptr, -- png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type) --{ -- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs) -- && offset_x != NULL && offset_y != NULL && unit_type != NULL) -- { -- png_debug1(1, "in %s retrieval function\n", "oFFs"); -- *offset_x = info_ptr->x_offset; -- *offset_y = info_ptr->y_offset; -- *unit_type = (int)info_ptr->offset_unit_type; -- return (PNG_INFO_oFFs); -- } -- return (0); --} --#endif -- --#if defined(PNG_pCAL_SUPPORTED) --png_uint_32 PNGAPI --png_get_pCAL(png_structp png_ptr, png_infop info_ptr, -- png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams, -- png_charp *units, png_charpp *params) --{ -- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL) -- && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL && -- nparams != NULL && units != NULL && params != NULL) -- { -- png_debug1(1, "in %s retrieval function\n", "pCAL"); -- *purpose = info_ptr->pcal_purpose; -- *X0 = info_ptr->pcal_X0; -- *X1 = info_ptr->pcal_X1; -- *type = (int)info_ptr->pcal_type; -- *nparams = (int)info_ptr->pcal_nparams; -- *units = info_ptr->pcal_units; -- *params = info_ptr->pcal_params; -- return (PNG_INFO_pCAL); -- } -- return (0); --} --#endif -- --#if defined(PNG_sCAL_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED --png_uint_32 PNGAPI --png_get_sCAL(png_structp png_ptr, png_infop info_ptr, -- int *unit, double *width, double *height) --{ -- if (png_ptr != NULL && info_ptr != NULL && -- (info_ptr->valid & PNG_INFO_sCAL)) -- { -- *unit = info_ptr->scal_unit; -- *width = info_ptr->scal_pixel_width; -- *height = info_ptr->scal_pixel_height; -- return (PNG_INFO_sCAL); -- } -- return(0); --} --#else --#ifdef PNG_FIXED_POINT_SUPPORTED --png_uint_32 PNGAPI --png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr, -- int *unit, png_charpp width, png_charpp height) --{ -- if (png_ptr != NULL && info_ptr != NULL && -- (info_ptr->valid & PNG_INFO_sCAL)) -- { -- *unit = info_ptr->scal_unit; -- *width = info_ptr->scal_s_width; -- *height = info_ptr->scal_s_height; -- return (PNG_INFO_sCAL); -- } -- return(0); --} --#endif --#endif --#endif -- --#if defined(PNG_pHYs_SUPPORTED) --png_uint_32 PNGAPI --png_get_pHYs(png_structp png_ptr, png_infop info_ptr, -- png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) --{ -- png_uint_32 retval = 0; -- -- if (png_ptr != NULL && info_ptr != NULL && -- (info_ptr->valid & PNG_INFO_pHYs)) -- { -- png_debug1(1, "in %s retrieval function\n", "pHYs"); -- if (res_x != NULL) -- { -- *res_x = info_ptr->x_pixels_per_unit; -- retval |= PNG_INFO_pHYs; -- } -- if (res_y != NULL) -- { -- *res_y = info_ptr->y_pixels_per_unit; -- retval |= PNG_INFO_pHYs; -- } -- if (unit_type != NULL) -- { -- *unit_type = (int)info_ptr->phys_unit_type; -- retval |= PNG_INFO_pHYs; -- } -- } -- return (retval); --} --#endif -- --png_uint_32 PNGAPI --png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette, -- int *num_palette) --{ -- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE) -- && palette != NULL) -- { -- png_debug1(1, "in %s retrieval function\n", "PLTE"); -- *palette = info_ptr->palette; -- *num_palette = info_ptr->num_palette; -- png_debug1(3, "num_palette = %d\n", *num_palette); -- return (PNG_INFO_PLTE); -- } -- return (0); --} -- --#if defined(PNG_sBIT_SUPPORTED) --png_uint_32 PNGAPI --png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit) --{ -- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT) -- && sig_bit != NULL) -- { -- png_debug1(1, "in %s retrieval function\n", "sBIT"); -- *sig_bit = &(info_ptr->sig_bit); -- return (PNG_INFO_sBIT); -- } -- return (0); --} --#endif -- --#if defined(PNG_TEXT_SUPPORTED) --png_uint_32 PNGAPI --png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr, -- int *num_text) --{ -- if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0) -- { -- png_debug1(1, "in %s retrieval function\n", -- (png_ptr->chunk_name[0] == '\0' ? "text" -- : (png_const_charp)png_ptr->chunk_name)); -- if (text_ptr != NULL) -- *text_ptr = info_ptr->text; -- if (num_text != NULL) -- *num_text = info_ptr->num_text; -- return ((png_uint_32)info_ptr->num_text); -- } -- if (num_text != NULL) -- *num_text = 0; -- return(0); --} --#endif -- --#if defined(PNG_tIME_SUPPORTED) --png_uint_32 PNGAPI --png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time) --{ -- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME) -- && mod_time != NULL) -- { -- png_debug1(1, "in %s retrieval function\n", "tIME"); -- *mod_time = &(info_ptr->mod_time); -- return (PNG_INFO_tIME); -- } -- return (0); --} --#endif -- --#if defined(PNG_tRNS_SUPPORTED) --png_uint_32 PNGAPI --png_get_tRNS(png_structp png_ptr, png_infop info_ptr, -- png_bytep *trans, int *num_trans, png_color_16p *trans_values) --{ -- png_uint_32 retval = 0; -- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) -- { -- png_debug1(1, "in %s retrieval function\n", "tRNS"); -- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- { -- if (trans != NULL) -- { -- *trans = info_ptr->trans; -- retval |= PNG_INFO_tRNS; -- } -- if (trans_values != NULL) -- *trans_values = &(info_ptr->trans_values); -- } -- else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */ -- { -- if (trans_values != NULL) -- { -- *trans_values = &(info_ptr->trans_values); -- retval |= PNG_INFO_tRNS; -- } -- if(trans != NULL) -- *trans = NULL; -- } -- if(num_trans != NULL) -- { -- *num_trans = info_ptr->num_trans; -- retval |= PNG_INFO_tRNS; -- } -- } -- return (retval); --} --#endif -- --#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) --png_uint_32 PNGAPI --png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr, -- png_unknown_chunkpp unknowns) --{ -- if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL) -- *unknowns = info_ptr->unknown_chunks; -- return ((png_uint_32)info_ptr->unknown_chunks_num); --} --#endif -- --#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) --png_byte PNGAPI --png_get_rgb_to_gray_status (png_structp png_ptr) --{ -- return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0); --} --#endif -- --#if defined(PNG_USER_CHUNKS_SUPPORTED) --png_voidp PNGAPI --png_get_user_chunk_ptr(png_structp png_ptr) --{ -- return (png_ptr? png_ptr->user_chunk_ptr : NULL); --} --#endif -- --#ifdef PNG_WRITE_SUPPORTED --png_uint_32 PNGAPI --png_get_compression_buffer_size(png_structp png_ptr) --{ -- return (png_uint_32)(png_ptr? png_ptr->zbuf_size : 0L); --} --#endif -- --#ifndef PNG_1_0_X --#ifdef PNG_ASSEMBLER_CODE_SUPPORTED --/* this function was added to libpng 1.2.0 and should exist by default */ --png_uint_32 PNGAPI --png_get_asm_flags (png_structp png_ptr) --{ -- return (png_uint_32)(png_ptr? png_ptr->asm_flags : 0L); --} -- --/* this function was added to libpng 1.2.0 and should exist by default */ --png_uint_32 PNGAPI --png_get_asm_flagmask (int flag_select) --{ -- png_uint_32 settable_asm_flags = 0; -- -- if (flag_select & PNG_SELECT_READ) -- settable_asm_flags |= -- PNG_ASM_FLAG_MMX_READ_COMBINE_ROW | -- PNG_ASM_FLAG_MMX_READ_INTERLACE | -- PNG_ASM_FLAG_MMX_READ_FILTER_SUB | -- PNG_ASM_FLAG_MMX_READ_FILTER_UP | -- PNG_ASM_FLAG_MMX_READ_FILTER_AVG | -- PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ; -- /* no non-MMX flags yet */ -- --#if 0 -- /* GRR: no write-flags yet, either, but someday... */ -- if (flag_select & PNG_SELECT_WRITE) -- settable_asm_flags |= -- PNG_ASM_FLAG_MMX_WRITE_ [whatever] ; --#endif /* 0 */ -- -- return settable_asm_flags; /* _theoretically_ settable capabilities only */ --} --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ -- -- --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) -- /* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */ --/* this function was added to libpng 1.2.0 */ --png_uint_32 PNGAPI --png_get_mmx_flagmask (int flag_select, int *compilerID) --{ -- png_uint_32 settable_mmx_flags = 0; -- -- if (flag_select & PNG_SELECT_READ) -- settable_mmx_flags |= -- PNG_ASM_FLAG_MMX_READ_COMBINE_ROW | -- PNG_ASM_FLAG_MMX_READ_INTERLACE | -- PNG_ASM_FLAG_MMX_READ_FILTER_SUB | -- PNG_ASM_FLAG_MMX_READ_FILTER_UP | -- PNG_ASM_FLAG_MMX_READ_FILTER_AVG | -- PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ; --#if 0 -- /* GRR: no MMX write support yet, but someday... */ -- if (flag_select & PNG_SELECT_WRITE) -- settable_mmx_flags |= -- PNG_ASM_FLAG_MMX_WRITE_ [whatever] ; --#endif /* 0 */ -- -- if (compilerID != NULL) { --#ifdef PNG_USE_PNGVCRD -- *compilerID = 1; /* MSVC */ --#else --#ifdef PNG_USE_PNGGCCRD -- *compilerID = 2; /* gcc/gas */ --#else -- *compilerID = -1; /* unknown (i.e., no asm/MMX code compiled) */ --#endif --#endif -- } -- -- return settable_mmx_flags; /* _theoretically_ settable capabilities only */ --} -- --/* this function was added to libpng 1.2.0 */ --png_byte PNGAPI --png_get_mmx_bitdepth_threshold (png_structp png_ptr) --{ -- return (png_byte)(png_ptr? png_ptr->mmx_bitdepth_threshold : 0); --} -- --/* this function was added to libpng 1.2.0 */ --png_uint_32 PNGAPI --png_get_mmx_rowbytes_threshold (png_structp png_ptr) --{ -- return (png_uint_32)(png_ptr? png_ptr->mmx_rowbytes_threshold : 0L); --} --#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */ -- --#ifdef PNG_SET_USER_LIMITS_SUPPORTED --/* these functions were added to libpng 1.2.6 */ --png_uint_32 PNGAPI --png_get_user_width_max (png_structp png_ptr) --{ -- return (png_ptr? png_ptr->user_width_max : 0); --} --png_uint_32 PNGAPI --png_get_user_height_max (png_structp png_ptr) --{ -- return (png_ptr? png_ptr->user_height_max : 0); --} --#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */ -- --#endif /* ?PNG_1_0_X */ -diff --git a/thirdparty/libpng/pngmem.c b/thirdparty/libpng/pngmem.c -deleted file mode 100644 -index 2682394..0000000 ---- a/thirdparty/libpng/pngmem.c -+++ /dev/null -@@ -1,595 +0,0 @@ -- --/* pngmem.c - stub functions for memory allocation -- * -- * libpng version 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- * -- * This file provides a location for all memory allocation. Users who -- * need special memory handling are expected to supply replacement -- * functions for png_malloc() and png_free(), and to use -- * png_create_read_struct_2() and png_create_write_struct_2() to -- * identify the replacement functions. -- */ -- --#define PNG_INTERNAL --#include "png.h" -- --/* Borland DOS special memory handler */ --#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) --/* if you change this, be sure to change the one in png.h also */ -- --/* Allocate memory for a png_struct. The malloc and memset can be replaced -- by a single call to calloc() if this is thought to improve performance. */ --png_voidp /* PRIVATE */ --png_create_struct(int type) --{ --#ifdef PNG_USER_MEM_SUPPORTED -- return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL)); --} -- --/* Alternate version of png_create_struct, for use with user-defined malloc. */ --png_voidp /* PRIVATE */ --png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr) --{ --#endif /* PNG_USER_MEM_SUPPORTED */ -- png_size_t size; -- png_voidp struct_ptr; -- -- if (type == PNG_STRUCT_INFO) -- size = png_sizeof(png_info); -- else if (type == PNG_STRUCT_PNG) -- size = png_sizeof(png_struct); -- else -- return (png_get_copyright(NULL)); -- --#ifdef PNG_USER_MEM_SUPPORTED -- if(malloc_fn != NULL) -- { -- png_struct dummy_struct; -- png_structp png_ptr = &dummy_struct; -- png_ptr->mem_ptr=mem_ptr; -- struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size); -- } -- else --#endif /* PNG_USER_MEM_SUPPORTED */ -- struct_ptr = (png_voidp)farmalloc(size); -- if (struct_ptr != NULL) -- png_memset(struct_ptr, 0, size); -- return (struct_ptr); --} -- --/* Free memory allocated by a png_create_struct() call */ --void /* PRIVATE */ --png_destroy_struct(png_voidp struct_ptr) --{ --#ifdef PNG_USER_MEM_SUPPORTED -- png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL); --} -- --/* Free memory allocated by a png_create_struct() call */ --void /* PRIVATE */ --png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, -- png_voidp mem_ptr) --{ --#endif -- if (struct_ptr != NULL) -- { --#ifdef PNG_USER_MEM_SUPPORTED -- if(free_fn != NULL) -- { -- png_struct dummy_struct; -- png_structp png_ptr = &dummy_struct; -- png_ptr->mem_ptr=mem_ptr; -- (*(free_fn))(png_ptr, struct_ptr); -- return; -- } --#endif /* PNG_USER_MEM_SUPPORTED */ -- farfree (struct_ptr); -- } --} -- --/* Allocate memory. For reasonable files, size should never exceed -- * 64K. However, zlib may allocate more then 64K if you don't tell -- * it not to. See zconf.h and png.h for more information. zlib does -- * need to allocate exactly 64K, so whatever you call here must -- * have the ability to do that. -- * -- * Borland seems to have a problem in DOS mode for exactly 64K. -- * It gives you a segment with an offset of 8 (perhaps to store its -- * memory stuff). zlib doesn't like this at all, so we have to -- * detect and deal with it. This code should not be needed in -- * Windows or OS/2 modes, and only in 16 bit mode. This code has -- * been updated by Alexander Lehmann for version 0.89 to waste less -- * memory. -- * -- * Note that we can't use png_size_t for the "size" declaration, -- * since on some systems a png_size_t is a 16-bit quantity, and as a -- * result, we would be truncating potentially larger memory requests -- * (which should cause a fatal error) and introducing major problems. -- */ -- --png_voidp PNGAPI --png_malloc(png_structp png_ptr, png_uint_32 size) --{ -- png_voidp ret; -- -- if (png_ptr == NULL || size == 0) -- return (NULL); -- --#ifdef PNG_USER_MEM_SUPPORTED -- if(png_ptr->malloc_fn != NULL) -- ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size)); -- else -- ret = (png_malloc_default(png_ptr, size)); -- if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) -- png_error(png_ptr, "Out of memory!"); -- return (ret); --} -- --png_voidp PNGAPI --png_malloc_default(png_structp png_ptr, png_uint_32 size) --{ -- png_voidp ret; --#endif /* PNG_USER_MEM_SUPPORTED */ -- --#ifdef PNG_MAX_MALLOC_64K -- if (size > (png_uint_32)65536L) -- { -- png_warning(png_ptr, "Cannot Allocate > 64K"); -- ret = NULL; -- } -- else --#endif -- -- if (size != (size_t)size) -- ret = NULL; -- else if (size == (png_uint_32)65536L) -- { -- if (png_ptr->offset_table == NULL) -- { -- /* try to see if we need to do any of this fancy stuff */ -- ret = farmalloc(size); -- if (ret == NULL || ((png_size_t)ret & 0xffff)) -- { -- int num_blocks; -- png_uint_32 total_size; -- png_bytep table; -- int i; -- png_byte huge * hptr; -- -- if (ret != NULL) -- { -- farfree(ret); -- ret = NULL; -- } -- -- if(png_ptr->zlib_window_bits > 14) -- num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14)); -- else -- num_blocks = 1; -- if (png_ptr->zlib_mem_level >= 7) -- num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7)); -- else -- num_blocks++; -- -- total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16; -- -- table = farmalloc(total_size); -- -- if (table == NULL) -- { --#ifndef PNG_USER_MEM_SUPPORTED -- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) -- png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */ -- else -- png_warning(png_ptr, "Out Of Memory."); --#endif -- return (NULL); -- } -- -- if ((png_size_t)table & 0xfff0) -- { --#ifndef PNG_USER_MEM_SUPPORTED -- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) -- png_error(png_ptr, -- "Farmalloc didn't return normalized pointer"); -- else -- png_warning(png_ptr, -- "Farmalloc didn't return normalized pointer"); --#endif -- return (NULL); -- } -- -- png_ptr->offset_table = table; -- png_ptr->offset_table_ptr = farmalloc(num_blocks * -- png_sizeof (png_bytep)); -- -- if (png_ptr->offset_table_ptr == NULL) -- { --#ifndef PNG_USER_MEM_SUPPORTED -- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) -- png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */ -- else -- png_warning(png_ptr, "Out Of memory."); --#endif -- return (NULL); -- } -- -- hptr = (png_byte huge *)table; -- if ((png_size_t)hptr & 0xf) -- { -- hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L); -- hptr = hptr + 16L; /* "hptr += 16L" fails on Turbo C++ 3.0 */ -- } -- for (i = 0; i < num_blocks; i++) -- { -- png_ptr->offset_table_ptr[i] = (png_bytep)hptr; -- hptr = hptr + (png_uint_32)65536L; /* "+=" fails on TC++3.0 */ -- } -- -- png_ptr->offset_table_number = num_blocks; -- png_ptr->offset_table_count = 0; -- png_ptr->offset_table_count_free = 0; -- } -- } -- -- if (png_ptr->offset_table_count >= png_ptr->offset_table_number) -- { --#ifndef PNG_USER_MEM_SUPPORTED -- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) -- png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */ -- else -- png_warning(png_ptr, "Out of Memory."); --#endif -- return (NULL); -- } -- -- ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++]; -- } -- else -- ret = farmalloc(size); -- --#ifndef PNG_USER_MEM_SUPPORTED -- if (ret == NULL) -- { -- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) -- png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */ -- else -- png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */ -- } --#endif -- -- return (ret); --} -- --/* free a pointer allocated by png_malloc(). In the default -- configuration, png_ptr is not used, but is passed in case it -- is needed. If ptr is NULL, return without taking any action. */ --void PNGAPI --png_free(png_structp png_ptr, png_voidp ptr) --{ -- if (png_ptr == NULL || ptr == NULL) -- return; -- --#ifdef PNG_USER_MEM_SUPPORTED -- if (png_ptr->free_fn != NULL) -- { -- (*(png_ptr->free_fn))(png_ptr, ptr); -- return; -- } -- else png_free_default(png_ptr, ptr); --} -- --void PNGAPI --png_free_default(png_structp png_ptr, png_voidp ptr) --{ --#endif /* PNG_USER_MEM_SUPPORTED */ -- -- if (png_ptr->offset_table != NULL) -- { -- int i; -- -- for (i = 0; i < png_ptr->offset_table_count; i++) -- { -- if (ptr == png_ptr->offset_table_ptr[i]) -- { -- ptr = NULL; -- png_ptr->offset_table_count_free++; -- break; -- } -- } -- if (png_ptr->offset_table_count_free == png_ptr->offset_table_count) -- { -- farfree(png_ptr->offset_table); -- farfree(png_ptr->offset_table_ptr); -- png_ptr->offset_table = NULL; -- png_ptr->offset_table_ptr = NULL; -- } -- } -- -- if (ptr != NULL) -- { -- farfree(ptr); -- } --} -- --#else /* Not the Borland DOS special memory handler */ -- --/* Allocate memory for a png_struct or a png_info. The malloc and -- memset can be replaced by a single call to calloc() if this is thought -- to improve performance noticably. */ --png_voidp /* PRIVATE */ --png_create_struct(int type) --{ --#ifdef PNG_USER_MEM_SUPPORTED -- return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL)); --} -- --/* Allocate memory for a png_struct or a png_info. The malloc and -- memset can be replaced by a single call to calloc() if this is thought -- to improve performance noticably. */ --png_voidp /* PRIVATE */ --png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr) --{ --#endif /* PNG_USER_MEM_SUPPORTED */ -- png_size_t size; -- png_voidp struct_ptr; -- -- if (type == PNG_STRUCT_INFO) -- size = png_sizeof(png_info); -- else if (type == PNG_STRUCT_PNG) -- size = png_sizeof(png_struct); -- else -- return (NULL); -- --#ifdef PNG_USER_MEM_SUPPORTED -- if(malloc_fn != NULL) -- { -- png_struct dummy_struct; -- png_structp png_ptr = &dummy_struct; -- png_ptr->mem_ptr=mem_ptr; -- struct_ptr = (*(malloc_fn))(png_ptr, size); -- if (struct_ptr != NULL) -- png_memset(struct_ptr, 0, size); -- return (struct_ptr); -- } --#endif /* PNG_USER_MEM_SUPPORTED */ -- --#if defined(__TURBOC__) && !defined(__FLAT__) -- struct_ptr = (png_voidp)farmalloc(size); --#else --# if defined(_MSC_VER) && defined(MAXSEG_64K) -- struct_ptr = (png_voidp)halloc(size,1); --# else -- struct_ptr = (png_voidp)malloc(size); --# endif --#endif -- if (struct_ptr != NULL) -- png_memset(struct_ptr, 0, size); -- -- return (struct_ptr); --} -- -- --/* Free memory allocated by a png_create_struct() call */ --void /* PRIVATE */ --png_destroy_struct(png_voidp struct_ptr) --{ --#ifdef PNG_USER_MEM_SUPPORTED -- png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL); --} -- --/* Free memory allocated by a png_create_struct() call */ --void /* PRIVATE */ --png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, -- png_voidp mem_ptr) --{ --#endif /* PNG_USER_MEM_SUPPORTED */ -- if (struct_ptr != NULL) -- { --#ifdef PNG_USER_MEM_SUPPORTED -- if(free_fn != NULL) -- { -- png_struct dummy_struct; -- png_structp png_ptr = &dummy_struct; -- png_ptr->mem_ptr=mem_ptr; -- (*(free_fn))(png_ptr, struct_ptr); -- return; -- } --#endif /* PNG_USER_MEM_SUPPORTED */ --#if defined(__TURBOC__) && !defined(__FLAT__) -- farfree(struct_ptr); --#else --# if defined(_MSC_VER) && defined(MAXSEG_64K) -- hfree(struct_ptr); --# else -- free(struct_ptr); --# endif --#endif -- } --} -- --/* Allocate memory. For reasonable files, size should never exceed -- 64K. However, zlib may allocate more then 64K if you don't tell -- it not to. See zconf.h and png.h for more information. zlib does -- need to allocate exactly 64K, so whatever you call here must -- have the ability to do that. */ -- --png_voidp PNGAPI --png_malloc(png_structp png_ptr, png_uint_32 size) --{ -- png_voidp ret; -- --#ifdef PNG_USER_MEM_SUPPORTED -- if (png_ptr == NULL || size == 0) -- return (NULL); -- -- if(png_ptr->malloc_fn != NULL) -- ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size)); -- else -- ret = (png_malloc_default(png_ptr, size)); -- if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) -- png_error(png_ptr, "Out of Memory!"); -- return (ret); --} -- --png_voidp PNGAPI --png_malloc_default(png_structp png_ptr, png_uint_32 size) --{ -- png_voidp ret; --#endif /* PNG_USER_MEM_SUPPORTED */ -- -- if (png_ptr == NULL || size == 0) -- return (NULL); -- --#ifdef PNG_MAX_MALLOC_64K -- if (size > (png_uint_32)65536L) -- { --#ifndef PNG_USER_MEM_SUPPORTED -- if(png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) -- png_error(png_ptr, "Cannot Allocate > 64K"); -- else --#endif -- return NULL; -- } --#endif -- -- /* Check for overflow */ --#if defined(__TURBOC__) && !defined(__FLAT__) -- if (size != (unsigned long)size) -- ret = NULL; -- else -- ret = farmalloc(size); --#else --# if defined(_MSC_VER) && defined(MAXSEG_64K) -- if (size != (unsigned long)size) -- ret = NULL; -- else -- ret = halloc(size, 1); --# else -- if (size != (size_t)size) -- ret = NULL; -- else -- ret = malloc((size_t)size); --# endif --#endif -- --#ifndef PNG_USER_MEM_SUPPORTED -- if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) -- png_error(png_ptr, "Out of Memory"); --#endif -- -- return (ret); --} -- --/* Free a pointer allocated by png_malloc(). If ptr is NULL, return -- without taking any action. */ --void PNGAPI --png_free(png_structp png_ptr, png_voidp ptr) --{ -- if (png_ptr == NULL || ptr == NULL) -- return; -- --#ifdef PNG_USER_MEM_SUPPORTED -- if (png_ptr->free_fn != NULL) -- { -- (*(png_ptr->free_fn))(png_ptr, ptr); -- return; -- } -- else png_free_default(png_ptr, ptr); --} --void PNGAPI --png_free_default(png_structp png_ptr, png_voidp ptr) --{ -- if (png_ptr == NULL || ptr == NULL) -- return; -- --#endif /* PNG_USER_MEM_SUPPORTED */ -- --#if defined(__TURBOC__) && !defined(__FLAT__) -- farfree(ptr); --#else --# if defined(_MSC_VER) && defined(MAXSEG_64K) -- hfree(ptr); --# else -- free(ptr); --# endif --#endif --} -- --#endif /* Not Borland DOS special memory handler */ -- --#if defined(PNG_1_0_X) --# define png_malloc_warn png_malloc --#else --/* This function was added at libpng version 1.2.3. The png_malloc_warn() -- * function will set up png_malloc() to issue a png_warning and return NULL -- * instead of issuing a png_error, if it fails to allocate the requested -- * memory. -- */ --png_voidp PNGAPI --png_malloc_warn(png_structp png_ptr, png_uint_32 size) --{ -- png_voidp ptr; -- png_uint_32 save_flags=png_ptr->flags; -- -- png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; -- ptr = (png_voidp)png_malloc((png_structp)png_ptr, size); -- png_ptr->flags=save_flags; -- return(ptr); --} --#endif -- --png_voidp PNGAPI --png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2, -- png_uint_32 length) --{ -- png_size_t size; -- -- size = (png_size_t)length; -- if ((png_uint_32)size != length) -- png_error(png_ptr,"Overflow in png_memcpy_check."); -- -- return(png_memcpy (s1, s2, size)); --} -- --png_voidp PNGAPI --png_memset_check (png_structp png_ptr, png_voidp s1, int value, -- png_uint_32 length) --{ -- png_size_t size; -- -- size = (png_size_t)length; -- if ((png_uint_32)size != length) -- png_error(png_ptr,"Overflow in png_memset_check."); -- -- return (png_memset (s1, value, size)); -- --} -- --#ifdef PNG_USER_MEM_SUPPORTED --/* This function is called when the application wants to use another method -- * of allocating and freeing memory. -- */ --void PNGAPI --png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr -- malloc_fn, png_free_ptr free_fn) --{ -- png_ptr->mem_ptr = mem_ptr; -- png_ptr->malloc_fn = malloc_fn; -- png_ptr->free_fn = free_fn; --} -- --/* This function returns a pointer to the mem_ptr associated with the user -- * functions. The application should free any memory associated with this -- * pointer before png_write_destroy and png_read_destroy are called. -- */ --png_voidp PNGAPI --png_get_mem_ptr(png_structp png_ptr) --{ -- return ((png_voidp)png_ptr->mem_ptr); --} --#endif /* PNG_USER_MEM_SUPPORTED */ -diff --git a/thirdparty/libpng/pngpread.c b/thirdparty/libpng/pngpread.c -deleted file mode 100644 -index bbf2e14..0000000 ---- a/thirdparty/libpng/pngpread.c -+++ /dev/null -@@ -1,1573 +0,0 @@ -- --/* pngpread.c - read a png file in push mode -- * -- * libpng version 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- */ -- --#define PNG_INTERNAL --#include "png.h" -- --#ifdef PNG_PROGRESSIVE_READ_SUPPORTED -- --/* push model modes */ --#define PNG_READ_SIG_MODE 0 --#define PNG_READ_CHUNK_MODE 1 --#define PNG_READ_IDAT_MODE 2 --#define PNG_SKIP_MODE 3 --#define PNG_READ_tEXt_MODE 4 --#define PNG_READ_zTXt_MODE 5 --#define PNG_READ_DONE_MODE 6 --#define PNG_READ_iTXt_MODE 7 --#define PNG_ERROR_MODE 8 -- --void PNGAPI --png_process_data(png_structp png_ptr, png_infop info_ptr, -- png_bytep buffer, png_size_t buffer_size) --{ -- png_push_restore_buffer(png_ptr, buffer, buffer_size); -- -- while (png_ptr->buffer_size) -- { -- png_process_some_data(png_ptr, info_ptr); -- } --} -- --/* What we do with the incoming data depends on what we were previously -- * doing before we ran out of data... -- */ --void /* PRIVATE */ --png_process_some_data(png_structp png_ptr, png_infop info_ptr) --{ -- switch (png_ptr->process_mode) -- { -- case PNG_READ_SIG_MODE: -- { -- png_push_read_sig(png_ptr, info_ptr); -- break; -- } -- case PNG_READ_CHUNK_MODE: -- { -- png_push_read_chunk(png_ptr, info_ptr); -- break; -- } -- case PNG_READ_IDAT_MODE: -- { -- png_push_read_IDAT(png_ptr); -- break; -- } --#if defined(PNG_READ_tEXt_SUPPORTED) -- case PNG_READ_tEXt_MODE: -- { -- png_push_read_tEXt(png_ptr, info_ptr); -- break; -- } --#endif --#if defined(PNG_READ_zTXt_SUPPORTED) -- case PNG_READ_zTXt_MODE: -- { -- png_push_read_zTXt(png_ptr, info_ptr); -- break; -- } --#endif --#if defined(PNG_READ_iTXt_SUPPORTED) -- case PNG_READ_iTXt_MODE: -- { -- png_push_read_iTXt(png_ptr, info_ptr); -- break; -- } --#endif -- case PNG_SKIP_MODE: -- { -- png_push_crc_finish(png_ptr); -- break; -- } -- default: -- { -- png_ptr->buffer_size = 0; -- break; -- } -- } --} -- --/* Read any remaining signature bytes from the stream and compare them with -- * the correct PNG signature. It is possible that this routine is called -- * with bytes already read from the signature, either because they have been -- * checked by the calling application, or because of multiple calls to this -- * routine. -- */ --void /* PRIVATE */ --png_push_read_sig(png_structp png_ptr, png_infop info_ptr) --{ -- png_size_t num_checked = png_ptr->sig_bytes, -- num_to_check = 8 - num_checked; -- -- if (png_ptr->buffer_size < num_to_check) -- { -- num_to_check = png_ptr->buffer_size; -- } -- -- png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]), -- num_to_check); -- png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes+num_to_check); -- -- if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) -- { -- if (num_checked < 4 && -- png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4)) -- png_error(png_ptr, "Not a PNG file"); -- else -- png_error(png_ptr, "PNG file corrupted by ASCII conversion"); -- } -- else -- { -- if (png_ptr->sig_bytes >= 8) -- { -- png_ptr->process_mode = PNG_READ_CHUNK_MODE; -- } -- } --} -- --void /* PRIVATE */ --png_push_read_chunk(png_structp png_ptr, png_infop info_ptr) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_IHDR; -- PNG_IDAT; -- PNG_IEND; -- PNG_PLTE; --#if defined(PNG_READ_bKGD_SUPPORTED) -- PNG_bKGD; --#endif --#if defined(PNG_READ_cHRM_SUPPORTED) -- PNG_cHRM; --#endif --#if defined(PNG_READ_gAMA_SUPPORTED) -- PNG_gAMA; --#endif --#if defined(PNG_READ_hIST_SUPPORTED) -- PNG_hIST; --#endif --#if defined(PNG_READ_iCCP_SUPPORTED) -- PNG_iCCP; --#endif --#if defined(PNG_READ_iTXt_SUPPORTED) -- PNG_iTXt; --#endif --#if defined(PNG_READ_oFFs_SUPPORTED) -- PNG_oFFs; --#endif --#if defined(PNG_READ_pCAL_SUPPORTED) -- PNG_pCAL; --#endif --#if defined(PNG_READ_pHYs_SUPPORTED) -- PNG_pHYs; --#endif --#if defined(PNG_READ_sBIT_SUPPORTED) -- PNG_sBIT; --#endif --#if defined(PNG_READ_sCAL_SUPPORTED) -- PNG_sCAL; --#endif --#if defined(PNG_READ_sRGB_SUPPORTED) -- PNG_sRGB; --#endif --#if defined(PNG_READ_sPLT_SUPPORTED) -- PNG_sPLT; --#endif --#if defined(PNG_READ_tEXt_SUPPORTED) -- PNG_tEXt; --#endif --#if defined(PNG_READ_tIME_SUPPORTED) -- PNG_tIME; --#endif --#if defined(PNG_READ_tRNS_SUPPORTED) -- PNG_tRNS; --#endif --#if defined(PNG_READ_zTXt_SUPPORTED) -- PNG_zTXt; --#endif --#endif /* PNG_USE_LOCAL_ARRAYS */ -- /* First we make sure we have enough data for the 4 byte chunk name -- * and the 4 byte chunk length before proceeding with decoding the -- * chunk data. To fully decode each of these chunks, we also make -- * sure we have enough data in the buffer for the 4 byte CRC at the -- * end of every chunk (except IDAT, which is handled separately). -- */ -- if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER)) -- { -- png_byte chunk_length[4]; -- -- if (png_ptr->buffer_size < 8) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- -- png_push_fill_buffer(png_ptr, chunk_length, 4); -- png_ptr->push_length = png_get_uint_31(png_ptr,chunk_length); -- png_reset_crc(png_ptr); -- png_crc_read(png_ptr, png_ptr->chunk_name, 4); -- png_ptr->mode |= PNG_HAVE_CHUNK_HEADER; -- } -- -- if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length); -- } -- else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length); -- -- png_ptr->process_mode = PNG_READ_DONE_MODE; -- png_push_have_end(png_ptr, info_ptr); -- } --#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED -- else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) -- png_ptr->mode |= PNG_HAVE_IDAT; -- png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length); -- if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) -- png_ptr->mode |= PNG_HAVE_PLTE; -- else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) -- { -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before IDAT"); -- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && -- !(png_ptr->mode & PNG_HAVE_PLTE)) -- png_error(png_ptr, "Missing PLTE before IDAT"); -- } -- } --#endif -- else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length); -- } -- else if (!png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4)) -- { -- /* If we reach an IDAT chunk, this means we have read all of the -- * header chunks, and we can start reading the image (or if this -- * is called after the image has been read - we have an error). -- */ -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before IDAT"); -- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && -- !(png_ptr->mode & PNG_HAVE_PLTE)) -- png_error(png_ptr, "Missing PLTE before IDAT"); -- -- if (png_ptr->mode & PNG_HAVE_IDAT) -- { -- if (png_ptr->push_length == 0) -- return; -- -- if (png_ptr->mode & PNG_AFTER_IDAT) -- png_error(png_ptr, "Too many IDAT's found"); -- } -- -- png_ptr->idat_size = png_ptr->push_length; -- png_ptr->mode |= PNG_HAVE_IDAT; -- png_ptr->process_mode = PNG_READ_IDAT_MODE; -- png_push_have_info(png_ptr, info_ptr); -- png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; -- png_ptr->zstream.next_out = png_ptr->row_buf; -- return; -- } --#if defined(PNG_READ_gAMA_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_sBIT_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_cHRM_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_sRGB_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_iCCP_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_sPLT_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_tRNS_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_bKGD_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_hIST_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_pHYs_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_oFFs_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_pCAL_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_sCAL_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_tIME_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_tEXt_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_zTXt_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif --#if defined(PNG_READ_iTXt_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length); -- } --#endif -- else -- { -- if (png_ptr->push_length + 4 > png_ptr->buffer_size) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length); -- } -- -- png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; --} -- --void /* PRIVATE */ --png_push_crc_skip(png_structp png_ptr, png_uint_32 skip) --{ -- png_ptr->process_mode = PNG_SKIP_MODE; -- png_ptr->skip_length = skip; --} -- --void /* PRIVATE */ --png_push_crc_finish(png_structp png_ptr) --{ -- if (png_ptr->skip_length && png_ptr->save_buffer_size) -- { -- png_size_t save_size; -- -- if (png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size) -- save_size = (png_size_t)png_ptr->skip_length; -- else -- save_size = png_ptr->save_buffer_size; -- -- png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); -- -- png_ptr->skip_length -= save_size; -- png_ptr->buffer_size -= save_size; -- png_ptr->save_buffer_size -= save_size; -- png_ptr->save_buffer_ptr += save_size; -- } -- if (png_ptr->skip_length && png_ptr->current_buffer_size) -- { -- png_size_t save_size; -- -- if (png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size) -- save_size = (png_size_t)png_ptr->skip_length; -- else -- save_size = png_ptr->current_buffer_size; -- -- png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size); -- -- png_ptr->skip_length -= save_size; -- png_ptr->buffer_size -= save_size; -- png_ptr->current_buffer_size -= save_size; -- png_ptr->current_buffer_ptr += save_size; -- } -- if (!png_ptr->skip_length) -- { -- if (png_ptr->buffer_size < 4) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- -- png_crc_finish(png_ptr, 0); -- png_ptr->process_mode = PNG_READ_CHUNK_MODE; -- } --} -- --void PNGAPI --png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length) --{ -- png_bytep ptr; -- -- ptr = buffer; -- if (png_ptr->save_buffer_size) -- { -- png_size_t save_size; -- -- if (length < png_ptr->save_buffer_size) -- save_size = length; -- else -- save_size = png_ptr->save_buffer_size; -- -- png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size); -- length -= save_size; -- ptr += save_size; -- png_ptr->buffer_size -= save_size; -- png_ptr->save_buffer_size -= save_size; -- png_ptr->save_buffer_ptr += save_size; -- } -- if (length && png_ptr->current_buffer_size) -- { -- png_size_t save_size; -- -- if (length < png_ptr->current_buffer_size) -- save_size = length; -- else -- save_size = png_ptr->current_buffer_size; -- -- png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size); -- png_ptr->buffer_size -= save_size; -- png_ptr->current_buffer_size -= save_size; -- png_ptr->current_buffer_ptr += save_size; -- } --} -- --void /* PRIVATE */ --png_push_save_buffer(png_structp png_ptr) --{ -- if (png_ptr->save_buffer_size) -- { -- if (png_ptr->save_buffer_ptr != png_ptr->save_buffer) -- { -- png_size_t i,istop; -- png_bytep sp; -- png_bytep dp; -- -- istop = png_ptr->save_buffer_size; -- for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer; -- i < istop; i++, sp++, dp++) -- { -- *dp = *sp; -- } -- } -- } -- if (png_ptr->save_buffer_size + png_ptr->current_buffer_size > -- png_ptr->save_buffer_max) -- { -- png_size_t new_max; -- png_bytep old_buffer; -- -- if (png_ptr->save_buffer_size > PNG_SIZE_MAX - -- (png_ptr->current_buffer_size + 256)) -- { -- png_error(png_ptr, "Potential overflow of save_buffer"); -- } -- new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256; -- old_buffer = png_ptr->save_buffer; -- png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr, -- (png_uint_32)new_max); -- png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size); -- png_free(png_ptr, old_buffer); -- png_ptr->save_buffer_max = new_max; -- } -- if (png_ptr->current_buffer_size) -- { -- png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size, -- png_ptr->current_buffer_ptr, png_ptr->current_buffer_size); -- png_ptr->save_buffer_size += png_ptr->current_buffer_size; -- png_ptr->current_buffer_size = 0; -- } -- png_ptr->save_buffer_ptr = png_ptr->save_buffer; -- png_ptr->buffer_size = 0; --} -- --void /* PRIVATE */ --png_push_restore_buffer(png_structp png_ptr, png_bytep buffer, -- png_size_t buffer_length) --{ -- png_ptr->current_buffer = buffer; -- png_ptr->current_buffer_size = buffer_length; -- png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size; -- png_ptr->current_buffer_ptr = png_ptr->current_buffer; --} -- --void /* PRIVATE */ --png_push_read_IDAT(png_structp png_ptr) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_IDAT; --#endif -- if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER)) -- { -- png_byte chunk_length[4]; -- -- if (png_ptr->buffer_size < 8) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- -- png_push_fill_buffer(png_ptr, chunk_length, 4); -- png_ptr->push_length = png_get_uint_31(png_ptr,chunk_length); -- png_reset_crc(png_ptr); -- png_crc_read(png_ptr, png_ptr->chunk_name, 4); -- png_ptr->mode |= PNG_HAVE_CHUNK_HEADER; -- -- if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4)) -- { -- png_ptr->process_mode = PNG_READ_CHUNK_MODE; -- if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) -- png_error(png_ptr, "Not enough compressed data"); -- return; -- } -- -- png_ptr->idat_size = png_ptr->push_length; -- } -- if (png_ptr->idat_size && png_ptr->save_buffer_size) -- { -- png_size_t save_size; -- -- if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size) -- { -- save_size = (png_size_t)png_ptr->idat_size; -- /* check for overflow */ -- if((png_uint_32)save_size != png_ptr->idat_size) -- png_error(png_ptr, "save_size overflowed in pngpread"); -- } -- else -- save_size = png_ptr->save_buffer_size; -- -- png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); -- if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) -- png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size); -- png_ptr->idat_size -= save_size; -- png_ptr->buffer_size -= save_size; -- png_ptr->save_buffer_size -= save_size; -- png_ptr->save_buffer_ptr += save_size; -- } -- if (png_ptr->idat_size && png_ptr->current_buffer_size) -- { -- png_size_t save_size; -- -- if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size) -- { -- save_size = (png_size_t)png_ptr->idat_size; -- /* check for overflow */ -- if((png_uint_32)save_size != png_ptr->idat_size) -- png_error(png_ptr, "save_size overflowed in pngpread"); -- } -- else -- save_size = png_ptr->current_buffer_size; -- -- png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size); -- if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) -- png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size); -- -- png_ptr->idat_size -= save_size; -- png_ptr->buffer_size -= save_size; -- png_ptr->current_buffer_size -= save_size; -- png_ptr->current_buffer_ptr += save_size; -- } -- if (!png_ptr->idat_size) -- { -- if (png_ptr->buffer_size < 4) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- -- png_crc_finish(png_ptr, 0); -- png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; -- png_ptr->mode |= PNG_AFTER_IDAT; -- } --} -- --void /* PRIVATE */ --png_process_IDAT_data(png_structp png_ptr, png_bytep buffer, -- png_size_t buffer_length) --{ -- int ret; -- -- if ((png_ptr->flags & PNG_FLAG_ZLIB_FINISHED) && buffer_length) -- png_error(png_ptr, "Extra compression data"); -- -- png_ptr->zstream.next_in = buffer; -- png_ptr->zstream.avail_in = (uInt)buffer_length; -- for(;;) -- { -- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); -- if (ret != Z_OK) -- { -- if (ret == Z_STREAM_END) -- { -- if (png_ptr->zstream.avail_in) -- png_error(png_ptr, "Extra compressed data"); -- if (!(png_ptr->zstream.avail_out)) -- { -- png_push_process_row(png_ptr); -- } -- -- png_ptr->mode |= PNG_AFTER_IDAT; -- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; -- break; -- } -- else if (ret == Z_BUF_ERROR) -- break; -- else -- png_error(png_ptr, "Decompression Error"); -- } -- if (!(png_ptr->zstream.avail_out)) -- { -- if (( --#if defined(PNG_READ_INTERLACING_SUPPORTED) -- png_ptr->interlaced && png_ptr->pass > 6) || -- (!png_ptr->interlaced && --#endif -- png_ptr->row_number == png_ptr->num_rows)) -- { -- if (png_ptr->zstream.avail_in) -- png_warning(png_ptr, "Too much data in IDAT chunks"); -- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; -- break; -- } -- png_push_process_row(png_ptr); -- png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; -- png_ptr->zstream.next_out = png_ptr->row_buf; -- } -- else -- break; -- } --} -- --void /* PRIVATE */ --png_push_process_row(png_structp png_ptr) --{ -- png_ptr->row_info.color_type = png_ptr->color_type; -- png_ptr->row_info.width = png_ptr->iwidth; -- png_ptr->row_info.channels = png_ptr->channels; -- png_ptr->row_info.bit_depth = png_ptr->bit_depth; -- png_ptr->row_info.pixel_depth = png_ptr->pixel_depth; -- -- png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, -- png_ptr->row_info.width); -- -- png_read_filter_row(png_ptr, &(png_ptr->row_info), -- png_ptr->row_buf + 1, png_ptr->prev_row + 1, -- (int)(png_ptr->row_buf[0])); -- -- png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf, -- png_ptr->rowbytes + 1); -- -- if (png_ptr->transformations) -- png_do_read_transformations(png_ptr); -- --#if defined(PNG_READ_INTERLACING_SUPPORTED) -- /* blow up interlaced rows to full size */ -- if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) -- { -- if (png_ptr->pass < 6) --/* old interface (pre-1.0.9): -- png_do_read_interlace(&(png_ptr->row_info), -- png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); -- */ -- png_do_read_interlace(png_ptr); -- -- switch (png_ptr->pass) -- { -- case 0: -- { -- int i; -- for (i = 0; i < 8 && png_ptr->pass == 0; i++) -- { -- png_push_have_row(png_ptr, png_ptr->row_buf + 1); -- png_read_push_finish_row(png_ptr); /* updates png_ptr->pass */ -- } -- if (png_ptr->pass == 2) /* pass 1 might be empty */ -- { -- for (i = 0; i < 4 && png_ptr->pass == 2; i++) -- { -- png_push_have_row(png_ptr, png_bytep_NULL); -- png_read_push_finish_row(png_ptr); -- } -- } -- if (png_ptr->pass == 4 && png_ptr->height <= 4) -- { -- for (i = 0; i < 2 && png_ptr->pass == 4; i++) -- { -- png_push_have_row(png_ptr, png_bytep_NULL); -- png_read_push_finish_row(png_ptr); -- } -- } -- if (png_ptr->pass == 6 && png_ptr->height <= 4) -- { -- png_push_have_row(png_ptr, png_bytep_NULL); -- png_read_push_finish_row(png_ptr); -- } -- break; -- } -- case 1: -- { -- int i; -- for (i = 0; i < 8 && png_ptr->pass == 1; i++) -- { -- png_push_have_row(png_ptr, png_ptr->row_buf + 1); -- png_read_push_finish_row(png_ptr); -- } -- if (png_ptr->pass == 2) /* skip top 4 generated rows */ -- { -- for (i = 0; i < 4 && png_ptr->pass == 2; i++) -- { -- png_push_have_row(png_ptr, png_bytep_NULL); -- png_read_push_finish_row(png_ptr); -- } -- } -- break; -- } -- case 2: -- { -- int i; -- for (i = 0; i < 4 && png_ptr->pass == 2; i++) -- { -- png_push_have_row(png_ptr, png_ptr->row_buf + 1); -- png_read_push_finish_row(png_ptr); -- } -- for (i = 0; i < 4 && png_ptr->pass == 2; i++) -- { -- png_push_have_row(png_ptr, png_bytep_NULL); -- png_read_push_finish_row(png_ptr); -- } -- if (png_ptr->pass == 4) /* pass 3 might be empty */ -- { -- for (i = 0; i < 2 && png_ptr->pass == 4; i++) -- { -- png_push_have_row(png_ptr, png_bytep_NULL); -- png_read_push_finish_row(png_ptr); -- } -- } -- break; -- } -- case 3: -- { -- int i; -- for (i = 0; i < 4 && png_ptr->pass == 3; i++) -- { -- png_push_have_row(png_ptr, png_ptr->row_buf + 1); -- png_read_push_finish_row(png_ptr); -- } -- if (png_ptr->pass == 4) /* skip top two generated rows */ -- { -- for (i = 0; i < 2 && png_ptr->pass == 4; i++) -- { -- png_push_have_row(png_ptr, png_bytep_NULL); -- png_read_push_finish_row(png_ptr); -- } -- } -- break; -- } -- case 4: -- { -- int i; -- for (i = 0; i < 2 && png_ptr->pass == 4; i++) -- { -- png_push_have_row(png_ptr, png_ptr->row_buf + 1); -- png_read_push_finish_row(png_ptr); -- } -- for (i = 0; i < 2 && png_ptr->pass == 4; i++) -- { -- png_push_have_row(png_ptr, png_bytep_NULL); -- png_read_push_finish_row(png_ptr); -- } -- if (png_ptr->pass == 6) /* pass 5 might be empty */ -- { -- png_push_have_row(png_ptr, png_bytep_NULL); -- png_read_push_finish_row(png_ptr); -- } -- break; -- } -- case 5: -- { -- int i; -- for (i = 0; i < 2 && png_ptr->pass == 5; i++) -- { -- png_push_have_row(png_ptr, png_ptr->row_buf + 1); -- png_read_push_finish_row(png_ptr); -- } -- if (png_ptr->pass == 6) /* skip top generated row */ -- { -- png_push_have_row(png_ptr, png_bytep_NULL); -- png_read_push_finish_row(png_ptr); -- } -- break; -- } -- case 6: -- { -- png_push_have_row(png_ptr, png_ptr->row_buf + 1); -- png_read_push_finish_row(png_ptr); -- if (png_ptr->pass != 6) -- break; -- png_push_have_row(png_ptr, png_bytep_NULL); -- png_read_push_finish_row(png_ptr); -- } -- } -- } -- else --#endif -- { -- png_push_have_row(png_ptr, png_ptr->row_buf + 1); -- png_read_push_finish_row(png_ptr); -- } --} -- --void /* PRIVATE */ --png_read_push_finish_row(png_structp png_ptr) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ -- -- /* start of interlace block */ -- const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; -- -- /* offset to next interlace block */ -- const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; -- -- /* start of interlace block in the y direction */ -- const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; -- -- /* offset to next interlace block in the y direction */ -- const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; -- -- /* Width of interlace block. This is not currently used - if you need -- * it, uncomment it here and in png.h -- const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; -- */ -- -- /* Height of interlace block. This is not currently used - if you need -- * it, uncomment it here and in png.h -- const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; -- */ --#endif -- -- png_ptr->row_number++; -- if (png_ptr->row_number < png_ptr->num_rows) -- return; -- -- if (png_ptr->interlaced) -- { -- png_ptr->row_number = 0; -- png_memset_check(png_ptr, png_ptr->prev_row, 0, -- png_ptr->rowbytes + 1); -- do -- { -- png_ptr->pass++; -- if ((png_ptr->pass == 1 && png_ptr->width < 5) || -- (png_ptr->pass == 3 && png_ptr->width < 3) || -- (png_ptr->pass == 5 && png_ptr->width < 2)) -- png_ptr->pass++; -- -- if (png_ptr->pass > 7) -- png_ptr->pass--; -- if (png_ptr->pass >= 7) -- break; -- -- png_ptr->iwidth = (png_ptr->width + -- png_pass_inc[png_ptr->pass] - 1 - -- png_pass_start[png_ptr->pass]) / -- png_pass_inc[png_ptr->pass]; -- -- png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, -- png_ptr->iwidth) + 1; -- -- if (png_ptr->transformations & PNG_INTERLACE) -- break; -- -- png_ptr->num_rows = (png_ptr->height + -- png_pass_yinc[png_ptr->pass] - 1 - -- png_pass_ystart[png_ptr->pass]) / -- png_pass_yinc[png_ptr->pass]; -- -- } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0); -- } --} -- --#if defined(PNG_READ_tEXt_SUPPORTED) --void /* PRIVATE */ --png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 -- length) --{ -- if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) -- { -- png_error(png_ptr, "Out of place tEXt"); -- /* to quiet some compiler warnings */ -- if(info_ptr == NULL) return; -- } -- --#ifdef PNG_MAX_MALLOC_64K -- png_ptr->skip_length = 0; /* This may not be necessary */ -- -- if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */ -- { -- png_warning(png_ptr, "tEXt chunk too large to fit in memory"); -- png_ptr->skip_length = length - (png_uint_32)65535L; -- length = (png_uint_32)65535L; -- } --#endif -- -- png_ptr->current_text = (png_charp)png_malloc(png_ptr, -- (png_uint_32)(length+1)); -- png_ptr->current_text[length] = '\0'; -- png_ptr->current_text_ptr = png_ptr->current_text; -- png_ptr->current_text_size = (png_size_t)length; -- png_ptr->current_text_left = (png_size_t)length; -- png_ptr->process_mode = PNG_READ_tEXt_MODE; --} -- --void /* PRIVATE */ --png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr->buffer_size && png_ptr->current_text_left) -- { -- png_size_t text_size; -- -- if (png_ptr->buffer_size < png_ptr->current_text_left) -- text_size = png_ptr->buffer_size; -- else -- text_size = png_ptr->current_text_left; -- png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); -- png_ptr->current_text_left -= text_size; -- png_ptr->current_text_ptr += text_size; -- } -- if (!(png_ptr->current_text_left)) -- { -- png_textp text_ptr; -- png_charp text; -- png_charp key; -- int ret; -- -- if (png_ptr->buffer_size < 4) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- -- png_push_crc_finish(png_ptr); -- --#if defined(PNG_MAX_MALLOC_64K) -- if (png_ptr->skip_length) -- return; --#endif -- -- key = png_ptr->current_text; -- -- for (text = key; *text; text++) -- /* empty loop */ ; -- -- if (text != key + png_ptr->current_text_size) -- text++; -- -- text_ptr = (png_textp)png_malloc(png_ptr, -- (png_uint_32)png_sizeof(png_text)); -- text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; -- text_ptr->key = key; --#ifdef PNG_iTXt_SUPPORTED -- text_ptr->lang = NULL; -- text_ptr->lang_key = NULL; --#endif -- text_ptr->text = text; -- -- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); -- -- png_free(png_ptr, key); -- png_free(png_ptr, text_ptr); -- png_ptr->current_text = NULL; -- -- if (ret) -- png_warning(png_ptr, "Insufficient memory to store text chunk."); -- } --} --#endif -- --#if defined(PNG_READ_zTXt_SUPPORTED) --void /* PRIVATE */ --png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 -- length) --{ -- if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) -- { -- png_error(png_ptr, "Out of place zTXt"); -- /* to quiet some compiler warnings */ -- if(info_ptr == NULL) return; -- } -- --#ifdef PNG_MAX_MALLOC_64K -- /* We can't handle zTXt chunks > 64K, since we don't have enough space -- * to be able to store the uncompressed data. Actually, the threshold -- * is probably around 32K, but it isn't as definite as 64K is. -- */ -- if (length > (png_uint_32)65535L) -- { -- png_warning(png_ptr, "zTXt chunk too large to fit in memory"); -- png_push_crc_skip(png_ptr, length); -- return; -- } --#endif -- -- png_ptr->current_text = (png_charp)png_malloc(png_ptr, -- (png_uint_32)(length+1)); -- png_ptr->current_text[length] = '\0'; -- png_ptr->current_text_ptr = png_ptr->current_text; -- png_ptr->current_text_size = (png_size_t)length; -- png_ptr->current_text_left = (png_size_t)length; -- png_ptr->process_mode = PNG_READ_zTXt_MODE; --} -- --void /* PRIVATE */ --png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr->buffer_size && png_ptr->current_text_left) -- { -- png_size_t text_size; -- -- if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left) -- text_size = png_ptr->buffer_size; -- else -- text_size = png_ptr->current_text_left; -- png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); -- png_ptr->current_text_left -= text_size; -- png_ptr->current_text_ptr += text_size; -- } -- if (!(png_ptr->current_text_left)) -- { -- png_textp text_ptr; -- png_charp text; -- png_charp key; -- int ret; -- png_size_t text_size, key_size; -- -- if (png_ptr->buffer_size < 4) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- -- png_push_crc_finish(png_ptr); -- -- key = png_ptr->current_text; -- -- for (text = key; *text; text++) -- /* empty loop */ ; -- -- /* zTXt can't have zero text */ -- if (text == key + png_ptr->current_text_size) -- { -- png_ptr->current_text = NULL; -- png_free(png_ptr, key); -- return; -- } -- -- text++; -- -- if (*text != PNG_TEXT_COMPRESSION_zTXt) /* check compression byte */ -- { -- png_ptr->current_text = NULL; -- png_free(png_ptr, key); -- return; -- } -- -- text++; -- -- png_ptr->zstream.next_in = (png_bytep )text; -- png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size - -- (text - key)); -- png_ptr->zstream.next_out = png_ptr->zbuf; -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -- -- key_size = text - key; -- text_size = 0; -- text = NULL; -- ret = Z_STREAM_END; -- -- while (png_ptr->zstream.avail_in) -- { -- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); -- if (ret != Z_OK && ret != Z_STREAM_END) -- { -- inflateReset(&png_ptr->zstream); -- png_ptr->zstream.avail_in = 0; -- png_ptr->current_text = NULL; -- png_free(png_ptr, key); -- png_free(png_ptr, text); -- return; -- } -- if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END) -- { -- if (text == NULL) -- { -- text = (png_charp)png_malloc(png_ptr, -- (png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out -- + key_size + 1)); -- png_memcpy(text + key_size, png_ptr->zbuf, -- png_ptr->zbuf_size - png_ptr->zstream.avail_out); -- png_memcpy(text, key, key_size); -- text_size = key_size + png_ptr->zbuf_size - -- png_ptr->zstream.avail_out; -- *(text + text_size) = '\0'; -- } -- else -- { -- png_charp tmp; -- -- tmp = text; -- text = (png_charp)png_malloc(png_ptr, text_size + -- (png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out -- + 1)); -- png_memcpy(text, tmp, text_size); -- png_free(png_ptr, tmp); -- png_memcpy(text + text_size, png_ptr->zbuf, -- png_ptr->zbuf_size - png_ptr->zstream.avail_out); -- text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out; -- *(text + text_size) = '\0'; -- } -- if (ret != Z_STREAM_END) -- { -- png_ptr->zstream.next_out = png_ptr->zbuf; -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -- } -- } -- else -- { -- break; -- } -- -- if (ret == Z_STREAM_END) -- break; -- } -- -- inflateReset(&png_ptr->zstream); -- png_ptr->zstream.avail_in = 0; -- -- if (ret != Z_STREAM_END) -- { -- png_ptr->current_text = NULL; -- png_free(png_ptr, key); -- png_free(png_ptr, text); -- return; -- } -- -- png_ptr->current_text = NULL; -- png_free(png_ptr, key); -- key = text; -- text += key_size; -- -- text_ptr = (png_textp)png_malloc(png_ptr, -- (png_uint_32)png_sizeof(png_text)); -- text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt; -- text_ptr->key = key; --#ifdef PNG_iTXt_SUPPORTED -- text_ptr->lang = NULL; -- text_ptr->lang_key = NULL; --#endif -- text_ptr->text = text; -- -- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); -- -- png_free(png_ptr, key); -- png_free(png_ptr, text_ptr); -- -- if (ret) -- png_warning(png_ptr, "Insufficient memory to store text chunk."); -- } --} --#endif -- --#if defined(PNG_READ_iTXt_SUPPORTED) --void /* PRIVATE */ --png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 -- length) --{ -- if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) -- { -- png_error(png_ptr, "Out of place iTXt"); -- /* to quiet some compiler warnings */ -- if(info_ptr == NULL) return; -- } -- --#ifdef PNG_MAX_MALLOC_64K -- png_ptr->skip_length = 0; /* This may not be necessary */ -- -- if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */ -- { -- png_warning(png_ptr, "iTXt chunk too large to fit in memory"); -- png_ptr->skip_length = length - (png_uint_32)65535L; -- length = (png_uint_32)65535L; -- } --#endif -- -- png_ptr->current_text = (png_charp)png_malloc(png_ptr, -- (png_uint_32)(length+1)); -- png_ptr->current_text[length] = '\0'; -- png_ptr->current_text_ptr = png_ptr->current_text; -- png_ptr->current_text_size = (png_size_t)length; -- png_ptr->current_text_left = (png_size_t)length; -- png_ptr->process_mode = PNG_READ_iTXt_MODE; --} -- --void /* PRIVATE */ --png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr) --{ -- -- if (png_ptr->buffer_size && png_ptr->current_text_left) -- { -- png_size_t text_size; -- -- if (png_ptr->buffer_size < png_ptr->current_text_left) -- text_size = png_ptr->buffer_size; -- else -- text_size = png_ptr->current_text_left; -- png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); -- png_ptr->current_text_left -= text_size; -- png_ptr->current_text_ptr += text_size; -- } -- if (!(png_ptr->current_text_left)) -- { -- png_textp text_ptr; -- png_charp key; -- int comp_flag; -- png_charp lang; -- png_charp lang_key; -- png_charp text; -- int ret; -- -- if (png_ptr->buffer_size < 4) -- { -- png_push_save_buffer(png_ptr); -- return; -- } -- -- png_push_crc_finish(png_ptr); -- --#if defined(PNG_MAX_MALLOC_64K) -- if (png_ptr->skip_length) -- return; --#endif -- -- key = png_ptr->current_text; -- -- for (lang = key; *lang; lang++) -- /* empty loop */ ; -- -- if (lang != key + png_ptr->current_text_size) -- lang++; -- -- comp_flag = *lang++; -- lang++; /* skip comp_type, always zero */ -- -- for (lang_key = lang; *lang_key; lang_key++) -- /* empty loop */ ; -- lang_key++; /* skip NUL separator */ -- -- for (text = lang_key; *text; text++) -- /* empty loop */ ; -- -- if (text != key + png_ptr->current_text_size) -- text++; -- -- text_ptr = (png_textp)png_malloc(png_ptr, -- (png_uint_32)png_sizeof(png_text)); -- text_ptr->compression = comp_flag + 2; -- text_ptr->key = key; -- text_ptr->lang = lang; -- text_ptr->lang_key = lang_key; -- text_ptr->text = text; -- text_ptr->text_length = 0; -- text_ptr->itxt_length = png_strlen(text); -- -- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); -- -- png_ptr->current_text = NULL; -- -- png_free(png_ptr, text_ptr); -- if (ret) -- png_warning(png_ptr, "Insufficient memory to store iTXt chunk."); -- } --} --#endif -- --/* This function is called when we haven't found a handler for this -- * chunk. If there isn't a problem with the chunk itself (ie a bad chunk -- * name or a critical chunk), the chunk is (currently) silently ignored. -- */ --void /* PRIVATE */ --png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 -- length) --{ -- png_uint_32 skip=0; -- png_check_chunk_name(png_ptr, png_ptr->chunk_name); -- -- if (!(png_ptr->chunk_name[0] & 0x20)) -- { --#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) -- if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != -- PNG_HANDLE_CHUNK_ALWAYS --#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) -- && png_ptr->read_user_chunk_fn == NULL --#endif -- ) --#endif -- png_chunk_error(png_ptr, "unknown critical chunk"); -- -- /* to quiet compiler warnings about unused info_ptr */ -- if (info_ptr == NULL) -- return; -- } -- --#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) -- if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) -- { -- png_unknown_chunk chunk; -- --#ifdef PNG_MAX_MALLOC_64K -- if (length > (png_uint_32)65535L) -- { -- png_warning(png_ptr, "unknown chunk too large to fit in memory"); -- skip = length - (png_uint_32)65535L; -- length = (png_uint_32)65535L; -- } --#endif -- -- png_strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name); -- chunk.data = (png_bytep)png_malloc(png_ptr, length); -- png_crc_read(png_ptr, chunk.data, length); -- chunk.size = length; --#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) -- if(png_ptr->read_user_chunk_fn != NULL) -- { -- /* callback to user unknown chunk handler */ -- if ((*(png_ptr->read_user_chunk_fn)) (png_ptr, &chunk) <= 0) -- { -- if (!(png_ptr->chunk_name[0] & 0x20)) -- if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != -- PNG_HANDLE_CHUNK_ALWAYS) -- png_chunk_error(png_ptr, "unknown critical chunk"); -- } -- png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); -- } -- else --#endif -- png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); -- png_free(png_ptr, chunk.data); -- } -- else --#endif -- skip=length; -- png_push_crc_skip(png_ptr, skip); --} -- --void /* PRIVATE */ --png_push_have_info(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr->info_fn != NULL) -- (*(png_ptr->info_fn))(png_ptr, info_ptr); --} -- --void /* PRIVATE */ --png_push_have_end(png_structp png_ptr, png_infop info_ptr) --{ -- if (png_ptr->end_fn != NULL) -- (*(png_ptr->end_fn))(png_ptr, info_ptr); --} -- --void /* PRIVATE */ --png_push_have_row(png_structp png_ptr, png_bytep row) --{ -- if (png_ptr->row_fn != NULL) -- (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number, -- (int)png_ptr->pass); --} -- --void PNGAPI --png_progressive_combine_row (png_structp png_ptr, -- png_bytep old_row, png_bytep new_row) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- const int FARDATA png_pass_dsp_mask[7] = -- {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; --#endif -- if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */ -- png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]); --} -- --void PNGAPI --png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr, -- png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, -- png_progressive_end_ptr end_fn) --{ -- png_ptr->info_fn = info_fn; -- png_ptr->row_fn = row_fn; -- png_ptr->end_fn = end_fn; -- -- png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer); --} -- --png_voidp PNGAPI --png_get_progressive_ptr(png_structp png_ptr) --{ -- return png_ptr->io_ptr; --} --#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ -diff --git a/thirdparty/libpng/pngread.c b/thirdparty/libpng/pngread.c -deleted file mode 100644 -index 2224022..0000000 ---- a/thirdparty/libpng/pngread.c -+++ /dev/null -@@ -1,1453 +0,0 @@ -- --/* pngread.c - read a PNG file -- * -- * libpng 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- * -- * This file contains routines that an application calls directly to -- * read a PNG file or stream. -- */ -- --#define PNG_INTERNAL --#include "png.h" -- --/* Create a PNG structure for reading, and allocate any memory needed. */ --png_structp PNGAPI --png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr, -- png_error_ptr error_fn, png_error_ptr warn_fn) --{ -- --#ifdef PNG_USER_MEM_SUPPORTED -- return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn, -- warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL)); --} -- --/* Alternate create PNG structure for reading, and allocate any memory needed. */ --png_structp PNGAPI --png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, -- png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, -- png_malloc_ptr malloc_fn, png_free_ptr free_fn) --{ --#endif /* PNG_USER_MEM_SUPPORTED */ -- -- png_structp png_ptr; -- --#ifdef PNG_SETJMP_SUPPORTED --#ifdef USE_FAR_KEYWORD -- jmp_buf jmpbuf; --#endif --#endif -- -- int i; -- -- png_debug(1, "in png_create_read_struct\n"); --#ifdef PNG_USER_MEM_SUPPORTED -- png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, -- (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr); --#else -- png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); --#endif -- if (png_ptr == NULL) -- return (NULL); -- --#if !defined(PNG_1_0_X) --#ifdef PNG_ASSEMBLER_CODE_SUPPORTED -- png_init_mmx_flags(png_ptr); /* 1.2.0 addition */ --#endif --#endif /* PNG_1_0_X */ -- -- /* added at libpng-1.2.6 */ --#ifdef PNG_SET_USER_LIMITS_SUPPORTED -- png_ptr->user_width_max=PNG_USER_WIDTH_MAX; -- png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; --#endif -- --#ifdef PNG_SETJMP_SUPPORTED --#ifdef USE_FAR_KEYWORD -- if (setjmp(jmpbuf)) --#else -- if (setjmp(png_ptr->jmpbuf)) --#endif -- { -- png_free(png_ptr, png_ptr->zbuf); -- png_ptr->zbuf=NULL; --#ifdef PNG_USER_MEM_SUPPORTED -- png_destroy_struct_2((png_voidp)png_ptr, -- (png_free_ptr)free_fn, (png_voidp)mem_ptr); --#else -- png_destroy_struct((png_voidp)png_ptr); --#endif -- return (NULL); -- } --#ifdef USE_FAR_KEYWORD -- png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf)); --#endif --#endif -- --#ifdef PNG_USER_MEM_SUPPORTED -- png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); --#endif -- -- png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); -- -- i=0; -- do -- { -- if(user_png_ver[i] != png_libpng_ver[i]) -- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; -- } while (png_libpng_ver[i++]); -- -- if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) -- { -- /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so -- * we must recompile any applications that use any older library version. -- * For versions after libpng 1.0, we will be compatible, so we need -- * only check the first digit. -- */ -- if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || -- (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || -- (user_png_ver[0] == '0' && user_png_ver[2] < '9')) -- { --#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) -- char msg[80]; -- if (user_png_ver) -- { -- sprintf(msg, "Application was compiled with png.h from libpng-%.20s", -- user_png_ver); -- png_warning(png_ptr, msg); -- } -- sprintf(msg, "Application is running with png.c from libpng-%.20s", -- png_libpng_ver); -- png_warning(png_ptr, msg); --#endif --#ifdef PNG_ERROR_NUMBERS_SUPPORTED -- png_ptr->flags=0; --#endif -- png_error(png_ptr, -- "Incompatible libpng version in application and library"); -- } -- } -- -- /* initialize zbuf - compression buffer */ -- png_ptr->zbuf_size = PNG_ZBUF_SIZE; -- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, -- (png_uint_32)png_ptr->zbuf_size); -- png_ptr->zstream.zalloc = png_zalloc; -- png_ptr->zstream.zfree = png_zfree; -- png_ptr->zstream.opaque = (voidpf)png_ptr; -- -- switch (inflateInit(&png_ptr->zstream)) -- { -- case Z_OK: /* Do nothing */ break; -- case Z_MEM_ERROR: -- case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break; -- case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); break; -- default: png_error(png_ptr, "Unknown zlib error"); -- } -- -- png_ptr->zstream.next_out = png_ptr->zbuf; -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -- -- png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL); -- --#ifdef PNG_SETJMP_SUPPORTED --/* Applications that neglect to set up their own setjmp() and then encounter -- a png_error() will longjmp here. Since the jmpbuf is then meaningless we -- abort instead of returning. */ --#ifdef USE_FAR_KEYWORD -- if (setjmp(jmpbuf)) -- PNG_ABORT(); -- png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf)); --#else -- if (setjmp(png_ptr->jmpbuf)) -- PNG_ABORT(); --#endif --#endif -- return (png_ptr); --} -- --/* Initialize PNG structure for reading, and allocate any memory needed. -- This interface is deprecated in favour of the png_create_read_struct(), -- and it will eventually disappear. */ --#undef png_read_init --void PNGAPI --png_read_init(png_structp png_ptr) --{ -- /* We only come here via pre-1.0.7-compiled applications */ -- png_read_init_2(png_ptr, "1.0.6 or earlier", 0, 0); --} -- --void PNGAPI --png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver, -- png_size_t png_struct_size, png_size_t png_info_size) --{ -- /* We only come here via pre-1.0.12-compiled applications */ --#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) -- if(png_sizeof(png_struct) > png_struct_size || -- png_sizeof(png_info) > png_info_size) -- { -- char msg[80]; -- png_ptr->warning_fn=NULL; -- if (user_png_ver) -- { -- sprintf(msg, "Application was compiled with png.h from libpng-%.20s", -- user_png_ver); -- png_warning(png_ptr, msg); -- } -- sprintf(msg, "Application is running with png.c from libpng-%.20s", -- png_libpng_ver); -- png_warning(png_ptr, msg); -- } --#endif -- if(png_sizeof(png_struct) > png_struct_size) -- { -- png_ptr->error_fn=NULL; --#ifdef PNG_ERROR_NUMBERS_SUPPORTED -- png_ptr->flags=0; --#endif -- png_error(png_ptr, -- "The png struct allocated by the application for reading is too small."); -- } -- if(png_sizeof(png_info) > png_info_size) -- { -- png_ptr->error_fn=NULL; --#ifdef PNG_ERROR_NUMBERS_SUPPORTED -- png_ptr->flags=0; --#endif -- png_error(png_ptr, -- "The info struct allocated by application for reading is too small."); -- } -- png_read_init_3(&png_ptr, user_png_ver, png_struct_size); --} -- --void PNGAPI --png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver, -- png_size_t png_struct_size) --{ --#ifdef PNG_SETJMP_SUPPORTED -- jmp_buf tmp_jmp; /* to save current jump buffer */ --#endif -- -- int i=0; -- -- png_structp png_ptr=*ptr_ptr; -- -- do -- { -- if(user_png_ver[i] != png_libpng_ver[i]) -- { --#ifdef PNG_LEGACY_SUPPORTED -- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; --#else -- png_ptr->warning_fn=NULL; -- png_warning(png_ptr, -- "Application uses deprecated png_read_init() and should be recompiled."); -- break; --#endif -- } -- } while (png_libpng_ver[i++]); -- -- png_debug(1, "in png_read_init_3\n"); -- --#ifdef PNG_SETJMP_SUPPORTED -- /* save jump buffer and error functions */ -- png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf)); --#endif -- -- if(png_sizeof(png_struct) > png_struct_size) -- { -- png_destroy_struct(png_ptr); -- *ptr_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); -- png_ptr = *ptr_ptr; -- } -- -- /* reset all variables to 0 */ -- png_memset(png_ptr, 0, png_sizeof (png_struct)); -- --#ifdef PNG_SETJMP_SUPPORTED -- /* restore jump buffer */ -- png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf)); --#endif -- -- /* added at libpng-1.2.6 */ --#ifdef PNG_SET_USER_LIMITS_SUPPORTED -- png_ptr->user_width_max=PNG_USER_WIDTH_MAX; -- png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; --#endif -- -- /* initialize zbuf - compression buffer */ -- png_ptr->zbuf_size = PNG_ZBUF_SIZE; -- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, -- (png_uint_32)png_ptr->zbuf_size); -- png_ptr->zstream.zalloc = png_zalloc; -- png_ptr->zstream.zfree = png_zfree; -- png_ptr->zstream.opaque = (voidpf)png_ptr; -- -- switch (inflateInit(&png_ptr->zstream)) -- { -- case Z_OK: /* Do nothing */ break; -- case Z_MEM_ERROR: -- case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory"); break; -- case Z_VERSION_ERROR: png_error(png_ptr, "zlib version"); break; -- default: png_error(png_ptr, "Unknown zlib error"); -- } -- -- png_ptr->zstream.next_out = png_ptr->zbuf; -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -- -- png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL); --} -- --#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED --/* Read the information before the actual image data. This has been -- * changed in v0.90 to allow reading a file that already has the magic -- * bytes read from the stream. You can tell libpng how many bytes have -- * been read from the beginning of the stream (up to the maximum of 8) -- * via png_set_sig_bytes(), and we will only check the remaining bytes -- * here. The application can then have access to the signature bytes we -- * read if it is determined that this isn't a valid PNG file. -- */ --void PNGAPI --png_read_info(png_structp png_ptr, png_infop info_ptr) --{ -- png_debug(1, "in png_read_info\n"); -- /* If we haven't checked all of the PNG signature bytes, do so now. */ -- if (png_ptr->sig_bytes < 8) -- { -- png_size_t num_checked = png_ptr->sig_bytes, -- num_to_check = 8 - num_checked; -- -- png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check); -- png_ptr->sig_bytes = 8; -- -- if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) -- { -- if (num_checked < 4 && -- png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4)) -- png_error(png_ptr, "Not a PNG file"); -- else -- png_error(png_ptr, "PNG file corrupted by ASCII conversion"); -- } -- if (num_checked < 3) -- png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; -- } -- -- for(;;) -- { --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_IHDR; -- PNG_IDAT; -- PNG_IEND; -- PNG_PLTE; --#if defined(PNG_READ_bKGD_SUPPORTED) -- PNG_bKGD; --#endif --#if defined(PNG_READ_cHRM_SUPPORTED) -- PNG_cHRM; --#endif --#if defined(PNG_READ_gAMA_SUPPORTED) -- PNG_gAMA; --#endif --#if defined(PNG_READ_hIST_SUPPORTED) -- PNG_hIST; --#endif --#if defined(PNG_READ_iCCP_SUPPORTED) -- PNG_iCCP; --#endif --#if defined(PNG_READ_iTXt_SUPPORTED) -- PNG_iTXt; --#endif --#if defined(PNG_READ_oFFs_SUPPORTED) -- PNG_oFFs; --#endif --#if defined(PNG_READ_pCAL_SUPPORTED) -- PNG_pCAL; --#endif --#if defined(PNG_READ_pHYs_SUPPORTED) -- PNG_pHYs; --#endif --#if defined(PNG_READ_sBIT_SUPPORTED) -- PNG_sBIT; --#endif --#if defined(PNG_READ_sCAL_SUPPORTED) -- PNG_sCAL; --#endif --#if defined(PNG_READ_sPLT_SUPPORTED) -- PNG_sPLT; --#endif --#if defined(PNG_READ_sRGB_SUPPORTED) -- PNG_sRGB; --#endif --#if defined(PNG_READ_tEXt_SUPPORTED) -- PNG_tEXt; --#endif --#if defined(PNG_READ_tIME_SUPPORTED) -- PNG_tIME; --#endif --#if defined(PNG_READ_tRNS_SUPPORTED) -- PNG_tRNS; --#endif --#if defined(PNG_READ_zTXt_SUPPORTED) -- PNG_zTXt; --#endif --#endif /* PNG_GLOBAL_ARRAYS */ -- png_byte chunk_length[4]; -- png_uint_32 length; -- -- png_read_data(png_ptr, chunk_length, 4); -- length = png_get_uint_31(png_ptr,chunk_length); -- -- png_reset_crc(png_ptr); -- png_crc_read(png_ptr, png_ptr->chunk_name, 4); -- -- png_debug2(0, "Reading %s chunk, length=%lu.\n", png_ptr->chunk_name, -- length); -- -- /* This should be a binary subdivision search or a hash for -- * matching the chunk name rather than a linear search. -- */ -- if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) -- png_handle_IHDR(png_ptr, info_ptr, length); -- else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) -- png_handle_IEND(png_ptr, info_ptr, length); --#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED -- else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name)) -- { -- if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) -- png_ptr->mode |= PNG_HAVE_IDAT; -- png_handle_unknown(png_ptr, info_ptr, length); -- if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) -- png_ptr->mode |= PNG_HAVE_PLTE; -- else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) -- { -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before IDAT"); -- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && -- !(png_ptr->mode & PNG_HAVE_PLTE)) -- png_error(png_ptr, "Missing PLTE before IDAT"); -- break; -- } -- } --#endif -- else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) -- png_handle_PLTE(png_ptr, info_ptr, length); -- else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) -- { -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before IDAT"); -- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && -- !(png_ptr->mode & PNG_HAVE_PLTE)) -- png_error(png_ptr, "Missing PLTE before IDAT"); -- -- png_ptr->idat_size = length; -- png_ptr->mode |= PNG_HAVE_IDAT; -- break; -- } --#if defined(PNG_READ_bKGD_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4)) -- png_handle_bKGD(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_cHRM_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4)) -- png_handle_cHRM(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_gAMA_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4)) -- png_handle_gAMA(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_hIST_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4)) -- png_handle_hIST(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_oFFs_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4)) -- png_handle_oFFs(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_pCAL_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4)) -- png_handle_pCAL(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_sCAL_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4)) -- png_handle_sCAL(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_pHYs_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4)) -- png_handle_pHYs(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_sBIT_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) -- png_handle_sBIT(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_sRGB_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4)) -- png_handle_sRGB(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_iCCP_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4)) -- png_handle_iCCP(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_sPLT_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4)) -- png_handle_sPLT(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_tEXt_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) -- png_handle_tEXt(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_tIME_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4)) -- png_handle_tIME(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_tRNS_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4)) -- png_handle_tRNS(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_zTXt_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4)) -- png_handle_zTXt(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_iTXt_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) -- png_handle_iTXt(png_ptr, info_ptr, length); --#endif -- else -- png_handle_unknown(png_ptr, info_ptr, length); -- } --} --#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ -- --/* optional call to update the users info_ptr structure */ --void PNGAPI --png_read_update_info(png_structp png_ptr, png_infop info_ptr) --{ -- png_debug(1, "in png_read_update_info\n"); -- if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) -- png_read_start_row(png_ptr); -- else -- png_warning(png_ptr, -- "Ignoring extra png_read_update_info() call; row buffer not reallocated"); -- png_read_transform_info(png_ptr, info_ptr); --} -- --#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED --/* Initialize palette, background, etc, after transformations -- * are set, but before any reading takes place. This allows -- * the user to obtain a gamma-corrected palette, for example. -- * If the user doesn't call this, we will do it ourselves. -- */ --void PNGAPI --png_start_read_image(png_structp png_ptr) --{ -- png_debug(1, "in png_start_read_image\n"); -- if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) -- png_read_start_row(png_ptr); --} --#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ -- --#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED --void PNGAPI --png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_IDAT; -- const int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; -- const int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; --#endif -- int ret; -- png_debug2(1, "in png_read_row (row %lu, pass %d)\n", -- png_ptr->row_number, png_ptr->pass); -- if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) -- png_read_start_row(png_ptr); -- if (png_ptr->row_number == 0 && png_ptr->pass == 0) -- { -- /* check for transforms that have been set but were defined out */ --#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED) -- if (png_ptr->transformations & PNG_INVERT_MONO) -- png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined."); --#endif --#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED) -- if (png_ptr->transformations & PNG_FILLER) -- png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined."); --#endif --#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && !defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_PACKSWAP) -- png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined."); --#endif --#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED) -- if (png_ptr->transformations & PNG_PACK) -- png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined."); --#endif --#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) -- if (png_ptr->transformations & PNG_SHIFT) -- png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined."); --#endif --#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED) -- if (png_ptr->transformations & PNG_BGR) -- png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined."); --#endif --#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_SWAP_BYTES) -- png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined."); --#endif -- } -- --#if defined(PNG_READ_INTERLACING_SUPPORTED) -- /* if interlaced and we do not need a new row, combine row and return */ -- if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) -- { -- switch (png_ptr->pass) -- { -- case 0: -- if (png_ptr->row_number & 0x07) -- { -- if (dsp_row != NULL) -- png_combine_row(png_ptr, dsp_row, -- png_pass_dsp_mask[png_ptr->pass]); -- png_read_finish_row(png_ptr); -- return; -- } -- break; -- case 1: -- if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) -- { -- if (dsp_row != NULL) -- png_combine_row(png_ptr, dsp_row, -- png_pass_dsp_mask[png_ptr->pass]); -- png_read_finish_row(png_ptr); -- return; -- } -- break; -- case 2: -- if ((png_ptr->row_number & 0x07) != 4) -- { -- if (dsp_row != NULL && (png_ptr->row_number & 4)) -- png_combine_row(png_ptr, dsp_row, -- png_pass_dsp_mask[png_ptr->pass]); -- png_read_finish_row(png_ptr); -- return; -- } -- break; -- case 3: -- if ((png_ptr->row_number & 3) || png_ptr->width < 3) -- { -- if (dsp_row != NULL) -- png_combine_row(png_ptr, dsp_row, -- png_pass_dsp_mask[png_ptr->pass]); -- png_read_finish_row(png_ptr); -- return; -- } -- break; -- case 4: -- if ((png_ptr->row_number & 3) != 2) -- { -- if (dsp_row != NULL && (png_ptr->row_number & 2)) -- png_combine_row(png_ptr, dsp_row, -- png_pass_dsp_mask[png_ptr->pass]); -- png_read_finish_row(png_ptr); -- return; -- } -- break; -- case 5: -- if ((png_ptr->row_number & 1) || png_ptr->width < 2) -- { -- if (dsp_row != NULL) -- png_combine_row(png_ptr, dsp_row, -- png_pass_dsp_mask[png_ptr->pass]); -- png_read_finish_row(png_ptr); -- return; -- } -- break; -- case 6: -- if (!(png_ptr->row_number & 1)) -- { -- png_read_finish_row(png_ptr); -- return; -- } -- break; -- } -- } --#endif -- -- if (!(png_ptr->mode & PNG_HAVE_IDAT)) -- png_error(png_ptr, "Invalid attempt to read row data"); -- -- png_ptr->zstream.next_out = png_ptr->row_buf; -- png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; -- do -- { -- if (!(png_ptr->zstream.avail_in)) -- { -- while (!png_ptr->idat_size) -- { -- png_byte chunk_length[4]; -- -- png_crc_finish(png_ptr, 0); -- -- png_read_data(png_ptr, chunk_length, 4); -- png_ptr->idat_size = png_get_uint_31(png_ptr,chunk_length); -- -- png_reset_crc(png_ptr); -- png_crc_read(png_ptr, png_ptr->chunk_name, 4); -- if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) -- png_error(png_ptr, "Not enough image data"); -- } -- png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; -- png_ptr->zstream.next_in = png_ptr->zbuf; -- if (png_ptr->zbuf_size > png_ptr->idat_size) -- png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; -- png_crc_read(png_ptr, png_ptr->zbuf, -- (png_size_t)png_ptr->zstream.avail_in); -- png_ptr->idat_size -= png_ptr->zstream.avail_in; -- } -- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); -- if (ret == Z_STREAM_END) -- { -- if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in || -- png_ptr->idat_size) -- png_error(png_ptr, "Extra compressed data"); -- png_ptr->mode |= PNG_AFTER_IDAT; -- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; -- break; -- } -- if (ret != Z_OK) -- png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : -- "Decompression error"); -- -- } while (png_ptr->zstream.avail_out); -- -- png_ptr->row_info.color_type = png_ptr->color_type; -- png_ptr->row_info.width = png_ptr->iwidth; -- png_ptr->row_info.channels = png_ptr->channels; -- png_ptr->row_info.bit_depth = png_ptr->bit_depth; -- png_ptr->row_info.pixel_depth = png_ptr->pixel_depth; -- png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, -- png_ptr->row_info.width); -- -- if(png_ptr->row_buf[0]) -- png_read_filter_row(png_ptr, &(png_ptr->row_info), -- png_ptr->row_buf + 1, png_ptr->prev_row + 1, -- (int)(png_ptr->row_buf[0])); -- -- png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf, -- png_ptr->rowbytes + 1); -- --#if defined(PNG_MNG_FEATURES_SUPPORTED) -- if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && -- (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) -- { -- /* Intrapixel differencing */ -- png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1); -- } --#endif -- -- if (png_ptr->transformations) -- png_do_read_transformations(png_ptr); -- --#if defined(PNG_READ_INTERLACING_SUPPORTED) -- /* blow up interlaced rows to full size */ -- if (png_ptr->interlaced && -- (png_ptr->transformations & PNG_INTERLACE)) -- { -- if (png_ptr->pass < 6) --/* old interface (pre-1.0.9): -- png_do_read_interlace(&(png_ptr->row_info), -- png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); -- */ -- png_do_read_interlace(png_ptr); -- -- if (dsp_row != NULL) -- png_combine_row(png_ptr, dsp_row, -- png_pass_dsp_mask[png_ptr->pass]); -- if (row != NULL) -- png_combine_row(png_ptr, row, -- png_pass_mask[png_ptr->pass]); -- } -- else --#endif -- { -- if (row != NULL) -- png_combine_row(png_ptr, row, 0xff); -- if (dsp_row != NULL) -- png_combine_row(png_ptr, dsp_row, 0xff); -- } -- png_read_finish_row(png_ptr); -- -- if (png_ptr->read_row_fn != NULL) -- (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); --} --#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ -- --#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED --/* Read one or more rows of image data. If the image is interlaced, -- * and png_set_interlace_handling() has been called, the rows need to -- * contain the contents of the rows from the previous pass. If the -- * image has alpha or transparency, and png_handle_alpha()[*] has been -- * called, the rows contents must be initialized to the contents of the -- * screen. -- * -- * "row" holds the actual image, and pixels are placed in it -- * as they arrive. If the image is displayed after each pass, it will -- * appear to "sparkle" in. "display_row" can be used to display a -- * "chunky" progressive image, with finer detail added as it becomes -- * available. If you do not want this "chunky" display, you may pass -- * NULL for display_row. If you do not want the sparkle display, and -- * you have not called png_handle_alpha(), you may pass NULL for rows. -- * If you have called png_handle_alpha(), and the image has either an -- * alpha channel or a transparency chunk, you must provide a buffer for -- * rows. In this case, you do not have to provide a display_row buffer -- * also, but you may. If the image is not interlaced, or if you have -- * not called png_set_interlace_handling(), the display_row buffer will -- * be ignored, so pass NULL to it. -- * -- * [*] png_handle_alpha() does not exist yet, as of libpng version 1.2.7 -- */ -- --void PNGAPI --png_read_rows(png_structp png_ptr, png_bytepp row, -- png_bytepp display_row, png_uint_32 num_rows) --{ -- png_uint_32 i; -- png_bytepp rp; -- png_bytepp dp; -- -- png_debug(1, "in png_read_rows\n"); -- rp = row; -- dp = display_row; -- if (rp != NULL && dp != NULL) -- for (i = 0; i < num_rows; i++) -- { -- png_bytep rptr = *rp++; -- png_bytep dptr = *dp++; -- -- png_read_row(png_ptr, rptr, dptr); -- } -- else if(rp != NULL) -- for (i = 0; i < num_rows; i++) -- { -- png_bytep rptr = *rp; -- png_read_row(png_ptr, rptr, png_bytep_NULL); -- rp++; -- } -- else if(dp != NULL) -- for (i = 0; i < num_rows; i++) -- { -- png_bytep dptr = *dp; -- png_read_row(png_ptr, png_bytep_NULL, dptr); -- dp++; -- } --} --#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ -- --#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED --/* Read the entire image. If the image has an alpha channel or a tRNS -- * chunk, and you have called png_handle_alpha()[*], you will need to -- * initialize the image to the current image that PNG will be overlaying. -- * We set the num_rows again here, in case it was incorrectly set in -- * png_read_start_row() by a call to png_read_update_info() or -- * png_start_read_image() if png_set_interlace_handling() wasn't called -- * prior to either of these functions like it should have been. You can -- * only call this function once. If you desire to have an image for -- * each pass of a interlaced image, use png_read_rows() instead. -- * -- * [*] png_handle_alpha() does not exist yet, as of libpng version 1.2.7 -- */ --void PNGAPI --png_read_image(png_structp png_ptr, png_bytepp image) --{ -- png_uint_32 i,image_height; -- int pass, j; -- png_bytepp rp; -- -- png_debug(1, "in png_read_image\n"); -- --#ifdef PNG_READ_INTERLACING_SUPPORTED -- pass = png_set_interlace_handling(png_ptr); --#else -- if (png_ptr->interlaced) -- png_error(png_ptr, -- "Cannot read interlaced image -- interlace handler disabled."); -- pass = 1; --#endif -- -- -- image_height=png_ptr->height; -- png_ptr->num_rows = image_height; /* Make sure this is set correctly */ -- -- for (j = 0; j < pass; j++) -- { -- rp = image; -- for (i = 0; i < image_height; i++) -- { -- png_read_row(png_ptr, *rp, png_bytep_NULL); -- rp++; -- } -- } --} --#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ -- --#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED --/* Read the end of the PNG file. Will not read past the end of the -- * file, will verify the end is accurate, and will read any comments -- * or time information at the end of the file, if info is not NULL. -- */ --void PNGAPI --png_read_end(png_structp png_ptr, png_infop info_ptr) --{ -- png_byte chunk_length[4]; -- png_uint_32 length; -- -- png_debug(1, "in png_read_end\n"); -- png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */ -- -- do -- { --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_IHDR; -- PNG_IDAT; -- PNG_IEND; -- PNG_PLTE; --#if defined(PNG_READ_bKGD_SUPPORTED) -- PNG_bKGD; --#endif --#if defined(PNG_READ_cHRM_SUPPORTED) -- PNG_cHRM; --#endif --#if defined(PNG_READ_gAMA_SUPPORTED) -- PNG_gAMA; --#endif --#if defined(PNG_READ_hIST_SUPPORTED) -- PNG_hIST; --#endif --#if defined(PNG_READ_iCCP_SUPPORTED) -- PNG_iCCP; --#endif --#if defined(PNG_READ_iTXt_SUPPORTED) -- PNG_iTXt; --#endif --#if defined(PNG_READ_oFFs_SUPPORTED) -- PNG_oFFs; --#endif --#if defined(PNG_READ_pCAL_SUPPORTED) -- PNG_pCAL; --#endif --#if defined(PNG_READ_pHYs_SUPPORTED) -- PNG_pHYs; --#endif --#if defined(PNG_READ_sBIT_SUPPORTED) -- PNG_sBIT; --#endif --#if defined(PNG_READ_sCAL_SUPPORTED) -- PNG_sCAL; --#endif --#if defined(PNG_READ_sPLT_SUPPORTED) -- PNG_sPLT; --#endif --#if defined(PNG_READ_sRGB_SUPPORTED) -- PNG_sRGB; --#endif --#if defined(PNG_READ_tEXt_SUPPORTED) -- PNG_tEXt; --#endif --#if defined(PNG_READ_tIME_SUPPORTED) -- PNG_tIME; --#endif --#if defined(PNG_READ_tRNS_SUPPORTED) -- PNG_tRNS; --#endif --#if defined(PNG_READ_zTXt_SUPPORTED) -- PNG_zTXt; --#endif --#endif /* PNG_GLOBAL_ARRAYS */ -- -- png_read_data(png_ptr, chunk_length, 4); -- length = png_get_uint_31(png_ptr,chunk_length); -- -- png_reset_crc(png_ptr); -- png_crc_read(png_ptr, png_ptr->chunk_name, 4); -- -- png_debug1(0, "Reading %s chunk.\n", png_ptr->chunk_name); -- -- if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) -- png_handle_IHDR(png_ptr, info_ptr, length); -- else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) -- png_handle_IEND(png_ptr, info_ptr, length); --#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED -- else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name)) -- { -- if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) -- { -- if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT) -- png_error(png_ptr, "Too many IDAT's found"); -- } -- else -- png_ptr->mode |= PNG_AFTER_IDAT; -- png_handle_unknown(png_ptr, info_ptr, length); -- if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) -- png_ptr->mode |= PNG_HAVE_PLTE; -- } --#endif -- else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) -- { -- /* Zero length IDATs are legal after the last IDAT has been -- * read, but not after other chunks have been read. -- */ -- if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT) -- png_error(png_ptr, "Too many IDAT's found"); -- png_crc_finish(png_ptr, length); -- } -- else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) -- png_handle_PLTE(png_ptr, info_ptr, length); --#if defined(PNG_READ_bKGD_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4)) -- png_handle_bKGD(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_cHRM_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4)) -- png_handle_cHRM(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_gAMA_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4)) -- png_handle_gAMA(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_hIST_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4)) -- png_handle_hIST(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_oFFs_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4)) -- png_handle_oFFs(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_pCAL_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4)) -- png_handle_pCAL(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_sCAL_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4)) -- png_handle_sCAL(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_pHYs_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4)) -- png_handle_pHYs(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_sBIT_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) -- png_handle_sBIT(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_sRGB_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4)) -- png_handle_sRGB(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_iCCP_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4)) -- png_handle_iCCP(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_sPLT_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4)) -- png_handle_sPLT(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_tEXt_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) -- png_handle_tEXt(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_tIME_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4)) -- png_handle_tIME(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_tRNS_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4)) -- png_handle_tRNS(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_zTXt_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4)) -- png_handle_zTXt(png_ptr, info_ptr, length); --#endif --#if defined(PNG_READ_iTXt_SUPPORTED) -- else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) -- png_handle_iTXt(png_ptr, info_ptr, length); --#endif -- else -- png_handle_unknown(png_ptr, info_ptr, length); -- } while (!(png_ptr->mode & PNG_HAVE_IEND)); --} --#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ -- --/* free all memory used by the read */ --void PNGAPI --png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, -- png_infopp end_info_ptr_ptr) --{ -- png_structp png_ptr = NULL; -- png_infop info_ptr = NULL, end_info_ptr = NULL; --#ifdef PNG_USER_MEM_SUPPORTED -- png_free_ptr free_fn; -- png_voidp mem_ptr; --#endif -- -- png_debug(1, "in png_destroy_read_struct\n"); -- if (png_ptr_ptr != NULL) -- png_ptr = *png_ptr_ptr; -- -- if (info_ptr_ptr != NULL) -- info_ptr = *info_ptr_ptr; -- -- if (end_info_ptr_ptr != NULL) -- end_info_ptr = *end_info_ptr_ptr; -- --#ifdef PNG_USER_MEM_SUPPORTED -- free_fn = png_ptr->free_fn; -- mem_ptr = png_ptr->mem_ptr; --#endif -- -- png_read_destroy(png_ptr, info_ptr, end_info_ptr); -- -- if (info_ptr != NULL) -- { --#if defined(PNG_TEXT_SUPPORTED) -- png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1); --#endif -- --#ifdef PNG_USER_MEM_SUPPORTED -- png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn, -- (png_voidp)mem_ptr); --#else -- png_destroy_struct((png_voidp)info_ptr); --#endif -- *info_ptr_ptr = NULL; -- } -- -- if (end_info_ptr != NULL) -- { --#if defined(PNG_READ_TEXT_SUPPORTED) -- png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1); --#endif --#ifdef PNG_USER_MEM_SUPPORTED -- png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn, -- (png_voidp)mem_ptr); --#else -- png_destroy_struct((png_voidp)end_info_ptr); --#endif -- *end_info_ptr_ptr = NULL; -- } -- -- if (png_ptr != NULL) -- { --#ifdef PNG_USER_MEM_SUPPORTED -- png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, -- (png_voidp)mem_ptr); --#else -- png_destroy_struct((png_voidp)png_ptr); --#endif -- *png_ptr_ptr = NULL; -- } --} -- --/* free all memory used by the read (old method) */ --void /* PRIVATE */ --png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr) --{ --#ifdef PNG_SETJMP_SUPPORTED -- jmp_buf tmp_jmp; --#endif -- png_error_ptr error_fn; -- png_error_ptr warning_fn; -- png_voidp error_ptr; --#ifdef PNG_USER_MEM_SUPPORTED -- png_free_ptr free_fn; --#endif -- -- png_debug(1, "in png_read_destroy\n"); -- if (info_ptr != NULL) -- png_info_destroy(png_ptr, info_ptr); -- -- if (end_info_ptr != NULL) -- png_info_destroy(png_ptr, end_info_ptr); -- -- png_free(png_ptr, png_ptr->zbuf); -- png_free(png_ptr, png_ptr->big_row_buf); -- png_free(png_ptr, png_ptr->prev_row); --#if defined(PNG_READ_DITHER_SUPPORTED) -- png_free(png_ptr, png_ptr->palette_lookup); -- png_free(png_ptr, png_ptr->dither_index); --#endif --#if defined(PNG_READ_GAMMA_SUPPORTED) -- png_free(png_ptr, png_ptr->gamma_table); --#endif --#if defined(PNG_READ_BACKGROUND_SUPPORTED) -- png_free(png_ptr, png_ptr->gamma_from_1); -- png_free(png_ptr, png_ptr->gamma_to_1); --#endif --#ifdef PNG_FREE_ME_SUPPORTED -- if (png_ptr->free_me & PNG_FREE_PLTE) -- png_zfree(png_ptr, png_ptr->palette); -- png_ptr->free_me &= ~PNG_FREE_PLTE; --#else -- if (png_ptr->flags & PNG_FLAG_FREE_PLTE) -- png_zfree(png_ptr, png_ptr->palette); -- png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; --#endif --#if defined(PNG_tRNS_SUPPORTED) || \ -- defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) --#ifdef PNG_FREE_ME_SUPPORTED -- if (png_ptr->free_me & PNG_FREE_TRNS) -- png_free(png_ptr, png_ptr->trans); -- png_ptr->free_me &= ~PNG_FREE_TRNS; --#else -- if (png_ptr->flags & PNG_FLAG_FREE_TRNS) -- png_free(png_ptr, png_ptr->trans); -- png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; --#endif --#endif --#if defined(PNG_READ_hIST_SUPPORTED) --#ifdef PNG_FREE_ME_SUPPORTED -- if (png_ptr->free_me & PNG_FREE_HIST) -- png_free(png_ptr, png_ptr->hist); -- png_ptr->free_me &= ~PNG_FREE_HIST; --#else -- if (png_ptr->flags & PNG_FLAG_FREE_HIST) -- png_free(png_ptr, png_ptr->hist); -- png_ptr->flags &= ~PNG_FLAG_FREE_HIST; --#endif --#endif --#if defined(PNG_READ_GAMMA_SUPPORTED) -- if (png_ptr->gamma_16_table != NULL) -- { -- int i; -- int istop = (1 << (8 - png_ptr->gamma_shift)); -- for (i = 0; i < istop; i++) -- { -- png_free(png_ptr, png_ptr->gamma_16_table[i]); -- } -- png_free(png_ptr, png_ptr->gamma_16_table); -- } --#if defined(PNG_READ_BACKGROUND_SUPPORTED) -- if (png_ptr->gamma_16_from_1 != NULL) -- { -- int i; -- int istop = (1 << (8 - png_ptr->gamma_shift)); -- for (i = 0; i < istop; i++) -- { -- png_free(png_ptr, png_ptr->gamma_16_from_1[i]); -- } -- png_free(png_ptr, png_ptr->gamma_16_from_1); -- } -- if (png_ptr->gamma_16_to_1 != NULL) -- { -- int i; -- int istop = (1 << (8 - png_ptr->gamma_shift)); -- for (i = 0; i < istop; i++) -- { -- png_free(png_ptr, png_ptr->gamma_16_to_1[i]); -- } -- png_free(png_ptr, png_ptr->gamma_16_to_1); -- } --#endif --#endif --#if defined(PNG_TIME_RFC1123_SUPPORTED) -- png_free(png_ptr, png_ptr->time_buffer); --#endif -- -- inflateEnd(&png_ptr->zstream); --#ifdef PNG_PROGRESSIVE_READ_SUPPORTED -- png_free(png_ptr, png_ptr->save_buffer); --#endif -- --#ifdef PNG_PROGRESSIVE_READ_SUPPORTED --#ifdef PNG_TEXT_SUPPORTED -- png_free(png_ptr, png_ptr->current_text); --#endif /* PNG_TEXT_SUPPORTED */ --#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ -- -- /* Save the important info out of the png_struct, in case it is -- * being used again. -- */ --#ifdef PNG_SETJMP_SUPPORTED -- png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf)); --#endif -- -- error_fn = png_ptr->error_fn; -- warning_fn = png_ptr->warning_fn; -- error_ptr = png_ptr->error_ptr; --#ifdef PNG_USER_MEM_SUPPORTED -- free_fn = png_ptr->free_fn; --#endif -- -- png_memset(png_ptr, 0, png_sizeof (png_struct)); -- -- png_ptr->error_fn = error_fn; -- png_ptr->warning_fn = warning_fn; -- png_ptr->error_ptr = error_ptr; --#ifdef PNG_USER_MEM_SUPPORTED -- png_ptr->free_fn = free_fn; --#endif -- --#ifdef PNG_SETJMP_SUPPORTED -- png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf)); --#endif -- --} -- --void PNGAPI --png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn) --{ -- png_ptr->read_row_fn = read_row_fn; --} -- -- --#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED --#if defined(PNG_INFO_IMAGE_SUPPORTED) --void PNGAPI --png_read_png(png_structp png_ptr, png_infop info_ptr, -- int transforms, -- voidp params) --{ -- int row; -- --#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) -- /* invert the alpha channel from opacity to transparency -- */ -- if (transforms & PNG_TRANSFORM_INVERT_ALPHA) -- png_set_invert_alpha(png_ptr); --#endif -- -- /* png_read_info() gives us all of the information from the -- * PNG file before the first IDAT (image data chunk). -- */ -- png_read_info(png_ptr, info_ptr); -- if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep)) -- png_error(png_ptr,"Image is too high to process with png_read_png()"); -- -- /* -------------- image transformations start here ------------------- */ -- --#if defined(PNG_READ_16_TO_8_SUPPORTED) -- /* tell libpng to strip 16 bit/color files down to 8 bits per color -- */ -- if (transforms & PNG_TRANSFORM_STRIP_16) -- png_set_strip_16(png_ptr); --#endif -- --#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) -- /* Strip alpha bytes from the input data without combining with -- * the background (not recommended). -- */ -- if (transforms & PNG_TRANSFORM_STRIP_ALPHA) -- png_set_strip_alpha(png_ptr); --#endif -- --#if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED) -- /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single -- * byte into separate bytes (useful for paletted and grayscale images). -- */ -- if (transforms & PNG_TRANSFORM_PACKING) -- png_set_packing(png_ptr); --#endif -- --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- /* Change the order of packed pixels to least significant bit first -- * (not useful if you are using png_set_packing). -- */ -- if (transforms & PNG_TRANSFORM_PACKSWAP) -- png_set_packswap(png_ptr); --#endif -- --#if defined(PNG_READ_EXPAND_SUPPORTED) -- /* Expand paletted colors into true RGB triplets -- * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel -- * Expand paletted or RGB images with transparency to full alpha -- * channels so the data will be available as RGBA quartets. -- */ -- if (transforms & PNG_TRANSFORM_EXPAND) -- if ((png_ptr->bit_depth < 8) || -- (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) || -- (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))) -- png_set_expand(png_ptr); --#endif -- -- /* We don't handle background color or gamma transformation or dithering. -- */ -- --#if defined(PNG_READ_INVERT_SUPPORTED) -- /* invert monochrome files to have 0 as white and 1 as black -- */ -- if (transforms & PNG_TRANSFORM_INVERT_MONO) -- png_set_invert_mono(png_ptr); --#endif -- --#if defined(PNG_READ_SHIFT_SUPPORTED) -- /* If you want to shift the pixel values from the range [0,255] or -- * [0,65535] to the original [0,7] or [0,31], or whatever range the -- * colors were originally in: -- */ -- if ((transforms & PNG_TRANSFORM_SHIFT) -- && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT)) -- { -- png_color_8p sig_bit; -- -- png_get_sBIT(png_ptr, info_ptr, &sig_bit); -- png_set_shift(png_ptr, sig_bit); -- } --#endif -- --#if defined(PNG_READ_BGR_SUPPORTED) -- /* flip the RGB pixels to BGR (or RGBA to BGRA) -- */ -- if (transforms & PNG_TRANSFORM_BGR) -- png_set_bgr(png_ptr); --#endif -- --#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) -- /* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) -- */ -- if (transforms & PNG_TRANSFORM_SWAP_ALPHA) -- png_set_swap_alpha(png_ptr); --#endif -- --#if defined(PNG_READ_SWAP_SUPPORTED) -- /* swap bytes of 16 bit files to least significant byte first -- */ -- if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) -- png_set_swap(png_ptr); --#endif -- -- /* We don't handle adding filler bytes */ -- -- /* Optional call to gamma correct and add the background to the palette -- * and update info structure. REQUIRED if you are expecting libpng to -- * update the palette for you (i.e., you selected such a transform above). -- */ -- png_read_update_info(png_ptr, info_ptr); -- -- /* -------------- image transformations end here ------------------- */ -- --#ifdef PNG_FREE_ME_SUPPORTED -- png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); --#endif -- if(info_ptr->row_pointers == NULL) -- { -- info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr, -- info_ptr->height * png_sizeof(png_bytep)); --#ifdef PNG_FREE_ME_SUPPORTED -- info_ptr->free_me |= PNG_FREE_ROWS; --#endif -- for (row = 0; row < (int)info_ptr->height; row++) -- { -- info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr, -- png_get_rowbytes(png_ptr, info_ptr)); -- } -- } -- -- png_read_image(png_ptr, info_ptr->row_pointers); -- info_ptr->valid |= PNG_INFO_IDAT; -- -- /* read rest of file, and get additional chunks in info_ptr - REQUIRED */ -- png_read_end(png_ptr, info_ptr); -- -- if(transforms == 0 || params == NULL) -- /* quiet compiler warnings */ return; -- --} --#endif --#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ -diff --git a/thirdparty/libpng/pngrio.c b/thirdparty/libpng/pngrio.c -deleted file mode 100644 -index 806f791..0000000 ---- a/thirdparty/libpng/pngrio.c -+++ /dev/null -@@ -1,161 +0,0 @@ -- --/* pngrio.c - functions for data input -- * -- * libpng 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- * -- * This file provides a location for all input. Users who need -- * special handling are expected to write a function that has the same -- * arguments as this and performs a similar function, but that possibly -- * has a different input method. Note that you shouldn't change this -- * function, but rather write a replacement function and then make -- * libpng use it at run time with png_set_read_fn(...). -- */ -- --#define PNG_INTERNAL --#include "png.h" -- --/* Read the data from whatever input you are using. The default routine -- reads from a file pointer. Note that this routine sometimes gets called -- with very small lengths, so you should implement some kind of simple -- buffering if you are using unbuffered reads. This should never be asked -- to read more then 64K on a 16 bit machine. */ --void /* PRIVATE */ --png_read_data(png_structp png_ptr, png_bytep data, png_size_t length) --{ -- png_debug1(4,"reading %d bytes\n", (int)length); -- if (png_ptr->read_data_fn != NULL) -- (*(png_ptr->read_data_fn))(png_ptr, data, length); -- else -- png_error(png_ptr, "Call to NULL read function"); --} -- --#if !defined(PNG_NO_STDIO) --/* This is the function that does the actual reading of data. If you are -- not reading from a standard C stream, you should create a replacement -- read_data function and use it at run time with png_set_read_fn(), rather -- than changing the library. */ --#ifndef USE_FAR_KEYWORD --void PNGAPI --png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) --{ -- png_size_t check; -- -- /* fread() returns 0 on error, so it is OK to store this in a png_size_t -- * instead of an int, which is what fread() actually returns. -- */ --#if defined(_WIN32_WCE) -- if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) -- check = 0; --#else -- check = (png_size_t)fread(data, (png_size_t)1, length, -- (png_FILE_p)png_ptr->io_ptr); --#endif -- -- if (check != length) -- png_error(png_ptr, "Read Error"); --} --#else --/* this is the model-independent version. Since the standard I/O library -- can't handle far buffers in the medium and small models, we have to copy -- the data. --*/ -- --#define NEAR_BUF_SIZE 1024 --#define MIN(a,b) (a <= b ? a : b) -- --static void /* PRIVATE */ --png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) --{ -- int check; -- png_byte *n_data; -- png_FILE_p io_ptr; -- -- /* Check if data really is near. If so, use usual code. */ -- n_data = (png_byte *)CVT_PTR_NOCHECK(data); -- io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); -- if ((png_bytep)n_data == data) -- { --#if defined(_WIN32_WCE) -- if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) -- check = 0; --#else -- check = fread(n_data, 1, length, io_ptr); --#endif -- } -- else -- { -- png_byte buf[NEAR_BUF_SIZE]; -- png_size_t read, remaining, err; -- check = 0; -- remaining = length; -- do -- { -- read = MIN(NEAR_BUF_SIZE, remaining); --#if defined(_WIN32_WCE) -- if ( !ReadFile((HANDLE)(io_ptr), buf, read, &err, NULL) ) -- err = 0; --#else -- err = fread(buf, (png_size_t)1, read, io_ptr); --#endif -- png_memcpy(data, buf, read); /* copy far buffer to near buffer */ -- if(err != read) -- break; -- else -- check += err; -- data += read; -- remaining -= read; -- } -- while (remaining != 0); -- } -- if ((png_uint_32)check != (png_uint_32)length) -- png_error(png_ptr, "read Error"); --} --#endif --#endif -- --/* This function allows the application to supply a new input function -- for libpng if standard C streams aren't being used. -- -- This function takes as its arguments: -- png_ptr - pointer to a png input data structure -- io_ptr - pointer to user supplied structure containing info about -- the input functions. May be NULL. -- read_data_fn - pointer to a new input function that takes as its -- arguments a pointer to a png_struct, a pointer to -- a location where input data can be stored, and a 32-bit -- unsigned int that is the number of bytes to be read. -- To exit and output any fatal error messages the new write -- function should call png_error(png_ptr, "Error msg"). */ --void PNGAPI --png_set_read_fn(png_structp png_ptr, png_voidp io_ptr, -- png_rw_ptr read_data_fn) --{ -- png_ptr->io_ptr = io_ptr; -- --#if !defined(PNG_NO_STDIO) -- if (read_data_fn != NULL) -- png_ptr->read_data_fn = read_data_fn; -- else -- png_ptr->read_data_fn = png_default_read_data; --#else -- png_ptr->read_data_fn = read_data_fn; --#endif -- -- /* It is an error to write to a read device */ -- if (png_ptr->write_data_fn != NULL) -- { -- png_ptr->write_data_fn = NULL; -- png_warning(png_ptr, -- "It's an error to set both read_data_fn and write_data_fn in the "); -- png_warning(png_ptr, -- "same structure. Resetting write_data_fn to NULL."); -- } -- --#if defined(PNG_WRITE_FLUSH_SUPPORTED) -- png_ptr->output_flush_fn = NULL; --#endif --} -diff --git a/thirdparty/libpng/pngrtran.c b/thirdparty/libpng/pngrtran.c -deleted file mode 100644 -index b914d0e..0000000 ---- a/thirdparty/libpng/pngrtran.c -+++ /dev/null -@@ -1,4177 +0,0 @@ -- --/* pngrtran.c - transforms the data in a row for PNG readers -- * -- * libpng version 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- * -- * This file contains functions optionally called by an application -- * in order to tell libpng how to handle data when reading a PNG. -- * Transformations that are used in both reading and writing are -- * in pngtrans.c. -- */ -- --#define PNG_INTERNAL --#include "png.h" -- --/* Set the action on getting a CRC error for an ancillary or critical chunk. */ --void PNGAPI --png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action) --{ -- png_debug(1, "in png_set_crc_action\n"); -- /* Tell libpng how we react to CRC errors in critical chunks */ -- switch (crit_action) -- { -- case PNG_CRC_NO_CHANGE: /* leave setting as is */ -- break; -- case PNG_CRC_WARN_USE: /* warn/use data */ -- png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; -- png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE; -- break; -- case PNG_CRC_QUIET_USE: /* quiet/use data */ -- png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; -- png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE | -- PNG_FLAG_CRC_CRITICAL_IGNORE; -- break; -- case PNG_CRC_WARN_DISCARD: /* not a valid action for critical data */ -- png_warning(png_ptr, "Can't discard critical data on CRC error."); -- case PNG_CRC_ERROR_QUIT: /* error/quit */ -- case PNG_CRC_DEFAULT: -- default: -- png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; -- break; -- } -- -- switch (ancil_action) -- { -- case PNG_CRC_NO_CHANGE: /* leave setting as is */ -- break; -- case PNG_CRC_WARN_USE: /* warn/use data */ -- png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; -- png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE; -- break; -- case PNG_CRC_QUIET_USE: /* quiet/use data */ -- png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; -- png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE | -- PNG_FLAG_CRC_ANCILLARY_NOWARN; -- break; -- case PNG_CRC_ERROR_QUIT: /* error/quit */ -- png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; -- png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN; -- break; -- case PNG_CRC_WARN_DISCARD: /* warn/discard data */ -- case PNG_CRC_DEFAULT: -- default: -- png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; -- break; -- } --} -- --#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ -- defined(PNG_FLOATING_POINT_SUPPORTED) --/* handle alpha and tRNS via a background color */ --void PNGAPI --png_set_background(png_structp png_ptr, -- png_color_16p background_color, int background_gamma_code, -- int need_expand, double background_gamma) --{ -- png_debug(1, "in png_set_background\n"); -- if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN) -- { -- png_warning(png_ptr, "Application must supply a known background gamma"); -- return; -- } -- -- png_ptr->transformations |= PNG_BACKGROUND; -- png_memcpy(&(png_ptr->background), background_color, -- png_sizeof(png_color_16)); -- png_ptr->background_gamma = (float)background_gamma; -- png_ptr->background_gamma_type = (png_byte)(background_gamma_code); -- png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0); -- -- /* Note: if need_expand is set and color_type is either RGB or RGB_ALPHA -- * (in which case need_expand is superfluous anyway), the background color -- * might actually be gray yet not be flagged as such. This is not a problem -- * for the current code, which uses PNG_BACKGROUND_IS_GRAY only to -- * decide when to do the png_do_gray_to_rgb() transformation. -- */ -- if ((need_expand && !(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) || -- (!need_expand && background_color->red == background_color->green && -- background_color->red == background_color->blue)) -- png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; --} --#endif -- --#if defined(PNG_READ_16_TO_8_SUPPORTED) --/* strip 16 bit depth files to 8 bit depth */ --void PNGAPI --png_set_strip_16(png_structp png_ptr) --{ -- png_debug(1, "in png_set_strip_16\n"); -- png_ptr->transformations |= PNG_16_TO_8; --} --#endif -- --#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) --void PNGAPI --png_set_strip_alpha(png_structp png_ptr) --{ -- png_debug(1, "in png_set_strip_alpha\n"); -- png_ptr->transformations |= PNG_STRIP_ALPHA; --} --#endif -- --#if defined(PNG_READ_DITHER_SUPPORTED) --/* Dither file to 8 bit. Supply a palette, the current number -- * of elements in the palette, the maximum number of elements -- * allowed, and a histogram if possible. If the current number -- * of colors is greater then the maximum number, the palette will be -- * modified to fit in the maximum number. "full_dither" indicates -- * whether we need a dithering cube set up for RGB images, or if we -- * simply are reducing the number of colors in a paletted image. -- */ -- --typedef struct png_dsort_struct --{ -- struct png_dsort_struct FAR * next; -- png_byte left; -- png_byte right; --} png_dsort; --typedef png_dsort FAR * png_dsortp; --typedef png_dsort FAR * FAR * png_dsortpp; -- --void PNGAPI --png_set_dither(png_structp png_ptr, png_colorp palette, -- int num_palette, int maximum_colors, png_uint_16p histogram, -- int full_dither) --{ -- png_debug(1, "in png_set_dither\n"); -- png_ptr->transformations |= PNG_DITHER; -- -- if (!full_dither) -- { -- int i; -- -- png_ptr->dither_index = (png_bytep)png_malloc(png_ptr, -- (png_uint_32)(num_palette * png_sizeof (png_byte))); -- for (i = 0; i < num_palette; i++) -- png_ptr->dither_index[i] = (png_byte)i; -- } -- -- if (num_palette > maximum_colors) -- { -- if (histogram != NULL) -- { -- /* This is easy enough, just throw out the least used colors. -- Perhaps not the best solution, but good enough. */ -- -- int i; -- -- /* initialize an array to sort colors */ -- png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr, -- (png_uint_32)(num_palette * png_sizeof (png_byte))); -- -- /* initialize the dither_sort array */ -- for (i = 0; i < num_palette; i++) -- png_ptr->dither_sort[i] = (png_byte)i; -- -- /* Find the least used palette entries by starting a -- bubble sort, and running it until we have sorted -- out enough colors. Note that we don't care about -- sorting all the colors, just finding which are -- least used. */ -- -- for (i = num_palette - 1; i >= maximum_colors; i--) -- { -- int done; /* to stop early if the list is pre-sorted */ -- int j; -- -- done = 1; -- for (j = 0; j < i; j++) -- { -- if (histogram[png_ptr->dither_sort[j]] -- < histogram[png_ptr->dither_sort[j + 1]]) -- { -- png_byte t; -- -- t = png_ptr->dither_sort[j]; -- png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1]; -- png_ptr->dither_sort[j + 1] = t; -- done = 0; -- } -- } -- if (done) -- break; -- } -- -- /* swap the palette around, and set up a table, if necessary */ -- if (full_dither) -- { -- int j = num_palette; -- -- /* put all the useful colors within the max, but don't -- move the others */ -- for (i = 0; i < maximum_colors; i++) -- { -- if ((int)png_ptr->dither_sort[i] >= maximum_colors) -- { -- do -- j--; -- while ((int)png_ptr->dither_sort[j] >= maximum_colors); -- palette[i] = palette[j]; -- } -- } -- } -- else -- { -- int j = num_palette; -- -- /* move all the used colors inside the max limit, and -- develop a translation table */ -- for (i = 0; i < maximum_colors; i++) -- { -- /* only move the colors we need to */ -- if ((int)png_ptr->dither_sort[i] >= maximum_colors) -- { -- png_color tmp_color; -- -- do -- j--; -- while ((int)png_ptr->dither_sort[j] >= maximum_colors); -- -- tmp_color = palette[j]; -- palette[j] = palette[i]; -- palette[i] = tmp_color; -- /* indicate where the color went */ -- png_ptr->dither_index[j] = (png_byte)i; -- png_ptr->dither_index[i] = (png_byte)j; -- } -- } -- -- /* find closest color for those colors we are not using */ -- for (i = 0; i < num_palette; i++) -- { -- if ((int)png_ptr->dither_index[i] >= maximum_colors) -- { -- int min_d, k, min_k, d_index; -- -- /* find the closest color to one we threw out */ -- d_index = png_ptr->dither_index[i]; -- min_d = PNG_COLOR_DIST(palette[d_index], palette[0]); -- for (k = 1, min_k = 0; k < maximum_colors; k++) -- { -- int d; -- -- d = PNG_COLOR_DIST(palette[d_index], palette[k]); -- -- if (d < min_d) -- { -- min_d = d; -- min_k = k; -- } -- } -- /* point to closest color */ -- png_ptr->dither_index[i] = (png_byte)min_k; -- } -- } -- } -- png_free(png_ptr, png_ptr->dither_sort); -- png_ptr->dither_sort=NULL; -- } -- else -- { -- /* This is much harder to do simply (and quickly). Perhaps -- we need to go through a median cut routine, but those -- don't always behave themselves with only a few colors -- as input. So we will just find the closest two colors, -- and throw out one of them (chosen somewhat randomly). -- [We don't understand this at all, so if someone wants to -- work on improving it, be our guest - AED, GRP] -- */ -- int i; -- int max_d; -- int num_new_palette; -- png_dsortp t; -- png_dsortpp hash; -- -- t=NULL; -- -- /* initialize palette index arrays */ -- png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr, -- (png_uint_32)(num_palette * png_sizeof (png_byte))); -- png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr, -- (png_uint_32)(num_palette * png_sizeof (png_byte))); -- -- /* initialize the sort array */ -- for (i = 0; i < num_palette; i++) -- { -- png_ptr->index_to_palette[i] = (png_byte)i; -- png_ptr->palette_to_index[i] = (png_byte)i; -- } -- -- hash = (png_dsortpp)png_malloc(png_ptr, (png_uint_32)(769 * -- png_sizeof (png_dsortp))); -- for (i = 0; i < 769; i++) -- hash[i] = NULL; --/* png_memset(hash, 0, 769 * png_sizeof (png_dsortp)); */ -- -- num_new_palette = num_palette; -- -- /* initial wild guess at how far apart the farthest pixel -- pair we will be eliminating will be. Larger -- numbers mean more areas will be allocated, Smaller -- numbers run the risk of not saving enough data, and -- having to do this all over again. -- -- I have not done extensive checking on this number. -- */ -- max_d = 96; -- -- while (num_new_palette > maximum_colors) -- { -- for (i = 0; i < num_new_palette - 1; i++) -- { -- int j; -- -- for (j = i + 1; j < num_new_palette; j++) -- { -- int d; -- -- d = PNG_COLOR_DIST(palette[i], palette[j]); -- -- if (d <= max_d) -- { -- -- t = (png_dsortp)png_malloc_warn(png_ptr, -- (png_uint_32)(png_sizeof(png_dsort))); -- if (t == NULL) -- break; -- t->next = hash[d]; -- t->left = (png_byte)i; -- t->right = (png_byte)j; -- hash[d] = t; -- } -- } -- if (t == NULL) -- break; -- } -- -- if (t != NULL) -- for (i = 0; i <= max_d; i++) -- { -- if (hash[i] != NULL) -- { -- png_dsortp p; -- -- for (p = hash[i]; p; p = p->next) -- { -- if ((int)png_ptr->index_to_palette[p->left] -- < num_new_palette && -- (int)png_ptr->index_to_palette[p->right] -- < num_new_palette) -- { -- int j, next_j; -- -- if (num_new_palette & 0x01) -- { -- j = p->left; -- next_j = p->right; -- } -- else -- { -- j = p->right; -- next_j = p->left; -- } -- -- num_new_palette--; -- palette[png_ptr->index_to_palette[j]] -- = palette[num_new_palette]; -- if (!full_dither) -- { -- int k; -- -- for (k = 0; k < num_palette; k++) -- { -- if (png_ptr->dither_index[k] == -- png_ptr->index_to_palette[j]) -- png_ptr->dither_index[k] = -- png_ptr->index_to_palette[next_j]; -- if ((int)png_ptr->dither_index[k] == -- num_new_palette) -- png_ptr->dither_index[k] = -- png_ptr->index_to_palette[j]; -- } -- } -- -- png_ptr->index_to_palette[png_ptr->palette_to_index -- [num_new_palette]] = png_ptr->index_to_palette[j]; -- png_ptr->palette_to_index[png_ptr->index_to_palette[j]] -- = png_ptr->palette_to_index[num_new_palette]; -- -- png_ptr->index_to_palette[j] = (png_byte)num_new_palette; -- png_ptr->palette_to_index[num_new_palette] = (png_byte)j; -- } -- if (num_new_palette <= maximum_colors) -- break; -- } -- if (num_new_palette <= maximum_colors) -- break; -- } -- } -- -- for (i = 0; i < 769; i++) -- { -- if (hash[i] != NULL) -- { -- png_dsortp p = hash[i]; -- while (p) -- { -- t = p->next; -- png_free(png_ptr, p); -- p = t; -- } -- } -- hash[i] = 0; -- } -- max_d += 96; -- } -- png_free(png_ptr, hash); -- png_free(png_ptr, png_ptr->palette_to_index); -- png_free(png_ptr, png_ptr->index_to_palette); -- png_ptr->palette_to_index=NULL; -- png_ptr->index_to_palette=NULL; -- } -- num_palette = maximum_colors; -- } -- if (png_ptr->palette == NULL) -- { -- png_ptr->palette = palette; -- } -- png_ptr->num_palette = (png_uint_16)num_palette; -- -- if (full_dither) -- { -- int i; -- png_bytep distance; -- int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS + -- PNG_DITHER_BLUE_BITS; -- int num_red = (1 << PNG_DITHER_RED_BITS); -- int num_green = (1 << PNG_DITHER_GREEN_BITS); -- int num_blue = (1 << PNG_DITHER_BLUE_BITS); -- png_size_t num_entries = ((png_size_t)1 << total_bits); -- -- png_ptr->palette_lookup = (png_bytep )png_malloc(png_ptr, -- (png_uint_32)(num_entries * png_sizeof (png_byte))); -- -- png_memset(png_ptr->palette_lookup, 0, num_entries * -- png_sizeof (png_byte)); -- -- distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries * -- png_sizeof(png_byte))); -- -- png_memset(distance, 0xff, num_entries * png_sizeof(png_byte)); -- -- for (i = 0; i < num_palette; i++) -- { -- int ir, ig, ib; -- int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS)); -- int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS)); -- int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS)); -- -- for (ir = 0; ir < num_red; ir++) -- { -- /* int dr = abs(ir - r); */ -- int dr = ((ir > r) ? ir - r : r - ir); -- int index_r = (ir << (PNG_DITHER_BLUE_BITS + PNG_DITHER_GREEN_BITS)); -- -- for (ig = 0; ig < num_green; ig++) -- { -- /* int dg = abs(ig - g); */ -- int dg = ((ig > g) ? ig - g : g - ig); -- int dt = dr + dg; -- int dm = ((dr > dg) ? dr : dg); -- int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS); -- -- for (ib = 0; ib < num_blue; ib++) -- { -- int d_index = index_g | ib; -- /* int db = abs(ib - b); */ -- int db = ((ib > b) ? ib - b : b - ib); -- int dmax = ((dm > db) ? dm : db); -- int d = dmax + dt + db; -- -- if (d < (int)distance[d_index]) -- { -- distance[d_index] = (png_byte)d; -- png_ptr->palette_lookup[d_index] = (png_byte)i; -- } -- } -- } -- } -- } -- -- png_free(png_ptr, distance); -- } --} --#endif -- --#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) --/* Transform the image from the file_gamma to the screen_gamma. We -- * only do transformations on images where the file_gamma and screen_gamma -- * are not close reciprocals, otherwise it slows things down slightly, and -- * also needlessly introduces small errors. -- * -- * We will turn off gamma transformation later if no semitransparent entries -- * are present in the tRNS array for palette images. We can't do it here -- * because we don't necessarily have the tRNS chunk yet. -- */ --void PNGAPI --png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma) --{ -- png_debug(1, "in png_set_gamma\n"); -- if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) || -- (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) || -- (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)) -- png_ptr->transformations |= PNG_GAMMA; -- png_ptr->gamma = (float)file_gamma; -- png_ptr->screen_gamma = (float)scrn_gamma; --} --#endif -- --#if defined(PNG_READ_EXPAND_SUPPORTED) --/* Expand paletted images to RGB, expand grayscale images of -- * less than 8-bit depth to 8-bit depth, and expand tRNS chunks -- * to alpha channels. -- */ --void PNGAPI --png_set_expand(png_structp png_ptr) --{ -- png_debug(1, "in png_set_expand\n"); -- png_ptr->transformations |= PNG_EXPAND; --} -- --/* GRR 19990627: the following three functions currently are identical -- * to png_set_expand(). However, it is entirely reasonable that someone -- * might wish to expand an indexed image to RGB but *not* expand a single, -- * fully transparent palette entry to a full alpha channel--perhaps instead -- * convert tRNS to the grayscale/RGB format (16-bit RGB value), or replace -- * the transparent color with a particular RGB value, or drop tRNS entirely. -- * IOW, a future version of the library may make the transformations flag -- * a bit more fine-grained, with separate bits for each of these three -- * functions. -- * -- * More to the point, these functions make it obvious what libpng will be -- * doing, whereas "expand" can (and does) mean any number of things. -- */ -- --/* Expand paletted images to RGB. */ --void PNGAPI --png_set_palette_to_rgb(png_structp png_ptr) --{ -- png_debug(1, "in png_set_expand\n"); -- png_ptr->transformations |= PNG_EXPAND; --} -- --/* Expand grayscale images of less than 8-bit depth to 8 bits. */ --void PNGAPI --png_set_gray_1_2_4_to_8(png_structp png_ptr) --{ -- png_debug(1, "in png_set_expand\n"); -- png_ptr->transformations |= PNG_EXPAND; --} -- --/* Expand tRNS chunks to alpha channels. */ --void PNGAPI --png_set_tRNS_to_alpha(png_structp png_ptr) --{ -- png_debug(1, "in png_set_expand\n"); -- png_ptr->transformations |= PNG_EXPAND; --} --#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */ -- --#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) --void PNGAPI --png_set_gray_to_rgb(png_structp png_ptr) --{ -- png_debug(1, "in png_set_gray_to_rgb\n"); -- png_ptr->transformations |= PNG_GRAY_TO_RGB; --} --#endif -- --#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) --#if defined(PNG_FLOATING_POINT_SUPPORTED) --/* Convert a RGB image to a grayscale of the same width. This allows us, -- * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image. -- */ -- --void PNGAPI --png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red, -- double green) --{ -- int red_fixed = (int)((float)red*100000.0 + 0.5); -- int green_fixed = (int)((float)green*100000.0 + 0.5); -- png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed); --} --#endif -- --void PNGAPI --png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action, -- png_fixed_point red, png_fixed_point green) --{ -- png_debug(1, "in png_set_rgb_to_gray\n"); -- switch(error_action) -- { -- case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY; -- break; -- case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN; -- break; -- case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR; -- } -- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) --#if defined(PNG_READ_EXPAND_SUPPORTED) -- png_ptr->transformations |= PNG_EXPAND; --#else -- { -- png_warning(png_ptr, "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED."); -- png_ptr->transformations &= ~PNG_RGB_TO_GRAY; -- } --#endif -- { -- png_uint_16 red_int, green_int; -- if(red < 0 || green < 0) -- { -- red_int = 6968; /* .212671 * 32768 + .5 */ -- green_int = 23434; /* .715160 * 32768 + .5 */ -- } -- else if(red + green < 100000L) -- { -- red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L); -- green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L); -- } -- else -- { -- png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients"); -- red_int = 6968; -- green_int = 23434; -- } -- png_ptr->rgb_to_gray_red_coeff = red_int; -- png_ptr->rgb_to_gray_green_coeff = green_int; -- png_ptr->rgb_to_gray_blue_coeff = (png_uint_16)(32768-red_int-green_int); -- } --} --#endif -- --#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ -- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ -- defined(PNG_LEGACY_SUPPORTED) --void PNGAPI --png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr -- read_user_transform_fn) --{ -- png_debug(1, "in png_set_read_user_transform_fn\n"); --#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) -- png_ptr->transformations |= PNG_USER_TRANSFORM; -- png_ptr->read_user_transform_fn = read_user_transform_fn; --#endif --#ifdef PNG_LEGACY_SUPPORTED -- if(read_user_transform_fn) -- png_warning(png_ptr, -- "This version of libpng does not support user transforms"); --#endif --} --#endif -- --/* Initialize everything needed for the read. This includes modifying -- * the palette. -- */ --void /* PRIVATE */ --png_init_read_transformations(png_structp png_ptr) --{ -- png_debug(1, "in png_init_read_transformations\n"); --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- if(png_ptr != NULL) --#endif -- { --#if defined(PNG_READ_BACKGROUND_SUPPORTED) || defined(PNG_READ_SHIFT_SUPPORTED) \ -- || defined(PNG_READ_GAMMA_SUPPORTED) -- int color_type = png_ptr->color_type; --#endif -- --#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED) -- if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) && -- (png_ptr->transformations & PNG_EXPAND)) -- { -- if (!(color_type & PNG_COLOR_MASK_COLOR)) /* i.e., GRAY or GRAY_ALPHA */ -- { -- /* expand background chunk. */ -- switch (png_ptr->bit_depth) -- { -- case 1: -- png_ptr->background.gray *= (png_uint_16)0xff; -- png_ptr->background.red = png_ptr->background.green -- = png_ptr->background.blue = png_ptr->background.gray; -- break; -- case 2: -- png_ptr->background.gray *= (png_uint_16)0x55; -- png_ptr->background.red = png_ptr->background.green -- = png_ptr->background.blue = png_ptr->background.gray; -- break; -- case 4: -- png_ptr->background.gray *= (png_uint_16)0x11; -- png_ptr->background.red = png_ptr->background.green -- = png_ptr->background.blue = png_ptr->background.gray; -- break; -- case 8: -- case 16: -- png_ptr->background.red = png_ptr->background.green -- = png_ptr->background.blue = png_ptr->background.gray; -- break; -- } -- } -- else if (color_type == PNG_COLOR_TYPE_PALETTE) -- { -- png_ptr->background.red = -- png_ptr->palette[png_ptr->background.index].red; -- png_ptr->background.green = -- png_ptr->palette[png_ptr->background.index].green; -- png_ptr->background.blue = -- png_ptr->palette[png_ptr->background.index].blue; -- --#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) -- if (png_ptr->transformations & PNG_INVERT_ALPHA) -- { --#if defined(PNG_READ_EXPAND_SUPPORTED) -- if (!(png_ptr->transformations & PNG_EXPAND)) --#endif -- { -- /* invert the alpha channel (in tRNS) unless the pixels are -- going to be expanded, in which case leave it for later */ -- int i,istop; -- istop=(int)png_ptr->num_trans; -- for (i=0; itrans[i] = (png_byte)(255 - png_ptr->trans[i]); -- } -- } --#endif -- -- } -- } --#endif -- --#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED) -- png_ptr->background_1 = png_ptr->background; --#endif --#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) -- -- if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0) -- && (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0) -- < PNG_GAMMA_THRESHOLD)) -- { -- int i,k; -- k=0; -- for (i=0; inum_trans; i++) -- { -- if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff) -- k=1; /* partial transparency is present */ -- } -- if (k == 0) -- png_ptr->transformations &= (~PNG_GAMMA); -- } -- -- if (png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY)) -- { -- png_build_gamma_table(png_ptr); --#if defined(PNG_READ_BACKGROUND_SUPPORTED) -- if (png_ptr->transformations & PNG_BACKGROUND) -- { -- if (color_type == PNG_COLOR_TYPE_PALETTE) -- { -- /* could skip if no transparency and -- */ -- png_color back, back_1; -- png_colorp palette = png_ptr->palette; -- int num_palette = png_ptr->num_palette; -- int i; -- if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE) -- { -- back.red = png_ptr->gamma_table[png_ptr->background.red]; -- back.green = png_ptr->gamma_table[png_ptr->background.green]; -- back.blue = png_ptr->gamma_table[png_ptr->background.blue]; -- -- back_1.red = png_ptr->gamma_to_1[png_ptr->background.red]; -- back_1.green = png_ptr->gamma_to_1[png_ptr->background.green]; -- back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue]; -- } -- else -- { -- double g, gs; -- -- switch (png_ptr->background_gamma_type) -- { -- case PNG_BACKGROUND_GAMMA_SCREEN: -- g = (png_ptr->screen_gamma); -- gs = 1.0; -- break; -- case PNG_BACKGROUND_GAMMA_FILE: -- g = 1.0 / (png_ptr->gamma); -- gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); -- break; -- case PNG_BACKGROUND_GAMMA_UNIQUE: -- g = 1.0 / (png_ptr->background_gamma); -- gs = 1.0 / (png_ptr->background_gamma * -- png_ptr->screen_gamma); -- break; -- default: -- g = 1.0; /* back_1 */ -- gs = 1.0; /* back */ -- } -- -- if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD) -- { -- back.red = (png_byte)png_ptr->background.red; -- back.green = (png_byte)png_ptr->background.green; -- back.blue = (png_byte)png_ptr->background.blue; -- } -- else -- { -- back.red = (png_byte)(pow( -- (double)png_ptr->background.red/255, gs) * 255.0 + .5); -- back.green = (png_byte)(pow( -- (double)png_ptr->background.green/255, gs) * 255.0 + .5); -- back.blue = (png_byte)(pow( -- (double)png_ptr->background.blue/255, gs) * 255.0 + .5); -- } -- -- back_1.red = (png_byte)(pow( -- (double)png_ptr->background.red/255, g) * 255.0 + .5); -- back_1.green = (png_byte)(pow( -- (double)png_ptr->background.green/255, g) * 255.0 + .5); -- back_1.blue = (png_byte)(pow( -- (double)png_ptr->background.blue/255, g) * 255.0 + .5); -- } -- for (i = 0; i < num_palette; i++) -- { -- if (i < (int)png_ptr->num_trans && png_ptr->trans[i] != 0xff) -- { -- if (png_ptr->trans[i] == 0) -- { -- palette[i] = back; -- } -- else /* if (png_ptr->trans[i] != 0xff) */ -- { -- png_byte v, w; -- -- v = png_ptr->gamma_to_1[palette[i].red]; -- png_composite(w, v, png_ptr->trans[i], back_1.red); -- palette[i].red = png_ptr->gamma_from_1[w]; -- -- v = png_ptr->gamma_to_1[palette[i].green]; -- png_composite(w, v, png_ptr->trans[i], back_1.green); -- palette[i].green = png_ptr->gamma_from_1[w]; -- -- v = png_ptr->gamma_to_1[palette[i].blue]; -- png_composite(w, v, png_ptr->trans[i], back_1.blue); -- palette[i].blue = png_ptr->gamma_from_1[w]; -- } -- } -- else -- { -- palette[i].red = png_ptr->gamma_table[palette[i].red]; -- palette[i].green = png_ptr->gamma_table[palette[i].green]; -- palette[i].blue = png_ptr->gamma_table[palette[i].blue]; -- } -- } -- } -- /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */ -- else -- /* color_type != PNG_COLOR_TYPE_PALETTE */ -- { -- double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1); -- double g = 1.0; -- double gs = 1.0; -- -- switch (png_ptr->background_gamma_type) -- { -- case PNG_BACKGROUND_GAMMA_SCREEN: -- g = (png_ptr->screen_gamma); -- gs = 1.0; -- break; -- case PNG_BACKGROUND_GAMMA_FILE: -- g = 1.0 / (png_ptr->gamma); -- gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); -- break; -- case PNG_BACKGROUND_GAMMA_UNIQUE: -- g = 1.0 / (png_ptr->background_gamma); -- gs = 1.0 / (png_ptr->background_gamma * -- png_ptr->screen_gamma); -- break; -- } -- -- png_ptr->background_1.gray = (png_uint_16)(pow( -- (double)png_ptr->background.gray / m, g) * m + .5); -- png_ptr->background.gray = (png_uint_16)(pow( -- (double)png_ptr->background.gray / m, gs) * m + .5); -- -- if ((png_ptr->background.red != png_ptr->background.green) || -- (png_ptr->background.red != png_ptr->background.blue) || -- (png_ptr->background.red != png_ptr->background.gray)) -- { -- /* RGB or RGBA with color background */ -- png_ptr->background_1.red = (png_uint_16)(pow( -- (double)png_ptr->background.red / m, g) * m + .5); -- png_ptr->background_1.green = (png_uint_16)(pow( -- (double)png_ptr->background.green / m, g) * m + .5); -- png_ptr->background_1.blue = (png_uint_16)(pow( -- (double)png_ptr->background.blue / m, g) * m + .5); -- png_ptr->background.red = (png_uint_16)(pow( -- (double)png_ptr->background.red / m, gs) * m + .5); -- png_ptr->background.green = (png_uint_16)(pow( -- (double)png_ptr->background.green / m, gs) * m + .5); -- png_ptr->background.blue = (png_uint_16)(pow( -- (double)png_ptr->background.blue / m, gs) * m + .5); -- } -- else -- { -- /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */ -- png_ptr->background_1.red = png_ptr->background_1.green -- = png_ptr->background_1.blue = png_ptr->background_1.gray; -- png_ptr->background.red = png_ptr->background.green -- = png_ptr->background.blue = png_ptr->background.gray; -- } -- } -- } -- else -- /* transformation does not include PNG_BACKGROUND */ --#endif /* PNG_READ_BACKGROUND_SUPPORTED */ -- if (color_type == PNG_COLOR_TYPE_PALETTE) -- { -- png_colorp palette = png_ptr->palette; -- int num_palette = png_ptr->num_palette; -- int i; -- -- for (i = 0; i < num_palette; i++) -- { -- palette[i].red = png_ptr->gamma_table[palette[i].red]; -- palette[i].green = png_ptr->gamma_table[palette[i].green]; -- palette[i].blue = png_ptr->gamma_table[palette[i].blue]; -- } -- } -- } --#if defined(PNG_READ_BACKGROUND_SUPPORTED) -- else --#endif --#endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */ --#if defined(PNG_READ_BACKGROUND_SUPPORTED) -- /* No GAMMA transformation */ -- if ((png_ptr->transformations & PNG_BACKGROUND) && -- (color_type == PNG_COLOR_TYPE_PALETTE)) -- { -- int i; -- int istop = (int)png_ptr->num_trans; -- png_color back; -- png_colorp palette = png_ptr->palette; -- -- back.red = (png_byte)png_ptr->background.red; -- back.green = (png_byte)png_ptr->background.green; -- back.blue = (png_byte)png_ptr->background.blue; -- -- for (i = 0; i < istop; i++) -- { -- if (png_ptr->trans[i] == 0) -- { -- palette[i] = back; -- } -- else if (png_ptr->trans[i] != 0xff) -- { -- /* The png_composite() macro is defined in png.h */ -- png_composite(palette[i].red, palette[i].red, -- png_ptr->trans[i], back.red); -- png_composite(palette[i].green, palette[i].green, -- png_ptr->trans[i], back.green); -- png_composite(palette[i].blue, palette[i].blue, -- png_ptr->trans[i], back.blue); -- } -- } -- } --#endif /* PNG_READ_BACKGROUND_SUPPORTED */ -- --#if defined(PNG_READ_SHIFT_SUPPORTED) -- if ((png_ptr->transformations & PNG_SHIFT) && -- (color_type == PNG_COLOR_TYPE_PALETTE)) -- { -- png_uint_16 i; -- png_uint_16 istop = png_ptr->num_palette; -- int sr = 8 - png_ptr->sig_bit.red; -- int sg = 8 - png_ptr->sig_bit.green; -- int sb = 8 - png_ptr->sig_bit.blue; -- -- if (sr < 0 || sr > 8) -- sr = 0; -- if (sg < 0 || sg > 8) -- sg = 0; -- if (sb < 0 || sb > 8) -- sb = 0; -- for (i = 0; i < istop; i++) -- { -- png_ptr->palette[i].red >>= sr; -- png_ptr->palette[i].green >>= sg; -- png_ptr->palette[i].blue >>= sb; -- } -- } --#endif /* PNG_READ_SHIFT_SUPPORTED */ -- } --#if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \ -- && !defined(PNG_READ_BACKGROUND_SUPPORTED) -- if(png_ptr) -- return; --#endif --} -- --/* Modify the info structure to reflect the transformations. The -- * info should be updated so a PNG file could be written with it, -- * assuming the transformations result in valid PNG data. -- */ --void /* PRIVATE */ --png_read_transform_info(png_structp png_ptr, png_infop info_ptr) --{ -- png_debug(1, "in png_read_transform_info\n"); --#if defined(PNG_READ_EXPAND_SUPPORTED) -- if (png_ptr->transformations & PNG_EXPAND) -- { -- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- { -- if (png_ptr->num_trans) -- info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA; -- else -- info_ptr->color_type = PNG_COLOR_TYPE_RGB; -- info_ptr->bit_depth = 8; -- info_ptr->num_trans = 0; -- } -- else -- { -- if (png_ptr->num_trans) -- info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; -- if (info_ptr->bit_depth < 8) -- info_ptr->bit_depth = 8; -- info_ptr->num_trans = 0; -- } -- } --#endif -- --#if defined(PNG_READ_BACKGROUND_SUPPORTED) -- if (png_ptr->transformations & PNG_BACKGROUND) -- { -- info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA; -- info_ptr->num_trans = 0; -- info_ptr->background = png_ptr->background; -- } --#endif -- --#if defined(PNG_READ_GAMMA_SUPPORTED) -- if (png_ptr->transformations & PNG_GAMMA) -- { --#ifdef PNG_FLOATING_POINT_SUPPORTED -- info_ptr->gamma = png_ptr->gamma; --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED -- info_ptr->int_gamma = png_ptr->int_gamma; --#endif -- } --#endif -- --#if defined(PNG_READ_16_TO_8_SUPPORTED) -- if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16)) -- info_ptr->bit_depth = 8; --#endif -- --#if defined(PNG_READ_DITHER_SUPPORTED) -- if (png_ptr->transformations & PNG_DITHER) -- { -- if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) || -- (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) && -- png_ptr->palette_lookup && info_ptr->bit_depth == 8) -- { -- info_ptr->color_type = PNG_COLOR_TYPE_PALETTE; -- } -- } --#endif -- --#if defined(PNG_READ_PACK_SUPPORTED) -- if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8)) -- info_ptr->bit_depth = 8; --#endif -- --#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) -- if (png_ptr->transformations & PNG_GRAY_TO_RGB) -- info_ptr->color_type |= PNG_COLOR_MASK_COLOR; --#endif -- --#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) -- if (png_ptr->transformations & PNG_RGB_TO_GRAY) -- info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR; --#endif -- -- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- info_ptr->channels = 1; -- else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) -- info_ptr->channels = 3; -- else -- info_ptr->channels = 1; -- --#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) -- if (png_ptr->transformations & PNG_STRIP_ALPHA) -- info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA; --#endif -- -- if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) -- info_ptr->channels++; -- --#if defined(PNG_READ_FILLER_SUPPORTED) -- /* STRIP_ALPHA and FILLER allowed: MASK_ALPHA bit stripped above */ -- if ((png_ptr->transformations & PNG_FILLER) && -- ((info_ptr->color_type == PNG_COLOR_TYPE_RGB) || -- (info_ptr->color_type == PNG_COLOR_TYPE_GRAY))) -- { -- info_ptr->channels++; -- /* if adding a true alpha channel not just filler */ --#if !defined(PNG_1_0_X) -- if (png_ptr->transformations & PNG_ADD_ALPHA) -- info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; --#endif -- } --#endif -- --#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \ --defined(PNG_READ_USER_TRANSFORM_SUPPORTED) -- if(png_ptr->transformations & PNG_USER_TRANSFORM) -- { -- if(info_ptr->bit_depth < png_ptr->user_transform_depth) -- info_ptr->bit_depth = png_ptr->user_transform_depth; -- if(info_ptr->channels < png_ptr->user_transform_channels) -- info_ptr->channels = png_ptr->user_transform_channels; -- } --#endif -- -- info_ptr->pixel_depth = (png_byte)(info_ptr->channels * -- info_ptr->bit_depth); -- -- info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth,info_ptr->width); -- --#if !defined(PNG_READ_EXPAND_SUPPORTED) -- if(png_ptr) -- return; --#endif --} -- --/* Transform the row. The order of transformations is significant, -- * and is very touchy. If you add a transformation, take care to -- * decide how it fits in with the other transformations here. -- */ --void /* PRIVATE */ --png_do_read_transformations(png_structp png_ptr) --{ -- png_debug(1, "in png_do_read_transformations\n"); --#if !defined(PNG_USELESS_TESTS_SUPPORTED) -- if (png_ptr->row_buf == NULL) -- { --#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) -- char msg[50]; -- -- sprintf(msg, "NULL row buffer for row %ld, pass %d", png_ptr->row_number, -- png_ptr->pass); -- png_error(png_ptr, msg); --#else -- png_error(png_ptr, "NULL row buffer"); --#endif -- } --#endif -- --#if defined(PNG_READ_EXPAND_SUPPORTED) -- if (png_ptr->transformations & PNG_EXPAND) -- { -- if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE) -- { -- png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1, -- png_ptr->palette, png_ptr->trans, png_ptr->num_trans); -- } -- else -- { -- if (png_ptr->num_trans) -- png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1, -- &(png_ptr->trans_values)); -- else -- png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1, -- NULL); -- } -- } --#endif -- --#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) -- if (png_ptr->transformations & PNG_STRIP_ALPHA) -- png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, -- PNG_FLAG_FILLER_AFTER); --#endif -- --#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) -- if (png_ptr->transformations & PNG_RGB_TO_GRAY) -- { -- int rgb_error = -- png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), png_ptr->row_buf + 1); -- if(rgb_error) -- { -- png_ptr->rgb_to_gray_status=1; -- if(png_ptr->transformations == PNG_RGB_TO_GRAY_WARN) -- png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel"); -- if(png_ptr->transformations == PNG_RGB_TO_GRAY_ERR) -- png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel"); -- } -- } --#endif -- --/* --From Andreas Dilger e-mail to png-implement, 26 March 1998: -- -- In most cases, the "simple transparency" should be done prior to doing -- gray-to-RGB, or you will have to test 3x as many bytes to check if a -- pixel is transparent. You would also need to make sure that the -- transparency information is upgraded to RGB. -- -- To summarize, the current flow is: -- - Gray + simple transparency -> compare 1 or 2 gray bytes and composite -- with background "in place" if transparent, -- convert to RGB if necessary -- - Gray + alpha -> composite with gray background and remove alpha bytes, -- convert to RGB if necessary -- -- To support RGB backgrounds for gray images we need: -- - Gray + simple transparency -> convert to RGB + simple transparency, compare -- 3 or 6 bytes and composite with background -- "in place" if transparent (3x compare/pixel -- compared to doing composite with gray bkgrnd) -- - Gray + alpha -> convert to RGB + alpha, composite with background and -- remove alpha bytes (3x float operations/pixel -- compared with composite on gray background) -- -- Greg's change will do this. The reason it wasn't done before is for -- performance, as this increases the per-pixel operations. If we would check -- in advance if the background was gray or RGB, and position the gray-to-RGB -- transform appropriately, then it would save a lot of work/time. -- */ -- --#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) -- /* if gray -> RGB, do so now only if background is non-gray; else do later -- * for performance reasons */ -- if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && -- !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) -- png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif -- --#if defined(PNG_READ_BACKGROUND_SUPPORTED) -- if ((png_ptr->transformations & PNG_BACKGROUND) && -- ((png_ptr->num_trans != 0 ) || -- (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) -- png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1, -- &(png_ptr->trans_values), &(png_ptr->background) --#if defined(PNG_READ_GAMMA_SUPPORTED) -- , &(png_ptr->background_1), -- png_ptr->gamma_table, png_ptr->gamma_from_1, -- png_ptr->gamma_to_1, png_ptr->gamma_16_table, -- png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1, -- png_ptr->gamma_shift --#endif --); --#endif -- --#if defined(PNG_READ_GAMMA_SUPPORTED) -- if ((png_ptr->transformations & PNG_GAMMA) && --#if defined(PNG_READ_BACKGROUND_SUPPORTED) -- !((png_ptr->transformations & PNG_BACKGROUND) && -- ((png_ptr->num_trans != 0) || -- (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) && --#endif -- (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)) -- png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1, -- png_ptr->gamma_table, png_ptr->gamma_16_table, -- png_ptr->gamma_shift); --#endif -- --#if defined(PNG_READ_16_TO_8_SUPPORTED) -- if (png_ptr->transformations & PNG_16_TO_8) -- png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif -- --#if defined(PNG_READ_DITHER_SUPPORTED) -- if (png_ptr->transformations & PNG_DITHER) -- { -- png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1, -- png_ptr->palette_lookup, png_ptr->dither_index); -- if(png_ptr->row_info.rowbytes == (png_uint_32)0) -- png_error(png_ptr, "png_do_dither returned rowbytes=0"); -- } --#endif -- --#if defined(PNG_READ_INVERT_SUPPORTED) -- if (png_ptr->transformations & PNG_INVERT_MONO) -- png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif -- --#if defined(PNG_READ_SHIFT_SUPPORTED) -- if (png_ptr->transformations & PNG_SHIFT) -- png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1, -- &(png_ptr->shift)); --#endif -- --#if defined(PNG_READ_PACK_SUPPORTED) -- if (png_ptr->transformations & PNG_PACK) -- png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif -- --#if defined(PNG_READ_BGR_SUPPORTED) -- if (png_ptr->transformations & PNG_BGR) -- png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif -- --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_PACKSWAP) -- png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif -- --#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) -- /* if gray -> RGB, do so now only if we did not do so above */ -- if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && -- (png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) -- png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif -- --#if defined(PNG_READ_FILLER_SUPPORTED) -- if (png_ptr->transformations & PNG_FILLER) -- png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, -- (png_uint_32)png_ptr->filler, png_ptr->flags); --#endif -- --#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) -- if (png_ptr->transformations & PNG_INVERT_ALPHA) -- png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif -- --#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) -- if (png_ptr->transformations & PNG_SWAP_ALPHA) -- png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif -- --#if defined(PNG_READ_SWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_SWAP_BYTES) -- png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif -- --#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) -- if (png_ptr->transformations & PNG_USER_TRANSFORM) -- { -- if(png_ptr->read_user_transform_fn != NULL) -- (*(png_ptr->read_user_transform_fn)) /* user read transform function */ -- (png_ptr, /* png_ptr */ -- &(png_ptr->row_info), /* row_info: */ -- /* png_uint_32 width; width of row */ -- /* png_uint_32 rowbytes; number of bytes in row */ -- /* png_byte color_type; color type of pixels */ -- /* png_byte bit_depth; bit depth of samples */ -- /* png_byte channels; number of channels (1-4) */ -- /* png_byte pixel_depth; bits per pixel (depth*channels) */ -- png_ptr->row_buf + 1); /* start of pixel data for row */ --#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) -- if(png_ptr->user_transform_depth) -- png_ptr->row_info.bit_depth = png_ptr->user_transform_depth; -- if(png_ptr->user_transform_channels) -- png_ptr->row_info.channels = png_ptr->user_transform_channels; --#endif -- png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth * -- png_ptr->row_info.channels); -- png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, -- png_ptr->row_info.width); -- } --#endif -- --} -- --#if defined(PNG_READ_PACK_SUPPORTED) --/* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel, -- * without changing the actual values. Thus, if you had a row with -- * a bit depth of 1, you would end up with bytes that only contained -- * the numbers 0 or 1. If you would rather they contain 0 and 255, use -- * png_do_shift() after this. -- */ --void /* PRIVATE */ --png_do_unpack(png_row_infop row_info, png_bytep row) --{ -- png_debug(1, "in png_do_unpack\n"); --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- if (row != NULL && row_info != NULL && row_info->bit_depth < 8) --#else -- if (row_info->bit_depth < 8) --#endif -- { -- png_uint_32 i; -- png_uint_32 row_width=row_info->width; -- -- switch (row_info->bit_depth) -- { -- case 1: -- { -- png_bytep sp = row + (png_size_t)((row_width - 1) >> 3); -- png_bytep dp = row + (png_size_t)row_width - 1; -- png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07); -- for (i = 0; i < row_width; i++) -- { -- *dp = (png_byte)((*sp >> shift) & 0x01); -- if (shift == 7) -- { -- shift = 0; -- sp--; -- } -- else -- shift++; -- -- dp--; -- } -- break; -- } -- case 2: -- { -- -- png_bytep sp = row + (png_size_t)((row_width - 1) >> 2); -- png_bytep dp = row + (png_size_t)row_width - 1; -- png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); -- for (i = 0; i < row_width; i++) -- { -- *dp = (png_byte)((*sp >> shift) & 0x03); -- if (shift == 6) -- { -- shift = 0; -- sp--; -- } -- else -- shift += 2; -- -- dp--; -- } -- break; -- } -- case 4: -- { -- png_bytep sp = row + (png_size_t)((row_width - 1) >> 1); -- png_bytep dp = row + (png_size_t)row_width - 1; -- png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); -- for (i = 0; i < row_width; i++) -- { -- *dp = (png_byte)((*sp >> shift) & 0x0f); -- if (shift == 4) -- { -- shift = 0; -- sp--; -- } -- else -- shift = 4; -- -- dp--; -- } -- break; -- } -- } -- row_info->bit_depth = 8; -- row_info->pixel_depth = (png_byte)(8 * row_info->channels); -- row_info->rowbytes = row_width * row_info->channels; -- } --} --#endif -- --#if defined(PNG_READ_SHIFT_SUPPORTED) --/* Reverse the effects of png_do_shift. This routine merely shifts the -- * pixels back to their significant bits values. Thus, if you have -- * a row of bit depth 8, but only 5 are significant, this will shift -- * the values back to 0 through 31. -- */ --void /* PRIVATE */ --png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits) --{ -- png_debug(1, "in png_do_unshift\n"); -- if ( --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- row != NULL && row_info != NULL && sig_bits != NULL && --#endif -- row_info->color_type != PNG_COLOR_TYPE_PALETTE) -- { -- int shift[4]; -- int channels = 0; -- int c; -- png_uint_16 value = 0; -- png_uint_32 row_width = row_info->width; -- -- if (row_info->color_type & PNG_COLOR_MASK_COLOR) -- { -- shift[channels++] = row_info->bit_depth - sig_bits->red; -- shift[channels++] = row_info->bit_depth - sig_bits->green; -- shift[channels++] = row_info->bit_depth - sig_bits->blue; -- } -- else -- { -- shift[channels++] = row_info->bit_depth - sig_bits->gray; -- } -- if (row_info->color_type & PNG_COLOR_MASK_ALPHA) -- { -- shift[channels++] = row_info->bit_depth - sig_bits->alpha; -- } -- -- for (c = 0; c < channels; c++) -- { -- if (shift[c] <= 0) -- shift[c] = 0; -- else -- value = 1; -- } -- -- if (!value) -- return; -- -- switch (row_info->bit_depth) -- { -- case 2: -- { -- png_bytep bp; -- png_uint_32 i; -- png_uint_32 istop = row_info->rowbytes; -- -- for (bp = row, i = 0; i < istop; i++) -- { -- *bp >>= 1; -- *bp++ &= 0x55; -- } -- break; -- } -- case 4: -- { -- png_bytep bp = row; -- png_uint_32 i; -- png_uint_32 istop = row_info->rowbytes; -- png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) | -- (png_byte)((int)0xf >> shift[0])); -- -- for (i = 0; i < istop; i++) -- { -- *bp >>= shift[0]; -- *bp++ &= mask; -- } -- break; -- } -- case 8: -- { -- png_bytep bp = row; -- png_uint_32 i; -- png_uint_32 istop = row_width * channels; -- -- for (i = 0; i < istop; i++) -- { -- *bp++ >>= shift[i%channels]; -- } -- break; -- } -- case 16: -- { -- png_bytep bp = row; -- png_uint_32 i; -- png_uint_32 istop = channels * row_width; -- -- for (i = 0; i < istop; i++) -- { -- value = (png_uint_16)((*bp << 8) + *(bp + 1)); -- value >>= shift[i%channels]; -- *bp++ = (png_byte)(value >> 8); -- *bp++ = (png_byte)(value & 0xff); -- } -- break; -- } -- } -- } --} --#endif -- --#if defined(PNG_READ_16_TO_8_SUPPORTED) --/* chop rows of bit depth 16 down to 8 */ --void /* PRIVATE */ --png_do_chop(png_row_infop row_info, png_bytep row) --{ -- png_debug(1, "in png_do_chop\n"); --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- if (row != NULL && row_info != NULL && row_info->bit_depth == 16) --#else -- if (row_info->bit_depth == 16) --#endif -- { -- png_bytep sp = row; -- png_bytep dp = row; -- png_uint_32 i; -- png_uint_32 istop = row_info->width * row_info->channels; -- -- for (i = 0; i> 8)) >> 8; -- * -- * Approximate calculation with shift/add instead of multiply/divide: -- * *dp = ((((png_uint_32)(*sp) << 8) | -- * (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8; -- * -- * What we actually do to avoid extra shifting and conversion: -- */ -- -- *dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0); --#else -- /* Simply discard the low order byte */ -- *dp = *sp; --#endif -- } -- row_info->bit_depth = 8; -- row_info->pixel_depth = (png_byte)(8 * row_info->channels); -- row_info->rowbytes = row_info->width * row_info->channels; -- } --} --#endif -- --#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) --void /* PRIVATE */ --png_do_read_swap_alpha(png_row_infop row_info, png_bytep row) --{ -- png_debug(1, "in png_do_read_swap_alpha\n"); --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- if (row != NULL && row_info != NULL) --#endif -- { -- png_uint_32 row_width = row_info->width; -- if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- { -- /* This converts from RGBA to ARGB */ -- if (row_info->bit_depth == 8) -- { -- png_bytep sp = row + row_info->rowbytes; -- png_bytep dp = sp; -- png_byte save; -- png_uint_32 i; -- -- for (i = 0; i < row_width; i++) -- { -- save = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = save; -- } -- } -- /* This converts from RRGGBBAA to AARRGGBB */ -- else -- { -- png_bytep sp = row + row_info->rowbytes; -- png_bytep dp = sp; -- png_byte save[2]; -- png_uint_32 i; -- -- for (i = 0; i < row_width; i++) -- { -- save[0] = *(--sp); -- save[1] = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = save[0]; -- *(--dp) = save[1]; -- } -- } -- } -- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) -- { -- /* This converts from GA to AG */ -- if (row_info->bit_depth == 8) -- { -- png_bytep sp = row + row_info->rowbytes; -- png_bytep dp = sp; -- png_byte save; -- png_uint_32 i; -- -- for (i = 0; i < row_width; i++) -- { -- save = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = save; -- } -- } -- /* This converts from GGAA to AAGG */ -- else -- { -- png_bytep sp = row + row_info->rowbytes; -- png_bytep dp = sp; -- png_byte save[2]; -- png_uint_32 i; -- -- for (i = 0; i < row_width; i++) -- { -- save[0] = *(--sp); -- save[1] = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = save[0]; -- *(--dp) = save[1]; -- } -- } -- } -- } --} --#endif -- --#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) --void /* PRIVATE */ --png_do_read_invert_alpha(png_row_infop row_info, png_bytep row) --{ -- png_debug(1, "in png_do_read_invert_alpha\n"); --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- if (row != NULL && row_info != NULL) --#endif -- { -- png_uint_32 row_width = row_info->width; -- if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- { -- /* This inverts the alpha channel in RGBA */ -- if (row_info->bit_depth == 8) -- { -- png_bytep sp = row + row_info->rowbytes; -- png_bytep dp = sp; -- png_uint_32 i; -- -- for (i = 0; i < row_width; i++) -- { -- *(--dp) = (png_byte)(255 - *(--sp)); -- --/* This does nothing: -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- We can replace it with: --*/ -- sp-=3; -- dp=sp; -- } -- } -- /* This inverts the alpha channel in RRGGBBAA */ -- else -- { -- png_bytep sp = row + row_info->rowbytes; -- png_bytep dp = sp; -- png_uint_32 i; -- -- for (i = 0; i < row_width; i++) -- { -- *(--dp) = (png_byte)(255 - *(--sp)); -- *(--dp) = (png_byte)(255 - *(--sp)); -- --/* This does nothing: -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- We can replace it with: --*/ -- sp-=6; -- dp=sp; -- } -- } -- } -- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) -- { -- /* This inverts the alpha channel in GA */ -- if (row_info->bit_depth == 8) -- { -- png_bytep sp = row + row_info->rowbytes; -- png_bytep dp = sp; -- png_uint_32 i; -- -- for (i = 0; i < row_width; i++) -- { -- *(--dp) = (png_byte)(255 - *(--sp)); -- *(--dp) = *(--sp); -- } -- } -- /* This inverts the alpha channel in GGAA */ -- else -- { -- png_bytep sp = row + row_info->rowbytes; -- png_bytep dp = sp; -- png_uint_32 i; -- -- for (i = 0; i < row_width; i++) -- { -- *(--dp) = (png_byte)(255 - *(--sp)); -- *(--dp) = (png_byte)(255 - *(--sp)); --/* -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); --*/ -- sp-=2; -- dp=sp; -- } -- } -- } -- } --} --#endif -- --#if defined(PNG_READ_FILLER_SUPPORTED) --/* Add filler channel if we have RGB color */ --void /* PRIVATE */ --png_do_read_filler(png_row_infop row_info, png_bytep row, -- png_uint_32 filler, png_uint_32 flags) --{ -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- -- png_byte hi_filler = (png_byte)((filler>>8) & 0xff); -- png_byte lo_filler = (png_byte)(filler & 0xff); -- -- png_debug(1, "in png_do_read_filler\n"); -- if ( --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- row != NULL && row_info != NULL && --#endif -- row_info->color_type == PNG_COLOR_TYPE_GRAY) -- { -- if(row_info->bit_depth == 8) -- { -- /* This changes the data from G to GX */ -- if (flags & PNG_FLAG_FILLER_AFTER) -- { -- png_bytep sp = row + (png_size_t)row_width; -- png_bytep dp = sp + (png_size_t)row_width; -- for (i = 1; i < row_width; i++) -- { -- *(--dp) = lo_filler; -- *(--dp) = *(--sp); -- } -- *(--dp) = lo_filler; -- row_info->channels = 2; -- row_info->pixel_depth = 16; -- row_info->rowbytes = row_width * 2; -- } -- /* This changes the data from G to XG */ -- else -- { -- png_bytep sp = row + (png_size_t)row_width; -- png_bytep dp = sp + (png_size_t)row_width; -- for (i = 0; i < row_width; i++) -- { -- *(--dp) = *(--sp); -- *(--dp) = lo_filler; -- } -- row_info->channels = 2; -- row_info->pixel_depth = 16; -- row_info->rowbytes = row_width * 2; -- } -- } -- else if(row_info->bit_depth == 16) -- { -- /* This changes the data from GG to GGXX */ -- if (flags & PNG_FLAG_FILLER_AFTER) -- { -- png_bytep sp = row + (png_size_t)row_width * 2; -- png_bytep dp = sp + (png_size_t)row_width * 2; -- for (i = 1; i < row_width; i++) -- { -- *(--dp) = hi_filler; -- *(--dp) = lo_filler; -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- } -- *(--dp) = hi_filler; -- *(--dp) = lo_filler; -- row_info->channels = 2; -- row_info->pixel_depth = 32; -- row_info->rowbytes = row_width * 4; -- } -- /* This changes the data from GG to XXGG */ -- else -- { -- png_bytep sp = row + (png_size_t)row_width * 2; -- png_bytep dp = sp + (png_size_t)row_width * 2; -- for (i = 0; i < row_width; i++) -- { -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = hi_filler; -- *(--dp) = lo_filler; -- } -- row_info->channels = 2; -- row_info->pixel_depth = 32; -- row_info->rowbytes = row_width * 4; -- } -- } -- } /* COLOR_TYPE == GRAY */ -- else if (row_info->color_type == PNG_COLOR_TYPE_RGB) -- { -- if(row_info->bit_depth == 8) -- { -- /* This changes the data from RGB to RGBX */ -- if (flags & PNG_FLAG_FILLER_AFTER) -- { -- png_bytep sp = row + (png_size_t)row_width * 3; -- png_bytep dp = sp + (png_size_t)row_width; -- for (i = 1; i < row_width; i++) -- { -- *(--dp) = lo_filler; -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- } -- *(--dp) = lo_filler; -- row_info->channels = 4; -- row_info->pixel_depth = 32; -- row_info->rowbytes = row_width * 4; -- } -- /* This changes the data from RGB to XRGB */ -- else -- { -- png_bytep sp = row + (png_size_t)row_width * 3; -- png_bytep dp = sp + (png_size_t)row_width; -- for (i = 0; i < row_width; i++) -- { -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = lo_filler; -- } -- row_info->channels = 4; -- row_info->pixel_depth = 32; -- row_info->rowbytes = row_width * 4; -- } -- } -- else if(row_info->bit_depth == 16) -- { -- /* This changes the data from RRGGBB to RRGGBBXX */ -- if (flags & PNG_FLAG_FILLER_AFTER) -- { -- png_bytep sp = row + (png_size_t)row_width * 6; -- png_bytep dp = sp + (png_size_t)row_width * 2; -- for (i = 1; i < row_width; i++) -- { -- *(--dp) = hi_filler; -- *(--dp) = lo_filler; -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- } -- *(--dp) = hi_filler; -- *(--dp) = lo_filler; -- row_info->channels = 4; -- row_info->pixel_depth = 64; -- row_info->rowbytes = row_width * 8; -- } -- /* This changes the data from RRGGBB to XXRRGGBB */ -- else -- { -- png_bytep sp = row + (png_size_t)row_width * 6; -- png_bytep dp = sp + (png_size_t)row_width * 2; -- for (i = 0; i < row_width; i++) -- { -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = *(--sp); -- *(--dp) = hi_filler; -- *(--dp) = lo_filler; -- } -- row_info->channels = 4; -- row_info->pixel_depth = 64; -- row_info->rowbytes = row_width * 8; -- } -- } -- } /* COLOR_TYPE == RGB */ --} --#endif -- --#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) --/* expand grayscale files to RGB, with or without alpha */ --void /* PRIVATE */ --png_do_gray_to_rgb(png_row_infop row_info, png_bytep row) --{ -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- -- png_debug(1, "in png_do_gray_to_rgb\n"); -- if (row_info->bit_depth >= 8 && --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- row != NULL && row_info != NULL && --#endif -- !(row_info->color_type & PNG_COLOR_MASK_COLOR)) -- { -- if (row_info->color_type == PNG_COLOR_TYPE_GRAY) -- { -- if (row_info->bit_depth == 8) -- { -- png_bytep sp = row + (png_size_t)row_width - 1; -- png_bytep dp = sp + (png_size_t)row_width * 2; -- for (i = 0; i < row_width; i++) -- { -- *(dp--) = *sp; -- *(dp--) = *sp; -- *(dp--) = *(sp--); -- } -- } -- else -- { -- png_bytep sp = row + (png_size_t)row_width * 2 - 1; -- png_bytep dp = sp + (png_size_t)row_width * 4; -- for (i = 0; i < row_width; i++) -- { -- *(dp--) = *sp; -- *(dp--) = *(sp - 1); -- *(dp--) = *sp; -- *(dp--) = *(sp - 1); -- *(dp--) = *(sp--); -- *(dp--) = *(sp--); -- } -- } -- } -- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) -- { -- if (row_info->bit_depth == 8) -- { -- png_bytep sp = row + (png_size_t)row_width * 2 - 1; -- png_bytep dp = sp + (png_size_t)row_width * 2; -- for (i = 0; i < row_width; i++) -- { -- *(dp--) = *(sp--); -- *(dp--) = *sp; -- *(dp--) = *sp; -- *(dp--) = *(sp--); -- } -- } -- else -- { -- png_bytep sp = row + (png_size_t)row_width * 4 - 1; -- png_bytep dp = sp + (png_size_t)row_width * 4; -- for (i = 0; i < row_width; i++) -- { -- *(dp--) = *(sp--); -- *(dp--) = *(sp--); -- *(dp--) = *sp; -- *(dp--) = *(sp - 1); -- *(dp--) = *sp; -- *(dp--) = *(sp - 1); -- *(dp--) = *(sp--); -- *(dp--) = *(sp--); -- } -- } -- } -- row_info->channels += (png_byte)2; -- row_info->color_type |= PNG_COLOR_MASK_COLOR; -- row_info->pixel_depth = (png_byte)(row_info->channels * -- row_info->bit_depth); -- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width); -- } --} --#endif -- --#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) --/* reduce RGB files to grayscale, with or without alpha -- * using the equation given in Poynton's ColorFAQ at -- * -- * Copyright (c) 1998-01-04 Charles Poynton poynton@inforamp.net -- * -- * Y = 0.212671 * R + 0.715160 * G + 0.072169 * B -- * -- * We approximate this with -- * -- * Y = 0.21268 * R + 0.7151 * G + 0.07217 * B -- * -- * which can be expressed with integers as -- * -- * Y = (6969 * R + 23434 * G + 2365 * B)/32768 -- * -- * The calculation is to be done in a linear colorspace. -- * -- * Other integer coefficents can be used via png_set_rgb_to_gray(). -- */ --int /* PRIVATE */ --png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row) -- --{ -- png_uint_32 i; -- -- png_uint_32 row_width = row_info->width; -- int rgb_error = 0; -- -- png_debug(1, "in png_do_rgb_to_gray\n"); -- if ( --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- row != NULL && row_info != NULL && --#endif -- (row_info->color_type & PNG_COLOR_MASK_COLOR)) -- { -- png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff; -- png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff; -- png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff; -- -- if (row_info->color_type == PNG_COLOR_TYPE_RGB) -- { -- if (row_info->bit_depth == 8) -- { --#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) -- if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL) -- { -- png_bytep sp = row; -- png_bytep dp = row; -- -- for (i = 0; i < row_width; i++) -- { -- png_byte red = png_ptr->gamma_to_1[*(sp++)]; -- png_byte green = png_ptr->gamma_to_1[*(sp++)]; -- png_byte blue = png_ptr->gamma_to_1[*(sp++)]; -- if(red != green || red != blue) -- { -- rgb_error |= 1; -- *(dp++) = png_ptr->gamma_from_1[ -- (rc*red+gc*green+bc*blue)>>15]; -- } -- else -- *(dp++) = *(sp-1); -- } -- } -- else --#endif -- { -- png_bytep sp = row; -- png_bytep dp = row; -- for (i = 0; i < row_width; i++) -- { -- png_byte red = *(sp++); -- png_byte green = *(sp++); -- png_byte blue = *(sp++); -- if(red != green || red != blue) -- { -- rgb_error |= 1; -- *(dp++) = (png_byte)((rc*red+gc*green+bc*blue)>>15); -- } -- else -- *(dp++) = *(sp-1); -- } -- } -- } -- -- else /* RGB bit_depth == 16 */ -- { --#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) -- if (png_ptr->gamma_16_to_1 != NULL && -- png_ptr->gamma_16_from_1 != NULL) -- { -- png_bytep sp = row; -- png_bytep dp = row; -- for (i = 0; i < row_width; i++) -- { -- png_uint_16 red, green, blue, w; -- -- red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; -- green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; -- blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; -- -- if(red == green && red == blue) -- w = red; -- else -- { -- png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >> -- png_ptr->gamma_shift][red>>8]; -- png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >> -- png_ptr->gamma_shift][green>>8]; -- png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >> -- png_ptr->gamma_shift][blue>>8]; -- png_uint_16 gray16 = (png_uint_16)((rc*red_1 + gc*green_1 -- + bc*blue_1)>>15); -- w = png_ptr->gamma_16_from_1[(gray16&0xff) >> -- png_ptr->gamma_shift][gray16 >> 8]; -- rgb_error |= 1; -- } -- -- *(dp++) = (png_byte)((w>>8) & 0xff); -- *(dp++) = (png_byte)(w & 0xff); -- } -- } -- else --#endif -- { -- png_bytep sp = row; -- png_bytep dp = row; -- for (i = 0; i < row_width; i++) -- { -- png_uint_16 red, green, blue, gray16; -- -- red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; -- green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; -- blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; -- -- if(red != green || red != blue) -- rgb_error |= 1; -- gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15); -- *(dp++) = (png_byte)((gray16>>8) & 0xff); -- *(dp++) = (png_byte)(gray16 & 0xff); -- } -- } -- } -- } -- if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- { -- if (row_info->bit_depth == 8) -- { --#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) -- if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL) -- { -- png_bytep sp = row; -- png_bytep dp = row; -- for (i = 0; i < row_width; i++) -- { -- png_byte red = png_ptr->gamma_to_1[*(sp++)]; -- png_byte green = png_ptr->gamma_to_1[*(sp++)]; -- png_byte blue = png_ptr->gamma_to_1[*(sp++)]; -- if(red != green || red != blue) -- rgb_error |= 1; -- *(dp++) = png_ptr->gamma_from_1 -- [(rc*red + gc*green + bc*blue)>>15]; -- *(dp++) = *(sp++); /* alpha */ -- } -- } -- else --#endif -- { -- png_bytep sp = row; -- png_bytep dp = row; -- for (i = 0; i < row_width; i++) -- { -- png_byte red = *(sp++); -- png_byte green = *(sp++); -- png_byte blue = *(sp++); -- if(red != green || red != blue) -- rgb_error |= 1; -- *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15); -- *(dp++) = *(sp++); /* alpha */ -- } -- } -- } -- else /* RGBA bit_depth == 16 */ -- { --#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) -- if (png_ptr->gamma_16_to_1 != NULL && -- png_ptr->gamma_16_from_1 != NULL) -- { -- png_bytep sp = row; -- png_bytep dp = row; -- for (i = 0; i < row_width; i++) -- { -- png_uint_16 red, green, blue, w; -- -- red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; -- green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; -- blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; -- -- if(red == green && red == blue) -- w = red; -- else -- { -- png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >> -- png_ptr->gamma_shift][red>>8]; -- png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >> -- png_ptr->gamma_shift][green>>8]; -- png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >> -- png_ptr->gamma_shift][blue>>8]; -- png_uint_16 gray16 = (png_uint_16)((rc * red_1 -- + gc * green_1 + bc * blue_1)>>15); -- w = png_ptr->gamma_16_from_1[(gray16&0xff) >> -- png_ptr->gamma_shift][gray16 >> 8]; -- rgb_error |= 1; -- } -- -- *(dp++) = (png_byte)((w>>8) & 0xff); -- *(dp++) = (png_byte)(w & 0xff); -- *(dp++) = *(sp++); /* alpha */ -- *(dp++) = *(sp++); -- } -- } -- else --#endif -- { -- png_bytep sp = row; -- png_bytep dp = row; -- for (i = 0; i < row_width; i++) -- { -- png_uint_16 red, green, blue, gray16; -- red = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2; -- green = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2; -- blue = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2; -- if(red != green || red != blue) -- rgb_error |= 1; -- gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15); -- *(dp++) = (png_byte)((gray16>>8) & 0xff); -- *(dp++) = (png_byte)(gray16 & 0xff); -- *(dp++) = *(sp++); /* alpha */ -- *(dp++) = *(sp++); -- } -- } -- } -- } -- row_info->channels -= (png_byte)2; -- row_info->color_type &= ~PNG_COLOR_MASK_COLOR; -- row_info->pixel_depth = (png_byte)(row_info->channels * -- row_info->bit_depth); -- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width); -- } -- return rgb_error; --} --#endif -- --/* Build a grayscale palette. Palette is assumed to be 1 << bit_depth -- * large of png_color. This lets grayscale images be treated as -- * paletted. Most useful for gamma correction and simplification -- * of code. -- */ --void PNGAPI --png_build_grayscale_palette(int bit_depth, png_colorp palette) --{ -- int num_palette; -- int color_inc; -- int i; -- int v; -- -- png_debug(1, "in png_do_build_grayscale_palette\n"); -- if (palette == NULL) -- return; -- -- switch (bit_depth) -- { -- case 1: -- num_palette = 2; -- color_inc = 0xff; -- break; -- case 2: -- num_palette = 4; -- color_inc = 0x55; -- break; -- case 4: -- num_palette = 16; -- color_inc = 0x11; -- break; -- case 8: -- num_palette = 256; -- color_inc = 1; -- break; -- default: -- num_palette = 0; -- color_inc = 0; -- break; -- } -- -- for (i = 0, v = 0; i < num_palette; i++, v += color_inc) -- { -- palette[i].red = (png_byte)v; -- palette[i].green = (png_byte)v; -- palette[i].blue = (png_byte)v; -- } --} -- --/* This function is currently unused. Do we really need it? */ --#if defined(PNG_READ_DITHER_SUPPORTED) && defined(PNG_CORRECT_PALETTE_SUPPORTED) --void /* PRIVATE */ --png_correct_palette(png_structp png_ptr, png_colorp palette, -- int num_palette) --{ -- png_debug(1, "in png_correct_palette\n"); --#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ -- defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) -- if (png_ptr->transformations & (PNG_GAMMA | PNG_BACKGROUND)) -- { -- png_color back, back_1; -- -- if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE) -- { -- back.red = png_ptr->gamma_table[png_ptr->background.red]; -- back.green = png_ptr->gamma_table[png_ptr->background.green]; -- back.blue = png_ptr->gamma_table[png_ptr->background.blue]; -- -- back_1.red = png_ptr->gamma_to_1[png_ptr->background.red]; -- back_1.green = png_ptr->gamma_to_1[png_ptr->background.green]; -- back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue]; -- } -- else -- { -- double g; -- -- g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma); -- -- if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_SCREEN || -- fabs(g - 1.0) < PNG_GAMMA_THRESHOLD) -- { -- back.red = png_ptr->background.red; -- back.green = png_ptr->background.green; -- back.blue = png_ptr->background.blue; -- } -- else -- { -- back.red = -- (png_byte)(pow((double)png_ptr->background.red/255, g) * -- 255.0 + 0.5); -- back.green = -- (png_byte)(pow((double)png_ptr->background.green/255, g) * -- 255.0 + 0.5); -- back.blue = -- (png_byte)(pow((double)png_ptr->background.blue/255, g) * -- 255.0 + 0.5); -- } -- -- g = 1.0 / png_ptr->background_gamma; -- -- back_1.red = -- (png_byte)(pow((double)png_ptr->background.red/255, g) * -- 255.0 + 0.5); -- back_1.green = -- (png_byte)(pow((double)png_ptr->background.green/255, g) * -- 255.0 + 0.5); -- back_1.blue = -- (png_byte)(pow((double)png_ptr->background.blue/255, g) * -- 255.0 + 0.5); -- } -- -- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- { -- png_uint_32 i; -- -- for (i = 0; i < (png_uint_32)num_palette; i++) -- { -- if (i < png_ptr->num_trans && png_ptr->trans[i] == 0) -- { -- palette[i] = back; -- } -- else if (i < png_ptr->num_trans && png_ptr->trans[i] != 0xff) -- { -- png_byte v, w; -- -- v = png_ptr->gamma_to_1[png_ptr->palette[i].red]; -- png_composite(w, v, png_ptr->trans[i], back_1.red); -- palette[i].red = png_ptr->gamma_from_1[w]; -- -- v = png_ptr->gamma_to_1[png_ptr->palette[i].green]; -- png_composite(w, v, png_ptr->trans[i], back_1.green); -- palette[i].green = png_ptr->gamma_from_1[w]; -- -- v = png_ptr->gamma_to_1[png_ptr->palette[i].blue]; -- png_composite(w, v, png_ptr->trans[i], back_1.blue); -- palette[i].blue = png_ptr->gamma_from_1[w]; -- } -- else -- { -- palette[i].red = png_ptr->gamma_table[palette[i].red]; -- palette[i].green = png_ptr->gamma_table[palette[i].green]; -- palette[i].blue = png_ptr->gamma_table[palette[i].blue]; -- } -- } -- } -- else -- { -- int i; -- -- for (i = 0; i < num_palette; i++) -- { -- if (palette[i].red == (png_byte)png_ptr->trans_values.gray) -- { -- palette[i] = back; -- } -- else -- { -- palette[i].red = png_ptr->gamma_table[palette[i].red]; -- palette[i].green = png_ptr->gamma_table[palette[i].green]; -- palette[i].blue = png_ptr->gamma_table[palette[i].blue]; -- } -- } -- } -- } -- else --#endif --#if defined(PNG_READ_GAMMA_SUPPORTED) -- if (png_ptr->transformations & PNG_GAMMA) -- { -- int i; -- -- for (i = 0; i < num_palette; i++) -- { -- palette[i].red = png_ptr->gamma_table[palette[i].red]; -- palette[i].green = png_ptr->gamma_table[palette[i].green]; -- palette[i].blue = png_ptr->gamma_table[palette[i].blue]; -- } -- } --#if defined(PNG_READ_BACKGROUND_SUPPORTED) -- else --#endif --#endif --#if defined(PNG_READ_BACKGROUND_SUPPORTED) -- if (png_ptr->transformations & PNG_BACKGROUND) -- { -- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- { -- png_color back; -- -- back.red = (png_byte)png_ptr->background.red; -- back.green = (png_byte)png_ptr->background.green; -- back.blue = (png_byte)png_ptr->background.blue; -- -- for (i = 0; i < (int)png_ptr->num_trans; i++) -- { -- if (png_ptr->trans[i] == 0) -- { -- palette[i].red = back.red; -- palette[i].green = back.green; -- palette[i].blue = back.blue; -- } -- else if (png_ptr->trans[i] != 0xff) -- { -- png_composite(palette[i].red, png_ptr->palette[i].red, -- png_ptr->trans[i], back.red); -- png_composite(palette[i].green, png_ptr->palette[i].green, -- png_ptr->trans[i], back.green); -- png_composite(palette[i].blue, png_ptr->palette[i].blue, -- png_ptr->trans[i], back.blue); -- } -- } -- } -- else /* assume grayscale palette (what else could it be?) */ -- { -- int i; -- -- for (i = 0; i < num_palette; i++) -- { -- if (i == (png_byte)png_ptr->trans_values.gray) -- { -- palette[i].red = (png_byte)png_ptr->background.red; -- palette[i].green = (png_byte)png_ptr->background.green; -- palette[i].blue = (png_byte)png_ptr->background.blue; -- } -- } -- } -- } --#endif --} --#endif -- --#if defined(PNG_READ_BACKGROUND_SUPPORTED) --/* Replace any alpha or transparency with the supplied background color. -- * "background" is already in the screen gamma, while "background_1" is -- * at a gamma of 1.0. Paletted files have already been taken care of. -- */ --void /* PRIVATE */ --png_do_background(png_row_infop row_info, png_bytep row, -- png_color_16p trans_values, png_color_16p background --#if defined(PNG_READ_GAMMA_SUPPORTED) -- , png_color_16p background_1, -- png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, -- png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, -- png_uint_16pp gamma_16_to_1, int gamma_shift --#endif -- ) --{ -- png_bytep sp, dp; -- png_uint_32 i; -- png_uint_32 row_width=row_info->width; -- int shift; -- -- png_debug(1, "in png_do_background\n"); -- if (background != NULL && --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- row != NULL && row_info != NULL && --#endif -- (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) || -- (row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_values))) -- { -- switch (row_info->color_type) -- { -- case PNG_COLOR_TYPE_GRAY: -- { -- switch (row_info->bit_depth) -- { -- case 1: -- { -- sp = row; -- shift = 7; -- for (i = 0; i < row_width; i++) -- { -- if ((png_uint_16)((*sp >> shift) & 0x01) -- == trans_values->gray) -- { -- *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); -- *sp |= (png_byte)(background->gray << shift); -- } -- if (!shift) -- { -- shift = 7; -- sp++; -- } -- else -- shift--; -- } -- break; -- } -- case 2: -- { --#if defined(PNG_READ_GAMMA_SUPPORTED) -- if (gamma_table != NULL) -- { -- sp = row; -- shift = 6; -- for (i = 0; i < row_width; i++) -- { -- if ((png_uint_16)((*sp >> shift) & 0x03) -- == trans_values->gray) -- { -- *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); -- *sp |= (png_byte)(background->gray << shift); -- } -- else -- { -- png_byte p = (png_byte)((*sp >> shift) & 0x03); -- png_byte g = (png_byte)((gamma_table [p | (p << 2) | -- (p << 4) | (p << 6)] >> 6) & 0x03); -- *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); -- *sp |= (png_byte)(g << shift); -- } -- if (!shift) -- { -- shift = 6; -- sp++; -- } -- else -- shift -= 2; -- } -- } -- else --#endif -- { -- sp = row; -- shift = 6; -- for (i = 0; i < row_width; i++) -- { -- if ((png_uint_16)((*sp >> shift) & 0x03) -- == trans_values->gray) -- { -- *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); -- *sp |= (png_byte)(background->gray << shift); -- } -- if (!shift) -- { -- shift = 6; -- sp++; -- } -- else -- shift -= 2; -- } -- } -- break; -- } -- case 4: -- { --#if defined(PNG_READ_GAMMA_SUPPORTED) -- if (gamma_table != NULL) -- { -- sp = row; -- shift = 4; -- for (i = 0; i < row_width; i++) -- { -- if ((png_uint_16)((*sp >> shift) & 0x0f) -- == trans_values->gray) -- { -- *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); -- *sp |= (png_byte)(background->gray << shift); -- } -- else -- { -- png_byte p = (png_byte)((*sp >> shift) & 0x0f); -- png_byte g = (png_byte)((gamma_table[p | -- (p << 4)] >> 4) & 0x0f); -- *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); -- *sp |= (png_byte)(g << shift); -- } -- if (!shift) -- { -- shift = 4; -- sp++; -- } -- else -- shift -= 4; -- } -- } -- else --#endif -- { -- sp = row; -- shift = 4; -- for (i = 0; i < row_width; i++) -- { -- if ((png_uint_16)((*sp >> shift) & 0x0f) -- == trans_values->gray) -- { -- *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); -- *sp |= (png_byte)(background->gray << shift); -- } -- if (!shift) -- { -- shift = 4; -- sp++; -- } -- else -- shift -= 4; -- } -- } -- break; -- } -- case 8: -- { --#if defined(PNG_READ_GAMMA_SUPPORTED) -- if (gamma_table != NULL) -- { -- sp = row; -- for (i = 0; i < row_width; i++, sp++) -- { -- if (*sp == trans_values->gray) -- { -- *sp = (png_byte)background->gray; -- } -- else -- { -- *sp = gamma_table[*sp]; -- } -- } -- } -- else --#endif -- { -- sp = row; -- for (i = 0; i < row_width; i++, sp++) -- { -- if (*sp == trans_values->gray) -- { -- *sp = (png_byte)background->gray; -- } -- } -- } -- break; -- } -- case 16: -- { --#if defined(PNG_READ_GAMMA_SUPPORTED) -- if (gamma_16 != NULL) -- { -- sp = row; -- for (i = 0; i < row_width; i++, sp += 2) -- { -- png_uint_16 v; -- -- v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); -- if (v == trans_values->gray) -- { -- /* background is already in screen gamma */ -- *sp = (png_byte)((background->gray >> 8) & 0xff); -- *(sp + 1) = (png_byte)(background->gray & 0xff); -- } -- else -- { -- v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; -- *sp = (png_byte)((v >> 8) & 0xff); -- *(sp + 1) = (png_byte)(v & 0xff); -- } -- } -- } -- else --#endif -- { -- sp = row; -- for (i = 0; i < row_width; i++, sp += 2) -- { -- png_uint_16 v; -- -- v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); -- if (v == trans_values->gray) -- { -- *sp = (png_byte)((background->gray >> 8) & 0xff); -- *(sp + 1) = (png_byte)(background->gray & 0xff); -- } -- } -- } -- break; -- } -- } -- break; -- } -- case PNG_COLOR_TYPE_RGB: -- { -- if (row_info->bit_depth == 8) -- { --#if defined(PNG_READ_GAMMA_SUPPORTED) -- if (gamma_table != NULL) -- { -- sp = row; -- for (i = 0; i < row_width; i++, sp += 3) -- { -- if (*sp == trans_values->red && -- *(sp + 1) == trans_values->green && -- *(sp + 2) == trans_values->blue) -- { -- *sp = (png_byte)background->red; -- *(sp + 1) = (png_byte)background->green; -- *(sp + 2) = (png_byte)background->blue; -- } -- else -- { -- *sp = gamma_table[*sp]; -- *(sp + 1) = gamma_table[*(sp + 1)]; -- *(sp + 2) = gamma_table[*(sp + 2)]; -- } -- } -- } -- else --#endif -- { -- sp = row; -- for (i = 0; i < row_width; i++, sp += 3) -- { -- if (*sp == trans_values->red && -- *(sp + 1) == trans_values->green && -- *(sp + 2) == trans_values->blue) -- { -- *sp = (png_byte)background->red; -- *(sp + 1) = (png_byte)background->green; -- *(sp + 2) = (png_byte)background->blue; -- } -- } -- } -- } -- else /* if (row_info->bit_depth == 16) */ -- { --#if defined(PNG_READ_GAMMA_SUPPORTED) -- if (gamma_16 != NULL) -- { -- sp = row; -- for (i = 0; i < row_width; i++, sp += 6) -- { -- png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); -- png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); -- png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5)); -- if (r == trans_values->red && g == trans_values->green && -- b == trans_values->blue) -- { -- /* background is already in screen gamma */ -- *sp = (png_byte)((background->red >> 8) & 0xff); -- *(sp + 1) = (png_byte)(background->red & 0xff); -- *(sp + 2) = (png_byte)((background->green >> 8) & 0xff); -- *(sp + 3) = (png_byte)(background->green & 0xff); -- *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff); -- *(sp + 5) = (png_byte)(background->blue & 0xff); -- } -- else -- { -- png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; -- *sp = (png_byte)((v >> 8) & 0xff); -- *(sp + 1) = (png_byte)(v & 0xff); -- v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; -- *(sp + 2) = (png_byte)((v >> 8) & 0xff); -- *(sp + 3) = (png_byte)(v & 0xff); -- v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; -- *(sp + 4) = (png_byte)((v >> 8) & 0xff); -- *(sp + 5) = (png_byte)(v & 0xff); -- } -- } -- } -- else --#endif -- { -- sp = row; -- for (i = 0; i < row_width; i++, sp += 6) -- { -- png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp+1)); -- png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); -- png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5)); -- -- if (r == trans_values->red && g == trans_values->green && -- b == trans_values->blue) -- { -- *sp = (png_byte)((background->red >> 8) & 0xff); -- *(sp + 1) = (png_byte)(background->red & 0xff); -- *(sp + 2) = (png_byte)((background->green >> 8) & 0xff); -- *(sp + 3) = (png_byte)(background->green & 0xff); -- *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff); -- *(sp + 5) = (png_byte)(background->blue & 0xff); -- } -- } -- } -- } -- break; -- } -- case PNG_COLOR_TYPE_GRAY_ALPHA: -- { -- if (row_info->bit_depth == 8) -- { --#if defined(PNG_READ_GAMMA_SUPPORTED) -- if (gamma_to_1 != NULL && gamma_from_1 != NULL && -- gamma_table != NULL) -- { -- sp = row; -- dp = row; -- for (i = 0; i < row_width; i++, sp += 2, dp++) -- { -- png_uint_16 a = *(sp + 1); -- -- if (a == 0xff) -- { -- *dp = gamma_table[*sp]; -- } -- else if (a == 0) -- { -- /* background is already in screen gamma */ -- *dp = (png_byte)background->gray; -- } -- else -- { -- png_byte v, w; -- -- v = gamma_to_1[*sp]; -- png_composite(w, v, a, background_1->gray); -- *dp = gamma_from_1[w]; -- } -- } -- } -- else --#endif -- { -- sp = row; -- dp = row; -- for (i = 0; i < row_width; i++, sp += 2, dp++) -- { -- png_byte a = *(sp + 1); -- -- if (a == 0xff) -- { -- *dp = *sp; -- } --#if defined(PNG_READ_GAMMA_SUPPORTED) -- else if (a == 0) -- { -- *dp = (png_byte)background->gray; -- } -- else -- { -- png_composite(*dp, *sp, a, background_1->gray); -- } --#else -- *dp = (png_byte)background->gray; --#endif -- } -- } -- } -- else /* if (png_ptr->bit_depth == 16) */ -- { --#if defined(PNG_READ_GAMMA_SUPPORTED) -- if (gamma_16 != NULL && gamma_16_from_1 != NULL && -- gamma_16_to_1 != NULL) -- { -- sp = row; -- dp = row; -- for (i = 0; i < row_width; i++, sp += 4, dp += 2) -- { -- png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); -- -- if (a == (png_uint_16)0xffff) -- { -- png_uint_16 v; -- -- v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; -- *dp = (png_byte)((v >> 8) & 0xff); -- *(dp + 1) = (png_byte)(v & 0xff); -- } --#if defined(PNG_READ_GAMMA_SUPPORTED) -- else if (a == 0) --#else -- else --#endif -- { -- /* background is already in screen gamma */ -- *dp = (png_byte)((background->gray >> 8) & 0xff); -- *(dp + 1) = (png_byte)(background->gray & 0xff); -- } --#if defined(PNG_READ_GAMMA_SUPPORTED) -- else -- { -- png_uint_16 g, v, w; -- -- g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; -- png_composite_16(v, g, a, background_1->gray); -- w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8]; -- *dp = (png_byte)((w >> 8) & 0xff); -- *(dp + 1) = (png_byte)(w & 0xff); -- } --#endif -- } -- } -- else --#endif -- { -- sp = row; -- dp = row; -- for (i = 0; i < row_width; i++, sp += 4, dp += 2) -- { -- png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); -- if (a == (png_uint_16)0xffff) -- { -- png_memcpy(dp, sp, 2); -- } --#if defined(PNG_READ_GAMMA_SUPPORTED) -- else if (a == 0) --#else -- else --#endif -- { -- *dp = (png_byte)((background->gray >> 8) & 0xff); -- *(dp + 1) = (png_byte)(background->gray & 0xff); -- } --#if defined(PNG_READ_GAMMA_SUPPORTED) -- else -- { -- png_uint_16 g, v; -- -- g = (png_uint_16)(((*sp) << 8) + *(sp + 1)); -- png_composite_16(v, g, a, background_1->gray); -- *dp = (png_byte)((v >> 8) & 0xff); -- *(dp + 1) = (png_byte)(v & 0xff); -- } --#endif -- } -- } -- } -- break; -- } -- case PNG_COLOR_TYPE_RGB_ALPHA: -- { -- if (row_info->bit_depth == 8) -- { --#if defined(PNG_READ_GAMMA_SUPPORTED) -- if (gamma_to_1 != NULL && gamma_from_1 != NULL && -- gamma_table != NULL) -- { -- sp = row; -- dp = row; -- for (i = 0; i < row_width; i++, sp += 4, dp += 3) -- { -- png_byte a = *(sp + 3); -- -- if (a == 0xff) -- { -- *dp = gamma_table[*sp]; -- *(dp + 1) = gamma_table[*(sp + 1)]; -- *(dp + 2) = gamma_table[*(sp + 2)]; -- } -- else if (a == 0) -- { -- /* background is already in screen gamma */ -- *dp = (png_byte)background->red; -- *(dp + 1) = (png_byte)background->green; -- *(dp + 2) = (png_byte)background->blue; -- } -- else -- { -- png_byte v, w; -- -- v = gamma_to_1[*sp]; -- png_composite(w, v, a, background_1->red); -- *dp = gamma_from_1[w]; -- v = gamma_to_1[*(sp + 1)]; -- png_composite(w, v, a, background_1->green); -- *(dp + 1) = gamma_from_1[w]; -- v = gamma_to_1[*(sp + 2)]; -- png_composite(w, v, a, background_1->blue); -- *(dp + 2) = gamma_from_1[w]; -- } -- } -- } -- else --#endif -- { -- sp = row; -- dp = row; -- for (i = 0; i < row_width; i++, sp += 4, dp += 3) -- { -- png_byte a = *(sp + 3); -- -- if (a == 0xff) -- { -- *dp = *sp; -- *(dp + 1) = *(sp + 1); -- *(dp + 2) = *(sp + 2); -- } -- else if (a == 0) -- { -- *dp = (png_byte)background->red; -- *(dp + 1) = (png_byte)background->green; -- *(dp + 2) = (png_byte)background->blue; -- } -- else -- { -- png_composite(*dp, *sp, a, background->red); -- png_composite(*(dp + 1), *(sp + 1), a, -- background->green); -- png_composite(*(dp + 2), *(sp + 2), a, -- background->blue); -- } -- } -- } -- } -- else /* if (row_info->bit_depth == 16) */ -- { --#if defined(PNG_READ_GAMMA_SUPPORTED) -- if (gamma_16 != NULL && gamma_16_from_1 != NULL && -- gamma_16_to_1 != NULL) -- { -- sp = row; -- dp = row; -- for (i = 0; i < row_width; i++, sp += 8, dp += 6) -- { -- png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) -- << 8) + (png_uint_16)(*(sp + 7))); -- if (a == (png_uint_16)0xffff) -- { -- png_uint_16 v; -- -- v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; -- *dp = (png_byte)((v >> 8) & 0xff); -- *(dp + 1) = (png_byte)(v & 0xff); -- v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; -- *(dp + 2) = (png_byte)((v >> 8) & 0xff); -- *(dp + 3) = (png_byte)(v & 0xff); -- v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; -- *(dp + 4) = (png_byte)((v >> 8) & 0xff); -- *(dp + 5) = (png_byte)(v & 0xff); -- } -- else if (a == 0) -- { -- /* background is already in screen gamma */ -- *dp = (png_byte)((background->red >> 8) & 0xff); -- *(dp + 1) = (png_byte)(background->red & 0xff); -- *(dp + 2) = (png_byte)((background->green >> 8) & 0xff); -- *(dp + 3) = (png_byte)(background->green & 0xff); -- *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff); -- *(dp + 5) = (png_byte)(background->blue & 0xff); -- } -- else -- { -- png_uint_16 v, w, x; -- -- v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; -- png_composite_16(w, v, a, background_1->red); -- x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8]; -- *dp = (png_byte)((x >> 8) & 0xff); -- *(dp + 1) = (png_byte)(x & 0xff); -- v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)]; -- png_composite_16(w, v, a, background_1->green); -- x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8]; -- *(dp + 2) = (png_byte)((x >> 8) & 0xff); -- *(dp + 3) = (png_byte)(x & 0xff); -- v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)]; -- png_composite_16(w, v, a, background_1->blue); -- x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8]; -- *(dp + 4) = (png_byte)((x >> 8) & 0xff); -- *(dp + 5) = (png_byte)(x & 0xff); -- } -- } -- } -- else --#endif -- { -- sp = row; -- dp = row; -- for (i = 0; i < row_width; i++, sp += 8, dp += 6) -- { -- png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) -- << 8) + (png_uint_16)(*(sp + 7))); -- if (a == (png_uint_16)0xffff) -- { -- png_memcpy(dp, sp, 6); -- } -- else if (a == 0) -- { -- *dp = (png_byte)((background->red >> 8) & 0xff); -- *(dp + 1) = (png_byte)(background->red & 0xff); -- *(dp + 2) = (png_byte)((background->green >> 8) & 0xff); -- *(dp + 3) = (png_byte)(background->green & 0xff); -- *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff); -- *(dp + 5) = (png_byte)(background->blue & 0xff); -- } -- else -- { -- png_uint_16 v; -- -- png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); -- png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) -- + *(sp + 3)); -- png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) -- + *(sp + 5)); -- -- png_composite_16(v, r, a, background->red); -- *dp = (png_byte)((v >> 8) & 0xff); -- *(dp + 1) = (png_byte)(v & 0xff); -- png_composite_16(v, g, a, background->green); -- *(dp + 2) = (png_byte)((v >> 8) & 0xff); -- *(dp + 3) = (png_byte)(v & 0xff); -- png_composite_16(v, b, a, background->blue); -- *(dp + 4) = (png_byte)((v >> 8) & 0xff); -- *(dp + 5) = (png_byte)(v & 0xff); -- } -- } -- } -- } -- break; -- } -- } -- -- if (row_info->color_type & PNG_COLOR_MASK_ALPHA) -- { -- row_info->color_type &= ~PNG_COLOR_MASK_ALPHA; -- row_info->channels--; -- row_info->pixel_depth = (png_byte)(row_info->channels * -- row_info->bit_depth); -- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width); -- } -- } --} --#endif -- --#if defined(PNG_READ_GAMMA_SUPPORTED) --/* Gamma correct the image, avoiding the alpha channel. Make sure -- * you do this after you deal with the transparency issue on grayscale -- * or RGB images. If your bit depth is 8, use gamma_table, if it -- * is 16, use gamma_16_table and gamma_shift. Build these with -- * build_gamma_table(). -- */ --void /* PRIVATE */ --png_do_gamma(png_row_infop row_info, png_bytep row, -- png_bytep gamma_table, png_uint_16pp gamma_16_table, -- int gamma_shift) --{ -- png_bytep sp; -- png_uint_32 i; -- png_uint_32 row_width=row_info->width; -- -- png_debug(1, "in png_do_gamma\n"); -- if ( --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- row != NULL && row_info != NULL && --#endif -- ((row_info->bit_depth <= 8 && gamma_table != NULL) || -- (row_info->bit_depth == 16 && gamma_16_table != NULL))) -- { -- switch (row_info->color_type) -- { -- case PNG_COLOR_TYPE_RGB: -- { -- if (row_info->bit_depth == 8) -- { -- sp = row; -- for (i = 0; i < row_width; i++) -- { -- *sp = gamma_table[*sp]; -- sp++; -- *sp = gamma_table[*sp]; -- sp++; -- *sp = gamma_table[*sp]; -- sp++; -- } -- } -- else /* if (row_info->bit_depth == 16) */ -- { -- sp = row; -- for (i = 0; i < row_width; i++) -- { -- png_uint_16 v; -- -- v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; -- *sp = (png_byte)((v >> 8) & 0xff); -- *(sp + 1) = (png_byte)(v & 0xff); -- sp += 2; -- v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; -- *sp = (png_byte)((v >> 8) & 0xff); -- *(sp + 1) = (png_byte)(v & 0xff); -- sp += 2; -- v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; -- *sp = (png_byte)((v >> 8) & 0xff); -- *(sp + 1) = (png_byte)(v & 0xff); -- sp += 2; -- } -- } -- break; -- } -- case PNG_COLOR_TYPE_RGB_ALPHA: -- { -- if (row_info->bit_depth == 8) -- { -- sp = row; -- for (i = 0; i < row_width; i++) -- { -- *sp = gamma_table[*sp]; -- sp++; -- *sp = gamma_table[*sp]; -- sp++; -- *sp = gamma_table[*sp]; -- sp++; -- sp++; -- } -- } -- else /* if (row_info->bit_depth == 16) */ -- { -- sp = row; -- for (i = 0; i < row_width; i++) -- { -- png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; -- *sp = (png_byte)((v >> 8) & 0xff); -- *(sp + 1) = (png_byte)(v & 0xff); -- sp += 2; -- v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; -- *sp = (png_byte)((v >> 8) & 0xff); -- *(sp + 1) = (png_byte)(v & 0xff); -- sp += 2; -- v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; -- *sp = (png_byte)((v >> 8) & 0xff); -- *(sp + 1) = (png_byte)(v & 0xff); -- sp += 4; -- } -- } -- break; -- } -- case PNG_COLOR_TYPE_GRAY_ALPHA: -- { -- if (row_info->bit_depth == 8) -- { -- sp = row; -- for (i = 0; i < row_width; i++) -- { -- *sp = gamma_table[*sp]; -- sp += 2; -- } -- } -- else /* if (row_info->bit_depth == 16) */ -- { -- sp = row; -- for (i = 0; i < row_width; i++) -- { -- png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; -- *sp = (png_byte)((v >> 8) & 0xff); -- *(sp + 1) = (png_byte)(v & 0xff); -- sp += 4; -- } -- } -- break; -- } -- case PNG_COLOR_TYPE_GRAY: -- { -- if (row_info->bit_depth == 2) -- { -- sp = row; -- for (i = 0; i < row_width; i += 4) -- { -- int a = *sp & 0xc0; -- int b = *sp & 0x30; -- int c = *sp & 0x0c; -- int d = *sp & 0x03; -- -- *sp = (png_byte)( -- ((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)]) ) & 0xc0)| -- ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)| -- ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)| -- ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) )); -- sp++; -- } -- } -- if (row_info->bit_depth == 4) -- { -- sp = row; -- for (i = 0; i < row_width; i += 2) -- { -- int msb = *sp & 0xf0; -- int lsb = *sp & 0x0f; -- -- *sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0) -- | (((int)gamma_table[(lsb << 4) | lsb]) >> 4)); -- sp++; -- } -- } -- else if (row_info->bit_depth == 8) -- { -- sp = row; -- for (i = 0; i < row_width; i++) -- { -- *sp = gamma_table[*sp]; -- sp++; -- } -- } -- else if (row_info->bit_depth == 16) -- { -- sp = row; -- for (i = 0; i < row_width; i++) -- { -- png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; -- *sp = (png_byte)((v >> 8) & 0xff); -- *(sp + 1) = (png_byte)(v & 0xff); -- sp += 2; -- } -- } -- break; -- } -- } -- } --} --#endif -- --#if defined(PNG_READ_EXPAND_SUPPORTED) --/* Expands a palette row to an RGB or RGBA row depending -- * upon whether you supply trans and num_trans. -- */ --void /* PRIVATE */ --png_do_expand_palette(png_row_infop row_info, png_bytep row, -- png_colorp palette, png_bytep trans, int num_trans) --{ -- int shift, value; -- png_bytep sp, dp; -- png_uint_32 i; -- png_uint_32 row_width=row_info->width; -- -- png_debug(1, "in png_do_expand_palette\n"); -- if ( --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- row != NULL && row_info != NULL && --#endif -- row_info->color_type == PNG_COLOR_TYPE_PALETTE) -- { -- if (row_info->bit_depth < 8) -- { -- switch (row_info->bit_depth) -- { -- case 1: -- { -- sp = row + (png_size_t)((row_width - 1) >> 3); -- dp = row + (png_size_t)row_width - 1; -- shift = 7 - (int)((row_width + 7) & 0x07); -- for (i = 0; i < row_width; i++) -- { -- if ((*sp >> shift) & 0x01) -- *dp = 1; -- else -- *dp = 0; -- if (shift == 7) -- { -- shift = 0; -- sp--; -- } -- else -- shift++; -- -- dp--; -- } -- break; -- } -- case 2: -- { -- sp = row + (png_size_t)((row_width - 1) >> 2); -- dp = row + (png_size_t)row_width - 1; -- shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); -- for (i = 0; i < row_width; i++) -- { -- value = (*sp >> shift) & 0x03; -- *dp = (png_byte)value; -- if (shift == 6) -- { -- shift = 0; -- sp--; -- } -- else -- shift += 2; -- -- dp--; -- } -- break; -- } -- case 4: -- { -- sp = row + (png_size_t)((row_width - 1) >> 1); -- dp = row + (png_size_t)row_width - 1; -- shift = (int)((row_width & 0x01) << 2); -- for (i = 0; i < row_width; i++) -- { -- value = (*sp >> shift) & 0x0f; -- *dp = (png_byte)value; -- if (shift == 4) -- { -- shift = 0; -- sp--; -- } -- else -- shift += 4; -- -- dp--; -- } -- break; -- } -- } -- row_info->bit_depth = 8; -- row_info->pixel_depth = 8; -- row_info->rowbytes = row_width; -- } -- switch (row_info->bit_depth) -- { -- case 8: -- { -- if (trans != NULL) -- { -- sp = row + (png_size_t)row_width - 1; -- dp = row + (png_size_t)(row_width << 2) - 1; -- -- for (i = 0; i < row_width; i++) -- { -- if ((int)(*sp) >= num_trans) -- *dp-- = 0xff; -- else -- *dp-- = trans[*sp]; -- *dp-- = palette[*sp].blue; -- *dp-- = palette[*sp].green; -- *dp-- = palette[*sp].red; -- sp--; -- } -- row_info->bit_depth = 8; -- row_info->pixel_depth = 32; -- row_info->rowbytes = row_width * 4; -- row_info->color_type = 6; -- row_info->channels = 4; -- } -- else -- { -- sp = row + (png_size_t)row_width - 1; -- dp = row + (png_size_t)(row_width * 3) - 1; -- -- for (i = 0; i < row_width; i++) -- { -- *dp-- = palette[*sp].blue; -- *dp-- = palette[*sp].green; -- *dp-- = palette[*sp].red; -- sp--; -- } -- row_info->bit_depth = 8; -- row_info->pixel_depth = 24; -- row_info->rowbytes = row_width * 3; -- row_info->color_type = 2; -- row_info->channels = 3; -- } -- break; -- } -- } -- } --} -- --/* If the bit depth < 8, it is expanded to 8. Also, if the -- * transparency value is supplied, an alpha channel is built. -- */ --void /* PRIVATE */ --png_do_expand(png_row_infop row_info, png_bytep row, -- png_color_16p trans_value) --{ -- int shift, value; -- png_bytep sp, dp; -- png_uint_32 i; -- png_uint_32 row_width=row_info->width; -- -- png_debug(1, "in png_do_expand\n"); --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- if (row != NULL && row_info != NULL) --#endif -- { -- if (row_info->color_type == PNG_COLOR_TYPE_GRAY) -- { -- png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0); -- -- if (row_info->bit_depth < 8) -- { -- switch (row_info->bit_depth) -- { -- case 1: -- { -- gray = (png_uint_16)(gray*0xff); -- sp = row + (png_size_t)((row_width - 1) >> 3); -- dp = row + (png_size_t)row_width - 1; -- shift = 7 - (int)((row_width + 7) & 0x07); -- for (i = 0; i < row_width; i++) -- { -- if ((*sp >> shift) & 0x01) -- *dp = 0xff; -- else -- *dp = 0; -- if (shift == 7) -- { -- shift = 0; -- sp--; -- } -- else -- shift++; -- -- dp--; -- } -- break; -- } -- case 2: -- { -- gray = (png_uint_16)(gray*0x55); -- sp = row + (png_size_t)((row_width - 1) >> 2); -- dp = row + (png_size_t)row_width - 1; -- shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); -- for (i = 0; i < row_width; i++) -- { -- value = (*sp >> shift) & 0x03; -- *dp = (png_byte)(value | (value << 2) | (value << 4) | -- (value << 6)); -- if (shift == 6) -- { -- shift = 0; -- sp--; -- } -- else -- shift += 2; -- -- dp--; -- } -- break; -- } -- case 4: -- { -- gray = (png_uint_16)(gray*0x11); -- sp = row + (png_size_t)((row_width - 1) >> 1); -- dp = row + (png_size_t)row_width - 1; -- shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); -- for (i = 0; i < row_width; i++) -- { -- value = (*sp >> shift) & 0x0f; -- *dp = (png_byte)(value | (value << 4)); -- if (shift == 4) -- { -- shift = 0; -- sp--; -- } -- else -- shift = 4; -- -- dp--; -- } -- break; -- } -- } -- row_info->bit_depth = 8; -- row_info->pixel_depth = 8; -- row_info->rowbytes = row_width; -- } -- -- if (trans_value != NULL) -- { -- if (row_info->bit_depth == 8) -- { -- sp = row + (png_size_t)row_width - 1; -- dp = row + (png_size_t)(row_width << 1) - 1; -- for (i = 0; i < row_width; i++) -- { -- if (*sp == gray) -- *dp-- = 0; -- else -- *dp-- = 0xff; -- *dp-- = *sp--; -- } -- } -- else if (row_info->bit_depth == 16) -- { -- sp = row + row_info->rowbytes - 1; -- dp = row + (row_info->rowbytes << 1) - 1; -- for (i = 0; i < row_width; i++) -- { -- if (((png_uint_16)*(sp) | -- ((png_uint_16)*(sp - 1) << 8)) == gray) -- { -- *dp-- = 0; -- *dp-- = 0; -- } -- else -- { -- *dp-- = 0xff; -- *dp-- = 0xff; -- } -- *dp-- = *sp--; -- *dp-- = *sp--; -- } -- } -- row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA; -- row_info->channels = 2; -- row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1); -- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, -- row_width); -- } -- } -- else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value) -- { -- if (row_info->bit_depth == 8) -- { -- sp = row + (png_size_t)row_info->rowbytes - 1; -- dp = row + (png_size_t)(row_width << 2) - 1; -- for (i = 0; i < row_width; i++) -- { -- if (*(sp - 2) == trans_value->red && -- *(sp - 1) == trans_value->green && -- *(sp - 0) == trans_value->blue) -- *dp-- = 0; -- else -- *dp-- = 0xff; -- *dp-- = *sp--; -- *dp-- = *sp--; -- *dp-- = *sp--; -- } -- } -- else if (row_info->bit_depth == 16) -- { -- sp = row + row_info->rowbytes - 1; -- dp = row + (png_size_t)(row_width << 3) - 1; -- for (i = 0; i < row_width; i++) -- { -- if ((((png_uint_16)*(sp - 4) | -- ((png_uint_16)*(sp - 5) << 8)) == trans_value->red) && -- (((png_uint_16)*(sp - 2) | -- ((png_uint_16)*(sp - 3) << 8)) == trans_value->green) && -- (((png_uint_16)*(sp - 0) | -- ((png_uint_16)*(sp - 1) << 8)) == trans_value->blue)) -- { -- *dp-- = 0; -- *dp-- = 0; -- } -- else -- { -- *dp-- = 0xff; -- *dp-- = 0xff; -- } -- *dp-- = *sp--; -- *dp-- = *sp--; -- *dp-- = *sp--; -- *dp-- = *sp--; -- *dp-- = *sp--; -- *dp-- = *sp--; -- } -- } -- row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA; -- row_info->channels = 4; -- row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2); -- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width); -- } -- } --} --#endif -- --#if defined(PNG_READ_DITHER_SUPPORTED) --void /* PRIVATE */ --png_do_dither(png_row_infop row_info, png_bytep row, -- png_bytep palette_lookup, png_bytep dither_lookup) --{ -- png_bytep sp, dp; -- png_uint_32 i; -- png_uint_32 row_width=row_info->width; -- -- png_debug(1, "in png_do_dither\n"); --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- if (row != NULL && row_info != NULL) --#endif -- { -- if (row_info->color_type == PNG_COLOR_TYPE_RGB && -- palette_lookup && row_info->bit_depth == 8) -- { -- int r, g, b, p; -- sp = row; -- dp = row; -- for (i = 0; i < row_width; i++) -- { -- r = *sp++; -- g = *sp++; -- b = *sp++; -- -- /* this looks real messy, but the compiler will reduce -- it down to a reasonable formula. For example, with -- 5 bits per color, we get: -- p = (((r >> 3) & 0x1f) << 10) | -- (((g >> 3) & 0x1f) << 5) | -- ((b >> 3) & 0x1f); -- */ -- p = (((r >> (8 - PNG_DITHER_RED_BITS)) & -- ((1 << PNG_DITHER_RED_BITS) - 1)) << -- (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) | -- (((g >> (8 - PNG_DITHER_GREEN_BITS)) & -- ((1 << PNG_DITHER_GREEN_BITS) - 1)) << -- (PNG_DITHER_BLUE_BITS)) | -- ((b >> (8 - PNG_DITHER_BLUE_BITS)) & -- ((1 << PNG_DITHER_BLUE_BITS) - 1)); -- -- *dp++ = palette_lookup[p]; -- } -- row_info->color_type = PNG_COLOR_TYPE_PALETTE; -- row_info->channels = 1; -- row_info->pixel_depth = row_info->bit_depth; -- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width); -- } -- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA && -- palette_lookup != NULL && row_info->bit_depth == 8) -- { -- int r, g, b, p; -- sp = row; -- dp = row; -- for (i = 0; i < row_width; i++) -- { -- r = *sp++; -- g = *sp++; -- b = *sp++; -- sp++; -- -- p = (((r >> (8 - PNG_DITHER_RED_BITS)) & -- ((1 << PNG_DITHER_RED_BITS) - 1)) << -- (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) | -- (((g >> (8 - PNG_DITHER_GREEN_BITS)) & -- ((1 << PNG_DITHER_GREEN_BITS) - 1)) << -- (PNG_DITHER_BLUE_BITS)) | -- ((b >> (8 - PNG_DITHER_BLUE_BITS)) & -- ((1 << PNG_DITHER_BLUE_BITS) - 1)); -- -- *dp++ = palette_lookup[p]; -- } -- row_info->color_type = PNG_COLOR_TYPE_PALETTE; -- row_info->channels = 1; -- row_info->pixel_depth = row_info->bit_depth; -- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,row_width); -- } -- else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE && -- dither_lookup && row_info->bit_depth == 8) -- { -- sp = row; -- for (i = 0; i < row_width; i++, sp++) -- { -- *sp = dither_lookup[*sp]; -- } -- } -- } --} --#endif -- --#ifdef PNG_FLOATING_POINT_SUPPORTED --#if defined(PNG_READ_GAMMA_SUPPORTED) --static int png_gamma_shift[] = -- {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0}; -- --/* We build the 8- or 16-bit gamma tables here. Note that for 16-bit -- * tables, we don't make a full table if we are reducing to 8-bit in -- * the future. Note also how the gamma_16 tables are segmented so that -- * we don't need to allocate > 64K chunks for a full 16-bit table. -- */ --void /* PRIVATE */ --png_build_gamma_table(png_structp png_ptr) --{ -- png_debug(1, "in png_build_gamma_table\n"); -- if(png_ptr->gamma != 0.0) -- { -- if (png_ptr->bit_depth <= 8) -- { -- int i; -- double g; -- -- if (png_ptr->screen_gamma > .000001) -- g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); -- else -- g = 1.0; -- -- png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr, -- (png_uint_32)256); -- -- for (i = 0; i < 256; i++) -- { -- png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0, -- g) * 255.0 + .5); -- } -- --#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ -- defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) -- if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY)) -- { -- -- g = 1.0 / (png_ptr->gamma); -- -- png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr, -- (png_uint_32)256); -- -- for (i = 0; i < 256; i++) -- { -- png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0, -- g) * 255.0 + .5); -- } -- -- -- png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr, -- (png_uint_32)256); -- -- if(png_ptr->screen_gamma > 0.000001) -- g = 1.0 / png_ptr->screen_gamma; -- else -- g = png_ptr->gamma; /* probably doing rgb_to_gray */ -- -- for (i = 0; i < 256; i++) -- { -- png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0, -- g) * 255.0 + .5); -- -- } -- } --#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */ -- } -- else -- { -- double g; -- int i, j, shift, num; -- int sig_bit; -- png_uint_32 ig; -- -- if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) -- { -- sig_bit = (int)png_ptr->sig_bit.red; -- if ((int)png_ptr->sig_bit.green > sig_bit) -- sig_bit = png_ptr->sig_bit.green; -- if ((int)png_ptr->sig_bit.blue > sig_bit) -- sig_bit = png_ptr->sig_bit.blue; -- } -- else -- { -- sig_bit = (int)png_ptr->sig_bit.gray; -- } -- -- if (sig_bit > 0) -- shift = 16 - sig_bit; -- else -- shift = 0; -- -- if (png_ptr->transformations & PNG_16_TO_8) -- { -- if (shift < (16 - PNG_MAX_GAMMA_8)) -- shift = (16 - PNG_MAX_GAMMA_8); -- } -- -- if (shift > 8) -- shift = 8; -- if (shift < 0) -- shift = 0; -- -- png_ptr->gamma_shift = (png_byte)shift; -- -- num = (1 << (8 - shift)); -- -- if (png_ptr->screen_gamma > .000001) -- g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); -- else -- g = 1.0; -- -- png_ptr->gamma_16_table = (png_uint_16pp)png_malloc(png_ptr, -- (png_uint_32)(num * png_sizeof (png_uint_16p))); -- -- if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND)) -- { -- double fin, fout; -- png_uint_32 last, max; -- -- for (i = 0; i < num; i++) -- { -- png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr, -- (png_uint_32)(256 * png_sizeof (png_uint_16))); -- } -- -- g = 1.0 / g; -- last = 0; -- for (i = 0; i < 256; i++) -- { -- fout = ((double)i + 0.5) / 256.0; -- fin = pow(fout, g); -- max = (png_uint_32)(fin * (double)((png_uint_32)num << 8)); -- while (last <= max) -- { -- png_ptr->gamma_16_table[(int)(last & (0xff >> shift))] -- [(int)(last >> (8 - shift))] = (png_uint_16)( -- (png_uint_16)i | ((png_uint_16)i << 8)); -- last++; -- } -- } -- while (last < ((png_uint_32)num << 8)) -- { -- png_ptr->gamma_16_table[(int)(last & (0xff >> shift))] -- [(int)(last >> (8 - shift))] = (png_uint_16)65535L; -- last++; -- } -- } -- else -- { -- for (i = 0; i < num; i++) -- { -- png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr, -- (png_uint_32)(256 * png_sizeof (png_uint_16))); -- -- ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4); -- for (j = 0; j < 256; j++) -- { -- png_ptr->gamma_16_table[i][j] = -- (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) / -- 65535.0, g) * 65535.0 + .5); -- } -- } -- } -- --#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ -- defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) -- if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY)) -- { -- -- g = 1.0 / (png_ptr->gamma); -- -- png_ptr->gamma_16_to_1 = (png_uint_16pp)png_malloc(png_ptr, -- (png_uint_32)(num * png_sizeof (png_uint_16p ))); -- -- for (i = 0; i < num; i++) -- { -- png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr, -- (png_uint_32)(256 * png_sizeof (png_uint_16))); -- -- ig = (((png_uint_32)i * -- (png_uint_32)png_gamma_shift[shift]) >> 4); -- for (j = 0; j < 256; j++) -- { -- png_ptr->gamma_16_to_1[i][j] = -- (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) / -- 65535.0, g) * 65535.0 + .5); -- } -- } -- -- if(png_ptr->screen_gamma > 0.000001) -- g = 1.0 / png_ptr->screen_gamma; -- else -- g = png_ptr->gamma; /* probably doing rgb_to_gray */ -- -- png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr, -- (png_uint_32)(num * png_sizeof (png_uint_16p))); -- -- for (i = 0; i < num; i++) -- { -- png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr, -- (png_uint_32)(256 * png_sizeof (png_uint_16))); -- -- ig = (((png_uint_32)i * -- (png_uint_32)png_gamma_shift[shift]) >> 4); -- for (j = 0; j < 256; j++) -- { -- png_ptr->gamma_16_from_1[i][j] = -- (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) / -- 65535.0, g) * 65535.0 + .5); -- } -- } -- } --#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */ -- } -- } --} --#endif --/* To do: install integer version of png_build_gamma_table here */ --#endif -- --#if defined(PNG_MNG_FEATURES_SUPPORTED) --/* undoes intrapixel differencing */ --void /* PRIVATE */ --png_do_read_intrapixel(png_row_infop row_info, png_bytep row) --{ -- png_debug(1, "in png_do_read_intrapixel\n"); -- if ( --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- row != NULL && row_info != NULL && --#endif -- (row_info->color_type & PNG_COLOR_MASK_COLOR)) -- { -- int bytes_per_pixel; -- png_uint_32 row_width = row_info->width; -- if (row_info->bit_depth == 8) -- { -- png_bytep rp; -- png_uint_32 i; -- -- if (row_info->color_type == PNG_COLOR_TYPE_RGB) -- bytes_per_pixel = 3; -- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- bytes_per_pixel = 4; -- else -- return; -- -- for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) -- { -- *(rp) = (png_byte)((256 + *rp + *(rp+1))&0xff); -- *(rp+2) = (png_byte)((256 + *(rp+2) + *(rp+1))&0xff); -- } -- } -- else if (row_info->bit_depth == 16) -- { -- png_bytep rp; -- png_uint_32 i; -- -- if (row_info->color_type == PNG_COLOR_TYPE_RGB) -- bytes_per_pixel = 6; -- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- bytes_per_pixel = 8; -- else -- return; -- -- for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) -- { -- png_uint_32 s0 = (*(rp ) << 8) | *(rp+1); -- png_uint_32 s1 = (*(rp+2) << 8) | *(rp+3); -- png_uint_32 s2 = (*(rp+4) << 8) | *(rp+5); -- png_uint_32 red = (png_uint_32)((s0+s1+65536L) & 0xffffL); -- png_uint_32 blue = (png_uint_32)((s2+s1+65536L) & 0xffffL); -- *(rp ) = (png_byte)((red >> 8) & 0xff); -- *(rp+1) = (png_byte)(red & 0xff); -- *(rp+4) = (png_byte)((blue >> 8) & 0xff); -- *(rp+5) = (png_byte)(blue & 0xff); -- } -- } -- } --} --#endif /* PNG_MNG_FEATURES_SUPPORTED */ -diff --git a/thirdparty/libpng/pngrutil.c b/thirdparty/libpng/pngrutil.c -deleted file mode 100644 -index ce52219..0000000 ---- a/thirdparty/libpng/pngrutil.c -+++ /dev/null -@@ -1,3124 +0,0 @@ --/* pngrutil.c - utilities to read a PNG file -- * -- * libpng version 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- * -- * This file contains routines that are only called from within -- * libpng itself during the course of reading an image. -- */ -- --#define PNG_INTERNAL --#include "png.h" -- --#if defined(_WIN32_WCE) --/* strtod() function is not supported on WindowsCE */ --# ifdef PNG_FLOATING_POINT_SUPPORTED --__inline double strtod(const char *nptr, char **endptr) --{ -- double result = 0; -- int len; -- wchar_t *str, *end; -- -- len = MultiByteToWideChar(CP_ACP, 0, nptr, -1, NULL, 0); -- str = (wchar_t *)malloc(len * sizeof(wchar_t)); -- if ( NULL != str ) -- { -- MultiByteToWideChar(CP_ACP, 0, nptr, -1, str, len); -- result = wcstod(str, &end); -- len = WideCharToMultiByte(CP_ACP, 0, end, -1, NULL, 0, NULL, NULL); -- *endptr = (char *)nptr + (png_strlen(nptr) - len + 1); -- free(str); -- } -- return result; --} --# endif --#endif -- --png_uint_32 /* PRIVATE */ --png_get_uint_31(png_structp png_ptr, png_bytep buf) --{ -- png_uint_32 i = png_get_uint_32(buf); -- if (i > PNG_UINT_31_MAX) -- png_error(png_ptr, "PNG unsigned integer out of range.\n"); -- return (i); --} --#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED --/* Grab an unsigned 32-bit integer from a buffer in big-endian format. */ --png_uint_32 /* PRIVATE */ --png_get_uint_32(png_bytep buf) --{ -- png_uint_32 i = ((png_uint_32)(*buf) << 24) + -- ((png_uint_32)(*(buf + 1)) << 16) + -- ((png_uint_32)(*(buf + 2)) << 8) + -- (png_uint_32)(*(buf + 3)); -- -- return (i); --} -- --#if defined(PNG_READ_pCAL_SUPPORTED) || defined(PNG_READ_oFFs_SUPPORTED) --/* Grab a signed 32-bit integer from a buffer in big-endian format. The -- * data is stored in the PNG file in two's complement format, and it is -- * assumed that the machine format for signed integers is the same. */ --png_int_32 /* PRIVATE */ --png_get_int_32(png_bytep buf) --{ -- png_int_32 i = ((png_int_32)(*buf) << 24) + -- ((png_int_32)(*(buf + 1)) << 16) + -- ((png_int_32)(*(buf + 2)) << 8) + -- (png_int_32)(*(buf + 3)); -- -- return (i); --} --#endif /* PNG_READ_pCAL_SUPPORTED */ -- --/* Grab an unsigned 16-bit integer from a buffer in big-endian format. */ --png_uint_16 /* PRIVATE */ --png_get_uint_16(png_bytep buf) --{ -- png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) + -- (png_uint_16)(*(buf + 1))); -- -- return (i); --} --#endif /* PNG_READ_BIG_ENDIAN_SUPPORTED */ -- --/* Read data, and (optionally) run it through the CRC. */ --void /* PRIVATE */ --png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length) --{ -- png_read_data(png_ptr, buf, length); -- png_calculate_crc(png_ptr, buf, length); --} -- --/* Optionally skip data and then check the CRC. Depending on whether we -- are reading a ancillary or critical chunk, and how the program has set -- things up, we may calculate the CRC on the data and print a message. -- Returns '1' if there was a CRC error, '0' otherwise. */ --int /* PRIVATE */ --png_crc_finish(png_structp png_ptr, png_uint_32 skip) --{ -- png_size_t i; -- png_size_t istop = png_ptr->zbuf_size; -- -- for (i = (png_size_t)skip; i > istop; i -= istop) -- { -- png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); -- } -- if (i) -- { -- png_crc_read(png_ptr, png_ptr->zbuf, i); -- } -- -- if (png_crc_error(png_ptr)) -- { -- if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */ -- !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) || -- (!(png_ptr->chunk_name[0] & 0x20) && /* Critical */ -- (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE))) -- { -- png_chunk_warning(png_ptr, "CRC error"); -- } -- else -- { -- png_chunk_error(png_ptr, "CRC error"); -- } -- return (1); -- } -- -- return (0); --} -- --/* Compare the CRC stored in the PNG file with that calculated by libpng from -- the data it has read thus far. */ --int /* PRIVATE */ --png_crc_error(png_structp png_ptr) --{ -- png_byte crc_bytes[4]; -- png_uint_32 crc; -- int need_crc = 1; -- -- if (png_ptr->chunk_name[0] & 0x20) /* ancillary */ -- { -- if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == -- (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) -- need_crc = 0; -- } -- else /* critical */ -- { -- if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) -- need_crc = 0; -- } -- -- png_read_data(png_ptr, crc_bytes, 4); -- -- if (need_crc) -- { -- crc = png_get_uint_32(crc_bytes); -- return ((int)(crc != png_ptr->crc)); -- } -- else -- return (0); --} -- --#if defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_READ_iTXt_SUPPORTED) || \ -- defined(PNG_READ_iCCP_SUPPORTED) --/* -- * Decompress trailing data in a chunk. The assumption is that chunkdata -- * points at an allocated area holding the contents of a chunk with a -- * trailing compressed part. What we get back is an allocated area -- * holding the original prefix part and an uncompressed version of the -- * trailing part (the malloc area passed in is freed). -- */ --png_charp /* PRIVATE */ --png_decompress_chunk(png_structp png_ptr, int comp_type, -- png_charp chunkdata, png_size_t chunklength, -- png_size_t prefix_size, png_size_t *newlength) --{ -- static char msg[] = "Error decoding compressed text"; -- png_charp text; -- png_size_t text_size; -- -- if (comp_type == PNG_COMPRESSION_TYPE_BASE) -- { -- int ret = Z_OK; -- png_ptr->zstream.next_in = (png_bytep)(chunkdata + prefix_size); -- png_ptr->zstream.avail_in = (uInt)(chunklength - prefix_size); -- png_ptr->zstream.next_out = png_ptr->zbuf; -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -- -- text_size = 0; -- text = NULL; -- -- while (png_ptr->zstream.avail_in) -- { -- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); -- if (ret != Z_OK && ret != Z_STREAM_END) -- { -- if (png_ptr->zstream.msg != NULL) -- png_warning(png_ptr, png_ptr->zstream.msg); -- else -- png_warning(png_ptr, msg); -- inflateReset(&png_ptr->zstream); -- png_ptr->zstream.avail_in = 0; -- -- if (text == NULL) -- { -- text_size = prefix_size + png_sizeof(msg) + 1; -- text = (png_charp)png_malloc_warn(png_ptr, text_size); -- if (text == NULL) -- { -- png_free(png_ptr,chunkdata); -- png_error(png_ptr,"Not enough memory to decompress chunk"); -- } -- png_memcpy(text, chunkdata, prefix_size); -- } -- -- text[text_size - 1] = 0x00; -- -- /* Copy what we can of the error message into the text chunk */ -- text_size = (png_size_t)(chunklength - (text - chunkdata) - 1); -- text_size = png_sizeof(msg) > text_size ? text_size : -- png_sizeof(msg); -- png_memcpy(text + prefix_size, msg, text_size + 1); -- break; -- } -- if (!png_ptr->zstream.avail_out || ret == Z_STREAM_END) -- { -- if (text == NULL) -- { -- text_size = prefix_size + -- png_ptr->zbuf_size - png_ptr->zstream.avail_out; -- text = (png_charp)png_malloc_warn(png_ptr, text_size + 1); -- if (text == NULL) -- { -- png_free(png_ptr,chunkdata); -- png_error(png_ptr,"Not enough memory to decompress chunk."); -- } -- png_memcpy(text + prefix_size, png_ptr->zbuf, -- text_size - prefix_size); -- png_memcpy(text, chunkdata, prefix_size); -- *(text + text_size) = 0x00; -- } -- else -- { -- png_charp tmp; -- -- tmp = text; -- text = (png_charp)png_malloc_warn(png_ptr, -- (png_uint_32)(text_size + -- png_ptr->zbuf_size - png_ptr->zstream.avail_out + 1)); -- if (text == NULL) -- { -- png_free(png_ptr, tmp); -- png_free(png_ptr, chunkdata); -- png_error(png_ptr,"Not enough memory to decompress chunk.."); -- } -- png_memcpy(text, tmp, text_size); -- png_free(png_ptr, tmp); -- png_memcpy(text + text_size, png_ptr->zbuf, -- (png_ptr->zbuf_size - png_ptr->zstream.avail_out)); -- text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out; -- *(text + text_size) = 0x00; -- } -- if (ret == Z_STREAM_END) -- break; -- else -- { -- png_ptr->zstream.next_out = png_ptr->zbuf; -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -- } -- } -- } -- if (ret != Z_STREAM_END) -- { --#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) -- char umsg[50]; -- -- if (ret == Z_BUF_ERROR) -- sprintf(umsg,"Buffer error in compressed datastream in %s chunk", -- png_ptr->chunk_name); -- else if (ret == Z_DATA_ERROR) -- sprintf(umsg,"Data error in compressed datastream in %s chunk", -- png_ptr->chunk_name); -- else -- sprintf(umsg,"Incomplete compressed datastream in %s chunk", -- png_ptr->chunk_name); -- png_warning(png_ptr, umsg); --#else -- png_warning(png_ptr, -- "Incomplete compressed datastream in chunk other than IDAT"); --#endif -- text_size=prefix_size; -- if (text == NULL) -- { -- text = (png_charp)png_malloc_warn(png_ptr, text_size+1); -- if (text == NULL) -- { -- png_free(png_ptr, chunkdata); -- png_error(png_ptr,"Not enough memory for text."); -- } -- png_memcpy(text, chunkdata, prefix_size); -- } -- *(text + text_size) = 0x00; -- } -- -- inflateReset(&png_ptr->zstream); -- png_ptr->zstream.avail_in = 0; -- -- png_free(png_ptr, chunkdata); -- chunkdata = text; -- *newlength=text_size; -- } -- else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */ -- { --#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) -- char umsg[50]; -- -- sprintf(umsg, "Unknown zTXt compression type %d", comp_type); -- png_warning(png_ptr, umsg); --#else -- png_warning(png_ptr, "Unknown zTXt compression type"); --#endif -- -- *(chunkdata + prefix_size) = 0x00; -- *newlength=prefix_size; -- } -- -- return chunkdata; --} --#endif -- --/* read and check the IDHR chunk */ --void /* PRIVATE */ --png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_byte buf[13]; -- png_uint_32 width, height; -- int bit_depth, color_type, compression_type, filter_type; -- int interlace_type; -- -- png_debug(1, "in png_handle_IHDR\n"); -- -- if (png_ptr->mode & PNG_HAVE_IHDR) -- png_error(png_ptr, "Out of place IHDR"); -- -- /* check the length */ -- if (length != 13) -- png_error(png_ptr, "Invalid IHDR chunk"); -- -- png_ptr->mode |= PNG_HAVE_IHDR; -- -- png_crc_read(png_ptr, buf, 13); -- png_crc_finish(png_ptr, 0); -- -- width = png_get_uint_31(png_ptr, buf); -- height = png_get_uint_31(png_ptr, buf + 4); -- bit_depth = buf[8]; -- color_type = buf[9]; -- compression_type = buf[10]; -- filter_type = buf[11]; -- interlace_type = buf[12]; -- -- /* set internal variables */ -- png_ptr->width = width; -- png_ptr->height = height; -- png_ptr->bit_depth = (png_byte)bit_depth; -- png_ptr->interlaced = (png_byte)interlace_type; -- png_ptr->color_type = (png_byte)color_type; --#if defined(PNG_MNG_FEATURES_SUPPORTED) -- png_ptr->filter_type = (png_byte)filter_type; --#endif -- png_ptr->compression_type = (png_byte)compression_type; -- -- /* find number of channels */ -- switch (png_ptr->color_type) -- { -- case PNG_COLOR_TYPE_GRAY: -- case PNG_COLOR_TYPE_PALETTE: -- png_ptr->channels = 1; -- break; -- case PNG_COLOR_TYPE_RGB: -- png_ptr->channels = 3; -- break; -- case PNG_COLOR_TYPE_GRAY_ALPHA: -- png_ptr->channels = 2; -- break; -- case PNG_COLOR_TYPE_RGB_ALPHA: -- png_ptr->channels = 4; -- break; -- } -- -- /* set up other useful info */ -- png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth * -- png_ptr->channels); -- png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,png_ptr->width); -- png_debug1(3,"bit_depth = %d\n", png_ptr->bit_depth); -- png_debug1(3,"channels = %d\n", png_ptr->channels); -- png_debug1(3,"rowbytes = %lu\n", png_ptr->rowbytes); -- png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, -- color_type, interlace_type, compression_type, filter_type); --} -- --/* read and check the palette */ --void /* PRIVATE */ --png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_color palette[PNG_MAX_PALETTE_LENGTH]; -- int num, i; --#ifndef PNG_NO_POINTER_INDEXING -- png_colorp pal_ptr; --#endif -- -- png_debug(1, "in png_handle_PLTE\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before PLTE"); -- else if (png_ptr->mode & PNG_HAVE_IDAT) -- { -- png_warning(png_ptr, "Invalid PLTE after IDAT"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else if (png_ptr->mode & PNG_HAVE_PLTE) -- png_error(png_ptr, "Duplicate PLTE chunk"); -- -- png_ptr->mode |= PNG_HAVE_PLTE; -- -- if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR)) -- { -- png_warning(png_ptr, -- "Ignoring PLTE chunk in grayscale PNG"); -- png_crc_finish(png_ptr, length); -- return; -- } --#if !defined(PNG_READ_OPT_PLTE_SUPPORTED) -- if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE) -- { -- png_crc_finish(png_ptr, length); -- return; -- } --#endif -- -- if (length > 3*PNG_MAX_PALETTE_LENGTH || length % 3) -- { -- if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE) -- { -- png_warning(png_ptr, "Invalid palette chunk"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else -- { -- png_error(png_ptr, "Invalid palette chunk"); -- } -- } -- -- num = (int)length / 3; -- --#ifndef PNG_NO_POINTER_INDEXING -- for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++) -- { -- png_byte buf[3]; -- -- png_crc_read(png_ptr, buf, 3); -- pal_ptr->red = buf[0]; -- pal_ptr->green = buf[1]; -- pal_ptr->blue = buf[2]; -- } --#else -- for (i = 0; i < num; i++) -- { -- png_byte buf[3]; -- -- png_crc_read(png_ptr, buf, 3); -- /* don't depend upon png_color being any order */ -- palette[i].red = buf[0]; -- palette[i].green = buf[1]; -- palette[i].blue = buf[2]; -- } --#endif -- -- /* If we actually NEED the PLTE chunk (ie for a paletted image), we do -- whatever the normal CRC configuration tells us. However, if we -- have an RGB image, the PLTE can be considered ancillary, so -- we will act as though it is. */ --#if !defined(PNG_READ_OPT_PLTE_SUPPORTED) -- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) --#endif -- { -- png_crc_finish(png_ptr, 0); -- } --#if !defined(PNG_READ_OPT_PLTE_SUPPORTED) -- else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */ -- { -- /* If we don't want to use the data from an ancillary chunk, -- we have two options: an error abort, or a warning and we -- ignore the data in this chunk (which should be OK, since -- it's considered ancillary for a RGB or RGBA image). */ -- if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE)) -- { -- if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) -- { -- png_chunk_error(png_ptr, "CRC error"); -- } -- else -- { -- png_chunk_warning(png_ptr, "CRC error"); -- return; -- } -- } -- /* Otherwise, we (optionally) emit a warning and use the chunk. */ -- else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) -- { -- png_chunk_warning(png_ptr, "CRC error"); -- } -- } --#endif -- -- png_set_PLTE(png_ptr, info_ptr, palette, num); -- --#if defined(PNG_READ_tRNS_SUPPORTED) -- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- { -- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) -- { -- if (png_ptr->num_trans > (png_uint_16)num) -- { -- png_warning(png_ptr, "Truncating incorrect tRNS chunk length"); -- png_ptr->num_trans = (png_uint_16)num; -- } -- if (info_ptr->num_trans > (png_uint_16)num) -- { -- png_warning(png_ptr, "Truncating incorrect info tRNS chunk length"); -- info_ptr->num_trans = (png_uint_16)num; -- } -- } -- } --#endif -- --} -- --void /* PRIVATE */ --png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_debug(1, "in png_handle_IEND\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT)) -- { -- png_error(png_ptr, "No image in file"); -- } -- -- png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND); -- -- if (length != 0) -- { -- png_warning(png_ptr, "Incorrect IEND chunk length"); -- } -- png_crc_finish(png_ptr, length); -- -- if (&info_ptr == NULL) /* quiet compiler warnings about unused info_ptr */ -- return; --} -- --#if defined(PNG_READ_gAMA_SUPPORTED) --void /* PRIVATE */ --png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_fixed_point igamma; --#ifdef PNG_FLOATING_POINT_SUPPORTED -- float file_gamma; --#endif -- png_byte buf[4]; -- -- png_debug(1, "in png_handle_gAMA\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before gAMA"); -- else if (png_ptr->mode & PNG_HAVE_IDAT) -- { -- png_warning(png_ptr, "Invalid gAMA after IDAT"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else if (png_ptr->mode & PNG_HAVE_PLTE) -- /* Should be an error, but we can cope with it */ -- png_warning(png_ptr, "Out of place gAMA chunk"); -- -- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) --#if defined(PNG_READ_sRGB_SUPPORTED) -- && !(info_ptr->valid & PNG_INFO_sRGB) --#endif -- ) -- { -- png_warning(png_ptr, "Duplicate gAMA chunk"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- if (length != 4) -- { -- png_warning(png_ptr, "Incorrect gAMA chunk length"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- png_crc_read(png_ptr, buf, 4); -- if (png_crc_finish(png_ptr, 0)) -- return; -- -- igamma = (png_fixed_point)png_get_uint_32(buf); -- /* check for zero gamma */ -- if (igamma == 0) -- { -- png_warning(png_ptr, -- "Ignoring gAMA chunk with gamma=0"); -- return; -- } -- --#if defined(PNG_READ_sRGB_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_sRGB) -- if (PNG_OUT_OF_RANGE(igamma, 45500L, 500)) -- { -- png_warning(png_ptr, -- "Ignoring incorrect gAMA value when sRGB is also present"); --#ifndef PNG_NO_CONSOLE_IO -- fprintf(stderr, "gamma = (%d/100000)\n", (int)igamma); --#endif -- return; -- } --#endif /* PNG_READ_sRGB_SUPPORTED */ -- --#ifdef PNG_FLOATING_POINT_SUPPORTED -- file_gamma = (float)igamma / (float)100000.0; --# ifdef PNG_READ_GAMMA_SUPPORTED -- png_ptr->gamma = file_gamma; --# endif -- png_set_gAMA(png_ptr, info_ptr, file_gamma); --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED -- png_set_gAMA_fixed(png_ptr, info_ptr, igamma); --#endif --} --#endif -- --#if defined(PNG_READ_sBIT_SUPPORTED) --void /* PRIVATE */ --png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_size_t truelen; -- png_byte buf[4]; -- -- png_debug(1, "in png_handle_sBIT\n"); -- -- buf[0] = buf[1] = buf[2] = buf[3] = 0; -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before sBIT"); -- else if (png_ptr->mode & PNG_HAVE_IDAT) -- { -- png_warning(png_ptr, "Invalid sBIT after IDAT"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else if (png_ptr->mode & PNG_HAVE_PLTE) -- { -- /* Should be an error, but we can cope with it */ -- png_warning(png_ptr, "Out of place sBIT chunk"); -- } -- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)) -- { -- png_warning(png_ptr, "Duplicate sBIT chunk"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- truelen = 3; -- else -- truelen = (png_size_t)png_ptr->channels; -- -- if (length != truelen || length > 4) -- { -- png_warning(png_ptr, "Incorrect sBIT chunk length"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- png_crc_read(png_ptr, buf, truelen); -- if (png_crc_finish(png_ptr, 0)) -- return; -- -- if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) -- { -- png_ptr->sig_bit.red = buf[0]; -- png_ptr->sig_bit.green = buf[1]; -- png_ptr->sig_bit.blue = buf[2]; -- png_ptr->sig_bit.alpha = buf[3]; -- } -- else -- { -- png_ptr->sig_bit.gray = buf[0]; -- png_ptr->sig_bit.red = buf[0]; -- png_ptr->sig_bit.green = buf[0]; -- png_ptr->sig_bit.blue = buf[0]; -- png_ptr->sig_bit.alpha = buf[1]; -- } -- png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit)); --} --#endif -- --#if defined(PNG_READ_cHRM_SUPPORTED) --void /* PRIVATE */ --png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_byte buf[4]; --#ifdef PNG_FLOATING_POINT_SUPPORTED -- float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; --#endif -- png_fixed_point int_x_white, int_y_white, int_x_red, int_y_red, int_x_green, -- int_y_green, int_x_blue, int_y_blue; -- -- png_uint_32 uint_x, uint_y; -- -- png_debug(1, "in png_handle_cHRM\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before cHRM"); -- else if (png_ptr->mode & PNG_HAVE_IDAT) -- { -- png_warning(png_ptr, "Invalid cHRM after IDAT"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else if (png_ptr->mode & PNG_HAVE_PLTE) -- /* Should be an error, but we can cope with it */ -- png_warning(png_ptr, "Missing PLTE before cHRM"); -- -- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM) --#if defined(PNG_READ_sRGB_SUPPORTED) -- && !(info_ptr->valid & PNG_INFO_sRGB) --#endif -- ) -- { -- png_warning(png_ptr, "Duplicate cHRM chunk"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- if (length != 32) -- { -- png_warning(png_ptr, "Incorrect cHRM chunk length"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- png_crc_read(png_ptr, buf, 4); -- uint_x = png_get_uint_32(buf); -- -- png_crc_read(png_ptr, buf, 4); -- uint_y = png_get_uint_32(buf); -- -- if (uint_x > 80000L || uint_y > 80000L || -- uint_x + uint_y > 100000L) -- { -- png_warning(png_ptr, "Invalid cHRM white point"); -- png_crc_finish(png_ptr, 24); -- return; -- } -- int_x_white = (png_fixed_point)uint_x; -- int_y_white = (png_fixed_point)uint_y; -- -- png_crc_read(png_ptr, buf, 4); -- uint_x = png_get_uint_32(buf); -- -- png_crc_read(png_ptr, buf, 4); -- uint_y = png_get_uint_32(buf); -- -- if (uint_x > 80000L || uint_y > 80000L || -- uint_x + uint_y > 100000L) -- { -- png_warning(png_ptr, "Invalid cHRM red point"); -- png_crc_finish(png_ptr, 16); -- return; -- } -- int_x_red = (png_fixed_point)uint_x; -- int_y_red = (png_fixed_point)uint_y; -- -- png_crc_read(png_ptr, buf, 4); -- uint_x = png_get_uint_32(buf); -- -- png_crc_read(png_ptr, buf, 4); -- uint_y = png_get_uint_32(buf); -- -- if (uint_x > 80000L || uint_y > 80000L || -- uint_x + uint_y > 100000L) -- { -- png_warning(png_ptr, "Invalid cHRM green point"); -- png_crc_finish(png_ptr, 8); -- return; -- } -- int_x_green = (png_fixed_point)uint_x; -- int_y_green = (png_fixed_point)uint_y; -- -- png_crc_read(png_ptr, buf, 4); -- uint_x = png_get_uint_32(buf); -- -- png_crc_read(png_ptr, buf, 4); -- uint_y = png_get_uint_32(buf); -- -- if (uint_x > 80000L || uint_y > 80000L || -- uint_x + uint_y > 100000L) -- { -- png_warning(png_ptr, "Invalid cHRM blue point"); -- png_crc_finish(png_ptr, 0); -- return; -- } -- int_x_blue = (png_fixed_point)uint_x; -- int_y_blue = (png_fixed_point)uint_y; -- --#ifdef PNG_FLOATING_POINT_SUPPORTED -- white_x = (float)int_x_white / (float)100000.0; -- white_y = (float)int_y_white / (float)100000.0; -- red_x = (float)int_x_red / (float)100000.0; -- red_y = (float)int_y_red / (float)100000.0; -- green_x = (float)int_x_green / (float)100000.0; -- green_y = (float)int_y_green / (float)100000.0; -- blue_x = (float)int_x_blue / (float)100000.0; -- blue_y = (float)int_y_blue / (float)100000.0; --#endif -- --#if defined(PNG_READ_sRGB_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_sRGB) -- { -- if (PNG_OUT_OF_RANGE(int_x_white, 31270, 1000) || -- PNG_OUT_OF_RANGE(int_y_white, 32900, 1000) || -- PNG_OUT_OF_RANGE(int_x_red, 64000L, 1000) || -- PNG_OUT_OF_RANGE(int_y_red, 33000, 1000) || -- PNG_OUT_OF_RANGE(int_x_green, 30000, 1000) || -- PNG_OUT_OF_RANGE(int_y_green, 60000L, 1000) || -- PNG_OUT_OF_RANGE(int_x_blue, 15000, 1000) || -- PNG_OUT_OF_RANGE(int_y_blue, 6000, 1000)) -- { -- -- png_warning(png_ptr, -- "Ignoring incorrect cHRM value when sRGB is also present"); --#ifndef PNG_NO_CONSOLE_IO --#ifdef PNG_FLOATING_POINT_SUPPORTED -- fprintf(stderr,"wx=%f, wy=%f, rx=%f, ry=%f\n", -- white_x, white_y, red_x, red_y); -- fprintf(stderr,"gx=%f, gy=%f, bx=%f, by=%f\n", -- green_x, green_y, blue_x, blue_y); --#else -- fprintf(stderr,"wx=%ld, wy=%ld, rx=%ld, ry=%ld\n", -- int_x_white, int_y_white, int_x_red, int_y_red); -- fprintf(stderr,"gx=%ld, gy=%ld, bx=%ld, by=%ld\n", -- int_x_green, int_y_green, int_x_blue, int_y_blue); --#endif --#endif /* PNG_NO_CONSOLE_IO */ -- } -- png_crc_finish(png_ptr, 0); -- return; -- } --#endif /* PNG_READ_sRGB_SUPPORTED */ -- --#ifdef PNG_FLOATING_POINT_SUPPORTED -- png_set_cHRM(png_ptr, info_ptr, -- white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y); --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED -- png_set_cHRM_fixed(png_ptr, info_ptr, -- int_x_white, int_y_white, int_x_red, int_y_red, int_x_green, -- int_y_green, int_x_blue, int_y_blue); --#endif -- if (png_crc_finish(png_ptr, 0)) -- return; --} --#endif -- --#if defined(PNG_READ_sRGB_SUPPORTED) --void /* PRIVATE */ --png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- int intent; -- png_byte buf[1]; -- -- png_debug(1, "in png_handle_sRGB\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before sRGB"); -- else if (png_ptr->mode & PNG_HAVE_IDAT) -- { -- png_warning(png_ptr, "Invalid sRGB after IDAT"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else if (png_ptr->mode & PNG_HAVE_PLTE) -- /* Should be an error, but we can cope with it */ -- png_warning(png_ptr, "Out of place sRGB chunk"); -- -- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)) -- { -- png_warning(png_ptr, "Duplicate sRGB chunk"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- if (length != 1) -- { -- png_warning(png_ptr, "Incorrect sRGB chunk length"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- png_crc_read(png_ptr, buf, 1); -- if (png_crc_finish(png_ptr, 0)) -- return; -- -- intent = buf[0]; -- /* check for bad intent */ -- if (intent >= PNG_sRGB_INTENT_LAST) -- { -- png_warning(png_ptr, "Unknown sRGB intent"); -- return; -- } -- --#if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED) -- if ((info_ptr->valid & PNG_INFO_gAMA)) -- { -- png_fixed_point igamma; --#ifdef PNG_FIXED_POINT_SUPPORTED -- igamma=info_ptr->int_gamma; --#else --# ifdef PNG_FLOATING_POINT_SUPPORTED -- igamma=(png_fixed_point)(info_ptr->gamma * 100000.); --# endif --#endif -- if (PNG_OUT_OF_RANGE(igamma, 45500L, 500)) -- { -- png_warning(png_ptr, -- "Ignoring incorrect gAMA value when sRGB is also present"); --#ifndef PNG_NO_CONSOLE_IO --# ifdef PNG_FIXED_POINT_SUPPORTED -- fprintf(stderr,"incorrect gamma=(%d/100000)\n",(int)png_ptr->int_gamma); --# else --# ifdef PNG_FLOATING_POINT_SUPPORTED -- fprintf(stderr,"incorrect gamma=%f\n",png_ptr->gamma); --# endif --# endif --#endif -- } -- } --#endif /* PNG_READ_gAMA_SUPPORTED */ -- --#ifdef PNG_READ_cHRM_SUPPORTED --#ifdef PNG_FIXED_POINT_SUPPORTED -- if (info_ptr->valid & PNG_INFO_cHRM) -- if (PNG_OUT_OF_RANGE(info_ptr->int_x_white, 31270, 1000) || -- PNG_OUT_OF_RANGE(info_ptr->int_y_white, 32900, 1000) || -- PNG_OUT_OF_RANGE(info_ptr->int_x_red, 64000L, 1000) || -- PNG_OUT_OF_RANGE(info_ptr->int_y_red, 33000, 1000) || -- PNG_OUT_OF_RANGE(info_ptr->int_x_green, 30000, 1000) || -- PNG_OUT_OF_RANGE(info_ptr->int_y_green, 60000L, 1000) || -- PNG_OUT_OF_RANGE(info_ptr->int_x_blue, 15000, 1000) || -- PNG_OUT_OF_RANGE(info_ptr->int_y_blue, 6000, 1000)) -- { -- png_warning(png_ptr, -- "Ignoring incorrect cHRM value when sRGB is also present"); -- } --#endif /* PNG_FIXED_POINT_SUPPORTED */ --#endif /* PNG_READ_cHRM_SUPPORTED */ -- -- png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent); --} --#endif /* PNG_READ_sRGB_SUPPORTED */ -- --#if defined(PNG_READ_iCCP_SUPPORTED) --void /* PRIVATE */ --png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --/* Note: this does not properly handle chunks that are > 64K under DOS */ --{ -- png_charp chunkdata; -- png_byte compression_type; -- png_bytep pC; -- png_charp profile; -- png_uint_32 skip = 0; -- png_uint_32 profile_size, profile_length; -- png_size_t slength, prefix_length, data_length; -- -- png_debug(1, "in png_handle_iCCP\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before iCCP"); -- else if (png_ptr->mode & PNG_HAVE_IDAT) -- { -- png_warning(png_ptr, "Invalid iCCP after IDAT"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else if (png_ptr->mode & PNG_HAVE_PLTE) -- /* Should be an error, but we can cope with it */ -- png_warning(png_ptr, "Out of place iCCP chunk"); -- -- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)) -- { -- png_warning(png_ptr, "Duplicate iCCP chunk"); -- png_crc_finish(png_ptr, length); -- return; -- } -- --#ifdef PNG_MAX_MALLOC_64K -- if (length > (png_uint_32)65535L) -- { -- png_warning(png_ptr, "iCCP chunk too large to fit in memory"); -- skip = length - (png_uint_32)65535L; -- length = (png_uint_32)65535L; -- } --#endif -- -- chunkdata = (png_charp)png_malloc(png_ptr, length + 1); -- slength = (png_size_t)length; -- png_crc_read(png_ptr, (png_bytep)chunkdata, slength); -- -- if (png_crc_finish(png_ptr, skip)) -- { -- png_free(png_ptr, chunkdata); -- return; -- } -- -- chunkdata[slength] = 0x00; -- -- for (profile = chunkdata; *profile; profile++) -- /* empty loop to find end of name */ ; -- -- ++profile; -- -- /* there should be at least one zero (the compression type byte) -- following the separator, and we should be on it */ -- if ( profile >= chunkdata + slength) -- { -- png_free(png_ptr, chunkdata); -- png_warning(png_ptr, "Malformed iCCP chunk"); -- return; -- } -- -- /* compression_type should always be zero */ -- compression_type = *profile++; -- if (compression_type) -- { -- png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk"); -- compression_type=0x00; /* Reset it to zero (libpng-1.0.6 through 1.0.8 -- wrote nonzero) */ -- } -- -- prefix_length = profile - chunkdata; -- chunkdata = png_decompress_chunk(png_ptr, compression_type, chunkdata, -- slength, prefix_length, &data_length); -- -- profile_length = data_length - prefix_length; -- -- if ( prefix_length > data_length || profile_length < 4) -- { -- png_free(png_ptr, chunkdata); -- png_warning(png_ptr, "Profile size field missing from iCCP chunk"); -- return; -- } -- -- /* Check the profile_size recorded in the first 32 bits of the ICC profile */ -- pC = (png_bytep)(chunkdata+prefix_length); -- profile_size = ((*(pC ))<<24) | -- ((*(pC+1))<<16) | -- ((*(pC+2))<< 8) | -- ((*(pC+3)) ); -- -- if(profile_size < profile_length) -- profile_length = profile_size; -- -- if(profile_size > profile_length) -- { -- png_free(png_ptr, chunkdata); -- png_warning(png_ptr, "Ignoring truncated iCCP profile.\n"); -- return; -- } -- -- png_set_iCCP(png_ptr, info_ptr, chunkdata, compression_type, -- chunkdata + prefix_length, profile_length); -- png_free(png_ptr, chunkdata); --} --#endif /* PNG_READ_iCCP_SUPPORTED */ -- --#if defined(PNG_READ_sPLT_SUPPORTED) --void /* PRIVATE */ --png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --/* Note: this does not properly handle chunks that are > 64K under DOS */ --{ -- png_bytep chunkdata; -- png_bytep entry_start; -- png_sPLT_t new_palette; --#ifdef PNG_NO_POINTER_INDEXING -- png_sPLT_entryp pp; --#endif -- int data_length, entry_size, i; -- png_uint_32 skip = 0; -- png_size_t slength; -- -- png_debug(1, "in png_handle_sPLT\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before sPLT"); -- else if (png_ptr->mode & PNG_HAVE_IDAT) -- { -- png_warning(png_ptr, "Invalid sPLT after IDAT"); -- png_crc_finish(png_ptr, length); -- return; -- } -- --#ifdef PNG_MAX_MALLOC_64K -- if (length > (png_uint_32)65535L) -- { -- png_warning(png_ptr, "sPLT chunk too large to fit in memory"); -- skip = length - (png_uint_32)65535L; -- length = (png_uint_32)65535L; -- } --#endif -- -- chunkdata = (png_bytep)png_malloc(png_ptr, length + 1); -- slength = (png_size_t)length; -- png_crc_read(png_ptr, (png_bytep)chunkdata, slength); -- -- if (png_crc_finish(png_ptr, skip)) -- { -- png_free(png_ptr, chunkdata); -- return; -- } -- -- chunkdata[slength] = 0x00; -- -- for (entry_start = chunkdata; *entry_start; entry_start++) -- /* empty loop to find end of name */ ; -- ++entry_start; -- -- /* a sample depth should follow the separator, and we should be on it */ -- if (entry_start > chunkdata + slength) -- { -- png_free(png_ptr, chunkdata); -- png_warning(png_ptr, "malformed sPLT chunk"); -- return; -- } -- -- new_palette.depth = *entry_start++; -- entry_size = (new_palette.depth == 8 ? 6 : 10); -- data_length = (slength - (entry_start - chunkdata)); -- -- /* integrity-check the data length */ -- if (data_length % entry_size) -- { -- png_free(png_ptr, chunkdata); -- png_warning(png_ptr, "sPLT chunk has bad length"); -- return; -- } -- -- new_palette.nentries = (png_uint_32) (data_length / entry_size); -- if ((png_uint_32) new_palette.nentries > (png_uint_32) (PNG_SIZE_MAX / -- png_sizeof(png_sPLT_entry))) -- { -- png_warning(png_ptr, "sPLT chunk too long"); -- return; -- } -- new_palette.entries = (png_sPLT_entryp)png_malloc_warn( -- png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry)); -- if (new_palette.entries == NULL) -- { -- png_warning(png_ptr, "sPLT chunk requires too much memory"); -- return; -- } -- --#ifndef PNG_NO_POINTER_INDEXING -- for (i = 0; i < new_palette.nentries; i++) -- { -- png_sPLT_entryp pp = new_palette.entries + i; -- -- if (new_palette.depth == 8) -- { -- pp->red = *entry_start++; -- pp->green = *entry_start++; -- pp->blue = *entry_start++; -- pp->alpha = *entry_start++; -- } -- else -- { -- pp->red = png_get_uint_16(entry_start); entry_start += 2; -- pp->green = png_get_uint_16(entry_start); entry_start += 2; -- pp->blue = png_get_uint_16(entry_start); entry_start += 2; -- pp->alpha = png_get_uint_16(entry_start); entry_start += 2; -- } -- pp->frequency = png_get_uint_16(entry_start); entry_start += 2; -- } --#else -- pp = new_palette.entries; -- for (i = 0; i < new_palette.nentries; i++) -- { -- -- if (new_palette.depth == 8) -- { -- pp[i].red = *entry_start++; -- pp[i].green = *entry_start++; -- pp[i].blue = *entry_start++; -- pp[i].alpha = *entry_start++; -- } -- else -- { -- pp[i].red = png_get_uint_16(entry_start); entry_start += 2; -- pp[i].green = png_get_uint_16(entry_start); entry_start += 2; -- pp[i].blue = png_get_uint_16(entry_start); entry_start += 2; -- pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2; -- } -- pp->frequency = png_get_uint_16(entry_start); entry_start += 2; -- } --#endif -- -- /* discard all chunk data except the name and stash that */ -- new_palette.name = (png_charp)chunkdata; -- -- png_set_sPLT(png_ptr, info_ptr, &new_palette, 1); -- -- png_free(png_ptr, chunkdata); -- png_free(png_ptr, new_palette.entries); --} --#endif /* PNG_READ_sPLT_SUPPORTED */ -- --#if defined(PNG_READ_tRNS_SUPPORTED) --void /* PRIVATE */ --png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_byte readbuf[PNG_MAX_PALETTE_LENGTH]; -- -- png_debug(1, "in png_handle_tRNS\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before tRNS"); -- else if (png_ptr->mode & PNG_HAVE_IDAT) -- { -- png_warning(png_ptr, "Invalid tRNS after IDAT"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) -- { -- png_warning(png_ptr, "Duplicate tRNS chunk"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) -- { -- png_byte buf[2]; -- -- if (length != 2) -- { -- png_warning(png_ptr, "Incorrect tRNS chunk length"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- png_crc_read(png_ptr, buf, 2); -- png_ptr->num_trans = 1; -- png_ptr->trans_values.gray = png_get_uint_16(buf); -- } -- else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) -- { -- png_byte buf[6]; -- -- if (length != 6) -- { -- png_warning(png_ptr, "Incorrect tRNS chunk length"); -- png_crc_finish(png_ptr, length); -- return; -- } -- png_crc_read(png_ptr, buf, (png_size_t)length); -- png_ptr->num_trans = 1; -- png_ptr->trans_values.red = png_get_uint_16(buf); -- png_ptr->trans_values.green = png_get_uint_16(buf + 2); -- png_ptr->trans_values.blue = png_get_uint_16(buf + 4); -- } -- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- { -- if (!(png_ptr->mode & PNG_HAVE_PLTE)) -- { -- /* Should be an error, but we can cope with it. */ -- png_warning(png_ptr, "Missing PLTE before tRNS"); -- } -- if (length > (png_uint_32)png_ptr->num_palette || -- length > PNG_MAX_PALETTE_LENGTH) -- { -- png_warning(png_ptr, "Incorrect tRNS chunk length"); -- png_crc_finish(png_ptr, length); -- return; -- } -- if (length == 0) -- { -- png_warning(png_ptr, "Zero length tRNS chunk"); -- png_crc_finish(png_ptr, length); -- return; -- } -- png_crc_read(png_ptr, readbuf, (png_size_t)length); -- png_ptr->num_trans = (png_uint_16)length; -- } -- else -- { -- png_warning(png_ptr, "tRNS chunk not allowed with alpha channel"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- if (png_crc_finish(png_ptr, 0)) -- return; -- -- png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans, -- &(png_ptr->trans_values)); --} --#endif -- --#if defined(PNG_READ_bKGD_SUPPORTED) --void /* PRIVATE */ --png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_size_t truelen; -- png_byte buf[6]; -- -- png_debug(1, "in png_handle_bKGD\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before bKGD"); -- else if (png_ptr->mode & PNG_HAVE_IDAT) -- { -- png_warning(png_ptr, "Invalid bKGD after IDAT"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && -- !(png_ptr->mode & PNG_HAVE_PLTE)) -- { -- png_warning(png_ptr, "Missing PLTE before bKGD"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)) -- { -- png_warning(png_ptr, "Duplicate bKGD chunk"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- truelen = 1; -- else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) -- truelen = 6; -- else -- truelen = 2; -- -- if (length != truelen) -- { -- png_warning(png_ptr, "Incorrect bKGD chunk length"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- png_crc_read(png_ptr, buf, truelen); -- if (png_crc_finish(png_ptr, 0)) -- return; -- -- /* We convert the index value into RGB components so that we can allow -- * arbitrary RGB values for background when we have transparency, and -- * so it is easy to determine the RGB values of the background color -- * from the info_ptr struct. */ -- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- { -- png_ptr->background.index = buf[0]; -- if(info_ptr->num_palette) -- { -- if(buf[0] > info_ptr->num_palette) -- { -- png_warning(png_ptr, "Incorrect bKGD chunk index value"); -- return; -- } -- png_ptr->background.red = -- (png_uint_16)png_ptr->palette[buf[0]].red; -- png_ptr->background.green = -- (png_uint_16)png_ptr->palette[buf[0]].green; -- png_ptr->background.blue = -- (png_uint_16)png_ptr->palette[buf[0]].blue; -- } -- } -- else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */ -- { -- png_ptr->background.red = -- png_ptr->background.green = -- png_ptr->background.blue = -- png_ptr->background.gray = png_get_uint_16(buf); -- } -- else -- { -- png_ptr->background.red = png_get_uint_16(buf); -- png_ptr->background.green = png_get_uint_16(buf + 2); -- png_ptr->background.blue = png_get_uint_16(buf + 4); -- } -- -- png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background)); --} --#endif -- --#if defined(PNG_READ_hIST_SUPPORTED) --void /* PRIVATE */ --png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- unsigned int num, i; -- png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH]; -- -- png_debug(1, "in png_handle_hIST\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before hIST"); -- else if (png_ptr->mode & PNG_HAVE_IDAT) -- { -- png_warning(png_ptr, "Invalid hIST after IDAT"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else if (!(png_ptr->mode & PNG_HAVE_PLTE)) -- { -- png_warning(png_ptr, "Missing PLTE before hIST"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)) -- { -- png_warning(png_ptr, "Duplicate hIST chunk"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- num = length / 2 ; -- if (num != (unsigned int) png_ptr->num_palette || num > -- (unsigned int) PNG_MAX_PALETTE_LENGTH) -- { -- png_warning(png_ptr, "Incorrect hIST chunk length"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- for (i = 0; i < num; i++) -- { -- png_byte buf[2]; -- -- png_crc_read(png_ptr, buf, 2); -- readbuf[i] = png_get_uint_16(buf); -- } -- -- if (png_crc_finish(png_ptr, 0)) -- return; -- -- png_set_hIST(png_ptr, info_ptr, readbuf); --} --#endif -- --#if defined(PNG_READ_pHYs_SUPPORTED) --void /* PRIVATE */ --png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_byte buf[9]; -- png_uint_32 res_x, res_y; -- int unit_type; -- -- png_debug(1, "in png_handle_pHYs\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before pHYs"); -- else if (png_ptr->mode & PNG_HAVE_IDAT) -- { -- png_warning(png_ptr, "Invalid pHYs after IDAT"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) -- { -- png_warning(png_ptr, "Duplicate pHYs chunk"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- if (length != 9) -- { -- png_warning(png_ptr, "Incorrect pHYs chunk length"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- png_crc_read(png_ptr, buf, 9); -- if (png_crc_finish(png_ptr, 0)) -- return; -- -- res_x = png_get_uint_32(buf); -- res_y = png_get_uint_32(buf + 4); -- unit_type = buf[8]; -- png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type); --} --#endif -- --#if defined(PNG_READ_oFFs_SUPPORTED) --void /* PRIVATE */ --png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_byte buf[9]; -- png_int_32 offset_x, offset_y; -- int unit_type; -- -- png_debug(1, "in png_handle_oFFs\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before oFFs"); -- else if (png_ptr->mode & PNG_HAVE_IDAT) -- { -- png_warning(png_ptr, "Invalid oFFs after IDAT"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) -- { -- png_warning(png_ptr, "Duplicate oFFs chunk"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- if (length != 9) -- { -- png_warning(png_ptr, "Incorrect oFFs chunk length"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- png_crc_read(png_ptr, buf, 9); -- if (png_crc_finish(png_ptr, 0)) -- return; -- -- offset_x = png_get_int_32(buf); -- offset_y = png_get_int_32(buf + 4); -- unit_type = buf[8]; -- png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type); --} --#endif -- --#if defined(PNG_READ_pCAL_SUPPORTED) --/* read the pCAL chunk (described in the PNG Extensions document) */ --void /* PRIVATE */ --png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_charp purpose; -- png_int_32 X0, X1; -- png_byte type, nparams; -- png_charp buf, units, endptr; -- png_charpp params; -- png_size_t slength; -- int i; -- -- png_debug(1, "in png_handle_pCAL\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before pCAL"); -- else if (png_ptr->mode & PNG_HAVE_IDAT) -- { -- png_warning(png_ptr, "Invalid pCAL after IDAT"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)) -- { -- png_warning(png_ptr, "Duplicate pCAL chunk"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- png_debug1(2, "Allocating and reading pCAL chunk data (%lu bytes)\n", -- length + 1); -- purpose = (png_charp)png_malloc_warn(png_ptr, length + 1); -- if (purpose == NULL) -- { -- png_warning(png_ptr, "No memory for pCAL purpose."); -- return; -- } -- slength = (png_size_t)length; -- png_crc_read(png_ptr, (png_bytep)purpose, slength); -- -- if (png_crc_finish(png_ptr, 0)) -- { -- png_free(png_ptr, purpose); -- return; -- } -- -- purpose[slength] = 0x00; /* null terminate the last string */ -- -- png_debug(3, "Finding end of pCAL purpose string\n"); -- for (buf = purpose; *buf; buf++) -- /* empty loop */ ; -- -- endptr = purpose + slength; -- -- /* We need to have at least 12 bytes after the purpose string -- in order to get the parameter information. */ -- if (endptr <= buf + 12) -- { -- png_warning(png_ptr, "Invalid pCAL data"); -- png_free(png_ptr, purpose); -- return; -- } -- -- png_debug(3, "Reading pCAL X0, X1, type, nparams, and units\n"); -- X0 = png_get_int_32((png_bytep)buf+1); -- X1 = png_get_int_32((png_bytep)buf+5); -- type = buf[9]; -- nparams = buf[10]; -- units = buf + 11; -- -- png_debug(3, "Checking pCAL equation type and number of parameters\n"); -- /* Check that we have the right number of parameters for known -- equation types. */ -- if ((type == PNG_EQUATION_LINEAR && nparams != 2) || -- (type == PNG_EQUATION_BASE_E && nparams != 3) || -- (type == PNG_EQUATION_ARBITRARY && nparams != 3) || -- (type == PNG_EQUATION_HYPERBOLIC && nparams != 4)) -- { -- png_warning(png_ptr, "Invalid pCAL parameters for equation type"); -- png_free(png_ptr, purpose); -- return; -- } -- else if (type >= PNG_EQUATION_LAST) -- { -- png_warning(png_ptr, "Unrecognized equation type for pCAL chunk"); -- } -- -- for (buf = units; *buf; buf++) -- /* Empty loop to move past the units string. */ ; -- -- png_debug(3, "Allocating pCAL parameters array\n"); -- params = (png_charpp)png_malloc_warn(png_ptr, (png_uint_32)(nparams -- *png_sizeof(png_charp))) ; -- if (params == NULL) -- { -- png_free(png_ptr, purpose); -- png_warning(png_ptr, "No memory for pCAL params."); -- return; -- } -- -- /* Get pointers to the start of each parameter string. */ -- for (i = 0; i < (int)nparams; i++) -- { -- buf++; /* Skip the null string terminator from previous parameter. */ -- -- png_debug1(3, "Reading pCAL parameter %d\n", i); -- for (params[i] = buf; *buf != 0x00 && buf <= endptr; buf++) -- /* Empty loop to move past each parameter string */ ; -- -- /* Make sure we haven't run out of data yet */ -- if (buf > endptr) -- { -- png_warning(png_ptr, "Invalid pCAL data"); -- png_free(png_ptr, purpose); -- png_free(png_ptr, params); -- return; -- } -- } -- -- png_set_pCAL(png_ptr, info_ptr, purpose, X0, X1, type, nparams, -- units, params); -- -- png_free(png_ptr, purpose); -- png_free(png_ptr, params); --} --#endif -- --#if defined(PNG_READ_sCAL_SUPPORTED) --/* read the sCAL chunk */ --void /* PRIVATE */ --png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_charp buffer, ep; --#ifdef PNG_FLOATING_POINT_SUPPORTED -- double width, height; -- png_charp vp; --#else --#ifdef PNG_FIXED_POINT_SUPPORTED -- png_charp swidth, sheight; --#endif --#endif -- png_size_t slength; -- -- png_debug(1, "in png_handle_sCAL\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before sCAL"); -- else if (png_ptr->mode & PNG_HAVE_IDAT) -- { -- png_warning(png_ptr, "Invalid sCAL after IDAT"); -- png_crc_finish(png_ptr, length); -- return; -- } -- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL)) -- { -- png_warning(png_ptr, "Duplicate sCAL chunk"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)\n", -- length + 1); -- buffer = (png_charp)png_malloc_warn(png_ptr, length + 1); -- if (buffer == NULL) -- { -- png_warning(png_ptr, "Out of memory while processing sCAL chunk"); -- return; -- } -- slength = (png_size_t)length; -- png_crc_read(png_ptr, (png_bytep)buffer, slength); -- -- if (png_crc_finish(png_ptr, 0)) -- { -- png_free(png_ptr, buffer); -- return; -- } -- -- buffer[slength] = 0x00; /* null terminate the last string */ -- -- ep = buffer + 1; /* skip unit byte */ -- --#ifdef PNG_FLOATING_POINT_SUPPORTED -- width = strtod(ep, &vp); -- if (*vp) -- { -- png_warning(png_ptr, "malformed width string in sCAL chunk"); -- return; -- } --#else --#ifdef PNG_FIXED_POINT_SUPPORTED -- swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1); -- if (swidth == NULL) -- { -- png_warning(png_ptr, "Out of memory while processing sCAL chunk width"); -- return; -- } -- png_memcpy(swidth, ep, (png_size_t)png_strlen(ep)); --#endif --#endif -- -- for (ep = buffer; *ep; ep++) -- /* empty loop */ ; -- ep++; -- --#ifdef PNG_FLOATING_POINT_SUPPORTED -- height = strtod(ep, &vp); -- if (*vp) -- { -- png_warning(png_ptr, "malformed height string in sCAL chunk"); -- return; -- } --#else --#ifdef PNG_FIXED_POINT_SUPPORTED -- sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1); -- if (swidth == NULL) -- { -- png_warning(png_ptr, "Out of memory while processing sCAL chunk height"); -- return; -- } -- png_memcpy(sheight, ep, (png_size_t)png_strlen(ep)); --#endif --#endif -- -- if (buffer + slength < ep --#ifdef PNG_FLOATING_POINT_SUPPORTED -- || width <= 0. || height <= 0. --#endif -- ) -- { -- png_warning(png_ptr, "Invalid sCAL data"); -- png_free(png_ptr, buffer); --#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) -- png_free(png_ptr, swidth); -- png_free(png_ptr, sheight); --#endif -- return; -- } -- -- --#ifdef PNG_FLOATING_POINT_SUPPORTED -- png_set_sCAL(png_ptr, info_ptr, buffer[0], width, height); --#else --#ifdef PNG_FIXED_POINT_SUPPORTED -- png_set_sCAL_s(png_ptr, info_ptr, buffer[0], swidth, sheight); --#endif --#endif -- -- png_free(png_ptr, buffer); --#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) -- png_free(png_ptr, swidth); -- png_free(png_ptr, sheight); --#endif --} --#endif -- --#if defined(PNG_READ_tIME_SUPPORTED) --void /* PRIVATE */ --png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_byte buf[7]; -- png_time mod_time; -- -- png_debug(1, "in png_handle_tIME\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Out of place tIME chunk"); -- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)) -- { -- png_warning(png_ptr, "Duplicate tIME chunk"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- if (png_ptr->mode & PNG_HAVE_IDAT) -- png_ptr->mode |= PNG_AFTER_IDAT; -- -- if (length != 7) -- { -- png_warning(png_ptr, "Incorrect tIME chunk length"); -- png_crc_finish(png_ptr, length); -- return; -- } -- -- png_crc_read(png_ptr, buf, 7); -- if (png_crc_finish(png_ptr, 0)) -- return; -- -- mod_time.second = buf[6]; -- mod_time.minute = buf[5]; -- mod_time.hour = buf[4]; -- mod_time.day = buf[3]; -- mod_time.month = buf[2]; -- mod_time.year = png_get_uint_16(buf); -- -- png_set_tIME(png_ptr, info_ptr, &mod_time); --} --#endif -- --#if defined(PNG_READ_tEXt_SUPPORTED) --/* Note: this does not properly handle chunks that are > 64K under DOS */ --void /* PRIVATE */ --png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_textp text_ptr; -- png_charp key; -- png_charp text; -- png_uint_32 skip = 0; -- png_size_t slength; -- int ret; -- -- png_debug(1, "in png_handle_tEXt\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before tEXt"); -- -- if (png_ptr->mode & PNG_HAVE_IDAT) -- png_ptr->mode |= PNG_AFTER_IDAT; -- --#ifdef PNG_MAX_MALLOC_64K -- if (length > (png_uint_32)65535L) -- { -- png_warning(png_ptr, "tEXt chunk too large to fit in memory"); -- skip = length - (png_uint_32)65535L; -- length = (png_uint_32)65535L; -- } --#endif -- -- key = (png_charp)png_malloc_warn(png_ptr, length + 1); -- if (key == NULL) -- { -- png_warning(png_ptr, "No memory to process text chunk."); -- return; -- } -- slength = (png_size_t)length; -- png_crc_read(png_ptr, (png_bytep)key, slength); -- -- if (png_crc_finish(png_ptr, skip)) -- { -- png_free(png_ptr, key); -- return; -- } -- -- key[slength] = 0x00; -- -- for (text = key; *text; text++) -- /* empty loop to find end of key */ ; -- -- if (text != key + slength) -- text++; -- -- text_ptr = (png_textp)png_malloc_warn(png_ptr, -- (png_uint_32)png_sizeof(png_text)); -- if (text_ptr == NULL) -- { -- png_warning(png_ptr, "Not enough memory to process text chunk."); -- png_free(png_ptr, key); -- return; -- } -- text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; -- text_ptr->key = key; --#ifdef PNG_iTXt_SUPPORTED -- text_ptr->lang = NULL; -- text_ptr->lang_key = NULL; -- text_ptr->itxt_length = 0; --#endif -- text_ptr->text = text; -- text_ptr->text_length = png_strlen(text); -- -- ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1); -- -- png_free(png_ptr, key); -- png_free(png_ptr, text_ptr); -- if (ret) -- png_warning(png_ptr, "Insufficient memory to process text chunk."); --} --#endif -- --#if defined(PNG_READ_zTXt_SUPPORTED) --/* note: this does not correctly handle chunks that are > 64K under DOS */ --void /* PRIVATE */ --png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_textp text_ptr; -- png_charp chunkdata; -- png_charp text; -- int comp_type; -- int ret; -- png_size_t slength, prefix_len, data_len; -- -- png_debug(1, "in png_handle_zTXt\n"); -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before zTXt"); -- -- if (png_ptr->mode & PNG_HAVE_IDAT) -- png_ptr->mode |= PNG_AFTER_IDAT; -- --#ifdef PNG_MAX_MALLOC_64K -- /* We will no doubt have problems with chunks even half this size, but -- there is no hard and fast rule to tell us where to stop. */ -- if (length > (png_uint_32)65535L) -- { -- png_warning(png_ptr,"zTXt chunk too large to fit in memory"); -- png_crc_finish(png_ptr, length); -- return; -- } --#endif -- -- chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); -- if (chunkdata == NULL) -- { -- png_warning(png_ptr,"Out of memory processing zTXt chunk."); -- return; -- } -- slength = (png_size_t)length; -- png_crc_read(png_ptr, (png_bytep)chunkdata, slength); -- if (png_crc_finish(png_ptr, 0)) -- { -- png_free(png_ptr, chunkdata); -- return; -- } -- -- chunkdata[slength] = 0x00; -- -- for (text = chunkdata; *text; text++) -- /* empty loop */ ; -- -- /* zTXt must have some text after the chunkdataword */ -- if (text == chunkdata + slength) -- { -- comp_type = PNG_TEXT_COMPRESSION_NONE; -- png_warning(png_ptr, "Zero length zTXt chunk"); -- } -- else -- { -- comp_type = *(++text); -- if (comp_type != PNG_TEXT_COMPRESSION_zTXt) -- { -- png_warning(png_ptr, "Unknown compression type in zTXt chunk"); -- comp_type = PNG_TEXT_COMPRESSION_zTXt; -- } -- text++; /* skip the compression_method byte */ -- } -- prefix_len = text - chunkdata; -- -- chunkdata = (png_charp)png_decompress_chunk(png_ptr, comp_type, chunkdata, -- (png_size_t)length, prefix_len, &data_len); -- -- text_ptr = (png_textp)png_malloc_warn(png_ptr, -- (png_uint_32)png_sizeof(png_text)); -- if (text_ptr == NULL) -- { -- png_warning(png_ptr,"Not enough memory to process zTXt chunk."); -- png_free(png_ptr, chunkdata); -- return; -- } -- text_ptr->compression = comp_type; -- text_ptr->key = chunkdata; --#ifdef PNG_iTXt_SUPPORTED -- text_ptr->lang = NULL; -- text_ptr->lang_key = NULL; -- text_ptr->itxt_length = 0; --#endif -- text_ptr->text = chunkdata + prefix_len; -- text_ptr->text_length = data_len; -- -- ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1); -- -- png_free(png_ptr, text_ptr); -- png_free(png_ptr, chunkdata); -- if (ret) -- png_error(png_ptr, "Insufficient memory to store zTXt chunk."); --} --#endif -- --#if defined(PNG_READ_iTXt_SUPPORTED) --/* note: this does not correctly handle chunks that are > 64K under DOS */ --void /* PRIVATE */ --png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_textp text_ptr; -- png_charp chunkdata; -- png_charp key, lang, text, lang_key; -- int comp_flag; -- int comp_type = 0; -- int ret; -- png_size_t slength, prefix_len, data_len; -- -- png_debug(1, "in png_handle_iTXt\n"); -- -- if (!(png_ptr->mode & PNG_HAVE_IHDR)) -- png_error(png_ptr, "Missing IHDR before iTXt"); -- -- if (png_ptr->mode & PNG_HAVE_IDAT) -- png_ptr->mode |= PNG_AFTER_IDAT; -- --#ifdef PNG_MAX_MALLOC_64K -- /* We will no doubt have problems with chunks even half this size, but -- there is no hard and fast rule to tell us where to stop. */ -- if (length > (png_uint_32)65535L) -- { -- png_warning(png_ptr,"iTXt chunk too large to fit in memory"); -- png_crc_finish(png_ptr, length); -- return; -- } --#endif -- -- chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); -- if (chunkdata == NULL) -- { -- png_warning(png_ptr, "No memory to process iTXt chunk."); -- return; -- } -- slength = (png_size_t)length; -- png_crc_read(png_ptr, (png_bytep)chunkdata, slength); -- if (png_crc_finish(png_ptr, 0)) -- { -- png_free(png_ptr, chunkdata); -- return; -- } -- -- chunkdata[slength] = 0x00; -- -- for (lang = chunkdata; *lang; lang++) -- /* empty loop */ ; -- lang++; /* skip NUL separator */ -- -- /* iTXt must have a language tag (possibly empty), two compression bytes, -- translated keyword (possibly empty), and possibly some text after the -- keyword */ -- -- if (lang >= chunkdata + slength) -- { -- comp_flag = PNG_TEXT_COMPRESSION_NONE; -- png_warning(png_ptr, "Zero length iTXt chunk"); -- } -- else -- { -- comp_flag = *lang++; -- comp_type = *lang++; -- } -- -- for (lang_key = lang; *lang_key; lang_key++) -- /* empty loop */ ; -- lang_key++; /* skip NUL separator */ -- -- for (text = lang_key; *text; text++) -- /* empty loop */ ; -- text++; /* skip NUL separator */ -- -- prefix_len = text - chunkdata; -- -- key=chunkdata; -- if (comp_flag) -- chunkdata = png_decompress_chunk(png_ptr, comp_type, chunkdata, -- (size_t)length, prefix_len, &data_len); -- else -- data_len=png_strlen(chunkdata + prefix_len); -- text_ptr = (png_textp)png_malloc_warn(png_ptr, -- (png_uint_32)png_sizeof(png_text)); -- if (text_ptr == NULL) -- { -- png_warning(png_ptr,"Not enough memory to process iTXt chunk."); -- png_free(png_ptr, chunkdata); -- return; -- } -- text_ptr->compression = (int)comp_flag + 1; -- text_ptr->lang_key = chunkdata+(lang_key-key); -- text_ptr->lang = chunkdata+(lang-key); -- text_ptr->itxt_length = data_len; -- text_ptr->text_length = 0; -- text_ptr->key = chunkdata; -- text_ptr->text = chunkdata + prefix_len; -- -- ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1); -- -- png_free(png_ptr, text_ptr); -- png_free(png_ptr, chunkdata); -- if (ret) -- png_error(png_ptr, "Insufficient memory to store iTXt chunk."); --} --#endif -- --/* This function is called when we haven't found a handler for a -- chunk. If there isn't a problem with the chunk itself (ie bad -- chunk name, CRC, or a critical chunk), the chunk is silently ignored -- -- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which -- case it will be saved away to be written out later. */ --void /* PRIVATE */ --png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) --{ -- png_uint_32 skip = 0; -- -- png_debug(1, "in png_handle_unknown\n"); -- -- if (png_ptr->mode & PNG_HAVE_IDAT) -- { --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_IDAT; --#endif -- if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* not an IDAT */ -- png_ptr->mode |= PNG_AFTER_IDAT; -- } -- -- png_check_chunk_name(png_ptr, png_ptr->chunk_name); -- -- if (!(png_ptr->chunk_name[0] & 0x20)) -- { --#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) -- if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != -- PNG_HANDLE_CHUNK_ALWAYS --#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) -- && png_ptr->read_user_chunk_fn == NULL --#endif -- ) --#endif -- png_chunk_error(png_ptr, "unknown critical chunk"); -- } -- --#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) -- if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) -- { -- png_unknown_chunk chunk; -- --#ifdef PNG_MAX_MALLOC_64K -- if (length > (png_uint_32)65535L) -- { -- png_warning(png_ptr, "unknown chunk too large to fit in memory"); -- skip = length - (png_uint_32)65535L; -- length = (png_uint_32)65535L; -- } --#endif -- png_strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name); -- chunk.data = (png_bytep)png_malloc(png_ptr, length); -- chunk.size = (png_size_t)length; -- png_crc_read(png_ptr, (png_bytep)chunk.data, length); --#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) -- if(png_ptr->read_user_chunk_fn != NULL) -- { -- /* callback to user unknown chunk handler */ -- if ((*(png_ptr->read_user_chunk_fn)) (png_ptr, &chunk) <= 0) -- { -- if (!(png_ptr->chunk_name[0] & 0x20)) -- if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != -- PNG_HANDLE_CHUNK_ALWAYS) -- { -- png_free(png_ptr, chunk.data); -- png_chunk_error(png_ptr, "unknown critical chunk"); -- } -- png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); -- } -- } -- else --#endif -- png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); -- png_free(png_ptr, chunk.data); -- } -- else --#endif -- skip = length; -- -- png_crc_finish(png_ptr, skip); -- --#if !defined(PNG_READ_USER_CHUNKS_SUPPORTED) -- if (&info_ptr == NULL) /* quiet compiler warnings about unused info_ptr */ -- return; --#endif --} -- --/* This function is called to verify that a chunk name is valid. -- This function can't have the "critical chunk check" incorporated -- into it, since in the future we will need to be able to call user -- functions to handle unknown critical chunks after we check that -- the chunk name itself is valid. */ -- --#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97)) -- --void /* PRIVATE */ --png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name) --{ -- png_debug(1, "in png_check_chunk_name\n"); -- if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) || -- isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3])) -- { -- png_chunk_error(png_ptr, "invalid chunk type"); -- } --} -- --/* Combines the row recently read in with the existing pixels in the -- row. This routine takes care of alpha and transparency if requested. -- This routine also handles the two methods of progressive display -- of interlaced images, depending on the mask value. -- The mask value describes which pixels are to be combined with -- the row. The pattern always repeats every 8 pixels, so just 8 -- bits are needed. A one indicates the pixel is to be combined, -- a zero indicates the pixel is to be skipped. This is in addition -- to any alpha or transparency value associated with the pixel. If -- you want all pixels to be combined, pass 0xff (255) in mask. */ --#ifndef PNG_HAVE_ASSEMBLER_COMBINE_ROW --void /* PRIVATE */ --png_combine_row(png_structp png_ptr, png_bytep row, int mask) --{ -- png_debug(1,"in png_combine_row\n"); -- if (mask == 0xff) -- { -- png_memcpy(row, png_ptr->row_buf + 1, -- PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width)); -- } -- else -- { -- switch (png_ptr->row_info.pixel_depth) -- { -- case 1: -- { -- png_bytep sp = png_ptr->row_buf + 1; -- png_bytep dp = row; -- int s_inc, s_start, s_end; -- int m = 0x80; -- int shift; -- png_uint_32 i; -- png_uint_32 row_width = png_ptr->width; -- --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_PACKSWAP) -- { -- s_start = 0; -- s_end = 7; -- s_inc = 1; -- } -- else --#endif -- { -- s_start = 7; -- s_end = 0; -- s_inc = -1; -- } -- -- shift = s_start; -- -- for (i = 0; i < row_width; i++) -- { -- if (m & mask) -- { -- int value; -- -- value = (*sp >> shift) & 0x01; -- *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); -- *dp |= (png_byte)(value << shift); -- } -- -- if (shift == s_end) -- { -- shift = s_start; -- sp++; -- dp++; -- } -- else -- shift += s_inc; -- -- if (m == 1) -- m = 0x80; -- else -- m >>= 1; -- } -- break; -- } -- case 2: -- { -- png_bytep sp = png_ptr->row_buf + 1; -- png_bytep dp = row; -- int s_start, s_end, s_inc; -- int m = 0x80; -- int shift; -- png_uint_32 i; -- png_uint_32 row_width = png_ptr->width; -- int value; -- --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_PACKSWAP) -- { -- s_start = 0; -- s_end = 6; -- s_inc = 2; -- } -- else --#endif -- { -- s_start = 6; -- s_end = 0; -- s_inc = -2; -- } -- -- shift = s_start; -- -- for (i = 0; i < row_width; i++) -- { -- if (m & mask) -- { -- value = (*sp >> shift) & 0x03; -- *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); -- *dp |= (png_byte)(value << shift); -- } -- -- if (shift == s_end) -- { -- shift = s_start; -- sp++; -- dp++; -- } -- else -- shift += s_inc; -- if (m == 1) -- m = 0x80; -- else -- m >>= 1; -- } -- break; -- } -- case 4: -- { -- png_bytep sp = png_ptr->row_buf + 1; -- png_bytep dp = row; -- int s_start, s_end, s_inc; -- int m = 0x80; -- int shift; -- png_uint_32 i; -- png_uint_32 row_width = png_ptr->width; -- int value; -- --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_PACKSWAP) -- { -- s_start = 0; -- s_end = 4; -- s_inc = 4; -- } -- else --#endif -- { -- s_start = 4; -- s_end = 0; -- s_inc = -4; -- } -- shift = s_start; -- -- for (i = 0; i < row_width; i++) -- { -- if (m & mask) -- { -- value = (*sp >> shift) & 0xf; -- *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); -- *dp |= (png_byte)(value << shift); -- } -- -- if (shift == s_end) -- { -- shift = s_start; -- sp++; -- dp++; -- } -- else -- shift += s_inc; -- if (m == 1) -- m = 0x80; -- else -- m >>= 1; -- } -- break; -- } -- default: -- { -- png_bytep sp = png_ptr->row_buf + 1; -- png_bytep dp = row; -- png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); -- png_uint_32 i; -- png_uint_32 row_width = png_ptr->width; -- png_byte m = 0x80; -- -- -- for (i = 0; i < row_width; i++) -- { -- if (m & mask) -- { -- png_memcpy(dp, sp, pixel_bytes); -- } -- -- sp += pixel_bytes; -- dp += pixel_bytes; -- -- if (m == 1) -- m = 0x80; -- else -- m >>= 1; -- } -- break; -- } -- } -- } --} --#endif /* !PNG_HAVE_ASSEMBLER_COMBINE_ROW */ -- --#ifdef PNG_READ_INTERLACING_SUPPORTED --#ifndef PNG_HAVE_ASSEMBLER_READ_INTERLACE /* else in pngvcrd.c, pnggccrd.c */ --/* OLD pre-1.0.9 interface: --void png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass, -- png_uint_32 transformations) -- */ --void /* PRIVATE */ --png_do_read_interlace(png_structp png_ptr) --{ -- png_row_infop row_info = &(png_ptr->row_info); -- png_bytep row = png_ptr->row_buf + 1; -- int pass = png_ptr->pass; -- png_uint_32 transformations = png_ptr->transformations; --#ifdef PNG_USE_LOCAL_ARRAYS -- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ -- /* offset to next interlace block */ -- const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; --#endif -- -- png_debug(1,"in png_do_read_interlace (stock C version)\n"); -- if (row != NULL && row_info != NULL) -- { -- png_uint_32 final_width; -- -- final_width = row_info->width * png_pass_inc[pass]; -- -- switch (row_info->pixel_depth) -- { -- case 1: -- { -- png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3); -- png_bytep dp = row + (png_size_t)((final_width - 1) >> 3); -- int sshift, dshift; -- int s_start, s_end, s_inc; -- int jstop = png_pass_inc[pass]; -- png_byte v; -- png_uint_32 i; -- int j; -- --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (transformations & PNG_PACKSWAP) -- { -- sshift = (int)((row_info->width + 7) & 0x07); -- dshift = (int)((final_width + 7) & 0x07); -- s_start = 7; -- s_end = 0; -- s_inc = -1; -- } -- else --#endif -- { -- sshift = 7 - (int)((row_info->width + 7) & 0x07); -- dshift = 7 - (int)((final_width + 7) & 0x07); -- s_start = 0; -- s_end = 7; -- s_inc = 1; -- } -- -- for (i = 0; i < row_info->width; i++) -- { -- v = (png_byte)((*sp >> sshift) & 0x01); -- for (j = 0; j < jstop; j++) -- { -- *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff); -- *dp |= (png_byte)(v << dshift); -- if (dshift == s_end) -- { -- dshift = s_start; -- dp--; -- } -- else -- dshift += s_inc; -- } -- if (sshift == s_end) -- { -- sshift = s_start; -- sp--; -- } -- else -- sshift += s_inc; -- } -- break; -- } -- case 2: -- { -- png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2); -- png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2); -- int sshift, dshift; -- int s_start, s_end, s_inc; -- int jstop = png_pass_inc[pass]; -- png_uint_32 i; -- --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (transformations & PNG_PACKSWAP) -- { -- sshift = (int)(((row_info->width + 3) & 0x03) << 1); -- dshift = (int)(((final_width + 3) & 0x03) << 1); -- s_start = 6; -- s_end = 0; -- s_inc = -2; -- } -- else --#endif -- { -- sshift = (int)((3 - ((row_info->width + 3) & 0x03)) << 1); -- dshift = (int)((3 - ((final_width + 3) & 0x03)) << 1); -- s_start = 0; -- s_end = 6; -- s_inc = 2; -- } -- -- for (i = 0; i < row_info->width; i++) -- { -- png_byte v; -- int j; -- -- v = (png_byte)((*sp >> sshift) & 0x03); -- for (j = 0; j < jstop; j++) -- { -- *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff); -- *dp |= (png_byte)(v << dshift); -- if (dshift == s_end) -- { -- dshift = s_start; -- dp--; -- } -- else -- dshift += s_inc; -- } -- if (sshift == s_end) -- { -- sshift = s_start; -- sp--; -- } -- else -- sshift += s_inc; -- } -- break; -- } -- case 4: -- { -- png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1); -- png_bytep dp = row + (png_size_t)((final_width - 1) >> 1); -- int sshift, dshift; -- int s_start, s_end, s_inc; -- png_uint_32 i; -- int jstop = png_pass_inc[pass]; -- --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (transformations & PNG_PACKSWAP) -- { -- sshift = (int)(((row_info->width + 1) & 0x01) << 2); -- dshift = (int)(((final_width + 1) & 0x01) << 2); -- s_start = 4; -- s_end = 0; -- s_inc = -4; -- } -- else --#endif -- { -- sshift = (int)((1 - ((row_info->width + 1) & 0x01)) << 2); -- dshift = (int)((1 - ((final_width + 1) & 0x01)) << 2); -- s_start = 0; -- s_end = 4; -- s_inc = 4; -- } -- -- for (i = 0; i < row_info->width; i++) -- { -- png_byte v = (png_byte)((*sp >> sshift) & 0xf); -- int j; -- -- for (j = 0; j < jstop; j++) -- { -- *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff); -- *dp |= (png_byte)(v << dshift); -- if (dshift == s_end) -- { -- dshift = s_start; -- dp--; -- } -- else -- dshift += s_inc; -- } -- if (sshift == s_end) -- { -- sshift = s_start; -- sp--; -- } -- else -- sshift += s_inc; -- } -- break; -- } -- default: -- { -- png_size_t pixel_bytes = (row_info->pixel_depth >> 3); -- png_bytep sp = row + (png_size_t)(row_info->width - 1) * pixel_bytes; -- png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes; -- -- int jstop = png_pass_inc[pass]; -- png_uint_32 i; -- -- for (i = 0; i < row_info->width; i++) -- { -- png_byte v[8]; -- int j; -- -- png_memcpy(v, sp, pixel_bytes); -- for (j = 0; j < jstop; j++) -- { -- png_memcpy(dp, v, pixel_bytes); -- dp -= pixel_bytes; -- } -- sp -= pixel_bytes; -- } -- break; -- } -- } -- row_info->width = final_width; -- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,final_width); -- } --#if !defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (&transformations == NULL) /* silence compiler warning */ -- return; --#endif --} --#endif /* !PNG_HAVE_ASSEMBLER_READ_INTERLACE */ --#endif /* PNG_READ_INTERLACING_SUPPORTED */ -- --#ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW --void /* PRIVATE */ --png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row, -- png_bytep prev_row, int filter) --{ -- png_debug(1, "in png_read_filter_row\n"); -- png_debug2(2,"row = %lu, filter = %d\n", png_ptr->row_number, filter); -- switch (filter) -- { -- case PNG_FILTER_VALUE_NONE: -- break; -- case PNG_FILTER_VALUE_SUB: -- { -- png_uint_32 i; -- png_uint_32 istop = row_info->rowbytes; -- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; -- png_bytep rp = row + bpp; -- png_bytep lp = row; -- -- for (i = bpp; i < istop; i++) -- { -- *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff); -- rp++; -- } -- break; -- } -- case PNG_FILTER_VALUE_UP: -- { -- png_uint_32 i; -- png_uint_32 istop = row_info->rowbytes; -- png_bytep rp = row; -- png_bytep pp = prev_row; -- -- for (i = 0; i < istop; i++) -- { -- *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); -- rp++; -- } -- break; -- } -- case PNG_FILTER_VALUE_AVG: -- { -- png_uint_32 i; -- png_bytep rp = row; -- png_bytep pp = prev_row; -- png_bytep lp = row; -- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; -- png_uint_32 istop = row_info->rowbytes - bpp; -- -- for (i = 0; i < bpp; i++) -- { -- *rp = (png_byte)(((int)(*rp) + -- ((int)(*pp++) / 2 )) & 0xff); -- rp++; -- } -- -- for (i = 0; i < istop; i++) -- { -- *rp = (png_byte)(((int)(*rp) + -- (int)(*pp++ + *lp++) / 2 ) & 0xff); -- rp++; -- } -- break; -- } -- case PNG_FILTER_VALUE_PAETH: -- { -- png_uint_32 i; -- png_bytep rp = row; -- png_bytep pp = prev_row; -- png_bytep lp = row; -- png_bytep cp = prev_row; -- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; -- png_uint_32 istop=row_info->rowbytes - bpp; -- -- for (i = 0; i < bpp; i++) -- { -- *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); -- rp++; -- } -- -- for (i = 0; i < istop; i++) /* use leftover rp,pp */ -- { -- int a, b, c, pa, pb, pc, p; -- -- a = *lp++; -- b = *pp++; -- c = *cp++; -- -- p = b - c; -- pc = a - c; -- --#ifdef PNG_USE_ABS -- pa = abs(p); -- pb = abs(pc); -- pc = abs(p + pc); --#else -- pa = p < 0 ? -p : p; -- pb = pc < 0 ? -pc : pc; -- pc = (p + pc) < 0 ? -(p + pc) : p + pc; --#endif -- -- /* -- if (pa <= pb && pa <= pc) -- p = a; -- else if (pb <= pc) -- p = b; -- else -- p = c; -- */ -- -- p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; -- -- *rp = (png_byte)(((int)(*rp) + p) & 0xff); -- rp++; -- } -- break; -- } -- default: -- png_warning(png_ptr, "Ignoring bad adaptive filter type"); -- *row=0; -- break; -- } --} --#endif /* !PNG_HAVE_ASSEMBLER_READ_FILTER_ROW */ -- --void /* PRIVATE */ --png_read_finish_row(png_structp png_ptr) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ -- -- /* start of interlace block */ -- const int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; -- -- /* offset to next interlace block */ -- const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; -- -- /* start of interlace block in the y direction */ -- const int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; -- -- /* offset to next interlace block in the y direction */ -- const int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; --#endif -- -- png_debug(1, "in png_read_finish_row\n"); -- png_ptr->row_number++; -- if (png_ptr->row_number < png_ptr->num_rows) -- return; -- -- if (png_ptr->interlaced) -- { -- png_ptr->row_number = 0; -- png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1); -- do -- { -- png_ptr->pass++; -- if (png_ptr->pass >= 7) -- break; -- png_ptr->iwidth = (png_ptr->width + -- png_pass_inc[png_ptr->pass] - 1 - -- png_pass_start[png_ptr->pass]) / -- png_pass_inc[png_ptr->pass]; -- -- png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, -- png_ptr->iwidth) + 1; -- -- if (!(png_ptr->transformations & PNG_INTERLACE)) -- { -- png_ptr->num_rows = (png_ptr->height + -- png_pass_yinc[png_ptr->pass] - 1 - -- png_pass_ystart[png_ptr->pass]) / -- png_pass_yinc[png_ptr->pass]; -- if (!(png_ptr->num_rows)) -- continue; -- } -- else /* if (png_ptr->transformations & PNG_INTERLACE) */ -- break; -- } while (png_ptr->iwidth == 0); -- -- if (png_ptr->pass < 7) -- return; -- } -- -- if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) -- { --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_IDAT; --#endif -- char extra; -- int ret; -- -- png_ptr->zstream.next_out = (Byte *)&extra; -- png_ptr->zstream.avail_out = (uInt)1; -- for(;;) -- { -- if (!(png_ptr->zstream.avail_in)) -- { -- while (!png_ptr->idat_size) -- { -- png_byte chunk_length[4]; -- -- png_crc_finish(png_ptr, 0); -- -- png_read_data(png_ptr, chunk_length, 4); -- png_ptr->idat_size = png_get_uint_31(png_ptr, chunk_length); -- png_reset_crc(png_ptr); -- png_crc_read(png_ptr, png_ptr->chunk_name, 4); -- if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4)) -- png_error(png_ptr, "Not enough image data"); -- -- } -- png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; -- png_ptr->zstream.next_in = png_ptr->zbuf; -- if (png_ptr->zbuf_size > png_ptr->idat_size) -- png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; -- png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in); -- png_ptr->idat_size -= png_ptr->zstream.avail_in; -- } -- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); -- if (ret == Z_STREAM_END) -- { -- if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in || -- png_ptr->idat_size) -- png_warning(png_ptr, "Extra compressed data"); -- png_ptr->mode |= PNG_AFTER_IDAT; -- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; -- break; -- } -- if (ret != Z_OK) -- png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : -- "Decompression Error"); -- -- if (!(png_ptr->zstream.avail_out)) -- { -- png_warning(png_ptr, "Extra compressed data."); -- png_ptr->mode |= PNG_AFTER_IDAT; -- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; -- break; -- } -- -- } -- png_ptr->zstream.avail_out = 0; -- } -- -- if (png_ptr->idat_size || png_ptr->zstream.avail_in) -- png_warning(png_ptr, "Extra compression data"); -- -- inflateReset(&png_ptr->zstream); -- -- png_ptr->mode |= PNG_AFTER_IDAT; --} -- --void /* PRIVATE */ --png_read_start_row(png_structp png_ptr) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ -- -- /* start of interlace block */ -- const int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; -- -- /* offset to next interlace block */ -- const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; -- -- /* start of interlace block in the y direction */ -- const int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; -- -- /* offset to next interlace block in the y direction */ -- const int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; --#endif -- -- int max_pixel_depth; -- png_uint_32 row_bytes; -- -- png_debug(1, "in png_read_start_row\n"); -- png_ptr->zstream.avail_in = 0; -- png_init_read_transformations(png_ptr); -- if (png_ptr->interlaced) -- { -- if (!(png_ptr->transformations & PNG_INTERLACE)) -- png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 - -- png_pass_ystart[0]) / png_pass_yinc[0]; -- else -- png_ptr->num_rows = png_ptr->height; -- -- png_ptr->iwidth = (png_ptr->width + -- png_pass_inc[png_ptr->pass] - 1 - -- png_pass_start[png_ptr->pass]) / -- png_pass_inc[png_ptr->pass]; -- -- row_bytes = PNG_ROWBYTES(png_ptr->pixel_depth,png_ptr->iwidth) + 1; -- -- png_ptr->irowbytes = (png_size_t)row_bytes; -- if((png_uint_32)png_ptr->irowbytes != row_bytes) -- png_error(png_ptr, "Rowbytes overflow in png_read_start_row"); -- } -- else -- { -- png_ptr->num_rows = png_ptr->height; -- png_ptr->iwidth = png_ptr->width; -- png_ptr->irowbytes = png_ptr->rowbytes + 1; -- } -- max_pixel_depth = png_ptr->pixel_depth; -- --#if defined(PNG_READ_PACK_SUPPORTED) -- if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8) -- max_pixel_depth = 8; --#endif -- --#if defined(PNG_READ_EXPAND_SUPPORTED) -- if (png_ptr->transformations & PNG_EXPAND) -- { -- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- { -- if (png_ptr->num_trans) -- max_pixel_depth = 32; -- else -- max_pixel_depth = 24; -- } -- else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) -- { -- if (max_pixel_depth < 8) -- max_pixel_depth = 8; -- if (png_ptr->num_trans) -- max_pixel_depth *= 2; -- } -- else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) -- { -- if (png_ptr->num_trans) -- { -- max_pixel_depth *= 4; -- max_pixel_depth /= 3; -- } -- } -- } --#endif -- --#if defined(PNG_READ_FILLER_SUPPORTED) -- if (png_ptr->transformations & (PNG_FILLER)) -- { -- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- max_pixel_depth = 32; -- else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) -- { -- if (max_pixel_depth <= 8) -- max_pixel_depth = 16; -- else -- max_pixel_depth = 32; -- } -- else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) -- { -- if (max_pixel_depth <= 32) -- max_pixel_depth = 32; -- else -- max_pixel_depth = 64; -- } -- } --#endif -- --#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) -- if (png_ptr->transformations & PNG_GRAY_TO_RGB) -- { -- if ( --#if defined(PNG_READ_EXPAND_SUPPORTED) -- (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) || --#endif --#if defined(PNG_READ_FILLER_SUPPORTED) -- (png_ptr->transformations & (PNG_FILLER)) || --#endif -- png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) -- { -- if (max_pixel_depth <= 16) -- max_pixel_depth = 32; -- else -- max_pixel_depth = 64; -- } -- else -- { -- if (max_pixel_depth <= 8) -- { -- if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- max_pixel_depth = 32; -- else -- max_pixel_depth = 24; -- } -- else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- max_pixel_depth = 64; -- else -- max_pixel_depth = 48; -- } -- } --#endif -- --#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \ --defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) -- if(png_ptr->transformations & PNG_USER_TRANSFORM) -- { -- int user_pixel_depth=png_ptr->user_transform_depth* -- png_ptr->user_transform_channels; -- if(user_pixel_depth > max_pixel_depth) -- max_pixel_depth=user_pixel_depth; -- } --#endif -- -- /* align the width on the next larger 8 pixels. Mainly used -- for interlacing */ -- row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7)); -- /* calculate the maximum bytes needed, adding a byte and a pixel -- for safety's sake */ -- row_bytes = PNG_ROWBYTES(max_pixel_depth,row_bytes) + -- 1 + ((max_pixel_depth + 7) >> 3); --#ifdef PNG_MAX_MALLOC_64K -- if (row_bytes > (png_uint_32)65536L) -- png_error(png_ptr, "This image requires a row greater than 64KB"); --#endif -- png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes+64); -- png_ptr->row_buf = png_ptr->big_row_buf+32; --#if defined(PNG_DEBUG) && defined(PNG_USE_PNGGCCRD) -- png_ptr->row_buf_size = row_bytes; --#endif -- --#ifdef PNG_MAX_MALLOC_64K -- if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L) -- png_error(png_ptr, "This image requires a row greater than 64KB"); --#endif -- if ((png_uint_32)png_ptr->rowbytes + 1 > PNG_SIZE_MAX) -- png_error(png_ptr, "Row has too many bytes to allocate in memory."); -- png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)( -- png_ptr->rowbytes + 1)); -- -- png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1); -- -- png_debug1(3, "width = %lu,\n", png_ptr->width); -- png_debug1(3, "height = %lu,\n", png_ptr->height); -- png_debug1(3, "iwidth = %lu,\n", png_ptr->iwidth); -- png_debug1(3, "num_rows = %lu\n", png_ptr->num_rows); -- png_debug1(3, "rowbytes = %lu,\n", png_ptr->rowbytes); -- png_debug1(3, "irowbytes = %lu,\n", png_ptr->irowbytes); -- -- png_ptr->flags |= PNG_FLAG_ROW_INIT; --} -diff --git a/thirdparty/libpng/pngset.c b/thirdparty/libpng/pngset.c -deleted file mode 100644 -index b9677a1..0000000 ---- a/thirdparty/libpng/pngset.c -+++ /dev/null -@@ -1,1219 +0,0 @@ -- --/* pngset.c - storage of image information into info struct -- * -- * libpng 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- * -- * The functions here are used during reads to store data from the file -- * into the info struct, and during writes to store application data -- * into the info struct for writing into the file. This abstracts the -- * info struct and allows us to change the structure in the future. -- */ -- --#define PNG_INTERNAL --#include "png.h" -- --#if defined(PNG_bKGD_SUPPORTED) --void PNGAPI --png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background) --{ -- png_debug1(1, "in %s storage function\n", "bKGD"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16)); -- info_ptr->valid |= PNG_INFO_bKGD; --} --#endif -- --#if defined(PNG_cHRM_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED --void PNGAPI --png_set_cHRM(png_structp png_ptr, png_infop info_ptr, -- double white_x, double white_y, double red_x, double red_y, -- double green_x, double green_y, double blue_x, double blue_y) --{ -- png_debug1(1, "in %s storage function\n", "cHRM"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- if (white_x < 0.0 || white_y < 0.0 || -- red_x < 0.0 || red_y < 0.0 || -- green_x < 0.0 || green_y < 0.0 || -- blue_x < 0.0 || blue_y < 0.0) -- { -- png_warning(png_ptr, -- "Ignoring attempt to set negative chromaticity value"); -- return; -- } -- if (white_x > 21474.83 || white_y > 21474.83 || -- red_x > 21474.83 || red_y > 21474.83 || -- green_x > 21474.83 || green_y > 21474.83 || -- blue_x > 21474.83 || blue_y > 21474.83) -- { -- png_warning(png_ptr, -- "Ignoring attempt to set chromaticity value exceeding 21474.83"); -- return; -- } -- -- info_ptr->x_white = (float)white_x; -- info_ptr->y_white = (float)white_y; -- info_ptr->x_red = (float)red_x; -- info_ptr->y_red = (float)red_y; -- info_ptr->x_green = (float)green_x; -- info_ptr->y_green = (float)green_y; -- info_ptr->x_blue = (float)blue_x; -- info_ptr->y_blue = (float)blue_y; --#ifdef PNG_FIXED_POINT_SUPPORTED -- info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5); -- info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5); -- info_ptr->int_x_red = (png_fixed_point)( red_x*100000.+0.5); -- info_ptr->int_y_red = (png_fixed_point)( red_y*100000.+0.5); -- info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5); -- info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5); -- info_ptr->int_x_blue = (png_fixed_point)( blue_x*100000.+0.5); -- info_ptr->int_y_blue = (png_fixed_point)( blue_y*100000.+0.5); --#endif -- info_ptr->valid |= PNG_INFO_cHRM; --} --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED --void PNGAPI --png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr, -- png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x, -- png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y, -- png_fixed_point blue_x, png_fixed_point blue_y) --{ -- png_debug1(1, "in %s storage function\n", "cHRM"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- if (white_x < 0 || white_y < 0 || -- red_x < 0 || red_y < 0 || -- green_x < 0 || green_y < 0 || -- blue_x < 0 || blue_y < 0) -- { -- png_warning(png_ptr, -- "Ignoring attempt to set negative chromaticity value"); -- return; -- } -- if (white_x > (double) PNG_UINT_31_MAX || -- white_y > (double) PNG_UINT_31_MAX || -- red_x > (double) PNG_UINT_31_MAX || -- red_y > (double) PNG_UINT_31_MAX || -- green_x > (double) PNG_UINT_31_MAX || -- green_y > (double) PNG_UINT_31_MAX || -- blue_x > (double) PNG_UINT_31_MAX || -- blue_y > (double) PNG_UINT_31_MAX) -- { -- png_warning(png_ptr, -- "Ignoring attempt to set chromaticity value exceeding 21474.83"); -- return; -- } -- info_ptr->int_x_white = white_x; -- info_ptr->int_y_white = white_y; -- info_ptr->int_x_red = red_x; -- info_ptr->int_y_red = red_y; -- info_ptr->int_x_green = green_x; -- info_ptr->int_y_green = green_y; -- info_ptr->int_x_blue = blue_x; -- info_ptr->int_y_blue = blue_y; --#ifdef PNG_FLOATING_POINT_SUPPORTED -- info_ptr->x_white = (float)(white_x/100000.); -- info_ptr->y_white = (float)(white_y/100000.); -- info_ptr->x_red = (float)( red_x/100000.); -- info_ptr->y_red = (float)( red_y/100000.); -- info_ptr->x_green = (float)(green_x/100000.); -- info_ptr->y_green = (float)(green_y/100000.); -- info_ptr->x_blue = (float)( blue_x/100000.); -- info_ptr->y_blue = (float)( blue_y/100000.); --#endif -- info_ptr->valid |= PNG_INFO_cHRM; --} --#endif --#endif -- --#if defined(PNG_gAMA_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED --void PNGAPI --png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma) --{ -- double gamma; -- png_debug1(1, "in %s storage function\n", "gAMA"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- /* Check for overflow */ -- if (file_gamma > 21474.83) -- { -- png_warning(png_ptr, "Limiting gamma to 21474.83"); -- gamma=21474.83; -- } -- else -- gamma=file_gamma; -- info_ptr->gamma = (float)gamma; --#ifdef PNG_FIXED_POINT_SUPPORTED -- info_ptr->int_gamma = (int)(gamma*100000.+.5); --#endif -- info_ptr->valid |= PNG_INFO_gAMA; -- if(gamma == 0.0) -- png_warning(png_ptr, "Setting gamma=0"); --} --#endif --void PNGAPI --png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point -- int_gamma) --{ -- png_fixed_point gamma; -- -- png_debug1(1, "in %s storage function\n", "gAMA"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- if (int_gamma > (png_fixed_point) PNG_UINT_31_MAX) -- { -- png_warning(png_ptr, "Limiting gamma to 21474.83"); -- gamma=PNG_UINT_31_MAX; -- } -- else -- { -- if (int_gamma < 0) -- { -- png_warning(png_ptr, "Setting negative gamma to zero"); -- gamma=0; -- } -- else -- gamma=int_gamma; -- } --#ifdef PNG_FLOATING_POINT_SUPPORTED -- info_ptr->gamma = (float)(gamma/100000.); --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED -- info_ptr->int_gamma = gamma; --#endif -- info_ptr->valid |= PNG_INFO_gAMA; -- if(gamma == 0) -- png_warning(png_ptr, "Setting gamma=0"); --} --#endif -- --#if defined(PNG_hIST_SUPPORTED) --void PNGAPI --png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist) --{ -- int i; -- -- png_debug1(1, "in %s storage function\n", "hIST"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- if (info_ptr->num_palette == 0) -- { -- png_warning(png_ptr, -- "Palette size 0, hIST allocation skipped."); -- return; -- } -- --#ifdef PNG_FREE_ME_SUPPORTED -- png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0); --#endif -- /* Changed from info->num_palette to 256 in version 1.2.1 */ -- png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr, -- (png_uint_32)(256 * png_sizeof (png_uint_16))); -- if (png_ptr->hist == NULL) -- { -- png_warning(png_ptr, "Insufficient memory for hIST chunk data."); -- return; -- } -- -- for (i = 0; i < info_ptr->num_palette; i++) -- png_ptr->hist[i] = hist[i]; -- info_ptr->hist = png_ptr->hist; -- info_ptr->valid |= PNG_INFO_hIST; -- --#ifdef PNG_FREE_ME_SUPPORTED -- info_ptr->free_me |= PNG_FREE_HIST; --#else -- png_ptr->flags |= PNG_FLAG_FREE_HIST; --#endif --} --#endif -- --void PNGAPI --png_set_IHDR(png_structp png_ptr, png_infop info_ptr, -- png_uint_32 width, png_uint_32 height, int bit_depth, -- int color_type, int interlace_type, int compression_type, -- int filter_type) --{ -- png_debug1(1, "in %s storage function\n", "IHDR"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- /* check for width and height valid values */ -- if (width == 0 || height == 0) -- png_error(png_ptr, "Image width or height is zero in IHDR"); --#ifdef PNG_SET_USER_LIMITS_SUPPORTED -- if (width > png_ptr->user_width_max || height > png_ptr->user_height_max) -- png_error(png_ptr, "image size exceeds user limits in IHDR"); --#else -- if (width > PNG_USER_WIDTH_MAX || height > PNG_USER_HEIGHT_MAX) -- png_error(png_ptr, "image size exceeds user limits in IHDR"); --#endif -- if (width > PNG_UINT_31_MAX || height > PNG_UINT_31_MAX) -- png_error(png_ptr, "Invalid image size in IHDR"); -- if ( width > (PNG_UINT_32_MAX -- >> 3) /* 8-byte RGBA pixels */ -- - 64 /* bigrowbuf hack */ -- - 1 /* filter byte */ -- - 7*8 /* rounding of width to multiple of 8 pixels */ -- - 8) /* extra max_pixel_depth pad */ -- png_warning(png_ptr, "Width is too large for libpng to process pixels"); -- -- /* check other values */ -- if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 && -- bit_depth != 8 && bit_depth != 16) -- png_error(png_ptr, "Invalid bit depth in IHDR"); -- -- if (color_type < 0 || color_type == 1 || -- color_type == 5 || color_type > 6) -- png_error(png_ptr, "Invalid color type in IHDR"); -- -- if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) || -- ((color_type == PNG_COLOR_TYPE_RGB || -- color_type == PNG_COLOR_TYPE_GRAY_ALPHA || -- color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8)) -- png_error(png_ptr, "Invalid color type/bit depth combination in IHDR"); -- -- if (interlace_type >= PNG_INTERLACE_LAST) -- png_error(png_ptr, "Unknown interlace method in IHDR"); -- -- if (compression_type != PNG_COMPRESSION_TYPE_BASE) -- png_error(png_ptr, "Unknown compression method in IHDR"); -- --#if defined(PNG_MNG_FEATURES_SUPPORTED) -- /* Accept filter_method 64 (intrapixel differencing) only if -- * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and -- * 2. Libpng did not read a PNG signature (this filter_method is only -- * used in PNG datastreams that are embedded in MNG datastreams) and -- * 3. The application called png_permit_mng_features with a mask that -- * included PNG_FLAG_MNG_FILTER_64 and -- * 4. The filter_method is 64 and -- * 5. The color_type is RGB or RGBA -- */ -- if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&png_ptr->mng_features_permitted) -- png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n"); -- if(filter_type != PNG_FILTER_TYPE_BASE) -- { -- if(!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && -- (filter_type == PNG_INTRAPIXEL_DIFFERENCING) && -- ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) && -- (color_type == PNG_COLOR_TYPE_RGB || -- color_type == PNG_COLOR_TYPE_RGB_ALPHA))) -- png_error(png_ptr, "Unknown filter method in IHDR"); -- if(png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) -- png_warning(png_ptr, "Invalid filter method in IHDR"); -- } --#else -- if(filter_type != PNG_FILTER_TYPE_BASE) -- png_error(png_ptr, "Unknown filter method in IHDR"); --#endif -- -- info_ptr->width = width; -- info_ptr->height = height; -- info_ptr->bit_depth = (png_byte)bit_depth; -- info_ptr->color_type =(png_byte) color_type; -- info_ptr->compression_type = (png_byte)compression_type; -- info_ptr->filter_type = (png_byte)filter_type; -- info_ptr->interlace_type = (png_byte)interlace_type; -- if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- info_ptr->channels = 1; -- else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) -- info_ptr->channels = 3; -- else -- info_ptr->channels = 1; -- if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) -- info_ptr->channels++; -- info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth); -- -- /* check for potential overflow */ -- if ( width > (PNG_UINT_32_MAX -- >> 3) /* 8-byte RGBA pixels */ -- - 64 /* bigrowbuf hack */ -- - 1 /* filter byte */ -- - 7*8 /* rounding of width to multiple of 8 pixels */ -- - 8) /* extra max_pixel_depth pad */ -- info_ptr->rowbytes = (png_size_t)0; -- else -- info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth,width); --} -- --#if defined(PNG_oFFs_SUPPORTED) --void PNGAPI --png_set_oFFs(png_structp png_ptr, png_infop info_ptr, -- png_int_32 offset_x, png_int_32 offset_y, int unit_type) --{ -- png_debug1(1, "in %s storage function\n", "oFFs"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- info_ptr->x_offset = offset_x; -- info_ptr->y_offset = offset_y; -- info_ptr->offset_unit_type = (png_byte)unit_type; -- info_ptr->valid |= PNG_INFO_oFFs; --} --#endif -- --#if defined(PNG_pCAL_SUPPORTED) --void PNGAPI --png_set_pCAL(png_structp png_ptr, png_infop info_ptr, -- png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams, -- png_charp units, png_charpp params) --{ -- png_uint_32 length; -- int i; -- -- png_debug1(1, "in %s storage function\n", "pCAL"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- length = png_strlen(purpose) + 1; -- png_debug1(3, "allocating purpose for info (%lu bytes)\n", length); -- info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length); -- if (info_ptr->pcal_purpose == NULL) -- { -- png_warning(png_ptr, "Insufficient memory for pCAL purpose."); -- return; -- } -- png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length); -- -- png_debug(3, "storing X0, X1, type, and nparams in info\n"); -- info_ptr->pcal_X0 = X0; -- info_ptr->pcal_X1 = X1; -- info_ptr->pcal_type = (png_byte)type; -- info_ptr->pcal_nparams = (png_byte)nparams; -- -- length = png_strlen(units) + 1; -- png_debug1(3, "allocating units for info (%lu bytes)\n", length); -- info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length); -- if (info_ptr->pcal_units == NULL) -- { -- png_warning(png_ptr, "Insufficient memory for pCAL units."); -- return; -- } -- png_memcpy(info_ptr->pcal_units, units, (png_size_t)length); -- -- info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr, -- (png_uint_32)((nparams + 1) * png_sizeof(png_charp))); -- if (info_ptr->pcal_params == NULL) -- { -- png_warning(png_ptr, "Insufficient memory for pCAL params."); -- return; -- } -- -- info_ptr->pcal_params[nparams] = NULL; -- -- for (i = 0; i < nparams; i++) -- { -- length = png_strlen(params[i]) + 1; -- png_debug2(3, "allocating parameter %d for info (%lu bytes)\n", i, length); -- info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length); -- if (info_ptr->pcal_params[i] == NULL) -- { -- png_warning(png_ptr, "Insufficient memory for pCAL parameter."); -- return; -- } -- png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length); -- } -- -- info_ptr->valid |= PNG_INFO_pCAL; --#ifdef PNG_FREE_ME_SUPPORTED -- info_ptr->free_me |= PNG_FREE_PCAL; --#endif --} --#endif -- --#if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED --void PNGAPI --png_set_sCAL(png_structp png_ptr, png_infop info_ptr, -- int unit, double width, double height) --{ -- png_debug1(1, "in %s storage function\n", "sCAL"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- info_ptr->scal_unit = (png_byte)unit; -- info_ptr->scal_pixel_width = width; -- info_ptr->scal_pixel_height = height; -- -- info_ptr->valid |= PNG_INFO_sCAL; --} --#else --#ifdef PNG_FIXED_POINT_SUPPORTED --void PNGAPI --png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr, -- int unit, png_charp swidth, png_charp sheight) --{ -- png_uint_32 length; -- -- png_debug1(1, "in %s storage function\n", "sCAL"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- info_ptr->scal_unit = (png_byte)unit; -- -- length = png_strlen(swidth) + 1; -- png_debug1(3, "allocating unit for info (%d bytes)\n", length); -- info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length); -- if (info_ptr->scal_s_width == NULL) -- { -- png_warning(png_ptr, "Memory allocation failed while processing sCAL."); -- } -- png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length); -- -- length = png_strlen(sheight) + 1; -- png_debug1(3, "allocating unit for info (%d bytes)\n", length); -- info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length); -- if (info_ptr->scal_s_height == NULL) -- { -- png_free (png_ptr, info_ptr->scal_s_width); -- png_warning(png_ptr, "Memory allocation failed while processing sCAL."); -- } -- png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length); -- -- info_ptr->valid |= PNG_INFO_sCAL; --#ifdef PNG_FREE_ME_SUPPORTED -- info_ptr->free_me |= PNG_FREE_SCAL; --#endif --} --#endif --#endif --#endif -- --#if defined(PNG_pHYs_SUPPORTED) --void PNGAPI --png_set_pHYs(png_structp png_ptr, png_infop info_ptr, -- png_uint_32 res_x, png_uint_32 res_y, int unit_type) --{ -- png_debug1(1, "in %s storage function\n", "pHYs"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- info_ptr->x_pixels_per_unit = res_x; -- info_ptr->y_pixels_per_unit = res_y; -- info_ptr->phys_unit_type = (png_byte)unit_type; -- info_ptr->valid |= PNG_INFO_pHYs; --} --#endif -- --void PNGAPI --png_set_PLTE(png_structp png_ptr, png_infop info_ptr, -- png_colorp palette, int num_palette) --{ -- -- png_debug1(1, "in %s storage function\n", "PLTE"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- /* -- * It may not actually be necessary to set png_ptr->palette here; -- * we do it for backward compatibility with the way the png_handle_tRNS -- * function used to do the allocation. -- */ --#ifdef PNG_FREE_ME_SUPPORTED -- png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0); --#endif -- -- /* Changed in libpng-1.2.1 to allocate 256 instead of num_palette entries, -- in case of an invalid PNG file that has too-large sample values. */ -- png_ptr->palette = (png_colorp)png_malloc(png_ptr, -- 256 * png_sizeof(png_color)); -- png_memset(png_ptr->palette, 0, 256 * png_sizeof(png_color)); -- png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof (png_color)); -- info_ptr->palette = png_ptr->palette; -- info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette; -- --#ifdef PNG_FREE_ME_SUPPORTED -- info_ptr->free_me |= PNG_FREE_PLTE; --#else -- png_ptr->flags |= PNG_FLAG_FREE_PLTE; --#endif -- -- info_ptr->valid |= PNG_INFO_PLTE; --} -- --#if defined(PNG_sBIT_SUPPORTED) --void PNGAPI --png_set_sBIT(png_structp png_ptr, png_infop info_ptr, -- png_color_8p sig_bit) --{ -- png_debug1(1, "in %s storage function\n", "sBIT"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof (png_color_8)); -- info_ptr->valid |= PNG_INFO_sBIT; --} --#endif -- --#if defined(PNG_sRGB_SUPPORTED) --void PNGAPI --png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent) --{ -- png_debug1(1, "in %s storage function\n", "sRGB"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- info_ptr->srgb_intent = (png_byte)intent; -- info_ptr->valid |= PNG_INFO_sRGB; --} -- --void PNGAPI --png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr, -- int intent) --{ --#if defined(PNG_gAMA_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED -- float file_gamma; --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED -- png_fixed_point int_file_gamma; --#endif --#endif --#if defined(PNG_cHRM_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED -- float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED -- png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, -- int_green_y, int_blue_x, int_blue_y; --#endif --#endif -- png_debug1(1, "in %s storage function\n", "sRGB_gAMA_and_cHRM"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- png_set_sRGB(png_ptr, info_ptr, intent); -- --#if defined(PNG_gAMA_SUPPORTED) --#ifdef PNG_FLOATING_POINT_SUPPORTED -- file_gamma = (float).45455; -- png_set_gAMA(png_ptr, info_ptr, file_gamma); --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED -- int_file_gamma = 45455L; -- png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma); --#endif --#endif -- --#if defined(PNG_cHRM_SUPPORTED) --#ifdef PNG_FIXED_POINT_SUPPORTED -- int_white_x = 31270L; -- int_white_y = 32900L; -- int_red_x = 64000L; -- int_red_y = 33000L; -- int_green_x = 30000L; -- int_green_y = 60000L; -- int_blue_x = 15000L; -- int_blue_y = 6000L; -- -- png_set_cHRM_fixed(png_ptr, info_ptr, -- int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, int_green_y, -- int_blue_x, int_blue_y); --#endif --#ifdef PNG_FLOATING_POINT_SUPPORTED -- white_x = (float).3127; -- white_y = (float).3290; -- red_x = (float).64; -- red_y = (float).33; -- green_x = (float).30; -- green_y = (float).60; -- blue_x = (float).15; -- blue_y = (float).06; -- -- png_set_cHRM(png_ptr, info_ptr, -- white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y); --#endif --#endif --} --#endif -- -- --#if defined(PNG_iCCP_SUPPORTED) --void PNGAPI --png_set_iCCP(png_structp png_ptr, png_infop info_ptr, -- png_charp name, int compression_type, -- png_charp profile, png_uint_32 proflen) --{ -- png_charp new_iccp_name; -- png_charp new_iccp_profile; -- -- png_debug1(1, "in %s storage function\n", "iCCP"); -- if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL) -- return; -- -- new_iccp_name = (png_charp)png_malloc_warn(png_ptr, png_strlen(name)+1); -- if (new_iccp_name == NULL) -- { -- png_warning(png_ptr, "Insufficient memory to process iCCP chunk."); -- return; -- } -- png_strcpy(new_iccp_name, name); -- new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen); -- if (new_iccp_profile == NULL) -- { -- png_free (png_ptr, new_iccp_name); -- png_warning(png_ptr, "Insufficient memory to process iCCP profile."); -- return; -- } -- png_memcpy(new_iccp_profile, profile, (png_size_t)proflen); -- -- png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0); -- -- info_ptr->iccp_proflen = proflen; -- info_ptr->iccp_name = new_iccp_name; -- info_ptr->iccp_profile = new_iccp_profile; -- /* Compression is always zero but is here so the API and info structure -- * does not have to change if we introduce multiple compression types */ -- info_ptr->iccp_compression = (png_byte)compression_type; --#ifdef PNG_FREE_ME_SUPPORTED -- info_ptr->free_me |= PNG_FREE_ICCP; --#endif -- info_ptr->valid |= PNG_INFO_iCCP; --} --#endif -- --#if defined(PNG_TEXT_SUPPORTED) --void PNGAPI --png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, -- int num_text) --{ -- int ret; -- ret=png_set_text_2(png_ptr, info_ptr, text_ptr, num_text); -- if (ret) -- png_error(png_ptr, "Insufficient memory to store text"); --} -- --int /* PRIVATE */ --png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, -- int num_text) --{ -- int i; -- -- png_debug1(1, "in %s storage function\n", (png_ptr->chunk_name[0] == '\0' ? -- "text" : (png_const_charp)png_ptr->chunk_name)); -- -- if (png_ptr == NULL || info_ptr == NULL || num_text == 0) -- return(0); -- -- /* Make sure we have enough space in the "text" array in info_struct -- * to hold all of the incoming text_ptr objects. -- */ -- if (info_ptr->num_text + num_text > info_ptr->max_text) -- { -- if (info_ptr->text != NULL) -- { -- png_textp old_text; -- int old_max; -- -- old_max = info_ptr->max_text; -- info_ptr->max_text = info_ptr->num_text + num_text + 8; -- old_text = info_ptr->text; -- info_ptr->text = (png_textp)png_malloc_warn(png_ptr, -- (png_uint_32)(info_ptr->max_text * png_sizeof (png_text))); -- if (info_ptr->text == NULL) -- { -- png_free(png_ptr, old_text); -- return(1); -- } -- png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max * -- png_sizeof(png_text))); -- png_free(png_ptr, old_text); -- } -- else -- { -- info_ptr->max_text = num_text + 8; -- info_ptr->num_text = 0; -- info_ptr->text = (png_textp)png_malloc_warn(png_ptr, -- (png_uint_32)(info_ptr->max_text * png_sizeof (png_text))); -- if (info_ptr->text == NULL) -- return(1); --#ifdef PNG_FREE_ME_SUPPORTED -- info_ptr->free_me |= PNG_FREE_TEXT; --#endif -- } -- png_debug1(3, "allocated %d entries for info_ptr->text\n", -- info_ptr->max_text); -- } -- for (i = 0; i < num_text; i++) -- { -- png_size_t text_length,key_len; -- png_size_t lang_len,lang_key_len; -- png_textp textp = &(info_ptr->text[info_ptr->num_text]); -- -- if (text_ptr[i].key == NULL) -- continue; -- -- key_len = png_strlen(text_ptr[i].key); -- -- if(text_ptr[i].compression <= 0) -- { -- lang_len = 0; -- lang_key_len = 0; -- } -- else --#ifdef PNG_iTXt_SUPPORTED -- { -- /* set iTXt data */ -- if (text_ptr[i].lang != NULL) -- lang_len = png_strlen(text_ptr[i].lang); -- else -- lang_len = 0; -- if (text_ptr[i].lang_key != NULL) -- lang_key_len = png_strlen(text_ptr[i].lang_key); -- else -- lang_key_len = 0; -- } --#else -- { -- png_warning(png_ptr, "iTXt chunk not supported."); -- continue; -- } --#endif -- -- if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0') -- { -- text_length = 0; --#ifdef PNG_iTXt_SUPPORTED -- if(text_ptr[i].compression > 0) -- textp->compression = PNG_ITXT_COMPRESSION_NONE; -- else --#endif -- textp->compression = PNG_TEXT_COMPRESSION_NONE; -- } -- else -- { -- text_length = png_strlen(text_ptr[i].text); -- textp->compression = text_ptr[i].compression; -- } -- -- textp->key = (png_charp)png_malloc_warn(png_ptr, -- (png_uint_32)(key_len + text_length + lang_len + lang_key_len + 4)); -- if (textp->key == NULL) -- return(1); -- png_debug2(2, "Allocated %lu bytes at %x in png_set_text\n", -- (png_uint_32)(key_len + lang_len + lang_key_len + text_length + 4), -- (int)textp->key); -- -- png_memcpy(textp->key, text_ptr[i].key, -- (png_size_t)(key_len)); -- *(textp->key+key_len) = '\0'; --#ifdef PNG_iTXt_SUPPORTED -- if (text_ptr[i].compression > 0) -- { -- textp->lang=textp->key + key_len + 1; -- png_memcpy(textp->lang, text_ptr[i].lang, lang_len); -- *(textp->lang+lang_len) = '\0'; -- textp->lang_key=textp->lang + lang_len + 1; -- png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len); -- *(textp->lang_key+lang_key_len) = '\0'; -- textp->text=textp->lang_key + lang_key_len + 1; -- } -- else --#endif -- { --#ifdef PNG_iTXt_SUPPORTED -- textp->lang=NULL; -- textp->lang_key=NULL; --#endif -- textp->text=textp->key + key_len + 1; -- } -- if(text_length) -- png_memcpy(textp->text, text_ptr[i].text, -- (png_size_t)(text_length)); -- *(textp->text+text_length) = '\0'; -- --#ifdef PNG_iTXt_SUPPORTED -- if(textp->compression > 0) -- { -- textp->text_length = 0; -- textp->itxt_length = text_length; -- } -- else --#endif -- { -- textp->text_length = text_length; --#ifdef PNG_iTXt_SUPPORTED -- textp->itxt_length = 0; --#endif -- } -- info_ptr->text[info_ptr->num_text]= *textp; -- info_ptr->num_text++; -- png_debug1(3, "transferred text chunk %d\n", info_ptr->num_text); -- } -- return(0); --} --#endif -- --#if defined(PNG_tIME_SUPPORTED) --void PNGAPI --png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time) --{ -- png_debug1(1, "in %s storage function\n", "tIME"); -- if (png_ptr == NULL || info_ptr == NULL || -- (png_ptr->mode & PNG_WROTE_tIME)) -- return; -- -- png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof (png_time)); -- info_ptr->valid |= PNG_INFO_tIME; --} --#endif -- --#if defined(PNG_tRNS_SUPPORTED) --void PNGAPI --png_set_tRNS(png_structp png_ptr, png_infop info_ptr, -- png_bytep trans, int num_trans, png_color_16p trans_values) --{ -- png_debug1(1, "in %s storage function\n", "tRNS"); -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- if (trans != NULL) -- { -- /* -- * It may not actually be necessary to set png_ptr->trans here; -- * we do it for backward compatibility with the way the png_handle_tRNS -- * function used to do the allocation. -- */ --#ifdef PNG_FREE_ME_SUPPORTED -- png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0); --#endif -- /* Changed from num_trans to 256 in version 1.2.1 */ -- png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr, -- (png_uint_32)256); -- png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans); --#ifdef PNG_FREE_ME_SUPPORTED -- info_ptr->free_me |= PNG_FREE_TRNS; --#else -- png_ptr->flags |= PNG_FLAG_FREE_TRNS; --#endif -- } -- -- if (trans_values != NULL) -- { -- png_memcpy(&(info_ptr->trans_values), trans_values, -- png_sizeof(png_color_16)); -- if (num_trans == 0) -- num_trans = 1; -- } -- info_ptr->num_trans = (png_uint_16)num_trans; -- info_ptr->valid |= PNG_INFO_tRNS; --} --#endif -- --#if defined(PNG_sPLT_SUPPORTED) --void PNGAPI --png_set_sPLT(png_structp png_ptr, -- png_infop info_ptr, png_sPLT_tp entries, int nentries) --{ -- png_sPLT_tp np; -- int i; -- -- np = (png_sPLT_tp)png_malloc_warn(png_ptr, -- (info_ptr->splt_palettes_num + nentries) * png_sizeof(png_sPLT_t)); -- if (np == NULL) -- { -- png_warning(png_ptr, "No memory for sPLT palettes."); -- return; -- } -- -- png_memcpy(np, info_ptr->splt_palettes, -- info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t)); -- png_free(png_ptr, info_ptr->splt_palettes); -- info_ptr->splt_palettes=NULL; -- -- for (i = 0; i < nentries; i++) -- { -- png_sPLT_tp to = np + info_ptr->splt_palettes_num + i; -- png_sPLT_tp from = entries + i; -- -- to->name = (png_charp)png_malloc(png_ptr, -- png_strlen(from->name) + 1); -- /* TODO: use png_malloc_warn */ -- png_strcpy(to->name, from->name); -- to->entries = (png_sPLT_entryp)png_malloc(png_ptr, -- from->nentries * png_sizeof(png_sPLT_t)); -- /* TODO: use png_malloc_warn */ -- png_memcpy(to->entries, from->entries, -- from->nentries * png_sizeof(png_sPLT_t)); -- to->nentries = from->nentries; -- to->depth = from->depth; -- } -- -- info_ptr->splt_palettes = np; -- info_ptr->splt_palettes_num += nentries; -- info_ptr->valid |= PNG_INFO_sPLT; --#ifdef PNG_FREE_ME_SUPPORTED -- info_ptr->free_me |= PNG_FREE_SPLT; --#endif --} --#endif /* PNG_sPLT_SUPPORTED */ -- --#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) --void PNGAPI --png_set_unknown_chunks(png_structp png_ptr, -- png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns) --{ -- png_unknown_chunkp np; -- int i; -- -- if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0) -- return; -- -- np = (png_unknown_chunkp)png_malloc_warn(png_ptr, -- (info_ptr->unknown_chunks_num + num_unknowns) * -- png_sizeof(png_unknown_chunk)); -- if (np == NULL) -- { -- png_warning(png_ptr, "Out of memory while processing unknown chunk."); -- return; -- } -- -- png_memcpy(np, info_ptr->unknown_chunks, -- info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk)); -- png_free(png_ptr, info_ptr->unknown_chunks); -- info_ptr->unknown_chunks=NULL; -- -- for (i = 0; i < num_unknowns; i++) -- { -- png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i; -- png_unknown_chunkp from = unknowns + i; -- -- png_strncpy((png_charp)to->name, (png_charp)from->name, 5); -- to->data = (png_bytep)png_malloc_warn(png_ptr, from->size); -- if (to->data == NULL) -- { -- png_warning(png_ptr, "Out of memory processing unknown chunk."); -- } -- else -- { -- png_memcpy(to->data, from->data, from->size); -- to->size = from->size; -- -- /* note our location in the read or write sequence */ -- to->location = (png_byte)(png_ptr->mode & 0xff); -- } -- } -- -- info_ptr->unknown_chunks = np; -- info_ptr->unknown_chunks_num += num_unknowns; --#ifdef PNG_FREE_ME_SUPPORTED -- info_ptr->free_me |= PNG_FREE_UNKN; --#endif --} --void PNGAPI --png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr, -- int chunk, int location) --{ -- if(png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk < -- (int)info_ptr->unknown_chunks_num) -- info_ptr->unknown_chunks[chunk].location = (png_byte)location; --} --#endif -- --#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ -- defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) --void PNGAPI --png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted) --{ -- /* This function is deprecated in favor of png_permit_mng_features() -- and will be removed from libpng-2.0.0 */ -- png_debug(1, "in png_permit_empty_plte, DEPRECATED.\n"); -- if (png_ptr == NULL) -- return; -- png_ptr->mng_features_permitted = (png_byte) -- ((png_ptr->mng_features_permitted & (~(PNG_FLAG_MNG_EMPTY_PLTE))) | -- ((empty_plte_permitted & PNG_FLAG_MNG_EMPTY_PLTE))); --} --#endif -- --#if defined(PNG_MNG_FEATURES_SUPPORTED) --png_uint_32 PNGAPI --png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features) --{ -- png_debug(1, "in png_permit_mng_features\n"); -- if (png_ptr == NULL) -- return (png_uint_32)0; -- png_ptr->mng_features_permitted = -- (png_byte)(mng_features & PNG_ALL_MNG_FEATURES); -- return (png_uint_32)png_ptr->mng_features_permitted; --} --#endif -- --#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) --void PNGAPI --png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep -- chunk_list, int num_chunks) --{ -- png_bytep new_list, p; -- int i, old_num_chunks; -- if (num_chunks == 0) -- { -- if(keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE) -- png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS; -- else -- png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS; -- -- if(keep == PNG_HANDLE_CHUNK_ALWAYS) -- png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS; -- else -- png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS; -- return; -- } -- if (chunk_list == NULL) -- return; -- old_num_chunks=png_ptr->num_chunk_list; -- new_list=(png_bytep)png_malloc(png_ptr, -- (png_uint_32)(5*(num_chunks+old_num_chunks))); -- if(png_ptr->chunk_list != NULL) -- { -- png_memcpy(new_list, png_ptr->chunk_list, -- (png_size_t)(5*old_num_chunks)); -- png_free(png_ptr, png_ptr->chunk_list); -- png_ptr->chunk_list=NULL; -- } -- png_memcpy(new_list+5*old_num_chunks, chunk_list, -- (png_size_t)(5*num_chunks)); -- for (p=new_list+5*old_num_chunks+4, i=0; inum_chunk_list=old_num_chunks+num_chunks; -- png_ptr->chunk_list=new_list; --#ifdef PNG_FREE_ME_SUPPORTED -- png_ptr->free_me |= PNG_FREE_LIST; --#endif --} --#endif -- --#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) --void PNGAPI --png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr, -- png_user_chunk_ptr read_user_chunk_fn) --{ -- png_debug(1, "in png_set_read_user_chunk_fn\n"); -- png_ptr->read_user_chunk_fn = read_user_chunk_fn; -- png_ptr->user_chunk_ptr = user_chunk_ptr; --} --#endif -- --#if defined(PNG_INFO_IMAGE_SUPPORTED) --void PNGAPI --png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers) --{ -- png_debug1(1, "in %s storage function\n", "rows"); -- -- if (png_ptr == NULL || info_ptr == NULL) -- return; -- -- if(info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers)) -- png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); -- info_ptr->row_pointers = row_pointers; -- if(row_pointers) -- info_ptr->valid |= PNG_INFO_IDAT; --} --#endif -- --#ifdef PNG_WRITE_SUPPORTED --void PNGAPI --png_set_compression_buffer_size(png_structp png_ptr, png_uint_32 size) --{ -- if(png_ptr->zbuf) -- png_free(png_ptr, png_ptr->zbuf); -- png_ptr->zbuf_size = (png_size_t)size; -- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size); -- png_ptr->zstream.next_out = png_ptr->zbuf; -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; --} --#endif -- --void PNGAPI --png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask) --{ -- if (png_ptr && info_ptr) -- info_ptr->valid &= ~(mask); --} -- -- --#ifndef PNG_1_0_X --#ifdef PNG_ASSEMBLER_CODE_SUPPORTED --/* this function was added to libpng 1.2.0 and should always exist by default */ --void PNGAPI --png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags) --{ -- png_uint_32 settable_asm_flags; -- png_uint_32 settable_mmx_flags; -- -- settable_mmx_flags = --#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW -- PNG_ASM_FLAG_MMX_READ_COMBINE_ROW | --#endif --#ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE -- PNG_ASM_FLAG_MMX_READ_INTERLACE | --#endif --#ifdef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW -- PNG_ASM_FLAG_MMX_READ_FILTER_SUB | -- PNG_ASM_FLAG_MMX_READ_FILTER_UP | -- PNG_ASM_FLAG_MMX_READ_FILTER_AVG | -- PNG_ASM_FLAG_MMX_READ_FILTER_PAETH | --#endif -- 0; -- -- /* could be some non-MMX ones in the future, but not currently: */ -- settable_asm_flags = settable_mmx_flags; -- -- if (!(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_COMPILED) || -- !(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU)) -- { -- /* clear all MMX flags if MMX isn't supported */ -- settable_asm_flags &= ~settable_mmx_flags; -- png_ptr->asm_flags &= ~settable_mmx_flags; -- } -- -- /* we're replacing the settable bits with those passed in by the user, -- * so first zero them out of the master copy, then logical-OR in the -- * allowed subset that was requested */ -- -- png_ptr->asm_flags &= ~settable_asm_flags; /* zero them */ -- png_ptr->asm_flags |= (asm_flags & settable_asm_flags); /* set them */ --} --#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */ -- --#ifdef PNG_ASSEMBLER_CODE_SUPPORTED --/* this function was added to libpng 1.2.0 */ --void PNGAPI --png_set_mmx_thresholds (png_structp png_ptr, -- png_byte mmx_bitdepth_threshold, -- png_uint_32 mmx_rowbytes_threshold) --{ -- png_ptr->mmx_bitdepth_threshold = mmx_bitdepth_threshold; -- png_ptr->mmx_rowbytes_threshold = mmx_rowbytes_threshold; --} --#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */ -- --#ifdef PNG_SET_USER_LIMITS_SUPPORTED --/* this function was added to libpng 1.2.6 */ --void PNGAPI --png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max, -- png_uint_32 user_height_max) --{ -- /* Images with dimensions larger than these limits will be -- * rejected by png_set_IHDR(). To accept any PNG datastream -- * regardless of dimensions, set both limits to 0x7ffffffL. -- */ -- png_ptr->user_width_max = user_width_max; -- png_ptr->user_height_max = user_height_max; --} --#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */ -- --#endif /* ?PNG_1_0_X */ -diff --git a/thirdparty/libpng/pngtrans.c b/thirdparty/libpng/pngtrans.c -deleted file mode 100644 -index f279f9e..0000000 ---- a/thirdparty/libpng/pngtrans.c -+++ /dev/null -@@ -1,644 +0,0 @@ -- --/* pngtrans.c - transforms the data in a row (used by both readers and writers) -- * -- * libpng 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- */ -- --#define PNG_INTERNAL --#include "png.h" -- --#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) --/* turn on BGR-to-RGB mapping */ --void PNGAPI --png_set_bgr(png_structp png_ptr) --{ -- png_debug(1, "in png_set_bgr\n"); -- png_ptr->transformations |= PNG_BGR; --} --#endif -- --#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) --/* turn on 16 bit byte swapping */ --void PNGAPI --png_set_swap(png_structp png_ptr) --{ -- png_debug(1, "in png_set_swap\n"); -- if (png_ptr->bit_depth == 16) -- png_ptr->transformations |= PNG_SWAP_BYTES; --} --#endif -- --#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) --/* turn on pixel packing */ --void PNGAPI --png_set_packing(png_structp png_ptr) --{ -- png_debug(1, "in png_set_packing\n"); -- if (png_ptr->bit_depth < 8) -- { -- png_ptr->transformations |= PNG_PACK; -- png_ptr->usr_bit_depth = 8; -- } --} --#endif -- --#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) --/* turn on packed pixel swapping */ --void PNGAPI --png_set_packswap(png_structp png_ptr) --{ -- png_debug(1, "in png_set_packswap\n"); -- if (png_ptr->bit_depth < 8) -- png_ptr->transformations |= PNG_PACKSWAP; --} --#endif -- --#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) --void PNGAPI --png_set_shift(png_structp png_ptr, png_color_8p true_bits) --{ -- png_debug(1, "in png_set_shift\n"); -- png_ptr->transformations |= PNG_SHIFT; -- png_ptr->shift = *true_bits; --} --#endif -- --#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ -- defined(PNG_WRITE_INTERLACING_SUPPORTED) --int PNGAPI --png_set_interlace_handling(png_structp png_ptr) --{ -- png_debug(1, "in png_set_interlace handling\n"); -- if (png_ptr->interlaced) -- { -- png_ptr->transformations |= PNG_INTERLACE; -- return (7); -- } -- -- return (1); --} --#endif -- --#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) --/* Add a filler byte on read, or remove a filler or alpha byte on write. -- * The filler type has changed in v0.95 to allow future 2-byte fillers -- * for 48-bit input data, as well as to avoid problems with some compilers -- * that don't like bytes as parameters. -- */ --void PNGAPI --png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc) --{ -- png_debug(1, "in png_set_filler\n"); -- png_ptr->transformations |= PNG_FILLER; -- png_ptr->filler = (png_byte)filler; -- if (filler_loc == PNG_FILLER_AFTER) -- png_ptr->flags |= PNG_FLAG_FILLER_AFTER; -- else -- png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER; -- -- /* This should probably go in the "do_read_filler" routine. -- * I attempted to do that in libpng-1.0.1a but that caused problems -- * so I restored it in libpng-1.0.2a -- */ -- -- if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) -- { -- png_ptr->usr_channels = 4; -- } -- -- /* Also I added this in libpng-1.0.2a (what happens when we expand -- * a less-than-8-bit grayscale to GA? */ -- -- if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8) -- { -- png_ptr->usr_channels = 2; -- } --} -- --#if !defined(PNG_1_0_X) --/* Added to libpng-1.2.7 */ --void PNGAPI --png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc) --{ -- png_debug(1, "in png_set_add_alpha\n"); -- png_set_filler(png_ptr, filler, filler_loc); -- png_ptr->transformations |= PNG_ADD_ALPHA; --} --#endif -- --#endif -- --#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ -- defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) --void PNGAPI --png_set_swap_alpha(png_structp png_ptr) --{ -- png_debug(1, "in png_set_swap_alpha\n"); -- png_ptr->transformations |= PNG_SWAP_ALPHA; --} --#endif -- --#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ -- defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) --void PNGAPI --png_set_invert_alpha(png_structp png_ptr) --{ -- png_debug(1, "in png_set_invert_alpha\n"); -- png_ptr->transformations |= PNG_INVERT_ALPHA; --} --#endif -- --#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) --void PNGAPI --png_set_invert_mono(png_structp png_ptr) --{ -- png_debug(1, "in png_set_invert_mono\n"); -- png_ptr->transformations |= PNG_INVERT_MONO; --} -- --/* invert monochrome grayscale data */ --void /* PRIVATE */ --png_do_invert(png_row_infop row_info, png_bytep row) --{ -- png_debug(1, "in png_do_invert\n"); -- /* This test removed from libpng version 1.0.13 and 1.2.0: -- * if (row_info->bit_depth == 1 && -- */ --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- if (row == NULL || row_info == NULL) -- return; --#endif -- if (row_info->color_type == PNG_COLOR_TYPE_GRAY) -- { -- png_bytep rp = row; -- png_uint_32 i; -- png_uint_32 istop = row_info->rowbytes; -- -- for (i = 0; i < istop; i++) -- { -- *rp = (png_byte)(~(*rp)); -- rp++; -- } -- } -- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && -- row_info->bit_depth == 8) -- { -- png_bytep rp = row; -- png_uint_32 i; -- png_uint_32 istop = row_info->rowbytes; -- -- for (i = 0; i < istop; i+=2) -- { -- *rp = (png_byte)(~(*rp)); -- rp+=2; -- } -- } -- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && -- row_info->bit_depth == 16) -- { -- png_bytep rp = row; -- png_uint_32 i; -- png_uint_32 istop = row_info->rowbytes; -- -- for (i = 0; i < istop; i+=4) -- { -- *rp = (png_byte)(~(*rp)); -- *(rp+1) = (png_byte)(~(*(rp+1))); -- rp+=4; -- } -- } --} --#endif -- --#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) --/* swaps byte order on 16 bit depth images */ --void /* PRIVATE */ --png_do_swap(png_row_infop row_info, png_bytep row) --{ -- png_debug(1, "in png_do_swap\n"); -- if ( --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- row != NULL && row_info != NULL && --#endif -- row_info->bit_depth == 16) -- { -- png_bytep rp = row; -- png_uint_32 i; -- png_uint_32 istop= row_info->width * row_info->channels; -- -- for (i = 0; i < istop; i++, rp += 2) -- { -- png_byte t = *rp; -- *rp = *(rp + 1); -- *(rp + 1) = t; -- } -- } --} --#endif -- --#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) --static png_byte onebppswaptable[256] = { -- 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, -- 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, -- 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, -- 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, -- 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, -- 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, -- 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, -- 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, -- 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, -- 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, -- 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, -- 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, -- 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, -- 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, -- 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, -- 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, -- 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, -- 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, -- 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, -- 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, -- 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, -- 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, -- 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, -- 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, -- 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, -- 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, -- 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, -- 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, -- 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, -- 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, -- 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, -- 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF --}; -- --static png_byte twobppswaptable[256] = { -- 0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0, -- 0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0, -- 0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4, -- 0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4, -- 0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8, -- 0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8, -- 0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC, -- 0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC, -- 0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1, -- 0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1, -- 0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5, -- 0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5, -- 0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9, -- 0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9, -- 0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD, -- 0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD, -- 0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2, -- 0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2, -- 0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6, -- 0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6, -- 0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA, -- 0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA, -- 0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE, -- 0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE, -- 0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3, -- 0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3, -- 0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7, -- 0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7, -- 0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB, -- 0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB, -- 0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF, -- 0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF --}; -- --static png_byte fourbppswaptable[256] = { -- 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, -- 0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, -- 0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71, -- 0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1, -- 0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72, -- 0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2, -- 0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73, -- 0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3, -- 0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74, -- 0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4, -- 0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75, -- 0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5, -- 0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76, -- 0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6, -- 0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77, -- 0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7, -- 0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78, -- 0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8, -- 0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79, -- 0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9, -- 0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A, -- 0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA, -- 0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B, -- 0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB, -- 0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C, -- 0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC, -- 0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D, -- 0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD, -- 0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E, -- 0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE, -- 0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F, -- 0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF --}; -- --/* swaps pixel packing order within bytes */ --void /* PRIVATE */ --png_do_packswap(png_row_infop row_info, png_bytep row) --{ -- png_debug(1, "in png_do_packswap\n"); -- if ( --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- row != NULL && row_info != NULL && --#endif -- row_info->bit_depth < 8) -- { -- png_bytep rp, end, table; -- -- end = row + row_info->rowbytes; -- -- if (row_info->bit_depth == 1) -- table = onebppswaptable; -- else if (row_info->bit_depth == 2) -- table = twobppswaptable; -- else if (row_info->bit_depth == 4) -- table = fourbppswaptable; -- else -- return; -- -- for (rp = row; rp < end; rp++) -- *rp = table[*rp]; -- } --} --#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */ -- --#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ -- defined(PNG_READ_STRIP_ALPHA_SUPPORTED) --/* remove filler or alpha byte(s) */ --void /* PRIVATE */ --png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags) --{ -- png_debug(1, "in png_do_strip_filler\n"); --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- if (row != NULL && row_info != NULL) --#endif -- { -- png_bytep sp=row; -- png_bytep dp=row; -- png_uint_32 row_width=row_info->width; -- png_uint_32 i; -- -- if (row_info->color_type == PNG_COLOR_TYPE_RGB && -- row_info->channels == 4) -- { -- if (row_info->bit_depth == 8) -- { -- /* This converts from RGBX or RGBA to RGB */ -- if (flags & PNG_FLAG_FILLER_AFTER) -- { -- dp+=3; sp+=4; -- for (i = 1; i < row_width; i++) -- { -- *dp++ = *sp++; -- *dp++ = *sp++; -- *dp++ = *sp++; -- sp++; -- } -- } -- /* This converts from XRGB or ARGB to RGB */ -- else -- { -- for (i = 0; i < row_width; i++) -- { -- sp++; -- *dp++ = *sp++; -- *dp++ = *sp++; -- *dp++ = *sp++; -- } -- } -- row_info->pixel_depth = 24; -- row_info->rowbytes = row_width * 3; -- } -- else /* if (row_info->bit_depth == 16) */ -- { -- if (flags & PNG_FLAG_FILLER_AFTER) -- { -- /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */ -- sp += 8; dp += 6; -- for (i = 1; i < row_width; i++) -- { -- /* This could be (although png_memcpy is probably slower): -- png_memcpy(dp, sp, 6); -- sp += 8; -- dp += 6; -- */ -- -- *dp++ = *sp++; -- *dp++ = *sp++; -- *dp++ = *sp++; -- *dp++ = *sp++; -- *dp++ = *sp++; -- *dp++ = *sp++; -- sp += 2; -- } -- } -- else -- { -- /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */ -- for (i = 0; i < row_width; i++) -- { -- /* This could be (although png_memcpy is probably slower): -- png_memcpy(dp, sp, 6); -- sp += 8; -- dp += 6; -- */ -- -- sp+=2; -- *dp++ = *sp++; -- *dp++ = *sp++; -- *dp++ = *sp++; -- *dp++ = *sp++; -- *dp++ = *sp++; -- *dp++ = *sp++; -- } -- } -- row_info->pixel_depth = 48; -- row_info->rowbytes = row_width * 6; -- } -- row_info->channels = 3; -- } -- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY && -- row_info->channels == 2) -- { -- if (row_info->bit_depth == 8) -- { -- /* This converts from GX or GA to G */ -- if (flags & PNG_FLAG_FILLER_AFTER) -- { -- for (i = 0; i < row_width; i++) -- { -- *dp++ = *sp++; -- sp++; -- } -- } -- /* This converts from XG or AG to G */ -- else -- { -- for (i = 0; i < row_width; i++) -- { -- sp++; -- *dp++ = *sp++; -- } -- } -- row_info->pixel_depth = 8; -- row_info->rowbytes = row_width; -- } -- else /* if (row_info->bit_depth == 16) */ -- { -- if (flags & PNG_FLAG_FILLER_AFTER) -- { -- /* This converts from GGXX or GGAA to GG */ -- sp += 4; dp += 2; -- for (i = 1; i < row_width; i++) -- { -- *dp++ = *sp++; -- *dp++ = *sp++; -- sp += 2; -- } -- } -- else -- { -- /* This converts from XXGG or AAGG to GG */ -- for (i = 0; i < row_width; i++) -- { -- sp += 2; -- *dp++ = *sp++; -- *dp++ = *sp++; -- } -- } -- row_info->pixel_depth = 16; -- row_info->rowbytes = row_width * 2; -- } -- row_info->channels = 1; -- } -- } --} --#endif -- --#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) --/* swaps red and blue bytes within a pixel */ --void /* PRIVATE */ --png_do_bgr(png_row_infop row_info, png_bytep row) --{ -- png_debug(1, "in png_do_bgr\n"); -- if ( --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- row != NULL && row_info != NULL && --#endif -- (row_info->color_type & PNG_COLOR_MASK_COLOR)) -- { -- png_uint_32 row_width = row_info->width; -- if (row_info->bit_depth == 8) -- { -- if (row_info->color_type == PNG_COLOR_TYPE_RGB) -- { -- png_bytep rp; -- png_uint_32 i; -- -- for (i = 0, rp = row; i < row_width; i++, rp += 3) -- { -- png_byte save = *rp; -- *rp = *(rp + 2); -- *(rp + 2) = save; -- } -- } -- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- { -- png_bytep rp; -- png_uint_32 i; -- -- for (i = 0, rp = row; i < row_width; i++, rp += 4) -- { -- png_byte save = *rp; -- *rp = *(rp + 2); -- *(rp + 2) = save; -- } -- } -- } -- else if (row_info->bit_depth == 16) -- { -- if (row_info->color_type == PNG_COLOR_TYPE_RGB) -- { -- png_bytep rp; -- png_uint_32 i; -- -- for (i = 0, rp = row; i < row_width; i++, rp += 6) -- { -- png_byte save = *rp; -- *rp = *(rp + 4); -- *(rp + 4) = save; -- save = *(rp + 1); -- *(rp + 1) = *(rp + 5); -- *(rp + 5) = save; -- } -- } -- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- { -- png_bytep rp; -- png_uint_32 i; -- -- for (i = 0, rp = row; i < row_width; i++, rp += 8) -- { -- png_byte save = *rp; -- *rp = *(rp + 4); -- *(rp + 4) = save; -- save = *(rp + 1); -- *(rp + 1) = *(rp + 5); -- *(rp + 5) = save; -- } -- } -- } -- } --} --#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */ -- --#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ -- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ -- defined(PNG_LEGACY_SUPPORTED) --void PNGAPI --png_set_user_transform_info(png_structp png_ptr, png_voidp -- user_transform_ptr, int user_transform_depth, int user_transform_channels) --{ -- png_debug(1, "in png_set_user_transform_info\n"); --#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) -- png_ptr->user_transform_ptr = user_transform_ptr; -- png_ptr->user_transform_depth = (png_byte)user_transform_depth; -- png_ptr->user_transform_channels = (png_byte)user_transform_channels; --#else -- if(user_transform_ptr || user_transform_depth || user_transform_channels) -- png_warning(png_ptr, -- "This version of libpng does not support user transform info"); --#endif --} --#endif -- --/* This function returns a pointer to the user_transform_ptr associated with -- * the user transform functions. The application should free any memory -- * associated with this pointer before png_write_destroy and png_read_destroy -- * are called. -- */ --png_voidp PNGAPI --png_get_user_transform_ptr(png_structp png_ptr) --{ --#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) -- return ((png_voidp)png_ptr->user_transform_ptr); --#else -- if(png_ptr) -- return (NULL); -- return (NULL); --#endif --} -diff --git a/thirdparty/libpng/pngvcrd.c b/thirdparty/libpng/pngvcrd.c -deleted file mode 100644 -index 05cfacb..0000000 ---- a/thirdparty/libpng/pngvcrd.c -+++ /dev/null -@@ -1,3903 +0,0 @@ --/* pngvcrd.c - mixed C/assembler version of utilities to read a PNG file -- * -- * For Intel x86 CPU and Microsoft Visual C++ compiler -- * -- * libpng version 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * Copyright (c) 1998, Intel Corporation -- * -- * Contributed by Nirav Chhatrapati, Intel Corporation, 1998 -- * Interface to libpng contributed by Gilles Vollant, 1999 -- * -- * -- * In png_do_read_interlace() in libpng versions 1.0.3a through 1.0.4d, -- * a sign error in the post-MMX cleanup code for each pixel_depth resulted -- * in bad pixels at the beginning of some rows of some images, and also -- * (due to out-of-range memory reads and writes) caused heap corruption -- * when compiled with MSVC 6.0. The error was fixed in version 1.0.4e. -- * -- * [png_read_filter_row_mmx_avg() bpp == 2 bugfix, GRR 20000916] -- * -- * [runtime MMX configuration, GRR 20010102] -- * -- */ -- --#define PNG_INTERNAL --#include "png.h" -- --#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD) -- --static int mmx_supported=2; -- -- --int PNGAPI --png_mmx_support(void) --{ -- int mmx_supported_local = 0; -- _asm { -- push ebx //CPUID will trash these -- push ecx -- push edx -- -- pushfd //Save Eflag to stack -- pop eax //Get Eflag from stack into eax -- mov ecx, eax //Make another copy of Eflag in ecx -- xor eax, 0x200000 //Toggle ID bit in Eflag [i.e. bit(21)] -- push eax //Save modified Eflag back to stack -- -- popfd //Restored modified value back to Eflag reg -- pushfd //Save Eflag to stack -- pop eax //Get Eflag from stack -- push ecx // save original Eflag to stack -- popfd // restore original Eflag -- xor eax, ecx //Compare the new Eflag with the original Eflag -- jz NOT_SUPPORTED //If the same, CPUID instruction is not supported, -- //skip following instructions and jump to -- //NOT_SUPPORTED label -- -- xor eax, eax //Set eax to zero -- -- _asm _emit 0x0f //CPUID instruction (two bytes opcode) -- _asm _emit 0xa2 -- -- cmp eax, 1 //make sure eax return non-zero value -- jl NOT_SUPPORTED //If eax is zero, mmx not supported -- -- xor eax, eax //set eax to zero -- inc eax //Now increment eax to 1. This instruction is -- //faster than the instruction "mov eax, 1" -- -- _asm _emit 0x0f //CPUID instruction -- _asm _emit 0xa2 -- -- and edx, 0x00800000 //mask out all bits but mmx bit(24) -- cmp edx, 0 // 0 = mmx not supported -- jz NOT_SUPPORTED // non-zero = Yes, mmx IS supported -- -- mov mmx_supported_local, 1 //set return value to 1 -- --NOT_SUPPORTED: -- mov eax, mmx_supported_local //move return value to eax -- pop edx //CPUID trashed these -- pop ecx -- pop ebx -- } -- -- //mmx_supported_local=0; // test code for force don't support MMX -- //printf("MMX : %u (1=MMX supported)\n",mmx_supported_local); -- -- mmx_supported = mmx_supported_local; -- return mmx_supported_local; --} -- --/* Combines the row recently read in with the previous row. -- This routine takes care of alpha and transparency if requested. -- This routine also handles the two methods of progressive display -- of interlaced images, depending on the mask value. -- The mask value describes which pixels are to be combined with -- the row. The pattern always repeats every 8 pixels, so just 8 -- bits are needed. A one indicates the pixel is to be combined; a -- zero indicates the pixel is to be skipped. This is in addition -- to any alpha or transparency value associated with the pixel. If -- you want all pixels to be combined, pass 0xff (255) in mask. */ -- --/* Use this routine for x86 platform - uses faster MMX routine if machine -- supports MMX */ -- --void /* PRIVATE */ --png_combine_row(png_structp png_ptr, png_bytep row, int mask) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; --#endif -- -- png_debug(1,"in png_combine_row_asm\n"); -- -- if (mmx_supported == 2) { --#if !defined(PNG_1_0_X) -- /* this should have happened in png_init_mmx_flags() already */ -- png_warning(png_ptr, "asm_flags may not have been initialized"); --#endif -- png_mmx_support(); -- } -- -- if (mask == 0xff) -- { -- png_memcpy(row, png_ptr->row_buf + 1, -- (png_size_t)PNG_ROWBYTES(png_ptr->row_info.pixel_depth, -- png_ptr->width)); -- } -- /* GRR: add "else if (mask == 0)" case? -- * or does png_combine_row() not even get called in that case? */ -- else -- { -- switch (png_ptr->row_info.pixel_depth) -- { -- case 1: -- { -- png_bytep sp; -- png_bytep dp; -- int s_inc, s_start, s_end; -- int m; -- int shift; -- png_uint_32 i; -- -- sp = png_ptr->row_buf + 1; -- dp = row; -- m = 0x80; --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_PACKSWAP) -- { -- s_start = 0; -- s_end = 7; -- s_inc = 1; -- } -- else --#endif -- { -- s_start = 7; -- s_end = 0; -- s_inc = -1; -- } -- -- shift = s_start; -- -- for (i = 0; i < png_ptr->width; i++) -- { -- if (m & mask) -- { -- int value; -- -- value = (*sp >> shift) & 0x1; -- *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); -- *dp |= (png_byte)(value << shift); -- } -- -- if (shift == s_end) -- { -- shift = s_start; -- sp++; -- dp++; -- } -- else -- shift += s_inc; -- -- if (m == 1) -- m = 0x80; -- else -- m >>= 1; -- } -- break; -- } -- -- case 2: -- { -- png_bytep sp; -- png_bytep dp; -- int s_start, s_end, s_inc; -- int m; -- int shift; -- png_uint_32 i; -- int value; -- -- sp = png_ptr->row_buf + 1; -- dp = row; -- m = 0x80; --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_PACKSWAP) -- { -- s_start = 0; -- s_end = 6; -- s_inc = 2; -- } -- else --#endif -- { -- s_start = 6; -- s_end = 0; -- s_inc = -2; -- } -- -- shift = s_start; -- -- for (i = 0; i < png_ptr->width; i++) -- { -- if (m & mask) -- { -- value = (*sp >> shift) & 0x3; -- *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); -- *dp |= (png_byte)(value << shift); -- } -- -- if (shift == s_end) -- { -- shift = s_start; -- sp++; -- dp++; -- } -- else -- shift += s_inc; -- if (m == 1) -- m = 0x80; -- else -- m >>= 1; -- } -- break; -- } -- -- case 4: -- { -- png_bytep sp; -- png_bytep dp; -- int s_start, s_end, s_inc; -- int m; -- int shift; -- png_uint_32 i; -- int value; -- -- sp = png_ptr->row_buf + 1; -- dp = row; -- m = 0x80; --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_PACKSWAP) -- { -- s_start = 0; -- s_end = 4; -- s_inc = 4; -- } -- else --#endif -- { -- s_start = 4; -- s_end = 0; -- s_inc = -4; -- } -- shift = s_start; -- -- for (i = 0; i < png_ptr->width; i++) -- { -- if (m & mask) -- { -- value = (*sp >> shift) & 0xf; -- *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); -- *dp |= (png_byte)(value << shift); -- } -- -- if (shift == s_end) -- { -- shift = s_start; -- sp++; -- dp++; -- } -- else -- shift += s_inc; -- if (m == 1) -- m = 0x80; -- else -- m >>= 1; -- } -- break; -- } -- -- case 8: -- { -- png_bytep srcptr; -- png_bytep dstptr; -- png_uint_32 len; -- int m; -- int diff, unmask; -- -- __int64 mask0=0x0102040810204080; -- --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) -- /* && mmx_supported */ ) --#else -- if (mmx_supported) --#endif -- { -- srcptr = png_ptr->row_buf + 1; -- dstptr = row; -- m = 0x80; -- unmask = ~mask; -- len = png_ptr->width &~7; //reduce to multiple of 8 -- diff = png_ptr->width & 7; //amount lost -- -- _asm -- { -- movd mm7, unmask //load bit pattern -- psubb mm6,mm6 //zero mm6 -- punpcklbw mm7,mm7 -- punpcklwd mm7,mm7 -- punpckldq mm7,mm7 //fill register with 8 masks -- -- movq mm0,mask0 -- -- pand mm0,mm7 //nonzero if keep byte -- pcmpeqb mm0,mm6 //zeros->1s, v versa -- -- mov ecx,len //load length of line (pixels) -- mov esi,srcptr //load source -- mov ebx,dstptr //load dest -- cmp ecx,0 //lcr -- je mainloop8end -- --mainloop8: -- movq mm4,[esi] -- pand mm4,mm0 -- movq mm6,mm0 -- pandn mm6,[ebx] -- por mm4,mm6 -- movq [ebx],mm4 -- -- add esi,8 //inc by 8 bytes processed -- add ebx,8 -- sub ecx,8 //dec by 8 pixels processed -- -- ja mainloop8 --mainloop8end: -- -- mov ecx,diff -- cmp ecx,0 -- jz end8 -- -- mov edx,mask -- sal edx,24 //make low byte the high byte -- --secondloop8: -- sal edx,1 //move high bit to CF -- jnc skip8 //if CF = 0 -- mov al,[esi] -- mov [ebx],al --skip8: -- inc esi -- inc ebx -- -- dec ecx -- jnz secondloop8 --end8: -- emms -- } -- } -- else /* mmx not supported - use modified C routine */ -- { -- register unsigned int incr1, initial_val, final_val; -- png_size_t pixel_bytes; -- png_uint_32 i; -- register int disp = png_pass_inc[png_ptr->pass]; -- int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; -- -- pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); -- srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* -- pixel_bytes; -- dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; -- initial_val = offset_table[png_ptr->pass]*pixel_bytes; -- final_val = png_ptr->width*pixel_bytes; -- incr1 = (disp)*pixel_bytes; -- for (i = initial_val; i < final_val; i += incr1) -- { -- png_memcpy(dstptr, srcptr, pixel_bytes); -- srcptr += incr1; -- dstptr += incr1; -- } -- } /* end of else */ -- -- break; -- } // end 8 bpp -- -- case 16: -- { -- png_bytep srcptr; -- png_bytep dstptr; -- png_uint_32 len; -- int unmask, diff; -- __int64 mask1=0x0101020204040808, -- mask0=0x1010202040408080; -- --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) -- /* && mmx_supported */ ) --#else -- if (mmx_supported) --#endif -- { -- srcptr = png_ptr->row_buf + 1; -- dstptr = row; -- -- unmask = ~mask; -- len = (png_ptr->width)&~7; -- diff = (png_ptr->width)&7; -- _asm -- { -- movd mm7, unmask //load bit pattern -- psubb mm6,mm6 //zero mm6 -- punpcklbw mm7,mm7 -- punpcklwd mm7,mm7 -- punpckldq mm7,mm7 //fill register with 8 masks -- -- movq mm0,mask0 -- movq mm1,mask1 -- -- pand mm0,mm7 -- pand mm1,mm7 -- -- pcmpeqb mm0,mm6 -- pcmpeqb mm1,mm6 -- -- mov ecx,len //load length of line -- mov esi,srcptr //load source -- mov ebx,dstptr //load dest -- cmp ecx,0 //lcr -- jz mainloop16end -- --mainloop16: -- movq mm4,[esi] -- pand mm4,mm0 -- movq mm6,mm0 -- movq mm7,[ebx] -- pandn mm6,mm7 -- por mm4,mm6 -- movq [ebx],mm4 -- -- movq mm5,[esi+8] -- pand mm5,mm1 -- movq mm7,mm1 -- movq mm6,[ebx+8] -- pandn mm7,mm6 -- por mm5,mm7 -- movq [ebx+8],mm5 -- -- add esi,16 //inc by 16 bytes processed -- add ebx,16 -- sub ecx,8 //dec by 8 pixels processed -- -- ja mainloop16 -- --mainloop16end: -- mov ecx,diff -- cmp ecx,0 -- jz end16 -- -- mov edx,mask -- sal edx,24 //make low byte the high byte --secondloop16: -- sal edx,1 //move high bit to CF -- jnc skip16 //if CF = 0 -- mov ax,[esi] -- mov [ebx],ax --skip16: -- add esi,2 -- add ebx,2 -- -- dec ecx -- jnz secondloop16 --end16: -- emms -- } -- } -- else /* mmx not supported - use modified C routine */ -- { -- register unsigned int incr1, initial_val, final_val; -- png_size_t pixel_bytes; -- png_uint_32 i; -- register int disp = png_pass_inc[png_ptr->pass]; -- int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; -- -- pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); -- srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* -- pixel_bytes; -- dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; -- initial_val = offset_table[png_ptr->pass]*pixel_bytes; -- final_val = png_ptr->width*pixel_bytes; -- incr1 = (disp)*pixel_bytes; -- for (i = initial_val; i < final_val; i += incr1) -- { -- png_memcpy(dstptr, srcptr, pixel_bytes); -- srcptr += incr1; -- dstptr += incr1; -- } -- } /* end of else */ -- -- break; -- } // end 16 bpp -- -- case 24: -- { -- png_bytep srcptr; -- png_bytep dstptr; -- png_uint_32 len; -- int unmask, diff; -- -- __int64 mask2=0x0101010202020404, //24bpp -- mask1=0x0408080810101020, -- mask0=0x2020404040808080; -- -- srcptr = png_ptr->row_buf + 1; -- dstptr = row; -- -- unmask = ~mask; -- len = (png_ptr->width)&~7; -- diff = (png_ptr->width)&7; -- --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) -- /* && mmx_supported */ ) --#else -- if (mmx_supported) --#endif -- { -- _asm -- { -- movd mm7, unmask //load bit pattern -- psubb mm6,mm6 //zero mm6 -- punpcklbw mm7,mm7 -- punpcklwd mm7,mm7 -- punpckldq mm7,mm7 //fill register with 8 masks -- -- movq mm0,mask0 -- movq mm1,mask1 -- movq mm2,mask2 -- -- pand mm0,mm7 -- pand mm1,mm7 -- pand mm2,mm7 -- -- pcmpeqb mm0,mm6 -- pcmpeqb mm1,mm6 -- pcmpeqb mm2,mm6 -- -- mov ecx,len //load length of line -- mov esi,srcptr //load source -- mov ebx,dstptr //load dest -- cmp ecx,0 -- jz mainloop24end -- --mainloop24: -- movq mm4,[esi] -- pand mm4,mm0 -- movq mm6,mm0 -- movq mm7,[ebx] -- pandn mm6,mm7 -- por mm4,mm6 -- movq [ebx],mm4 -- -- -- movq mm5,[esi+8] -- pand mm5,mm1 -- movq mm7,mm1 -- movq mm6,[ebx+8] -- pandn mm7,mm6 -- por mm5,mm7 -- movq [ebx+8],mm5 -- -- movq mm6,[esi+16] -- pand mm6,mm2 -- movq mm4,mm2 -- movq mm7,[ebx+16] -- pandn mm4,mm7 -- por mm6,mm4 -- movq [ebx+16],mm6 -- -- add esi,24 //inc by 24 bytes processed -- add ebx,24 -- sub ecx,8 //dec by 8 pixels processed -- -- ja mainloop24 -- --mainloop24end: -- mov ecx,diff -- cmp ecx,0 -- jz end24 -- -- mov edx,mask -- sal edx,24 //make low byte the high byte --secondloop24: -- sal edx,1 //move high bit to CF -- jnc skip24 //if CF = 0 -- mov ax,[esi] -- mov [ebx],ax -- xor eax,eax -- mov al,[esi+2] -- mov [ebx+2],al --skip24: -- add esi,3 -- add ebx,3 -- -- dec ecx -- jnz secondloop24 -- --end24: -- emms -- } -- } -- else /* mmx not supported - use modified C routine */ -- { -- register unsigned int incr1, initial_val, final_val; -- png_size_t pixel_bytes; -- png_uint_32 i; -- register int disp = png_pass_inc[png_ptr->pass]; -- int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; -- -- pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); -- srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* -- pixel_bytes; -- dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; -- initial_val = offset_table[png_ptr->pass]*pixel_bytes; -- final_val = png_ptr->width*pixel_bytes; -- incr1 = (disp)*pixel_bytes; -- for (i = initial_val; i < final_val; i += incr1) -- { -- png_memcpy(dstptr, srcptr, pixel_bytes); -- srcptr += incr1; -- dstptr += incr1; -- } -- } /* end of else */ -- -- break; -- } // end 24 bpp -- -- case 32: -- { -- png_bytep srcptr; -- png_bytep dstptr; -- png_uint_32 len; -- int unmask, diff; -- -- __int64 mask3=0x0101010102020202, //32bpp -- mask2=0x0404040408080808, -- mask1=0x1010101020202020, -- mask0=0x4040404080808080; -- -- srcptr = png_ptr->row_buf + 1; -- dstptr = row; -- -- unmask = ~mask; -- len = (png_ptr->width)&~7; -- diff = (png_ptr->width)&7; -- --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) -- /* && mmx_supported */ ) --#else -- if (mmx_supported) --#endif -- { -- _asm -- { -- movd mm7, unmask //load bit pattern -- psubb mm6,mm6 //zero mm6 -- punpcklbw mm7,mm7 -- punpcklwd mm7,mm7 -- punpckldq mm7,mm7 //fill register with 8 masks -- -- movq mm0,mask0 -- movq mm1,mask1 -- movq mm2,mask2 -- movq mm3,mask3 -- -- pand mm0,mm7 -- pand mm1,mm7 -- pand mm2,mm7 -- pand mm3,mm7 -- -- pcmpeqb mm0,mm6 -- pcmpeqb mm1,mm6 -- pcmpeqb mm2,mm6 -- pcmpeqb mm3,mm6 -- -- mov ecx,len //load length of line -- mov esi,srcptr //load source -- mov ebx,dstptr //load dest -- -- cmp ecx,0 //lcr -- jz mainloop32end -- --mainloop32: -- movq mm4,[esi] -- pand mm4,mm0 -- movq mm6,mm0 -- movq mm7,[ebx] -- pandn mm6,mm7 -- por mm4,mm6 -- movq [ebx],mm4 -- -- movq mm5,[esi+8] -- pand mm5,mm1 -- movq mm7,mm1 -- movq mm6,[ebx+8] -- pandn mm7,mm6 -- por mm5,mm7 -- movq [ebx+8],mm5 -- -- movq mm6,[esi+16] -- pand mm6,mm2 -- movq mm4,mm2 -- movq mm7,[ebx+16] -- pandn mm4,mm7 -- por mm6,mm4 -- movq [ebx+16],mm6 -- -- movq mm7,[esi+24] -- pand mm7,mm3 -- movq mm5,mm3 -- movq mm4,[ebx+24] -- pandn mm5,mm4 -- por mm7,mm5 -- movq [ebx+24],mm7 -- -- add esi,32 //inc by 32 bytes processed -- add ebx,32 -- sub ecx,8 //dec by 8 pixels processed -- -- ja mainloop32 -- --mainloop32end: -- mov ecx,diff -- cmp ecx,0 -- jz end32 -- -- mov edx,mask -- sal edx,24 //make low byte the high byte --secondloop32: -- sal edx,1 //move high bit to CF -- jnc skip32 //if CF = 0 -- mov eax,[esi] -- mov [ebx],eax --skip32: -- add esi,4 -- add ebx,4 -- -- dec ecx -- jnz secondloop32 -- --end32: -- emms -- } -- } -- else /* mmx _not supported - Use modified C routine */ -- { -- register unsigned int incr1, initial_val, final_val; -- png_size_t pixel_bytes; -- png_uint_32 i; -- register int disp = png_pass_inc[png_ptr->pass]; -- int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; -- -- pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); -- srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* -- pixel_bytes; -- dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; -- initial_val = offset_table[png_ptr->pass]*pixel_bytes; -- final_val = png_ptr->width*pixel_bytes; -- incr1 = (disp)*pixel_bytes; -- for (i = initial_val; i < final_val; i += incr1) -- { -- png_memcpy(dstptr, srcptr, pixel_bytes); -- srcptr += incr1; -- dstptr += incr1; -- } -- } /* end of else */ -- -- break; -- } // end 32 bpp -- -- case 48: -- { -- png_bytep srcptr; -- png_bytep dstptr; -- png_uint_32 len; -- int unmask, diff; -- -- __int64 mask5=0x0101010101010202, -- mask4=0x0202020204040404, -- mask3=0x0404080808080808, -- mask2=0x1010101010102020, -- mask1=0x2020202040404040, -- mask0=0x4040808080808080; -- --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) -- /* && mmx_supported */ ) --#else -- if (mmx_supported) --#endif -- { -- srcptr = png_ptr->row_buf + 1; -- dstptr = row; -- -- unmask = ~mask; -- len = (png_ptr->width)&~7; -- diff = (png_ptr->width)&7; -- _asm -- { -- movd mm7, unmask //load bit pattern -- psubb mm6,mm6 //zero mm6 -- punpcklbw mm7,mm7 -- punpcklwd mm7,mm7 -- punpckldq mm7,mm7 //fill register with 8 masks -- -- movq mm0,mask0 -- movq mm1,mask1 -- movq mm2,mask2 -- movq mm3,mask3 -- movq mm4,mask4 -- movq mm5,mask5 -- -- pand mm0,mm7 -- pand mm1,mm7 -- pand mm2,mm7 -- pand mm3,mm7 -- pand mm4,mm7 -- pand mm5,mm7 -- -- pcmpeqb mm0,mm6 -- pcmpeqb mm1,mm6 -- pcmpeqb mm2,mm6 -- pcmpeqb mm3,mm6 -- pcmpeqb mm4,mm6 -- pcmpeqb mm5,mm6 -- -- mov ecx,len //load length of line -- mov esi,srcptr //load source -- mov ebx,dstptr //load dest -- -- cmp ecx,0 -- jz mainloop48end -- --mainloop48: -- movq mm7,[esi] -- pand mm7,mm0 -- movq mm6,mm0 -- pandn mm6,[ebx] -- por mm7,mm6 -- movq [ebx],mm7 -- -- movq mm6,[esi+8] -- pand mm6,mm1 -- movq mm7,mm1 -- pandn mm7,[ebx+8] -- por mm6,mm7 -- movq [ebx+8],mm6 -- -- movq mm6,[esi+16] -- pand mm6,mm2 -- movq mm7,mm2 -- pandn mm7,[ebx+16] -- por mm6,mm7 -- movq [ebx+16],mm6 -- -- movq mm7,[esi+24] -- pand mm7,mm3 -- movq mm6,mm3 -- pandn mm6,[ebx+24] -- por mm7,mm6 -- movq [ebx+24],mm7 -- -- movq mm6,[esi+32] -- pand mm6,mm4 -- movq mm7,mm4 -- pandn mm7,[ebx+32] -- por mm6,mm7 -- movq [ebx+32],mm6 -- -- movq mm7,[esi+40] -- pand mm7,mm5 -- movq mm6,mm5 -- pandn mm6,[ebx+40] -- por mm7,mm6 -- movq [ebx+40],mm7 -- -- add esi,48 //inc by 32 bytes processed -- add ebx,48 -- sub ecx,8 //dec by 8 pixels processed -- -- ja mainloop48 --mainloop48end: -- -- mov ecx,diff -- cmp ecx,0 -- jz end48 -- -- mov edx,mask -- sal edx,24 //make low byte the high byte -- --secondloop48: -- sal edx,1 //move high bit to CF -- jnc skip48 //if CF = 0 -- mov eax,[esi] -- mov [ebx],eax --skip48: -- add esi,4 -- add ebx,4 -- -- dec ecx -- jnz secondloop48 -- --end48: -- emms -- } -- } -- else /* mmx _not supported - Use modified C routine */ -- { -- register unsigned int incr1, initial_val, final_val; -- png_size_t pixel_bytes; -- png_uint_32 i; -- register int disp = png_pass_inc[png_ptr->pass]; -- int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; -- -- pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); -- srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* -- pixel_bytes; -- dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; -- initial_val = offset_table[png_ptr->pass]*pixel_bytes; -- final_val = png_ptr->width*pixel_bytes; -- incr1 = (disp)*pixel_bytes; -- for (i = initial_val; i < final_val; i += incr1) -- { -- png_memcpy(dstptr, srcptr, pixel_bytes); -- srcptr += incr1; -- dstptr += incr1; -- } -- } /* end of else */ -- -- break; -- } // end 48 bpp -- -- default: -- { -- png_bytep sptr; -- png_bytep dp; -- png_size_t pixel_bytes; -- int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; -- unsigned int i; -- register int disp = png_pass_inc[png_ptr->pass]; // get the offset -- register unsigned int incr1, initial_val, final_val; -- -- pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); -- sptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* -- pixel_bytes; -- dp = row + offset_table[png_ptr->pass]*pixel_bytes; -- initial_val = offset_table[png_ptr->pass]*pixel_bytes; -- final_val = png_ptr->width*pixel_bytes; -- incr1 = (disp)*pixel_bytes; -- for (i = initial_val; i < final_val; i += incr1) -- { -- png_memcpy(dp, sptr, pixel_bytes); -- sptr += incr1; -- dp += incr1; -- } -- break; -- } -- } /* end switch (png_ptr->row_info.pixel_depth) */ -- } /* end if (non-trivial mask) */ -- --} /* end png_combine_row() */ -- -- --#if defined(PNG_READ_INTERLACING_SUPPORTED) -- --void /* PRIVATE */ --png_do_read_interlace(png_structp png_ptr) --{ -- png_row_infop row_info = &(png_ptr->row_info); -- png_bytep row = png_ptr->row_buf + 1; -- int pass = png_ptr->pass; -- png_uint_32 transformations = png_ptr->transformations; --#ifdef PNG_USE_LOCAL_ARRAYS -- const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; --#endif -- -- png_debug(1,"in png_do_read_interlace\n"); -- -- if (mmx_supported == 2) { --#if !defined(PNG_1_0_X) -- /* this should have happened in png_init_mmx_flags() already */ -- png_warning(png_ptr, "asm_flags may not have been initialized"); --#endif -- png_mmx_support(); -- } -- -- if (row != NULL && row_info != NULL) -- { -- png_uint_32 final_width; -- -- final_width = row_info->width * png_pass_inc[pass]; -- -- switch (row_info->pixel_depth) -- { -- case 1: -- { -- png_bytep sp, dp; -- int sshift, dshift; -- int s_start, s_end, s_inc; -- png_byte v; -- png_uint_32 i; -- int j; -- -- sp = row + (png_size_t)((row_info->width - 1) >> 3); -- dp = row + (png_size_t)((final_width - 1) >> 3); --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (transformations & PNG_PACKSWAP) -- { -- sshift = (int)((row_info->width + 7) & 7); -- dshift = (int)((final_width + 7) & 7); -- s_start = 7; -- s_end = 0; -- s_inc = -1; -- } -- else --#endif -- { -- sshift = 7 - (int)((row_info->width + 7) & 7); -- dshift = 7 - (int)((final_width + 7) & 7); -- s_start = 0; -- s_end = 7; -- s_inc = 1; -- } -- -- for (i = row_info->width; i; i--) -- { -- v = (png_byte)((*sp >> sshift) & 0x1); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff); -- *dp |= (png_byte)(v << dshift); -- if (dshift == s_end) -- { -- dshift = s_start; -- dp--; -- } -- else -- dshift += s_inc; -- } -- if (sshift == s_end) -- { -- sshift = s_start; -- sp--; -- } -- else -- sshift += s_inc; -- } -- break; -- } -- -- case 2: -- { -- png_bytep sp, dp; -- int sshift, dshift; -- int s_start, s_end, s_inc; -- png_uint_32 i; -- -- sp = row + (png_size_t)((row_info->width - 1) >> 2); -- dp = row + (png_size_t)((final_width - 1) >> 2); --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (transformations & PNG_PACKSWAP) -- { -- sshift = (png_size_t)(((row_info->width + 3) & 3) << 1); -- dshift = (png_size_t)(((final_width + 3) & 3) << 1); -- s_start = 6; -- s_end = 0; -- s_inc = -2; -- } -- else --#endif -- { -- sshift = (png_size_t)((3 - ((row_info->width + 3) & 3)) << 1); -- dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1); -- s_start = 0; -- s_end = 6; -- s_inc = 2; -- } -- -- for (i = row_info->width; i; i--) -- { -- png_byte v; -- int j; -- -- v = (png_byte)((*sp >> sshift) & 0x3); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff); -- *dp |= (png_byte)(v << dshift); -- if (dshift == s_end) -- { -- dshift = s_start; -- dp--; -- } -- else -- dshift += s_inc; -- } -- if (sshift == s_end) -- { -- sshift = s_start; -- sp--; -- } -- else -- sshift += s_inc; -- } -- break; -- } -- -- case 4: -- { -- png_bytep sp, dp; -- int sshift, dshift; -- int s_start, s_end, s_inc; -- png_uint_32 i; -- -- sp = row + (png_size_t)((row_info->width - 1) >> 1); -- dp = row + (png_size_t)((final_width - 1) >> 1); --#if defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (transformations & PNG_PACKSWAP) -- { -- sshift = (png_size_t)(((row_info->width + 1) & 1) << 2); -- dshift = (png_size_t)(((final_width + 1) & 1) << 2); -- s_start = 4; -- s_end = 0; -- s_inc = -4; -- } -- else --#endif -- { -- sshift = (png_size_t)((1 - ((row_info->width + 1) & 1)) << 2); -- dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2); -- s_start = 0; -- s_end = 4; -- s_inc = 4; -- } -- -- for (i = row_info->width; i; i--) -- { -- png_byte v; -- int j; -- -- v = (png_byte)((*sp >> sshift) & 0xf); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff); -- *dp |= (png_byte)(v << dshift); -- if (dshift == s_end) -- { -- dshift = s_start; -- dp--; -- } -- else -- dshift += s_inc; -- } -- if (sshift == s_end) -- { -- sshift = s_start; -- sp--; -- } -- else -- sshift += s_inc; -- } -- break; -- } -- -- default: // This is the place where the routine is modified -- { -- __int64 const4 = 0x0000000000FFFFFF; -- // __int64 const5 = 0x000000FFFFFF0000; // unused... -- __int64 const6 = 0x00000000000000FF; -- png_bytep sptr, dp; -- png_uint_32 i; -- png_size_t pixel_bytes; -- int width = row_info->width; -- -- pixel_bytes = (row_info->pixel_depth >> 3); -- -- sptr = row + (width - 1) * pixel_bytes; -- dp = row + (final_width - 1) * pixel_bytes; -- // New code by Nirav Chhatrapati - Intel Corporation -- // sign fix by GRR -- // NOTE: there is NO MMX code for 48-bit and 64-bit images -- -- // use MMX routine if machine supports it --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE) -- /* && mmx_supported */ ) --#else -- if (mmx_supported) --#endif -- { -- if (pixel_bytes == 3) -- { -- if (((pass == 0) || (pass == 1)) && width) -- { -- _asm -- { -- mov esi, sptr -- mov edi, dp -- mov ecx, width -- sub edi, 21 // (png_pass_inc[pass] - 1)*pixel_bytes --loop_pass0: -- movd mm0, [esi] ; X X X X X v2 v1 v0 -- pand mm0, const4 ; 0 0 0 0 0 v2 v1 v0 -- movq mm1, mm0 ; 0 0 0 0 0 v2 v1 v0 -- psllq mm0, 16 ; 0 0 0 v2 v1 v0 0 0 -- movq mm2, mm0 ; 0 0 0 v2 v1 v0 0 0 -- psllq mm0, 24 ; v2 v1 v0 0 0 0 0 0 -- psrlq mm1, 8 ; 0 0 0 0 0 0 v2 v1 -- por mm0, mm2 ; v2 v1 v0 v2 v1 v0 0 0 -- por mm0, mm1 ; v2 v1 v0 v2 v1 v0 v2 v1 -- movq mm3, mm0 ; v2 v1 v0 v2 v1 v0 v2 v1 -- psllq mm0, 16 ; v0 v2 v1 v0 v2 v1 0 0 -- movq mm4, mm3 ; v2 v1 v0 v2 v1 v0 v2 v1 -- punpckhdq mm3, mm0 ; v0 v2 v1 v0 v2 v1 v0 v2 -- movq [edi+16] , mm4 -- psrlq mm0, 32 ; 0 0 0 0 v0 v2 v1 v0 -- movq [edi+8] , mm3 -- punpckldq mm0, mm4 ; v1 v0 v2 v1 v0 v2 v1 v0 -- sub esi, 3 -- movq [edi], mm0 -- sub edi, 24 -- //sub esi, 3 -- dec ecx -- jnz loop_pass0 -- EMMS -- } -- } -- else if (((pass == 2) || (pass == 3)) && width) -- { -- _asm -- { -- mov esi, sptr -- mov edi, dp -- mov ecx, width -- sub edi, 9 // (png_pass_inc[pass] - 1)*pixel_bytes --loop_pass2: -- movd mm0, [esi] ; X X X X X v2 v1 v0 -- pand mm0, const4 ; 0 0 0 0 0 v2 v1 v0 -- movq mm1, mm0 ; 0 0 0 0 0 v2 v1 v0 -- psllq mm0, 16 ; 0 0 0 v2 v1 v0 0 0 -- movq mm2, mm0 ; 0 0 0 v2 v1 v0 0 0 -- psllq mm0, 24 ; v2 v1 v0 0 0 0 0 0 -- psrlq mm1, 8 ; 0 0 0 0 0 0 v2 v1 -- por mm0, mm2 ; v2 v1 v0 v2 v1 v0 0 0 -- por mm0, mm1 ; v2 v1 v0 v2 v1 v0 v2 v1 -- movq [edi+4], mm0 ; move to memory -- psrlq mm0, 16 ; 0 0 v2 v1 v0 v2 v1 v0 -- movd [edi], mm0 ; move to memory -- sub esi, 3 -- sub edi, 12 -- dec ecx -- jnz loop_pass2 -- EMMS -- } -- } -- else if (width) /* && ((pass == 4) || (pass == 5)) */ -- { -- int width_mmx = ((width >> 1) << 1) - 8; -- if (width_mmx < 0) -- width_mmx = 0; -- width -= width_mmx; // 8 or 9 pix, 24 or 27 bytes -- if (width_mmx) -- { -- _asm -- { -- mov esi, sptr -- mov edi, dp -- mov ecx, width_mmx -- sub esi, 3 -- sub edi, 9 --loop_pass4: -- movq mm0, [esi] ; X X v2 v1 v0 v5 v4 v3 -- movq mm7, mm0 ; X X v2 v1 v0 v5 v4 v3 -- movq mm6, mm0 ; X X v2 v1 v0 v5 v4 v3 -- psllq mm0, 24 ; v1 v0 v5 v4 v3 0 0 0 -- pand mm7, const4 ; 0 0 0 0 0 v5 v4 v3 -- psrlq mm6, 24 ; 0 0 0 X X v2 v1 v0 -- por mm0, mm7 ; v1 v0 v5 v4 v3 v5 v4 v3 -- movq mm5, mm6 ; 0 0 0 X X v2 v1 v0 -- psllq mm6, 8 ; 0 0 X X v2 v1 v0 0 -- movq [edi], mm0 ; move quad to memory -- psrlq mm5, 16 ; 0 0 0 0 0 X X v2 -- pand mm5, const6 ; 0 0 0 0 0 0 0 v2 -- por mm6, mm5 ; 0 0 X X v2 v1 v0 v2 -- movd [edi+8], mm6 ; move double to memory -- sub esi, 6 -- sub edi, 12 -- sub ecx, 2 -- jnz loop_pass4 -- EMMS -- } -- } -- -- sptr -= width_mmx*3; -- dp -= width_mmx*6; -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- -- png_memcpy(v, sptr, 3); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, 3); -- dp -= 3; -- } -- sptr -= 3; -- } -- } -- } /* end of pixel_bytes == 3 */ -- -- else if (pixel_bytes == 1) -- { -- if (((pass == 0) || (pass == 1)) && width) -- { -- int width_mmx = ((width >> 2) << 2); -- width -= width_mmx; -- if (width_mmx) -- { -- _asm -- { -- mov esi, sptr -- mov edi, dp -- mov ecx, width_mmx -- sub edi, 31 -- sub esi, 3 --loop1_pass0: -- movd mm0, [esi] ; X X X X v0 v1 v2 v3 -- movq mm1, mm0 ; X X X X v0 v1 v2 v3 -- punpcklbw mm0, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 -- movq mm2, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 -- punpcklwd mm0, mm0 ; v2 v2 v2 v2 v3 v3 v3 v3 -- movq mm3, mm0 ; v2 v2 v2 v2 v3 v3 v3 v3 -- punpckldq mm0, mm0 ; v3 v3 v3 v3 v3 v3 v3 v3 -- punpckhdq mm3, mm3 ; v2 v2 v2 v2 v2 v2 v2 v2 -- movq [edi], mm0 ; move to memory v3 -- punpckhwd mm2, mm2 ; v0 v0 v0 v0 v1 v1 v1 v1 -- movq [edi+8], mm3 ; move to memory v2 -- movq mm4, mm2 ; v0 v0 v0 v0 v1 v1 v1 v1 -- punpckldq mm2, mm2 ; v1 v1 v1 v1 v1 v1 v1 v1 -- punpckhdq mm4, mm4 ; v0 v0 v0 v0 v0 v0 v0 v0 -- movq [edi+16], mm2 ; move to memory v1 -- movq [edi+24], mm4 ; move to memory v0 -- sub esi, 4 -- sub edi, 32 -- sub ecx, 4 -- jnz loop1_pass0 -- EMMS -- } -- } -- -- sptr -= width_mmx; -- dp -= width_mmx*8; -- for (i = width; i; i--) -- { -- int j; -- -- /* I simplified this part in version 1.0.4e -- * here and in several other instances where -- * pixel_bytes == 1 -- GR-P -- * -- * Original code: -- * -- * png_byte v[8]; -- * png_memcpy(v, sptr, pixel_bytes); -- * for (j = 0; j < png_pass_inc[pass]; j++) -- * { -- * png_memcpy(dp, v, pixel_bytes); -- * dp -= pixel_bytes; -- * } -- * sptr -= pixel_bytes; -- * -- * Replacement code is in the next three lines: -- */ -- -- for (j = 0; j < png_pass_inc[pass]; j++) -- *dp-- = *sptr; -- sptr--; -- } -- } -- else if (((pass == 2) || (pass == 3)) && width) -- { -- int width_mmx = ((width >> 2) << 2); -- width -= width_mmx; -- if (width_mmx) -- { -- _asm -- { -- mov esi, sptr -- mov edi, dp -- mov ecx, width_mmx -- sub edi, 15 -- sub esi, 3 --loop1_pass2: -- movd mm0, [esi] ; X X X X v0 v1 v2 v3 -- punpcklbw mm0, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 -- movq mm1, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 -- punpcklwd mm0, mm0 ; v2 v2 v2 v2 v3 v3 v3 v3 -- punpckhwd mm1, mm1 ; v0 v0 v0 v0 v1 v1 v1 v1 -- movq [edi], mm0 ; move to memory v2 and v3 -- sub esi, 4 -- movq [edi+8], mm1 ; move to memory v1 and v0 -- sub edi, 16 -- sub ecx, 4 -- jnz loop1_pass2 -- EMMS -- } -- } -- -- sptr -= width_mmx; -- dp -= width_mmx*4; -- for (i = width; i; i--) -- { -- int j; -- -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- *dp-- = *sptr; -- } -- sptr --; -- } -- } -- else if (width) /* && ((pass == 4) || (pass == 5))) */ -- { -- int width_mmx = ((width >> 3) << 3); -- width -= width_mmx; -- if (width_mmx) -- { -- _asm -- { -- mov esi, sptr -- mov edi, dp -- mov ecx, width_mmx -- sub edi, 15 -- sub esi, 7 --loop1_pass4: -- movq mm0, [esi] ; v0 v1 v2 v3 v4 v5 v6 v7 -- movq mm1, mm0 ; v0 v1 v2 v3 v4 v5 v6 v7 -- punpcklbw mm0, mm0 ; v4 v4 v5 v5 v6 v6 v7 v7 -- //movq mm1, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 -- punpckhbw mm1, mm1 ;v0 v0 v1 v1 v2 v2 v3 v3 -- movq [edi+8], mm1 ; move to memory v0 v1 v2 and v3 -- sub esi, 8 -- movq [edi], mm0 ; move to memory v4 v5 v6 and v7 -- //sub esi, 4 -- sub edi, 16 -- sub ecx, 8 -- jnz loop1_pass4 -- EMMS -- } -- } -- -- sptr -= width_mmx; -- dp -= width_mmx*2; -- for (i = width; i; i--) -- { -- int j; -- -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- *dp-- = *sptr; -- } -- sptr --; -- } -- } -- } /* end of pixel_bytes == 1 */ -- -- else if (pixel_bytes == 2) -- { -- if (((pass == 0) || (pass == 1)) && width) -- { -- int width_mmx = ((width >> 1) << 1); -- width -= width_mmx; -- if (width_mmx) -- { -- _asm -- { -- mov esi, sptr -- mov edi, dp -- mov ecx, width_mmx -- sub esi, 2 -- sub edi, 30 --loop2_pass0: -- movd mm0, [esi] ; X X X X v1 v0 v3 v2 -- punpcklwd mm0, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 -- movq mm1, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 -- punpckldq mm0, mm0 ; v3 v2 v3 v2 v3 v2 v3 v2 -- punpckhdq mm1, mm1 ; v1 v0 v1 v0 v1 v0 v1 v0 -- movq [edi], mm0 -- movq [edi + 8], mm0 -- movq [edi + 16], mm1 -- movq [edi + 24], mm1 -- sub esi, 4 -- sub edi, 32 -- sub ecx, 2 -- jnz loop2_pass0 -- EMMS -- } -- } -- -- sptr -= (width_mmx*2 - 2); // sign fixed -- dp -= (width_mmx*16 - 2); // sign fixed -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- sptr -= 2; -- png_memcpy(v, sptr, 2); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- dp -= 2; -- png_memcpy(dp, v, 2); -- } -- } -- } -- else if (((pass == 2) || (pass == 3)) && width) -- { -- int width_mmx = ((width >> 1) << 1) ; -- width -= width_mmx; -- if (width_mmx) -- { -- _asm -- { -- mov esi, sptr -- mov edi, dp -- mov ecx, width_mmx -- sub esi, 2 -- sub edi, 14 --loop2_pass2: -- movd mm0, [esi] ; X X X X v1 v0 v3 v2 -- punpcklwd mm0, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 -- movq mm1, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 -- punpckldq mm0, mm0 ; v3 v2 v3 v2 v3 v2 v3 v2 -- punpckhdq mm1, mm1 ; v1 v0 v1 v0 v1 v0 v1 v0 -- movq [edi], mm0 -- sub esi, 4 -- movq [edi + 8], mm1 -- //sub esi, 4 -- sub edi, 16 -- sub ecx, 2 -- jnz loop2_pass2 -- EMMS -- } -- } -- -- sptr -= (width_mmx*2 - 2); // sign fixed -- dp -= (width_mmx*8 - 2); // sign fixed -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- sptr -= 2; -- png_memcpy(v, sptr, 2); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- dp -= 2; -- png_memcpy(dp, v, 2); -- } -- } -- } -- else if (width) // pass == 4 or 5 -- { -- int width_mmx = ((width >> 1) << 1) ; -- width -= width_mmx; -- if (width_mmx) -- { -- _asm -- { -- mov esi, sptr -- mov edi, dp -- mov ecx, width_mmx -- sub esi, 2 -- sub edi, 6 --loop2_pass4: -- movd mm0, [esi] ; X X X X v1 v0 v3 v2 -- punpcklwd mm0, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 -- sub esi, 4 -- movq [edi], mm0 -- sub edi, 8 -- sub ecx, 2 -- jnz loop2_pass4 -- EMMS -- } -- } -- -- sptr -= (width_mmx*2 - 2); // sign fixed -- dp -= (width_mmx*4 - 2); // sign fixed -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- sptr -= 2; -- png_memcpy(v, sptr, 2); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- dp -= 2; -- png_memcpy(dp, v, 2); -- } -- } -- } -- } /* end of pixel_bytes == 2 */ -- -- else if (pixel_bytes == 4) -- { -- if (((pass == 0) || (pass == 1)) && width) -- { -- int width_mmx = ((width >> 1) << 1) ; -- width -= width_mmx; -- if (width_mmx) -- { -- _asm -- { -- mov esi, sptr -- mov edi, dp -- mov ecx, width_mmx -- sub esi, 4 -- sub edi, 60 --loop4_pass0: -- movq mm0, [esi] ; v3 v2 v1 v0 v7 v6 v5 v4 -- movq mm1, mm0 ; v3 v2 v1 v0 v7 v6 v5 v4 -- punpckldq mm0, mm0 ; v7 v6 v5 v4 v7 v6 v5 v4 -- punpckhdq mm1, mm1 ; v3 v2 v1 v0 v3 v2 v1 v0 -- movq [edi], mm0 -- movq [edi + 8], mm0 -- movq [edi + 16], mm0 -- movq [edi + 24], mm0 -- movq [edi+32], mm1 -- movq [edi + 40], mm1 -- movq [edi+ 48], mm1 -- sub esi, 8 -- movq [edi + 56], mm1 -- sub edi, 64 -- sub ecx, 2 -- jnz loop4_pass0 -- EMMS -- } -- } -- -- sptr -= (width_mmx*4 - 4); // sign fixed -- dp -= (width_mmx*32 - 4); // sign fixed -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- sptr -= 4; -- png_memcpy(v, sptr, 4); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- dp -= 4; -- png_memcpy(dp, v, 4); -- } -- } -- } -- else if (((pass == 2) || (pass == 3)) && width) -- { -- int width_mmx = ((width >> 1) << 1) ; -- width -= width_mmx; -- if (width_mmx) -- { -- _asm -- { -- mov esi, sptr -- mov edi, dp -- mov ecx, width_mmx -- sub esi, 4 -- sub edi, 28 --loop4_pass2: -- movq mm0, [esi] ; v3 v2 v1 v0 v7 v6 v5 v4 -- movq mm1, mm0 ; v3 v2 v1 v0 v7 v6 v5 v4 -- punpckldq mm0, mm0 ; v7 v6 v5 v4 v7 v6 v5 v4 -- punpckhdq mm1, mm1 ; v3 v2 v1 v0 v3 v2 v1 v0 -- movq [edi], mm0 -- movq [edi + 8], mm0 -- movq [edi+16], mm1 -- movq [edi + 24], mm1 -- sub esi, 8 -- sub edi, 32 -- sub ecx, 2 -- jnz loop4_pass2 -- EMMS -- } -- } -- -- sptr -= (width_mmx*4 - 4); // sign fixed -- dp -= (width_mmx*16 - 4); // sign fixed -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- sptr -= 4; -- png_memcpy(v, sptr, 4); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- dp -= 4; -- png_memcpy(dp, v, 4); -- } -- } -- } -- else if (width) // pass == 4 or 5 -- { -- int width_mmx = ((width >> 1) << 1) ; -- width -= width_mmx; -- if (width_mmx) -- { -- _asm -- { -- mov esi, sptr -- mov edi, dp -- mov ecx, width_mmx -- sub esi, 4 -- sub edi, 12 --loop4_pass4: -- movq mm0, [esi] ; v3 v2 v1 v0 v7 v6 v5 v4 -- movq mm1, mm0 ; v3 v2 v1 v0 v7 v6 v5 v4 -- punpckldq mm0, mm0 ; v7 v6 v5 v4 v7 v6 v5 v4 -- punpckhdq mm1, mm1 ; v3 v2 v1 v0 v3 v2 v1 v0 -- movq [edi], mm0 -- sub esi, 8 -- movq [edi + 8], mm1 -- sub edi, 16 -- sub ecx, 2 -- jnz loop4_pass4 -- EMMS -- } -- } -- -- sptr -= (width_mmx*4 - 4); // sign fixed -- dp -= (width_mmx*8 - 4); // sign fixed -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- sptr -= 4; -- png_memcpy(v, sptr, 4); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- dp -= 4; -- png_memcpy(dp, v, 4); -- } -- } -- } -- -- } /* end of pixel_bytes == 4 */ -- -- else if (pixel_bytes == 6) -- { -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- png_memcpy(v, sptr, 6); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, 6); -- dp -= 6; -- } -- sptr -= 6; -- } -- } /* end of pixel_bytes == 6 */ -- -- else -- { -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- png_memcpy(v, sptr, pixel_bytes); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, pixel_bytes); -- dp -= pixel_bytes; -- } -- sptr-= pixel_bytes; -- } -- } -- } /* end of mmx_supported */ -- -- else /* MMX not supported: use modified C code - takes advantage -- * of inlining of memcpy for a constant */ -- { -- if (pixel_bytes == 1) -- { -- for (i = width; i; i--) -- { -- int j; -- for (j = 0; j < png_pass_inc[pass]; j++) -- *dp-- = *sptr; -- sptr--; -- } -- } -- else if (pixel_bytes == 3) -- { -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- png_memcpy(v, sptr, pixel_bytes); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, pixel_bytes); -- dp -= pixel_bytes; -- } -- sptr -= pixel_bytes; -- } -- } -- else if (pixel_bytes == 2) -- { -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- png_memcpy(v, sptr, pixel_bytes); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, pixel_bytes); -- dp -= pixel_bytes; -- } -- sptr -= pixel_bytes; -- } -- } -- else if (pixel_bytes == 4) -- { -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- png_memcpy(v, sptr, pixel_bytes); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, pixel_bytes); -- dp -= pixel_bytes; -- } -- sptr -= pixel_bytes; -- } -- } -- else if (pixel_bytes == 6) -- { -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- png_memcpy(v, sptr, pixel_bytes); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, pixel_bytes); -- dp -= pixel_bytes; -- } -- sptr -= pixel_bytes; -- } -- } -- else -- { -- for (i = width; i; i--) -- { -- png_byte v[8]; -- int j; -- png_memcpy(v, sptr, pixel_bytes); -- for (j = 0; j < png_pass_inc[pass]; j++) -- { -- png_memcpy(dp, v, pixel_bytes); -- dp -= pixel_bytes; -- } -- sptr -= pixel_bytes; -- } -- } -- -- } /* end of MMX not supported */ -- break; -- } -- } /* end switch (row_info->pixel_depth) */ -- -- row_info->width = final_width; -- -- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,final_width); -- } -- --} -- --#endif /* PNG_READ_INTERLACING_SUPPORTED */ -- -- --// These variables are utilized in the functions below. They are declared --// globally here to ensure alignment on 8-byte boundaries. -- --union uAll { -- __int64 use; -- double align; --} LBCarryMask = {0x0101010101010101}, -- HBClearMask = {0x7f7f7f7f7f7f7f7f}, -- ActiveMask, ActiveMask2, ActiveMaskEnd, ShiftBpp, ShiftRem; -- -- --// Optimized code for PNG Average filter decoder --void /* PRIVATE */ --png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row -- , png_bytep prev_row) --{ -- int bpp; -- png_uint_32 FullLength; -- png_uint_32 MMXLength; -- //png_uint_32 len; -- int diff; -- -- bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel -- FullLength = row_info->rowbytes; // # of bytes to filter -- _asm { -- // Init address pointers and offset -- mov edi, row // edi ==> Avg(x) -- xor ebx, ebx // ebx ==> x -- mov edx, edi -- mov esi, prev_row // esi ==> Prior(x) -- sub edx, bpp // edx ==> Raw(x-bpp) -- -- xor eax, eax -- // Compute the Raw value for the first bpp bytes -- // Raw(x) = Avg(x) + (Prior(x)/2) --davgrlp: -- mov al, [esi + ebx] // Load al with Prior(x) -- inc ebx -- shr al, 1 // divide by 2 -- add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx -- cmp ebx, bpp -- mov [edi+ebx-1], al // Write back Raw(x); -- // mov does not affect flags; -1 to offset inc ebx -- jb davgrlp -- // get # of bytes to alignment -- mov diff, edi // take start of row -- add diff, ebx // add bpp -- add diff, 0xf // add 7 + 8 to incr past alignment boundary -- and diff, 0xfffffff8 // mask to alignment boundary -- sub diff, edi // subtract from start ==> value ebx at alignment -- jz davggo -- // fix alignment -- // Compute the Raw value for the bytes upto the alignment boundary -- // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) -- xor ecx, ecx --davglp1: -- xor eax, eax -- mov cl, [esi + ebx] // load cl with Prior(x) -- mov al, [edx + ebx] // load al with Raw(x-bpp) -- add ax, cx -- inc ebx -- shr ax, 1 // divide by 2 -- add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx -- cmp ebx, diff // Check if at alignment boundary -- mov [edi+ebx-1], al // Write back Raw(x); -- // mov does not affect flags; -1 to offset inc ebx -- jb davglp1 // Repeat until at alignment boundary --davggo: -- mov eax, FullLength -- mov ecx, eax -- sub eax, ebx // subtract alignment fix -- and eax, 0x00000007 // calc bytes over mult of 8 -- sub ecx, eax // drop over bytes from original length -- mov MMXLength, ecx -- } // end _asm block -- // Now do the math for the rest of the row -- switch ( bpp ) -- { -- case 3: -- { -- ActiveMask.use = 0x0000000000ffffff; -- ShiftBpp.use = 24; // == 3 * 8 -- ShiftRem.use = 40; // == 64 - 24 -- _asm { -- // Re-init address pointers and offset -- movq mm7, ActiveMask -- mov ebx, diff // ebx ==> x = offset to alignment boundary -- movq mm5, LBCarryMask -- mov edi, row // edi ==> Avg(x) -- movq mm4, HBClearMask -- mov esi, prev_row // esi ==> Prior(x) -- // PRIME the pump (load the first Raw(x-bpp) data set -- movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes -- // (we correct position in loop below) --davg3lp: -- movq mm0, [edi + ebx] // Load mm0 with Avg(x) -- // Add (Prev_row/2) to Average -- movq mm3, mm5 -- psrlq mm2, ShiftRem // Correct position Raw(x-bpp) data -- movq mm1, [esi + ebx] // Load mm1 with Prior(x) -- movq mm6, mm7 -- pand mm3, mm1 // get lsb for each prev_row byte -- psrlq mm1, 1 // divide prev_row bytes by 2 -- pand mm1, mm4 // clear invalid bit 7 of each byte -- paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte -- // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry -- movq mm1, mm3 // now use mm1 for getting LBCarrys -- pand mm1, mm2 // get LBCarrys for each byte where both -- // lsb's were == 1 (Only valid for active group) -- psrlq mm2, 1 // divide raw bytes by 2 -- pand mm2, mm4 // clear invalid bit 7 of each byte -- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte -- pand mm2, mm6 // Leave only Active Group 1 bytes to add to Avg -- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active -- // byte -- // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry -- psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 3-5 -- movq mm2, mm0 // mov updated Raws to mm2 -- psllq mm2, ShiftBpp // shift data to position correctly -- movq mm1, mm3 // now use mm1 for getting LBCarrys -- pand mm1, mm2 // get LBCarrys for each byte where both -- // lsb's were == 1 (Only valid for active group) -- psrlq mm2, 1 // divide raw bytes by 2 -- pand mm2, mm4 // clear invalid bit 7 of each byte -- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte -- pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg -- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active -- // byte -- -- // Add 3rd active group (Raw(x-bpp)/2) to Average with LBCarry -- psllq mm6, ShiftBpp // shift the mm6 mask to cover the last two -- // bytes -- movq mm2, mm0 // mov updated Raws to mm2 -- psllq mm2, ShiftBpp // shift data to position correctly -- // Data only needs to be shifted once here to -- // get the correct x-bpp offset. -- movq mm1, mm3 // now use mm1 for getting LBCarrys -- pand mm1, mm2 // get LBCarrys for each byte where both -- // lsb's were == 1 (Only valid for active group) -- psrlq mm2, 1 // divide raw bytes by 2 -- pand mm2, mm4 // clear invalid bit 7 of each byte -- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte -- pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg -- add ebx, 8 -- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active -- // byte -- -- // Now ready to write back to memory -- movq [edi + ebx - 8], mm0 -- // Move updated Raw(x) to use as Raw(x-bpp) for next loop -- cmp ebx, MMXLength -- movq mm2, mm0 // mov updated Raw(x) to mm2 -- jb davg3lp -- } // end _asm block -- } -- break; -- -- case 6: -- case 4: -- case 7: -- case 5: -- { -- ActiveMask.use = 0xffffffffffffffff; // use shift below to clear -- // appropriate inactive bytes -- ShiftBpp.use = bpp << 3; -- ShiftRem.use = 64 - ShiftBpp.use; -- _asm { -- movq mm4, HBClearMask -- // Re-init address pointers and offset -- mov ebx, diff // ebx ==> x = offset to alignment boundary -- // Load ActiveMask and clear all bytes except for 1st active group -- movq mm7, ActiveMask -- mov edi, row // edi ==> Avg(x) -- psrlq mm7, ShiftRem -- mov esi, prev_row // esi ==> Prior(x) -- movq mm6, mm7 -- movq mm5, LBCarryMask -- psllq mm6, ShiftBpp // Create mask for 2nd active group -- // PRIME the pump (load the first Raw(x-bpp) data set -- movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes -- // (we correct position in loop below) --davg4lp: -- movq mm0, [edi + ebx] -- psrlq mm2, ShiftRem // shift data to position correctly -- movq mm1, [esi + ebx] -- // Add (Prev_row/2) to Average -- movq mm3, mm5 -- pand mm3, mm1 // get lsb for each prev_row byte -- psrlq mm1, 1 // divide prev_row bytes by 2 -- pand mm1, mm4 // clear invalid bit 7 of each byte -- paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte -- // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry -- movq mm1, mm3 // now use mm1 for getting LBCarrys -- pand mm1, mm2 // get LBCarrys for each byte where both -- // lsb's were == 1 (Only valid for active group) -- psrlq mm2, 1 // divide raw bytes by 2 -- pand mm2, mm4 // clear invalid bit 7 of each byte -- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte -- pand mm2, mm7 // Leave only Active Group 1 bytes to add to Avg -- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active -- // byte -- // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry -- movq mm2, mm0 // mov updated Raws to mm2 -- psllq mm2, ShiftBpp // shift data to position correctly -- add ebx, 8 -- movq mm1, mm3 // now use mm1 for getting LBCarrys -- pand mm1, mm2 // get LBCarrys for each byte where both -- // lsb's were == 1 (Only valid for active group) -- psrlq mm2, 1 // divide raw bytes by 2 -- pand mm2, mm4 // clear invalid bit 7 of each byte -- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte -- pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg -- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active -- // byte -- cmp ebx, MMXLength -- // Now ready to write back to memory -- movq [edi + ebx - 8], mm0 -- // Prep Raw(x-bpp) for next loop -- movq mm2, mm0 // mov updated Raws to mm2 -- jb davg4lp -- } // end _asm block -- } -- break; -- case 2: -- { -- ActiveMask.use = 0x000000000000ffff; -- ShiftBpp.use = 16; // == 2 * 8 [BUGFIX] -- ShiftRem.use = 48; // == 64 - 16 [BUGFIX] -- _asm { -- // Load ActiveMask -- movq mm7, ActiveMask -- // Re-init address pointers and offset -- mov ebx, diff // ebx ==> x = offset to alignment boundary -- movq mm5, LBCarryMask -- mov edi, row // edi ==> Avg(x) -- movq mm4, HBClearMask -- mov esi, prev_row // esi ==> Prior(x) -- // PRIME the pump (load the first Raw(x-bpp) data set -- movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes -- // (we correct position in loop below) --davg2lp: -- movq mm0, [edi + ebx] -- psrlq mm2, ShiftRem // shift data to position correctly [BUGFIX] -- movq mm1, [esi + ebx] -- // Add (Prev_row/2) to Average -- movq mm3, mm5 -- pand mm3, mm1 // get lsb for each prev_row byte -- psrlq mm1, 1 // divide prev_row bytes by 2 -- pand mm1, mm4 // clear invalid bit 7 of each byte -- movq mm6, mm7 -- paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte -- // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry -- movq mm1, mm3 // now use mm1 for getting LBCarrys -- pand mm1, mm2 // get LBCarrys for each byte where both -- // lsb's were == 1 (Only valid for active group) -- psrlq mm2, 1 // divide raw bytes by 2 -- pand mm2, mm4 // clear invalid bit 7 of each byte -- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte -- pand mm2, mm6 // Leave only Active Group 1 bytes to add to Avg -- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte -- // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry -- psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 2 & 3 -- movq mm2, mm0 // mov updated Raws to mm2 -- psllq mm2, ShiftBpp // shift data to position correctly -- movq mm1, mm3 // now use mm1 for getting LBCarrys -- pand mm1, mm2 // get LBCarrys for each byte where both -- // lsb's were == 1 (Only valid for active group) -- psrlq mm2, 1 // divide raw bytes by 2 -- pand mm2, mm4 // clear invalid bit 7 of each byte -- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte -- pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg -- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte -- -- // Add rdd active group (Raw(x-bpp)/2) to Average with LBCarry -- psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 4 & 5 -- movq mm2, mm0 // mov updated Raws to mm2 -- psllq mm2, ShiftBpp // shift data to position correctly -- // Data only needs to be shifted once here to -- // get the correct x-bpp offset. -- movq mm1, mm3 // now use mm1 for getting LBCarrys -- pand mm1, mm2 // get LBCarrys for each byte where both -- // lsb's were == 1 (Only valid for active group) -- psrlq mm2, 1 // divide raw bytes by 2 -- pand mm2, mm4 // clear invalid bit 7 of each byte -- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte -- pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg -- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte -- -- // Add 4th active group (Raw(x-bpp)/2) to Average with LBCarry -- psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 6 & 7 -- movq mm2, mm0 // mov updated Raws to mm2 -- psllq mm2, ShiftBpp // shift data to position correctly -- // Data only needs to be shifted once here to -- // get the correct x-bpp offset. -- add ebx, 8 -- movq mm1, mm3 // now use mm1 for getting LBCarrys -- pand mm1, mm2 // get LBCarrys for each byte where both -- // lsb's were == 1 (Only valid for active group) -- psrlq mm2, 1 // divide raw bytes by 2 -- pand mm2, mm4 // clear invalid bit 7 of each byte -- paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte -- pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg -- paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte -- -- cmp ebx, MMXLength -- // Now ready to write back to memory -- movq [edi + ebx - 8], mm0 -- // Prep Raw(x-bpp) for next loop -- movq mm2, mm0 // mov updated Raws to mm2 -- jb davg2lp -- } // end _asm block -- } -- break; -- -- case 1: // bpp == 1 -- { -- _asm { -- // Re-init address pointers and offset -- mov ebx, diff // ebx ==> x = offset to alignment boundary -- mov edi, row // edi ==> Avg(x) -- cmp ebx, FullLength // Test if offset at end of array -- jnb davg1end -- // Do Paeth decode for remaining bytes -- mov esi, prev_row // esi ==> Prior(x) -- mov edx, edi -- xor ecx, ecx // zero ecx before using cl & cx in loop below -- sub edx, bpp // edx ==> Raw(x-bpp) --davg1lp: -- // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) -- xor eax, eax -- mov cl, [esi + ebx] // load cl with Prior(x) -- mov al, [edx + ebx] // load al with Raw(x-bpp) -- add ax, cx -- inc ebx -- shr ax, 1 // divide by 2 -- add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx -- cmp ebx, FullLength // Check if at end of array -- mov [edi+ebx-1], al // Write back Raw(x); -- // mov does not affect flags; -1 to offset inc ebx -- jb davg1lp --davg1end: -- } // end _asm block -- } -- return; -- -- case 8: // bpp == 8 -- { -- _asm { -- // Re-init address pointers and offset -- mov ebx, diff // ebx ==> x = offset to alignment boundary -- movq mm5, LBCarryMask -- mov edi, row // edi ==> Avg(x) -- movq mm4, HBClearMask -- mov esi, prev_row // esi ==> Prior(x) -- // PRIME the pump (load the first Raw(x-bpp) data set -- movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes -- // (NO NEED to correct position in loop below) --davg8lp: -- movq mm0, [edi + ebx] -- movq mm3, mm5 -- movq mm1, [esi + ebx] -- add ebx, 8 -- pand mm3, mm1 // get lsb for each prev_row byte -- psrlq mm1, 1 // divide prev_row bytes by 2 -- pand mm3, mm2 // get LBCarrys for each byte where both -- // lsb's were == 1 -- psrlq mm2, 1 // divide raw bytes by 2 -- pand mm1, mm4 // clear invalid bit 7 of each byte -- paddb mm0, mm3 // add LBCarrys to Avg for each byte -- pand mm2, mm4 // clear invalid bit 7 of each byte -- paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte -- paddb mm0, mm2 // add (Raw/2) to Avg for each byte -- cmp ebx, MMXLength -- movq [edi + ebx - 8], mm0 -- movq mm2, mm0 // reuse as Raw(x-bpp) -- jb davg8lp -- } // end _asm block -- } -- break; -- default: // bpp greater than 8 -- { -- _asm { -- movq mm5, LBCarryMask -- // Re-init address pointers and offset -- mov ebx, diff // ebx ==> x = offset to alignment boundary -- mov edi, row // edi ==> Avg(x) -- movq mm4, HBClearMask -- mov edx, edi -- mov esi, prev_row // esi ==> Prior(x) -- sub edx, bpp // edx ==> Raw(x-bpp) --davgAlp: -- movq mm0, [edi + ebx] -- movq mm3, mm5 -- movq mm1, [esi + ebx] -- pand mm3, mm1 // get lsb for each prev_row byte -- movq mm2, [edx + ebx] -- psrlq mm1, 1 // divide prev_row bytes by 2 -- pand mm3, mm2 // get LBCarrys for each byte where both -- // lsb's were == 1 -- psrlq mm2, 1 // divide raw bytes by 2 -- pand mm1, mm4 // clear invalid bit 7 of each byte -- paddb mm0, mm3 // add LBCarrys to Avg for each byte -- pand mm2, mm4 // clear invalid bit 7 of each byte -- paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte -- add ebx, 8 -- paddb mm0, mm2 // add (Raw/2) to Avg for each byte -- cmp ebx, MMXLength -- movq [edi + ebx - 8], mm0 -- jb davgAlp -- } // end _asm block -- } -- break; -- } // end switch ( bpp ) -- -- _asm { -- // MMX acceleration complete now do clean-up -- // Check if any remaining bytes left to decode -- mov ebx, MMXLength // ebx ==> x = offset bytes remaining after MMX -- mov edi, row // edi ==> Avg(x) -- cmp ebx, FullLength // Test if offset at end of array -- jnb davgend -- // Do Paeth decode for remaining bytes -- mov esi, prev_row // esi ==> Prior(x) -- mov edx, edi -- xor ecx, ecx // zero ecx before using cl & cx in loop below -- sub edx, bpp // edx ==> Raw(x-bpp) --davglp2: -- // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) -- xor eax, eax -- mov cl, [esi + ebx] // load cl with Prior(x) -- mov al, [edx + ebx] // load al with Raw(x-bpp) -- add ax, cx -- inc ebx -- shr ax, 1 // divide by 2 -- add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx -- cmp ebx, FullLength // Check if at end of array -- mov [edi+ebx-1], al // Write back Raw(x); -- // mov does not affect flags; -1 to offset inc ebx -- jb davglp2 --davgend: -- emms // End MMX instructions; prep for possible FP instrs. -- } // end _asm block --} -- --// Optimized code for PNG Paeth filter decoder --void /* PRIVATE */ --png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row, -- png_bytep prev_row) --{ -- png_uint_32 FullLength; -- png_uint_32 MMXLength; -- //png_uint_32 len; -- int bpp; -- int diff; -- //int ptemp; -- int patemp, pbtemp, pctemp; -- -- bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel -- FullLength = row_info->rowbytes; // # of bytes to filter -- _asm -- { -- xor ebx, ebx // ebx ==> x offset -- mov edi, row -- xor edx, edx // edx ==> x-bpp offset -- mov esi, prev_row -- xor eax, eax -- -- // Compute the Raw value for the first bpp bytes -- // Note: the formula works out to be always -- // Paeth(x) = Raw(x) + Prior(x) where x < bpp --dpthrlp: -- mov al, [edi + ebx] -- add al, [esi + ebx] -- inc ebx -- cmp ebx, bpp -- mov [edi + ebx - 1], al -- jb dpthrlp -- // get # of bytes to alignment -- mov diff, edi // take start of row -- add diff, ebx // add bpp -- xor ecx, ecx -- add diff, 0xf // add 7 + 8 to incr past alignment boundary -- and diff, 0xfffffff8 // mask to alignment boundary -- sub diff, edi // subtract from start ==> value ebx at alignment -- jz dpthgo -- // fix alignment --dpthlp1: -- xor eax, eax -- // pav = p - a = (a + b - c) - a = b - c -- mov al, [esi + ebx] // load Prior(x) into al -- mov cl, [esi + edx] // load Prior(x-bpp) into cl -- sub eax, ecx // subtract Prior(x-bpp) -- mov patemp, eax // Save pav for later use -- xor eax, eax -- // pbv = p - b = (a + b - c) - b = a - c -- mov al, [edi + edx] // load Raw(x-bpp) into al -- sub eax, ecx // subtract Prior(x-bpp) -- mov ecx, eax -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- add eax, patemp // pcv = pav + pbv -- // pc = abs(pcv) -- test eax, 0x80000000 -- jz dpthpca -- neg eax // reverse sign of neg values --dpthpca: -- mov pctemp, eax // save pc for later use -- // pb = abs(pbv) -- test ecx, 0x80000000 -- jz dpthpba -- neg ecx // reverse sign of neg values --dpthpba: -- mov pbtemp, ecx // save pb for later use -- // pa = abs(pav) -- mov eax, patemp -- test eax, 0x80000000 -- jz dpthpaa -- neg eax // reverse sign of neg values --dpthpaa: -- mov patemp, eax // save pa for later use -- // test if pa <= pb -- cmp eax, ecx -- jna dpthabb -- // pa > pb; now test if pb <= pc -- cmp ecx, pctemp -- jna dpthbbc -- // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) -- mov cl, [esi + edx] // load Prior(x-bpp) into cl -- jmp dpthpaeth --dpthbbc: -- // pb <= pc; Raw(x) = Paeth(x) + Prior(x) -- mov cl, [esi + ebx] // load Prior(x) into cl -- jmp dpthpaeth --dpthabb: -- // pa <= pb; now test if pa <= pc -- cmp eax, pctemp -- jna dpthabc -- // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) -- mov cl, [esi + edx] // load Prior(x-bpp) into cl -- jmp dpthpaeth --dpthabc: -- // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) -- mov cl, [edi + edx] // load Raw(x-bpp) into cl --dpthpaeth: -- inc ebx -- inc edx -- // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 -- add [edi + ebx - 1], cl -- cmp ebx, diff -- jb dpthlp1 --dpthgo: -- mov ecx, FullLength -- mov eax, ecx -- sub eax, ebx // subtract alignment fix -- and eax, 0x00000007 // calc bytes over mult of 8 -- sub ecx, eax // drop over bytes from original length -- mov MMXLength, ecx -- } // end _asm block -- // Now do the math for the rest of the row -- switch ( bpp ) -- { -- case 3: -- { -- ActiveMask.use = 0x0000000000ffffff; -- ActiveMaskEnd.use = 0xffff000000000000; -- ShiftBpp.use = 24; // == bpp(3) * 8 -- ShiftRem.use = 40; // == 64 - 24 -- _asm -- { -- mov ebx, diff -- mov edi, row -- mov esi, prev_row -- pxor mm0, mm0 -- // PRIME the pump (load the first Raw(x-bpp) data set -- movq mm1, [edi+ebx-8] --dpth3lp: -- psrlq mm1, ShiftRem // shift last 3 bytes to 1st 3 bytes -- movq mm2, [esi + ebx] // load b=Prior(x) -- punpcklbw mm1, mm0 // Unpack High bytes of a -- movq mm3, [esi+ebx-8] // Prep c=Prior(x-bpp) bytes -- punpcklbw mm2, mm0 // Unpack High bytes of b -- psrlq mm3, ShiftRem // shift last 3 bytes to 1st 3 bytes -- // pav = p - a = (a + b - c) - a = b - c -- movq mm4, mm2 -- punpcklbw mm3, mm0 // Unpack High bytes of c -- // pbv = p - b = (a + b - c) - b = a - c -- movq mm5, mm1 -- psubw mm4, mm3 -- pxor mm7, mm7 -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- movq mm6, mm4 -- psubw mm5, mm3 -- -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 -- paddw mm6, mm5 -- pand mm0, mm4 // Only pav bytes < 0 in mm7 -- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 -- psubw mm4, mm0 -- pand mm7, mm5 // Only pbv bytes < 0 in mm0 -- psubw mm4, mm0 -- psubw mm5, mm7 -- pxor mm0, mm0 -- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 -- pand mm0, mm6 // Only pav bytes < 0 in mm7 -- psubw mm5, mm7 -- psubw mm6, mm0 -- // test pa <= pb -- movq mm7, mm4 -- psubw mm6, mm0 -- pcmpgtw mm7, mm5 // pa > pb? -- movq mm0, mm7 -- // use mm7 mask to merge pa & pb -- pand mm5, mm7 -- // use mm0 mask copy to merge a & b -- pand mm2, mm0 -- pandn mm7, mm4 -- pandn mm0, mm1 -- paddw mm7, mm5 -- paddw mm0, mm2 -- // test ((pa <= pb)? pa:pb) <= pc -- pcmpgtw mm7, mm6 // pab > pc? -- pxor mm1, mm1 -- pand mm3, mm7 -- pandn mm7, mm0 -- paddw mm7, mm3 -- pxor mm0, mm0 -- packuswb mm7, mm1 -- movq mm3, [esi + ebx] // load c=Prior(x-bpp) -- pand mm7, ActiveMask -- movq mm2, mm3 // load b=Prior(x) step 1 -- paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) -- punpcklbw mm3, mm0 // Unpack High bytes of c -- movq [edi + ebx], mm7 // write back updated value -- movq mm1, mm7 // Now mm1 will be used as Raw(x-bpp) -- // Now do Paeth for 2nd set of bytes (3-5) -- psrlq mm2, ShiftBpp // load b=Prior(x) step 2 -- punpcklbw mm1, mm0 // Unpack High bytes of a -- pxor mm7, mm7 -- punpcklbw mm2, mm0 // Unpack High bytes of b -- // pbv = p - b = (a + b - c) - b = a - c -- movq mm5, mm1 -- // pav = p - a = (a + b - c) - a = b - c -- movq mm4, mm2 -- psubw mm5, mm3 -- psubw mm4, mm3 -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = -- // pav + pbv = pbv + pav -- movq mm6, mm5 -- paddw mm6, mm4 -- -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- pcmpgtw mm0, mm5 // Create mask pbv bytes < 0 -- pcmpgtw mm7, mm4 // Create mask pav bytes < 0 -- pand mm0, mm5 // Only pbv bytes < 0 in mm0 -- pand mm7, mm4 // Only pav bytes < 0 in mm7 -- psubw mm5, mm0 -- psubw mm4, mm7 -- psubw mm5, mm0 -- psubw mm4, mm7 -- pxor mm0, mm0 -- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 -- pand mm0, mm6 // Only pav bytes < 0 in mm7 -- psubw mm6, mm0 -- // test pa <= pb -- movq mm7, mm4 -- psubw mm6, mm0 -- pcmpgtw mm7, mm5 // pa > pb? -- movq mm0, mm7 -- // use mm7 mask to merge pa & pb -- pand mm5, mm7 -- // use mm0 mask copy to merge a & b -- pand mm2, mm0 -- pandn mm7, mm4 -- pandn mm0, mm1 -- paddw mm7, mm5 -- paddw mm0, mm2 -- // test ((pa <= pb)? pa:pb) <= pc -- pcmpgtw mm7, mm6 // pab > pc? -- movq mm2, [esi + ebx] // load b=Prior(x) -- pand mm3, mm7 -- pandn mm7, mm0 -- pxor mm1, mm1 -- paddw mm7, mm3 -- pxor mm0, mm0 -- packuswb mm7, mm1 -- movq mm3, mm2 // load c=Prior(x-bpp) step 1 -- pand mm7, ActiveMask -- punpckhbw mm2, mm0 // Unpack High bytes of b -- psllq mm7, ShiftBpp // Shift bytes to 2nd group of 3 bytes -- // pav = p - a = (a + b - c) - a = b - c -- movq mm4, mm2 -- paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) -- psllq mm3, ShiftBpp // load c=Prior(x-bpp) step 2 -- movq [edi + ebx], mm7 // write back updated value -- movq mm1, mm7 -- punpckhbw mm3, mm0 // Unpack High bytes of c -- psllq mm1, ShiftBpp // Shift bytes -- // Now mm1 will be used as Raw(x-bpp) -- // Now do Paeth for 3rd, and final, set of bytes (6-7) -- pxor mm7, mm7 -- punpckhbw mm1, mm0 // Unpack High bytes of a -- psubw mm4, mm3 -- // pbv = p - b = (a + b - c) - b = a - c -- movq mm5, mm1 -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- movq mm6, mm4 -- psubw mm5, mm3 -- pxor mm0, mm0 -- paddw mm6, mm5 -- -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 -- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 -- pand mm0, mm4 // Only pav bytes < 0 in mm7 -- pand mm7, mm5 // Only pbv bytes < 0 in mm0 -- psubw mm4, mm0 -- psubw mm5, mm7 -- psubw mm4, mm0 -- psubw mm5, mm7 -- pxor mm0, mm0 -- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 -- pand mm0, mm6 // Only pav bytes < 0 in mm7 -- psubw mm6, mm0 -- // test pa <= pb -- movq mm7, mm4 -- psubw mm6, mm0 -- pcmpgtw mm7, mm5 // pa > pb? -- movq mm0, mm7 -- // use mm0 mask copy to merge a & b -- pand mm2, mm0 -- // use mm7 mask to merge pa & pb -- pand mm5, mm7 -- pandn mm0, mm1 -- pandn mm7, mm4 -- paddw mm0, mm2 -- paddw mm7, mm5 -- // test ((pa <= pb)? pa:pb) <= pc -- pcmpgtw mm7, mm6 // pab > pc? -- pand mm3, mm7 -- pandn mm7, mm0 -- paddw mm7, mm3 -- pxor mm1, mm1 -- packuswb mm1, mm7 -- // Step ebx to next set of 8 bytes and repeat loop til done -- add ebx, 8 -- pand mm1, ActiveMaskEnd -- paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) -- -- cmp ebx, MMXLength -- pxor mm0, mm0 // pxor does not affect flags -- movq [edi + ebx - 8], mm1 // write back updated value -- // mm1 will be used as Raw(x-bpp) next loop -- // mm3 ready to be used as Prior(x-bpp) next loop -- jb dpth3lp -- } // end _asm block -- } -- break; -- -- case 6: -- case 7: -- case 5: -- { -- ActiveMask.use = 0x00000000ffffffff; -- ActiveMask2.use = 0xffffffff00000000; -- ShiftBpp.use = bpp << 3; // == bpp * 8 -- ShiftRem.use = 64 - ShiftBpp.use; -- _asm -- { -- mov ebx, diff -- mov edi, row -- mov esi, prev_row -- // PRIME the pump (load the first Raw(x-bpp) data set -- movq mm1, [edi+ebx-8] -- pxor mm0, mm0 --dpth6lp: -- // Must shift to position Raw(x-bpp) data -- psrlq mm1, ShiftRem -- // Do first set of 4 bytes -- movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes -- punpcklbw mm1, mm0 // Unpack Low bytes of a -- movq mm2, [esi + ebx] // load b=Prior(x) -- punpcklbw mm2, mm0 // Unpack Low bytes of b -- // Must shift to position Prior(x-bpp) data -- psrlq mm3, ShiftRem -- // pav = p - a = (a + b - c) - a = b - c -- movq mm4, mm2 -- punpcklbw mm3, mm0 // Unpack Low bytes of c -- // pbv = p - b = (a + b - c) - b = a - c -- movq mm5, mm1 -- psubw mm4, mm3 -- pxor mm7, mm7 -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- movq mm6, mm4 -- psubw mm5, mm3 -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 -- paddw mm6, mm5 -- pand mm0, mm4 // Only pav bytes < 0 in mm7 -- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 -- psubw mm4, mm0 -- pand mm7, mm5 // Only pbv bytes < 0 in mm0 -- psubw mm4, mm0 -- psubw mm5, mm7 -- pxor mm0, mm0 -- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 -- pand mm0, mm6 // Only pav bytes < 0 in mm7 -- psubw mm5, mm7 -- psubw mm6, mm0 -- // test pa <= pb -- movq mm7, mm4 -- psubw mm6, mm0 -- pcmpgtw mm7, mm5 // pa > pb? -- movq mm0, mm7 -- // use mm7 mask to merge pa & pb -- pand mm5, mm7 -- // use mm0 mask copy to merge a & b -- pand mm2, mm0 -- pandn mm7, mm4 -- pandn mm0, mm1 -- paddw mm7, mm5 -- paddw mm0, mm2 -- // test ((pa <= pb)? pa:pb) <= pc -- pcmpgtw mm7, mm6 // pab > pc? -- pxor mm1, mm1 -- pand mm3, mm7 -- pandn mm7, mm0 -- paddw mm7, mm3 -- pxor mm0, mm0 -- packuswb mm7, mm1 -- movq mm3, [esi + ebx - 8] // load c=Prior(x-bpp) -- pand mm7, ActiveMask -- psrlq mm3, ShiftRem -- movq mm2, [esi + ebx] // load b=Prior(x) step 1 -- paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) -- movq mm6, mm2 -- movq [edi + ebx], mm7 // write back updated value -- movq mm1, [edi+ebx-8] -- psllq mm6, ShiftBpp -- movq mm5, mm7 -- psrlq mm1, ShiftRem -- por mm3, mm6 -- psllq mm5, ShiftBpp -- punpckhbw mm3, mm0 // Unpack High bytes of c -- por mm1, mm5 -- // Do second set of 4 bytes -- punpckhbw mm2, mm0 // Unpack High bytes of b -- punpckhbw mm1, mm0 // Unpack High bytes of a -- // pav = p - a = (a + b - c) - a = b - c -- movq mm4, mm2 -- // pbv = p - b = (a + b - c) - b = a - c -- movq mm5, mm1 -- psubw mm4, mm3 -- pxor mm7, mm7 -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- movq mm6, mm4 -- psubw mm5, mm3 -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 -- paddw mm6, mm5 -- pand mm0, mm4 // Only pav bytes < 0 in mm7 -- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 -- psubw mm4, mm0 -- pand mm7, mm5 // Only pbv bytes < 0 in mm0 -- psubw mm4, mm0 -- psubw mm5, mm7 -- pxor mm0, mm0 -- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 -- pand mm0, mm6 // Only pav bytes < 0 in mm7 -- psubw mm5, mm7 -- psubw mm6, mm0 -- // test pa <= pb -- movq mm7, mm4 -- psubw mm6, mm0 -- pcmpgtw mm7, mm5 // pa > pb? -- movq mm0, mm7 -- // use mm7 mask to merge pa & pb -- pand mm5, mm7 -- // use mm0 mask copy to merge a & b -- pand mm2, mm0 -- pandn mm7, mm4 -- pandn mm0, mm1 -- paddw mm7, mm5 -- paddw mm0, mm2 -- // test ((pa <= pb)? pa:pb) <= pc -- pcmpgtw mm7, mm6 // pab > pc? -- pxor mm1, mm1 -- pand mm3, mm7 -- pandn mm7, mm0 -- pxor mm1, mm1 -- paddw mm7, mm3 -- pxor mm0, mm0 -- // Step ex to next set of 8 bytes and repeat loop til done -- add ebx, 8 -- packuswb mm1, mm7 -- paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) -- cmp ebx, MMXLength -- movq [edi + ebx - 8], mm1 // write back updated value -- // mm1 will be used as Raw(x-bpp) next loop -- jb dpth6lp -- } // end _asm block -- } -- break; -- -- case 4: -- { -- ActiveMask.use = 0x00000000ffffffff; -- _asm { -- mov ebx, diff -- mov edi, row -- mov esi, prev_row -- pxor mm0, mm0 -- // PRIME the pump (load the first Raw(x-bpp) data set -- movq mm1, [edi+ebx-8] // Only time should need to read -- // a=Raw(x-bpp) bytes --dpth4lp: -- // Do first set of 4 bytes -- movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes -- punpckhbw mm1, mm0 // Unpack Low bytes of a -- movq mm2, [esi + ebx] // load b=Prior(x) -- punpcklbw mm2, mm0 // Unpack High bytes of b -- // pav = p - a = (a + b - c) - a = b - c -- movq mm4, mm2 -- punpckhbw mm3, mm0 // Unpack High bytes of c -- // pbv = p - b = (a + b - c) - b = a - c -- movq mm5, mm1 -- psubw mm4, mm3 -- pxor mm7, mm7 -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- movq mm6, mm4 -- psubw mm5, mm3 -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 -- paddw mm6, mm5 -- pand mm0, mm4 // Only pav bytes < 0 in mm7 -- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 -- psubw mm4, mm0 -- pand mm7, mm5 // Only pbv bytes < 0 in mm0 -- psubw mm4, mm0 -- psubw mm5, mm7 -- pxor mm0, mm0 -- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 -- pand mm0, mm6 // Only pav bytes < 0 in mm7 -- psubw mm5, mm7 -- psubw mm6, mm0 -- // test pa <= pb -- movq mm7, mm4 -- psubw mm6, mm0 -- pcmpgtw mm7, mm5 // pa > pb? -- movq mm0, mm7 -- // use mm7 mask to merge pa & pb -- pand mm5, mm7 -- // use mm0 mask copy to merge a & b -- pand mm2, mm0 -- pandn mm7, mm4 -- pandn mm0, mm1 -- paddw mm7, mm5 -- paddw mm0, mm2 -- // test ((pa <= pb)? pa:pb) <= pc -- pcmpgtw mm7, mm6 // pab > pc? -- pxor mm1, mm1 -- pand mm3, mm7 -- pandn mm7, mm0 -- paddw mm7, mm3 -- pxor mm0, mm0 -- packuswb mm7, mm1 -- movq mm3, [esi + ebx] // load c=Prior(x-bpp) -- pand mm7, ActiveMask -- movq mm2, mm3 // load b=Prior(x) step 1 -- paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) -- punpcklbw mm3, mm0 // Unpack High bytes of c -- movq [edi + ebx], mm7 // write back updated value -- movq mm1, mm7 // Now mm1 will be used as Raw(x-bpp) -- // Do second set of 4 bytes -- punpckhbw mm2, mm0 // Unpack Low bytes of b -- punpcklbw mm1, mm0 // Unpack Low bytes of a -- // pav = p - a = (a + b - c) - a = b - c -- movq mm4, mm2 -- // pbv = p - b = (a + b - c) - b = a - c -- movq mm5, mm1 -- psubw mm4, mm3 -- pxor mm7, mm7 -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- movq mm6, mm4 -- psubw mm5, mm3 -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 -- paddw mm6, mm5 -- pand mm0, mm4 // Only pav bytes < 0 in mm7 -- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 -- psubw mm4, mm0 -- pand mm7, mm5 // Only pbv bytes < 0 in mm0 -- psubw mm4, mm0 -- psubw mm5, mm7 -- pxor mm0, mm0 -- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 -- pand mm0, mm6 // Only pav bytes < 0 in mm7 -- psubw mm5, mm7 -- psubw mm6, mm0 -- // test pa <= pb -- movq mm7, mm4 -- psubw mm6, mm0 -- pcmpgtw mm7, mm5 // pa > pb? -- movq mm0, mm7 -- // use mm7 mask to merge pa & pb -- pand mm5, mm7 -- // use mm0 mask copy to merge a & b -- pand mm2, mm0 -- pandn mm7, mm4 -- pandn mm0, mm1 -- paddw mm7, mm5 -- paddw mm0, mm2 -- // test ((pa <= pb)? pa:pb) <= pc -- pcmpgtw mm7, mm6 // pab > pc? -- pxor mm1, mm1 -- pand mm3, mm7 -- pandn mm7, mm0 -- pxor mm1, mm1 -- paddw mm7, mm3 -- pxor mm0, mm0 -- // Step ex to next set of 8 bytes and repeat loop til done -- add ebx, 8 -- packuswb mm1, mm7 -- paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) -- cmp ebx, MMXLength -- movq [edi + ebx - 8], mm1 // write back updated value -- // mm1 will be used as Raw(x-bpp) next loop -- jb dpth4lp -- } // end _asm block -- } -- break; -- case 8: // bpp == 8 -- { -- ActiveMask.use = 0x00000000ffffffff; -- _asm { -- mov ebx, diff -- mov edi, row -- mov esi, prev_row -- pxor mm0, mm0 -- // PRIME the pump (load the first Raw(x-bpp) data set -- movq mm1, [edi+ebx-8] // Only time should need to read -- // a=Raw(x-bpp) bytes --dpth8lp: -- // Do first set of 4 bytes -- movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes -- punpcklbw mm1, mm0 // Unpack Low bytes of a -- movq mm2, [esi + ebx] // load b=Prior(x) -- punpcklbw mm2, mm0 // Unpack Low bytes of b -- // pav = p - a = (a + b - c) - a = b - c -- movq mm4, mm2 -- punpcklbw mm3, mm0 // Unpack Low bytes of c -- // pbv = p - b = (a + b - c) - b = a - c -- movq mm5, mm1 -- psubw mm4, mm3 -- pxor mm7, mm7 -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- movq mm6, mm4 -- psubw mm5, mm3 -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 -- paddw mm6, mm5 -- pand mm0, mm4 // Only pav bytes < 0 in mm7 -- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 -- psubw mm4, mm0 -- pand mm7, mm5 // Only pbv bytes < 0 in mm0 -- psubw mm4, mm0 -- psubw mm5, mm7 -- pxor mm0, mm0 -- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 -- pand mm0, mm6 // Only pav bytes < 0 in mm7 -- psubw mm5, mm7 -- psubw mm6, mm0 -- // test pa <= pb -- movq mm7, mm4 -- psubw mm6, mm0 -- pcmpgtw mm7, mm5 // pa > pb? -- movq mm0, mm7 -- // use mm7 mask to merge pa & pb -- pand mm5, mm7 -- // use mm0 mask copy to merge a & b -- pand mm2, mm0 -- pandn mm7, mm4 -- pandn mm0, mm1 -- paddw mm7, mm5 -- paddw mm0, mm2 -- // test ((pa <= pb)? pa:pb) <= pc -- pcmpgtw mm7, mm6 // pab > pc? -- pxor mm1, mm1 -- pand mm3, mm7 -- pandn mm7, mm0 -- paddw mm7, mm3 -- pxor mm0, mm0 -- packuswb mm7, mm1 -- movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes -- pand mm7, ActiveMask -- movq mm2, [esi + ebx] // load b=Prior(x) -- paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) -- punpckhbw mm3, mm0 // Unpack High bytes of c -- movq [edi + ebx], mm7 // write back updated value -- movq mm1, [edi+ebx-8] // read a=Raw(x-bpp) bytes -- -- // Do second set of 4 bytes -- punpckhbw mm2, mm0 // Unpack High bytes of b -- punpckhbw mm1, mm0 // Unpack High bytes of a -- // pav = p - a = (a + b - c) - a = b - c -- movq mm4, mm2 -- // pbv = p - b = (a + b - c) - b = a - c -- movq mm5, mm1 -- psubw mm4, mm3 -- pxor mm7, mm7 -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- movq mm6, mm4 -- psubw mm5, mm3 -- // pa = abs(p-a) = abs(pav) -- // pb = abs(p-b) = abs(pbv) -- // pc = abs(p-c) = abs(pcv) -- pcmpgtw mm0, mm4 // Create mask pav bytes < 0 -- paddw mm6, mm5 -- pand mm0, mm4 // Only pav bytes < 0 in mm7 -- pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 -- psubw mm4, mm0 -- pand mm7, mm5 // Only pbv bytes < 0 in mm0 -- psubw mm4, mm0 -- psubw mm5, mm7 -- pxor mm0, mm0 -- pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 -- pand mm0, mm6 // Only pav bytes < 0 in mm7 -- psubw mm5, mm7 -- psubw mm6, mm0 -- // test pa <= pb -- movq mm7, mm4 -- psubw mm6, mm0 -- pcmpgtw mm7, mm5 // pa > pb? -- movq mm0, mm7 -- // use mm7 mask to merge pa & pb -- pand mm5, mm7 -- // use mm0 mask copy to merge a & b -- pand mm2, mm0 -- pandn mm7, mm4 -- pandn mm0, mm1 -- paddw mm7, mm5 -- paddw mm0, mm2 -- // test ((pa <= pb)? pa:pb) <= pc -- pcmpgtw mm7, mm6 // pab > pc? -- pxor mm1, mm1 -- pand mm3, mm7 -- pandn mm7, mm0 -- pxor mm1, mm1 -- paddw mm7, mm3 -- pxor mm0, mm0 -- // Step ex to next set of 8 bytes and repeat loop til done -- add ebx, 8 -- packuswb mm1, mm7 -- paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) -- cmp ebx, MMXLength -- movq [edi + ebx - 8], mm1 // write back updated value -- // mm1 will be used as Raw(x-bpp) next loop -- jb dpth8lp -- } // end _asm block -- } -- break; -- -- case 1: // bpp = 1 -- case 2: // bpp = 2 -- default: // bpp > 8 -- { -- _asm { -- mov ebx, diff -- cmp ebx, FullLength -- jnb dpthdend -- mov edi, row -- mov esi, prev_row -- // Do Paeth decode for remaining bytes -- mov edx, ebx -- xor ecx, ecx // zero ecx before using cl & cx in loop below -- sub edx, bpp // Set edx = ebx - bpp --dpthdlp: -- xor eax, eax -- // pav = p - a = (a + b - c) - a = b - c -- mov al, [esi + ebx] // load Prior(x) into al -- mov cl, [esi + edx] // load Prior(x-bpp) into cl -- sub eax, ecx // subtract Prior(x-bpp) -- mov patemp, eax // Save pav for later use -- xor eax, eax -- // pbv = p - b = (a + b - c) - b = a - c -- mov al, [edi + edx] // load Raw(x-bpp) into al -- sub eax, ecx // subtract Prior(x-bpp) -- mov ecx, eax -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- add eax, patemp // pcv = pav + pbv -- // pc = abs(pcv) -- test eax, 0x80000000 -- jz dpthdpca -- neg eax // reverse sign of neg values --dpthdpca: -- mov pctemp, eax // save pc for later use -- // pb = abs(pbv) -- test ecx, 0x80000000 -- jz dpthdpba -- neg ecx // reverse sign of neg values --dpthdpba: -- mov pbtemp, ecx // save pb for later use -- // pa = abs(pav) -- mov eax, patemp -- test eax, 0x80000000 -- jz dpthdpaa -- neg eax // reverse sign of neg values --dpthdpaa: -- mov patemp, eax // save pa for later use -- // test if pa <= pb -- cmp eax, ecx -- jna dpthdabb -- // pa > pb; now test if pb <= pc -- cmp ecx, pctemp -- jna dpthdbbc -- // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) -- mov cl, [esi + edx] // load Prior(x-bpp) into cl -- jmp dpthdpaeth --dpthdbbc: -- // pb <= pc; Raw(x) = Paeth(x) + Prior(x) -- mov cl, [esi + ebx] // load Prior(x) into cl -- jmp dpthdpaeth --dpthdabb: -- // pa <= pb; now test if pa <= pc -- cmp eax, pctemp -- jna dpthdabc -- // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) -- mov cl, [esi + edx] // load Prior(x-bpp) into cl -- jmp dpthdpaeth --dpthdabc: -- // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) -- mov cl, [edi + edx] // load Raw(x-bpp) into cl --dpthdpaeth: -- inc ebx -- inc edx -- // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 -- add [edi + ebx - 1], cl -- cmp ebx, FullLength -- jb dpthdlp --dpthdend: -- } // end _asm block -- } -- return; // No need to go further with this one -- } // end switch ( bpp ) -- _asm -- { -- // MMX acceleration complete now do clean-up -- // Check if any remaining bytes left to decode -- mov ebx, MMXLength -- cmp ebx, FullLength -- jnb dpthend -- mov edi, row -- mov esi, prev_row -- // Do Paeth decode for remaining bytes -- mov edx, ebx -- xor ecx, ecx // zero ecx before using cl & cx in loop below -- sub edx, bpp // Set edx = ebx - bpp --dpthlp2: -- xor eax, eax -- // pav = p - a = (a + b - c) - a = b - c -- mov al, [esi + ebx] // load Prior(x) into al -- mov cl, [esi + edx] // load Prior(x-bpp) into cl -- sub eax, ecx // subtract Prior(x-bpp) -- mov patemp, eax // Save pav for later use -- xor eax, eax -- // pbv = p - b = (a + b - c) - b = a - c -- mov al, [edi + edx] // load Raw(x-bpp) into al -- sub eax, ecx // subtract Prior(x-bpp) -- mov ecx, eax -- // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv -- add eax, patemp // pcv = pav + pbv -- // pc = abs(pcv) -- test eax, 0x80000000 -- jz dpthpca2 -- neg eax // reverse sign of neg values --dpthpca2: -- mov pctemp, eax // save pc for later use -- // pb = abs(pbv) -- test ecx, 0x80000000 -- jz dpthpba2 -- neg ecx // reverse sign of neg values --dpthpba2: -- mov pbtemp, ecx // save pb for later use -- // pa = abs(pav) -- mov eax, patemp -- test eax, 0x80000000 -- jz dpthpaa2 -- neg eax // reverse sign of neg values --dpthpaa2: -- mov patemp, eax // save pa for later use -- // test if pa <= pb -- cmp eax, ecx -- jna dpthabb2 -- // pa > pb; now test if pb <= pc -- cmp ecx, pctemp -- jna dpthbbc2 -- // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) -- mov cl, [esi + edx] // load Prior(x-bpp) into cl -- jmp dpthpaeth2 --dpthbbc2: -- // pb <= pc; Raw(x) = Paeth(x) + Prior(x) -- mov cl, [esi + ebx] // load Prior(x) into cl -- jmp dpthpaeth2 --dpthabb2: -- // pa <= pb; now test if pa <= pc -- cmp eax, pctemp -- jna dpthabc2 -- // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) -- mov cl, [esi + edx] // load Prior(x-bpp) into cl -- jmp dpthpaeth2 --dpthabc2: -- // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) -- mov cl, [edi + edx] // load Raw(x-bpp) into cl --dpthpaeth2: -- inc ebx -- inc edx -- // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 -- add [edi + ebx - 1], cl -- cmp ebx, FullLength -- jb dpthlp2 --dpthend: -- emms // End MMX instructions; prep for possible FP instrs. -- } // end _asm block --} -- --// Optimized code for PNG Sub filter decoder --void /* PRIVATE */ --png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row) --{ -- //int test; -- int bpp; -- png_uint_32 FullLength; -- png_uint_32 MMXLength; -- int diff; -- -- bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel -- FullLength = row_info->rowbytes - bpp; // # of bytes to filter -- _asm { -- mov edi, row -- mov esi, edi // lp = row -- add edi, bpp // rp = row + bpp -- xor eax, eax -- // get # of bytes to alignment -- mov diff, edi // take start of row -- add diff, 0xf // add 7 + 8 to incr past -- // alignment boundary -- xor ebx, ebx -- and diff, 0xfffffff8 // mask to alignment boundary -- sub diff, edi // subtract from start ==> value -- // ebx at alignment -- jz dsubgo -- // fix alignment --dsublp1: -- mov al, [esi+ebx] -- add [edi+ebx], al -- inc ebx -- cmp ebx, diff -- jb dsublp1 --dsubgo: -- mov ecx, FullLength -- mov edx, ecx -- sub edx, ebx // subtract alignment fix -- and edx, 0x00000007 // calc bytes over mult of 8 -- sub ecx, edx // drop over bytes from length -- mov MMXLength, ecx -- } // end _asm block -- -- // Now do the math for the rest of the row -- switch ( bpp ) -- { -- case 3: -- { -- ActiveMask.use = 0x0000ffffff000000; -- ShiftBpp.use = 24; // == 3 * 8 -- ShiftRem.use = 40; // == 64 - 24 -- _asm { -- mov edi, row -- movq mm7, ActiveMask // Load ActiveMask for 2nd active byte group -- mov esi, edi // lp = row -- add edi, bpp // rp = row + bpp -- movq mm6, mm7 -- mov ebx, diff -- psllq mm6, ShiftBpp // Move mask in mm6 to cover 3rd active -- // byte group -- // PRIME the pump (load the first Raw(x-bpp) data set -- movq mm1, [edi+ebx-8] --dsub3lp: -- psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes -- // no need for mask; shift clears inactive bytes -- // Add 1st active group -- movq mm0, [edi+ebx] -- paddb mm0, mm1 -- // Add 2nd active group -- movq mm1, mm0 // mov updated Raws to mm1 -- psllq mm1, ShiftBpp // shift data to position correctly -- pand mm1, mm7 // mask to use only 2nd active group -- paddb mm0, mm1 -- // Add 3rd active group -- movq mm1, mm0 // mov updated Raws to mm1 -- psllq mm1, ShiftBpp // shift data to position correctly -- pand mm1, mm6 // mask to use only 3rd active group -- add ebx, 8 -- paddb mm0, mm1 -- cmp ebx, MMXLength -- movq [edi+ebx-8], mm0 // Write updated Raws back to array -- // Prep for doing 1st add at top of loop -- movq mm1, mm0 -- jb dsub3lp -- } // end _asm block -- } -- break; -- -- case 1: -- { -- // Placed here just in case this is a duplicate of the -- // non-MMX code for the SUB filter in png_read_filter_row below -- // -- // png_bytep rp; -- // png_bytep lp; -- // png_uint_32 i; -- // bpp = (row_info->pixel_depth + 7) >> 3; -- // for (i = (png_uint_32)bpp, rp = row + bpp, lp = row; -- // i < row_info->rowbytes; i++, rp++, lp++) -- // { -- // *rp = (png_byte)(((int)(*rp) + (int)(*lp)) & 0xff); -- // } -- _asm { -- mov ebx, diff -- mov edi, row -- cmp ebx, FullLength -- jnb dsub1end -- mov esi, edi // lp = row -- xor eax, eax -- add edi, bpp // rp = row + bpp --dsub1lp: -- mov al, [esi+ebx] -- add [edi+ebx], al -- inc ebx -- cmp ebx, FullLength -- jb dsub1lp --dsub1end: -- } // end _asm block -- } -- return; -- -- case 6: -- case 7: -- case 4: -- case 5: -- { -- ShiftBpp.use = bpp << 3; -- ShiftRem.use = 64 - ShiftBpp.use; -- _asm { -- mov edi, row -- mov ebx, diff -- mov esi, edi // lp = row -- add edi, bpp // rp = row + bpp -- // PRIME the pump (load the first Raw(x-bpp) data set -- movq mm1, [edi+ebx-8] --dsub4lp: -- psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes -- // no need for mask; shift clears inactive bytes -- movq mm0, [edi+ebx] -- paddb mm0, mm1 -- // Add 2nd active group -- movq mm1, mm0 // mov updated Raws to mm1 -- psllq mm1, ShiftBpp // shift data to position correctly -- // there is no need for any mask -- // since shift clears inactive bits/bytes -- add ebx, 8 -- paddb mm0, mm1 -- cmp ebx, MMXLength -- movq [edi+ebx-8], mm0 -- movq mm1, mm0 // Prep for doing 1st add at top of loop -- jb dsub4lp -- } // end _asm block -- } -- break; -- -- case 2: -- { -- ActiveMask.use = 0x00000000ffff0000; -- ShiftBpp.use = 16; // == 2 * 8 -- ShiftRem.use = 48; // == 64 - 16 -- _asm { -- movq mm7, ActiveMask // Load ActiveMask for 2nd active byte group -- mov ebx, diff -- movq mm6, mm7 -- mov edi, row -- psllq mm6, ShiftBpp // Move mask in mm6 to cover 3rd active -- // byte group -- mov esi, edi // lp = row -- movq mm5, mm6 -- add edi, bpp // rp = row + bpp -- psllq mm5, ShiftBpp // Move mask in mm5 to cover 4th active -- // byte group -- // PRIME the pump (load the first Raw(x-bpp) data set -- movq mm1, [edi+ebx-8] --dsub2lp: -- // Add 1st active group -- psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes -- // no need for mask; shift clears inactive -- // bytes -- movq mm0, [edi+ebx] -- paddb mm0, mm1 -- // Add 2nd active group -- movq mm1, mm0 // mov updated Raws to mm1 -- psllq mm1, ShiftBpp // shift data to position correctly -- pand mm1, mm7 // mask to use only 2nd active group -- paddb mm0, mm1 -- // Add 3rd active group -- movq mm1, mm0 // mov updated Raws to mm1 -- psllq mm1, ShiftBpp // shift data to position correctly -- pand mm1, mm6 // mask to use only 3rd active group -- paddb mm0, mm1 -- // Add 4th active group -- movq mm1, mm0 // mov updated Raws to mm1 -- psllq mm1, ShiftBpp // shift data to position correctly -- pand mm1, mm5 // mask to use only 4th active group -- add ebx, 8 -- paddb mm0, mm1 -- cmp ebx, MMXLength -- movq [edi+ebx-8], mm0 // Write updated Raws back to array -- movq mm1, mm0 // Prep for doing 1st add at top of loop -- jb dsub2lp -- } // end _asm block -- } -- break; -- case 8: -- { -- _asm { -- mov edi, row -- mov ebx, diff -- mov esi, edi // lp = row -- add edi, bpp // rp = row + bpp -- mov ecx, MMXLength -- movq mm7, [edi+ebx-8] // PRIME the pump (load the first -- // Raw(x-bpp) data set -- and ecx, 0x0000003f // calc bytes over mult of 64 --dsub8lp: -- movq mm0, [edi+ebx] // Load Sub(x) for 1st 8 bytes -- paddb mm0, mm7 -- movq mm1, [edi+ebx+8] // Load Sub(x) for 2nd 8 bytes -- movq [edi+ebx], mm0 // Write Raw(x) for 1st 8 bytes -- // Now mm0 will be used as Raw(x-bpp) for -- // the 2nd group of 8 bytes. This will be -- // repeated for each group of 8 bytes with -- // the 8th group being used as the Raw(x-bpp) -- // for the 1st group of the next loop. -- paddb mm1, mm0 -- movq mm2, [edi+ebx+16] // Load Sub(x) for 3rd 8 bytes -- movq [edi+ebx+8], mm1 // Write Raw(x) for 2nd 8 bytes -- paddb mm2, mm1 -- movq mm3, [edi+ebx+24] // Load Sub(x) for 4th 8 bytes -- movq [edi+ebx+16], mm2 // Write Raw(x) for 3rd 8 bytes -- paddb mm3, mm2 -- movq mm4, [edi+ebx+32] // Load Sub(x) for 5th 8 bytes -- movq [edi+ebx+24], mm3 // Write Raw(x) for 4th 8 bytes -- paddb mm4, mm3 -- movq mm5, [edi+ebx+40] // Load Sub(x) for 6th 8 bytes -- movq [edi+ebx+32], mm4 // Write Raw(x) for 5th 8 bytes -- paddb mm5, mm4 -- movq mm6, [edi+ebx+48] // Load Sub(x) for 7th 8 bytes -- movq [edi+ebx+40], mm5 // Write Raw(x) for 6th 8 bytes -- paddb mm6, mm5 -- movq mm7, [edi+ebx+56] // Load Sub(x) for 8th 8 bytes -- movq [edi+ebx+48], mm6 // Write Raw(x) for 7th 8 bytes -- add ebx, 64 -- paddb mm7, mm6 -- cmp ebx, ecx -- movq [edi+ebx-8], mm7 // Write Raw(x) for 8th 8 bytes -- jb dsub8lp -- cmp ebx, MMXLength -- jnb dsub8lt8 --dsub8lpA: -- movq mm0, [edi+ebx] -- add ebx, 8 -- paddb mm0, mm7 -- cmp ebx, MMXLength -- movq [edi+ebx-8], mm0 // use -8 to offset early add to ebx -- movq mm7, mm0 // Move calculated Raw(x) data to mm1 to -- // be the new Raw(x-bpp) for the next loop -- jb dsub8lpA --dsub8lt8: -- } // end _asm block -- } -- break; -- -- default: // bpp greater than 8 bytes -- { -- _asm { -- mov ebx, diff -- mov edi, row -- mov esi, edi // lp = row -- add edi, bpp // rp = row + bpp --dsubAlp: -- movq mm0, [edi+ebx] -- movq mm1, [esi+ebx] -- add ebx, 8 -- paddb mm0, mm1 -- cmp ebx, MMXLength -- movq [edi+ebx-8], mm0 // mov does not affect flags; -8 to offset -- // add ebx -- jb dsubAlp -- } // end _asm block -- } -- break; -- -- } // end switch ( bpp ) -- -- _asm { -- mov ebx, MMXLength -- mov edi, row -- cmp ebx, FullLength -- jnb dsubend -- mov esi, edi // lp = row -- xor eax, eax -- add edi, bpp // rp = row + bpp --dsublp2: -- mov al, [esi+ebx] -- add [edi+ebx], al -- inc ebx -- cmp ebx, FullLength -- jb dsublp2 --dsubend: -- emms // End MMX instructions; prep for possible FP instrs. -- } // end _asm block --} -- --// Optimized code for PNG Up filter decoder --void /* PRIVATE */ --png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row, -- png_bytep prev_row) --{ -- png_uint_32 len; -- len = row_info->rowbytes; // # of bytes to filter -- _asm { -- mov edi, row -- // get # of bytes to alignment -- mov ecx, edi -- xor ebx, ebx -- add ecx, 0x7 -- xor eax, eax -- and ecx, 0xfffffff8 -- mov esi, prev_row -- sub ecx, edi -- jz dupgo -- // fix alignment --duplp1: -- mov al, [edi+ebx] -- add al, [esi+ebx] -- inc ebx -- cmp ebx, ecx -- mov [edi + ebx-1], al // mov does not affect flags; -1 to offset inc ebx -- jb duplp1 --dupgo: -- mov ecx, len -- mov edx, ecx -- sub edx, ebx // subtract alignment fix -- and edx, 0x0000003f // calc bytes over mult of 64 -- sub ecx, edx // drop over bytes from length -- // Unrolled loop - use all MMX registers and interleave to reduce -- // number of branch instructions (loops) and reduce partial stalls --duploop: -- movq mm1, [esi+ebx] -- movq mm0, [edi+ebx] -- movq mm3, [esi+ebx+8] -- paddb mm0, mm1 -- movq mm2, [edi+ebx+8] -- movq [edi+ebx], mm0 -- paddb mm2, mm3 -- movq mm5, [esi+ebx+16] -- movq [edi+ebx+8], mm2 -- movq mm4, [edi+ebx+16] -- movq mm7, [esi+ebx+24] -- paddb mm4, mm5 -- movq mm6, [edi+ebx+24] -- movq [edi+ebx+16], mm4 -- paddb mm6, mm7 -- movq mm1, [esi+ebx+32] -- movq [edi+ebx+24], mm6 -- movq mm0, [edi+ebx+32] -- movq mm3, [esi+ebx+40] -- paddb mm0, mm1 -- movq mm2, [edi+ebx+40] -- movq [edi+ebx+32], mm0 -- paddb mm2, mm3 -- movq mm5, [esi+ebx+48] -- movq [edi+ebx+40], mm2 -- movq mm4, [edi+ebx+48] -- movq mm7, [esi+ebx+56] -- paddb mm4, mm5 -- movq mm6, [edi+ebx+56] -- movq [edi+ebx+48], mm4 -- add ebx, 64 -- paddb mm6, mm7 -- cmp ebx, ecx -- movq [edi+ebx-8], mm6 // (+56)movq does not affect flags; -- // -8 to offset add ebx -- jb duploop -- -- cmp edx, 0 // Test for bytes over mult of 64 -- jz dupend -- -- -- // 2 lines added by lcreeve@netins.net -- // (mail 11 Jul 98 in png-implement list) -- cmp edx, 8 //test for less than 8 bytes -- jb duplt8 -- -- -- add ecx, edx -- and edx, 0x00000007 // calc bytes over mult of 8 -- sub ecx, edx // drop over bytes from length -- jz duplt8 -- // Loop using MMX registers mm0 & mm1 to update 8 bytes simultaneously --duplpA: -- movq mm1, [esi+ebx] -- movq mm0, [edi+ebx] -- add ebx, 8 -- paddb mm0, mm1 -- cmp ebx, ecx -- movq [edi+ebx-8], mm0 // movq does not affect flags; -8 to offset add ebx -- jb duplpA -- cmp edx, 0 // Test for bytes over mult of 8 -- jz dupend --duplt8: -- xor eax, eax -- add ecx, edx // move over byte count into counter -- // Loop using x86 registers to update remaining bytes --duplp2: -- mov al, [edi + ebx] -- add al, [esi + ebx] -- inc ebx -- cmp ebx, ecx -- mov [edi + ebx-1], al // mov does not affect flags; -1 to offset inc ebx -- jb duplp2 --dupend: -- // Conversion of filtered row completed -- emms // End MMX instructions; prep for possible FP instrs. -- } // end _asm block --} -- -- --// Optimized png_read_filter_row routines --void /* PRIVATE */ --png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep -- row, png_bytep prev_row, int filter) --{ --#ifdef PNG_DEBUG -- char filnm[10]; --#endif -- -- if (mmx_supported == 2) { --#if !defined(PNG_1_0_X) -- /* this should have happened in png_init_mmx_flags() already */ -- png_warning(png_ptr, "asm_flags may not have been initialized"); --#endif -- png_mmx_support(); -- } -- --#ifdef PNG_DEBUG -- png_debug(1, "in png_read_filter_row\n"); -- switch (filter) -- { -- case 0: sprintf(filnm, "none"); -- break; --#if !defined(PNG_1_0_X) -- case 1: sprintf(filnm, "sub-%s", -- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "MMX" : "x86"); -- break; -- case 2: sprintf(filnm, "up-%s", -- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "MMX" : "x86"); -- break; -- case 3: sprintf(filnm, "avg-%s", -- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "MMX" : "x86"); -- break; -- case 4: sprintf(filnm, "Paeth-%s", -- (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "MMX":"x86"); -- break; --#else -- case 1: sprintf(filnm, "sub"); -- break; -- case 2: sprintf(filnm, "up"); -- break; -- case 3: sprintf(filnm, "avg"); -- break; -- case 4: sprintf(filnm, "Paeth"); -- break; --#endif -- default: sprintf(filnm, "unknw"); -- break; -- } -- png_debug2(0,"row=%5d, %s, ", png_ptr->row_number, filnm); -- png_debug2(0, "pd=%2d, b=%d, ", (int)row_info->pixel_depth, -- (int)((row_info->pixel_depth + 7) >> 3)); -- png_debug1(0,"len=%8d, ", row_info->rowbytes); --#endif /* PNG_DEBUG */ -- -- switch (filter) -- { -- case PNG_FILTER_VALUE_NONE: -- break; -- -- case PNG_FILTER_VALUE_SUB: -- { --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB) && -- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && -- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) --#else -- if (mmx_supported) --#endif -- { -- png_read_filter_row_mmx_sub(row_info, row); -- } -- else -- { -- png_uint_32 i; -- png_uint_32 istop = row_info->rowbytes; -- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; -- png_bytep rp = row + bpp; -- png_bytep lp = row; -- -- for (i = bpp; i < istop; i++) -- { -- *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff); -- rp++; -- } -- } -- break; -- } -- -- case PNG_FILTER_VALUE_UP: -- { --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP) && -- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && -- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) --#else -- if (mmx_supported) --#endif -- { -- png_read_filter_row_mmx_up(row_info, row, prev_row); -- } -- else -- { -- png_uint_32 i; -- png_uint_32 istop = row_info->rowbytes; -- png_bytep rp = row; -- png_bytep pp = prev_row; -- -- for (i = 0; i < istop; ++i) -- { -- *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); -- rp++; -- } -- } -- break; -- } -- -- case PNG_FILTER_VALUE_AVG: -- { --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG) && -- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && -- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) --#else -- if (mmx_supported) --#endif -- { -- png_read_filter_row_mmx_avg(row_info, row, prev_row); -- } -- else -- { -- png_uint_32 i; -- png_bytep rp = row; -- png_bytep pp = prev_row; -- png_bytep lp = row; -- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; -- png_uint_32 istop = row_info->rowbytes - bpp; -- -- for (i = 0; i < bpp; i++) -- { -- *rp = (png_byte)(((int)(*rp) + -- ((int)(*pp++) >> 1)) & 0xff); -- rp++; -- } -- -- for (i = 0; i < istop; i++) -- { -- *rp = (png_byte)(((int)(*rp) + -- ((int)(*pp++ + *lp++) >> 1)) & 0xff); -- rp++; -- } -- } -- break; -- } -- -- case PNG_FILTER_VALUE_PAETH: -- { --#if !defined(PNG_1_0_X) -- if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH) && -- (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && -- (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) --#else -- if (mmx_supported) --#endif -- { -- png_read_filter_row_mmx_paeth(row_info, row, prev_row); -- } -- else -- { -- png_uint_32 i; -- png_bytep rp = row; -- png_bytep pp = prev_row; -- png_bytep lp = row; -- png_bytep cp = prev_row; -- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; -- png_uint_32 istop=row_info->rowbytes - bpp; -- -- for (i = 0; i < bpp; i++) -- { -- *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); -- rp++; -- } -- -- for (i = 0; i < istop; i++) // use leftover rp,pp -- { -- int a, b, c, pa, pb, pc, p; -- -- a = *lp++; -- b = *pp++; -- c = *cp++; -- -- p = b - c; -- pc = a - c; -- --#ifdef PNG_USE_ABS -- pa = abs(p); -- pb = abs(pc); -- pc = abs(p + pc); --#else -- pa = p < 0 ? -p : p; -- pb = pc < 0 ? -pc : pc; -- pc = (p + pc) < 0 ? -(p + pc) : p + pc; --#endif -- -- /* -- if (pa <= pb && pa <= pc) -- p = a; -- else if (pb <= pc) -- p = b; -- else -- p = c; -- */ -- -- p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; -- -- *rp = (png_byte)(((int)(*rp) + p) & 0xff); -- rp++; -- } -- } -- break; -- } -- -- default: -- png_warning(png_ptr, "Ignoring bad row filter type"); -- *row=0; -- break; -- } --} -- --#endif /* PNG_ASSEMBLER_CODE_SUPPORTED && PNG_USE_PNGVCRD */ -diff --git a/thirdparty/libpng/pngwio.c b/thirdparty/libpng/pngwio.c -deleted file mode 100644 -index adc57b3..0000000 ---- a/thirdparty/libpng/pngwio.c -+++ /dev/null -@@ -1,228 +0,0 @@ -- --/* pngwio.c - functions for data output -- * -- * libpng 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- * -- * This file provides a location for all output. Users who need -- * special handling are expected to write functions that have the same -- * arguments as these and perform similar functions, but that possibly -- * use different output methods. Note that you shouldn't change these -- * functions, but rather write replacement functions and then change -- * them at run time with png_set_write_fn(...). -- */ -- --#define PNG_INTERNAL --#include "png.h" --#ifdef PNG_WRITE_SUPPORTED -- --/* Write the data to whatever output you are using. The default routine -- writes to a file pointer. Note that this routine sometimes gets called -- with very small lengths, so you should implement some kind of simple -- buffering if you are using unbuffered writes. This should never be asked -- to write more than 64K on a 16 bit machine. */ -- --void /* PRIVATE */ --png_write_data(png_structp png_ptr, png_bytep data, png_size_t length) --{ -- if (png_ptr->write_data_fn != NULL ) -- (*(png_ptr->write_data_fn))(png_ptr, data, length); -- else -- png_error(png_ptr, "Call to NULL write function"); --} -- --#if !defined(PNG_NO_STDIO) --/* This is the function that does the actual writing of data. If you are -- not writing to a standard C stream, you should create a replacement -- write_data function and use it at run time with png_set_write_fn(), rather -- than changing the library. */ --#ifndef USE_FAR_KEYWORD --void PNGAPI --png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) --{ -- png_uint_32 check; -- --#if defined(_WIN32_WCE) -- if ( !WriteFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) -- check = 0; --#else -- check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr)); --#endif -- if (check != length) -- png_error(png_ptr, "Write Error"); --} --#else --/* this is the model-independent version. Since the standard I/O library -- can't handle far buffers in the medium and small models, we have to copy -- the data. --*/ -- --#define NEAR_BUF_SIZE 1024 --#define MIN(a,b) (a <= b ? a : b) -- --void PNGAPI --png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) --{ -- png_uint_32 check; -- png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */ -- png_FILE_p io_ptr; -- -- /* Check if data really is near. If so, use usual code. */ -- near_data = (png_byte *)CVT_PTR_NOCHECK(data); -- io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); -- if ((png_bytep)near_data == data) -- { --#if defined(_WIN32_WCE) -- if ( !WriteFile(io_ptr, near_data, length, &check, NULL) ) -- check = 0; --#else -- check = fwrite(near_data, 1, length, io_ptr); --#endif -- } -- else -- { -- png_byte buf[NEAR_BUF_SIZE]; -- png_size_t written, remaining, err; -- check = 0; -- remaining = length; -- do -- { -- written = MIN(NEAR_BUF_SIZE, remaining); -- png_memcpy(buf, data, written); /* copy far buffer to near buffer */ --#if defined(_WIN32_WCE) -- if ( !WriteFile(io_ptr, buf, written, &err, NULL) ) -- err = 0; --#else -- err = fwrite(buf, 1, written, io_ptr); --#endif -- if (err != written) -- break; -- else -- check += err; -- data += written; -- remaining -= written; -- } -- while (remaining != 0); -- } -- if (check != length) -- png_error(png_ptr, "Write Error"); --} -- --#endif --#endif -- --/* This function is called to output any data pending writing (normally -- to disk). After png_flush is called, there should be no data pending -- writing in any buffers. */ --#if defined(PNG_WRITE_FLUSH_SUPPORTED) --void /* PRIVATE */ --png_flush(png_structp png_ptr) --{ -- if (png_ptr->output_flush_fn != NULL) -- (*(png_ptr->output_flush_fn))(png_ptr); --} -- --#if !defined(PNG_NO_STDIO) --void PNGAPI --png_default_flush(png_structp png_ptr) --{ --#if !defined(_WIN32_WCE) -- png_FILE_p io_ptr; -- io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr)); -- if (io_ptr != NULL) -- fflush(io_ptr); --#endif --} --#endif --#endif -- --/* This function allows the application to supply new output functions for -- libpng if standard C streams aren't being used. -- -- This function takes as its arguments: -- png_ptr - pointer to a png output data structure -- io_ptr - pointer to user supplied structure containing info about -- the output functions. May be NULL. -- write_data_fn - pointer to a new output function that takes as its -- arguments a pointer to a png_struct, a pointer to -- data to be written, and a 32-bit unsigned int that is -- the number of bytes to be written. The new write -- function should call png_error(png_ptr, "Error msg") -- to exit and output any fatal error messages. -- flush_data_fn - pointer to a new flush function that takes as its -- arguments a pointer to a png_struct. After a call to -- the flush function, there should be no data in any buffers -- or pending transmission. If the output method doesn't do -- any buffering of ouput, a function prototype must still be -- supplied although it doesn't have to do anything. If -- PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile -- time, output_flush_fn will be ignored, although it must be -- supplied for compatibility. */ --void PNGAPI --png_set_write_fn(png_structp png_ptr, png_voidp io_ptr, -- png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn) --{ -- png_ptr->io_ptr = io_ptr; -- --#if !defined(PNG_NO_STDIO) -- if (write_data_fn != NULL) -- png_ptr->write_data_fn = write_data_fn; -- else -- png_ptr->write_data_fn = png_default_write_data; --#else -- png_ptr->write_data_fn = write_data_fn; --#endif -- --#if defined(PNG_WRITE_FLUSH_SUPPORTED) --#if !defined(PNG_NO_STDIO) -- if (output_flush_fn != NULL) -- png_ptr->output_flush_fn = output_flush_fn; -- else -- png_ptr->output_flush_fn = png_default_flush; --#else -- png_ptr->output_flush_fn = output_flush_fn; --#endif --#endif /* PNG_WRITE_FLUSH_SUPPORTED */ -- -- /* It is an error to read while writing a png file */ -- if (png_ptr->read_data_fn != NULL) -- { -- png_ptr->read_data_fn = NULL; -- png_warning(png_ptr, -- "Attempted to set both read_data_fn and write_data_fn in"); -- png_warning(png_ptr, -- "the same structure. Resetting read_data_fn to NULL."); -- } --} -- --#if defined(USE_FAR_KEYWORD) --#if defined(_MSC_VER) --void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check) --{ -- void *near_ptr; -- void FAR *far_ptr; -- FP_OFF(near_ptr) = FP_OFF(ptr); -- far_ptr = (void FAR *)near_ptr; -- if(check != 0) -- if(FP_SEG(ptr) != FP_SEG(far_ptr)) -- png_error(png_ptr,"segment lost in conversion"); -- return(near_ptr); --} --# else --void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check) --{ -- void *near_ptr; -- void FAR *far_ptr; -- near_ptr = (void FAR *)ptr; -- far_ptr = (void FAR *)near_ptr; -- if(check != 0) -- if(far_ptr != ptr) -- png_error(png_ptr,"segment lost in conversion"); -- return(near_ptr); --} --# endif --# endif --#endif /* PNG_WRITE_SUPPORTED */ -diff --git a/thirdparty/libpng/pngwrite.c b/thirdparty/libpng/pngwrite.c -deleted file mode 100644 -index f422173..0000000 ---- a/thirdparty/libpng/pngwrite.c -+++ /dev/null -@@ -1,1464 +0,0 @@ -- --/* pngwrite.c - general routines to write a PNG file -- * -- * libpng 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- */ -- --/* get internal access to png.h */ --#define PNG_INTERNAL --#include "png.h" --#ifdef PNG_WRITE_SUPPORTED -- --/* Writes all the PNG information. This is the suggested way to use the -- * library. If you have a new chunk to add, make a function to write it, -- * and put it in the correct location here. If you want the chunk written -- * after the image data, put it in png_write_end(). I strongly encourage -- * you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing -- * the chunk, as that will keep the code from breaking if you want to just -- * write a plain PNG file. If you have long comments, I suggest writing -- * them in png_write_end(), and compressing them. -- */ --void PNGAPI --png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr) --{ -- png_debug(1, "in png_write_info_before_PLTE\n"); -- if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) -- { -- png_write_sig(png_ptr); /* write PNG signature */ --#if defined(PNG_MNG_FEATURES_SUPPORTED) -- if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted)) -- { -- png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n"); -- png_ptr->mng_features_permitted=0; -- } --#endif -- /* write IHDR information. */ -- png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height, -- info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type, -- info_ptr->filter_type, --#if defined(PNG_WRITE_INTERLACING_SUPPORTED) -- info_ptr->interlace_type); --#else -- 0); --#endif -- /* the rest of these check to see if the valid field has the appropriate -- flag set, and if it does, writes the chunk. */ --#if defined(PNG_WRITE_gAMA_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_gAMA) -- { --# ifdef PNG_FLOATING_POINT_SUPPORTED -- png_write_gAMA(png_ptr, info_ptr->gamma); --#else --#ifdef PNG_FIXED_POINT_SUPPORTED -- png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma); --# endif --#endif -- } --#endif --#if defined(PNG_WRITE_sRGB_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_sRGB) -- png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent); --#endif --#if defined(PNG_WRITE_iCCP_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_iCCP) -- png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE, -- info_ptr->iccp_profile, (int)info_ptr->iccp_proflen); --#endif --#if defined(PNG_WRITE_sBIT_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_sBIT) -- png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type); --#endif --#if defined(PNG_WRITE_cHRM_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_cHRM) -- { --#ifdef PNG_FLOATING_POINT_SUPPORTED -- png_write_cHRM(png_ptr, -- info_ptr->x_white, info_ptr->y_white, -- info_ptr->x_red, info_ptr->y_red, -- info_ptr->x_green, info_ptr->y_green, -- info_ptr->x_blue, info_ptr->y_blue); --#else --# ifdef PNG_FIXED_POINT_SUPPORTED -- png_write_cHRM_fixed(png_ptr, -- info_ptr->int_x_white, info_ptr->int_y_white, -- info_ptr->int_x_red, info_ptr->int_y_red, -- info_ptr->int_x_green, info_ptr->int_y_green, -- info_ptr->int_x_blue, info_ptr->int_y_blue); --# endif --#endif -- } --#endif --#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) -- if (info_ptr->unknown_chunks_num) -- { -- png_unknown_chunk *up; -- -- png_debug(5, "writing extra chunks\n"); -- -- for (up = info_ptr->unknown_chunks; -- up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; -- up++) -- { -- int keep=png_handle_as_unknown(png_ptr, up->name); -- if (keep != PNG_HANDLE_CHUNK_NEVER && -- up->location && !(up->location & PNG_HAVE_PLTE) && -- !(up->location & PNG_HAVE_IDAT) && -- ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS || -- (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) -- { -- png_write_chunk(png_ptr, up->name, up->data, up->size); -- } -- } -- } --#endif -- png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE; -- } --} -- --void PNGAPI --png_write_info(png_structp png_ptr, png_infop info_ptr) --{ --#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) -- int i; --#endif -- -- png_debug(1, "in png_write_info\n"); -- -- png_write_info_before_PLTE(png_ptr, info_ptr); -- -- if (info_ptr->valid & PNG_INFO_PLTE) -- png_write_PLTE(png_ptr, info_ptr->palette, -- (png_uint_32)info_ptr->num_palette); -- else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- png_error(png_ptr, "Valid palette required for paletted images\n"); -- --#if defined(PNG_WRITE_tRNS_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_tRNS) -- { --#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) -- /* invert the alpha channel (in tRNS) */ -- if ((png_ptr->transformations & PNG_INVERT_ALPHA) && -- info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- { -- int j; -- for (j=0; j<(int)info_ptr->num_trans; j++) -- info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]); -- } --#endif -- png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values), -- info_ptr->num_trans, info_ptr->color_type); -- } --#endif --#if defined(PNG_WRITE_bKGD_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_bKGD) -- png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type); --#endif --#if defined(PNG_WRITE_hIST_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_hIST) -- png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette); --#endif --#if defined(PNG_WRITE_oFFs_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_oFFs) -- png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset, -- info_ptr->offset_unit_type); --#endif --#if defined(PNG_WRITE_pCAL_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_pCAL) -- png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0, -- info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams, -- info_ptr->pcal_units, info_ptr->pcal_params); --#endif --#if defined(PNG_WRITE_sCAL_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_sCAL) --#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) -- png_write_sCAL(png_ptr, (int)info_ptr->scal_unit, -- info_ptr->scal_pixel_width, info_ptr->scal_pixel_height); --#else --#ifdef PNG_FIXED_POINT_SUPPORTED -- png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit, -- info_ptr->scal_s_width, info_ptr->scal_s_height); --#else -- png_warning(png_ptr, -- "png_write_sCAL not supported; sCAL chunk not written.\n"); --#endif --#endif --#endif --#if defined(PNG_WRITE_pHYs_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_pHYs) -- png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit, -- info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type); --#endif --#if defined(PNG_WRITE_tIME_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_tIME) -- { -- png_write_tIME(png_ptr, &(info_ptr->mod_time)); -- png_ptr->mode |= PNG_WROTE_tIME; -- } --#endif --#if defined(PNG_WRITE_sPLT_SUPPORTED) -- if (info_ptr->valid & PNG_INFO_sPLT) -- for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) -- png_write_sPLT(png_ptr, info_ptr->splt_palettes + i); --#endif --#if defined(PNG_WRITE_TEXT_SUPPORTED) -- /* Check to see if we need to write text chunks */ -- for (i = 0; i < info_ptr->num_text; i++) -- { -- png_debug2(2, "Writing header text chunk %d, type %d\n", i, -- info_ptr->text[i].compression); -- /* an internationalized chunk? */ -- if (info_ptr->text[i].compression > 0) -- { --#if defined(PNG_WRITE_iTXt_SUPPORTED) -- /* write international chunk */ -- png_write_iTXt(png_ptr, -- info_ptr->text[i].compression, -- info_ptr->text[i].key, -- info_ptr->text[i].lang, -- info_ptr->text[i].lang_key, -- info_ptr->text[i].text); --#else -- png_warning(png_ptr, "Unable to write international text\n"); --#endif -- /* Mark this chunk as written */ -- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; -- } -- /* If we want a compressed text chunk */ -- else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt) -- { --#if defined(PNG_WRITE_zTXt_SUPPORTED) -- /* write compressed chunk */ -- png_write_zTXt(png_ptr, info_ptr->text[i].key, -- info_ptr->text[i].text, 0, -- info_ptr->text[i].compression); --#else -- png_warning(png_ptr, "Unable to write compressed text\n"); --#endif -- /* Mark this chunk as written */ -- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR; -- } -- else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) -- { --#if defined(PNG_WRITE_tEXt_SUPPORTED) -- /* write uncompressed chunk */ -- png_write_tEXt(png_ptr, info_ptr->text[i].key, -- info_ptr->text[i].text, -- 0); --#else -- png_warning(png_ptr, "Unable to write uncompressed text\n"); --#endif -- /* Mark this chunk as written */ -- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; -- } -- } --#endif --#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) -- if (info_ptr->unknown_chunks_num) -- { -- png_unknown_chunk *up; -- -- png_debug(5, "writing extra chunks\n"); -- -- for (up = info_ptr->unknown_chunks; -- up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; -- up++) -- { -- int keep=png_handle_as_unknown(png_ptr, up->name); -- if (keep != PNG_HANDLE_CHUNK_NEVER && -- up->location && (up->location & PNG_HAVE_PLTE) && -- !(up->location & PNG_HAVE_IDAT) && -- ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS || -- (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) -- { -- png_write_chunk(png_ptr, up->name, up->data, up->size); -- } -- } -- } --#endif --} -- --/* Writes the end of the PNG file. If you don't want to write comments or -- * time information, you can pass NULL for info. If you already wrote these -- * in png_write_info(), do not write them again here. If you have long -- * comments, I suggest writing them here, and compressing them. -- */ --void PNGAPI --png_write_end(png_structp png_ptr, png_infop info_ptr) --{ -- png_debug(1, "in png_write_end\n"); -- if (!(png_ptr->mode & PNG_HAVE_IDAT)) -- png_error(png_ptr, "No IDATs written into file"); -- -- /* see if user wants us to write information chunks */ -- if (info_ptr != NULL) -- { --#if defined(PNG_WRITE_TEXT_SUPPORTED) -- int i; /* local index variable */ --#endif --#if defined(PNG_WRITE_tIME_SUPPORTED) -- /* check to see if user has supplied a time chunk */ -- if ((info_ptr->valid & PNG_INFO_tIME) && -- !(png_ptr->mode & PNG_WROTE_tIME)) -- png_write_tIME(png_ptr, &(info_ptr->mod_time)); --#endif --#if defined(PNG_WRITE_TEXT_SUPPORTED) -- /* loop through comment chunks */ -- for (i = 0; i < info_ptr->num_text; i++) -- { -- png_debug2(2, "Writing trailer text chunk %d, type %d\n", i, -- info_ptr->text[i].compression); -- /* an internationalized chunk? */ -- if (info_ptr->text[i].compression > 0) -- { --#if defined(PNG_WRITE_iTXt_SUPPORTED) -- /* write international chunk */ -- png_write_iTXt(png_ptr, -- info_ptr->text[i].compression, -- info_ptr->text[i].key, -- info_ptr->text[i].lang, -- info_ptr->text[i].lang_key, -- info_ptr->text[i].text); --#else -- png_warning(png_ptr, "Unable to write international text\n"); --#endif -- /* Mark this chunk as written */ -- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; -- } -- else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt) -- { --#if defined(PNG_WRITE_zTXt_SUPPORTED) -- /* write compressed chunk */ -- png_write_zTXt(png_ptr, info_ptr->text[i].key, -- info_ptr->text[i].text, 0, -- info_ptr->text[i].compression); --#else -- png_warning(png_ptr, "Unable to write compressed text\n"); --#endif -- /* Mark this chunk as written */ -- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR; -- } -- else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) -- { --#if defined(PNG_WRITE_tEXt_SUPPORTED) -- /* write uncompressed chunk */ -- png_write_tEXt(png_ptr, info_ptr->text[i].key, -- info_ptr->text[i].text, 0); --#else -- png_warning(png_ptr, "Unable to write uncompressed text\n"); --#endif -- -- /* Mark this chunk as written */ -- info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; -- } -- } --#endif --#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) -- if (info_ptr->unknown_chunks_num) -- { -- png_unknown_chunk *up; -- -- png_debug(5, "writing extra chunks\n"); -- -- for (up = info_ptr->unknown_chunks; -- up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; -- up++) -- { -- int keep=png_handle_as_unknown(png_ptr, up->name); -- if (keep != PNG_HANDLE_CHUNK_NEVER && -- up->location && (up->location & PNG_AFTER_IDAT) && -- ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS || -- (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) -- { -- png_write_chunk(png_ptr, up->name, up->data, up->size); -- } -- } -- } --#endif -- } -- -- png_ptr->mode |= PNG_AFTER_IDAT; -- -- /* write end of PNG file */ -- png_write_IEND(png_ptr); --#if 0 --/* This flush, added in libpng-1.0.8, causes some applications to crash -- because they do not set png_ptr->output_flush_fn */ -- png_flush(png_ptr); --#endif --} -- --#if defined(PNG_WRITE_tIME_SUPPORTED) --#if !defined(_WIN32_WCE) --/* "time.h" functions are not supported on WindowsCE */ --void PNGAPI --png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime) --{ -- png_debug(1, "in png_convert_from_struct_tm\n"); -- ptime->year = (png_uint_16)(1900 + ttime->tm_year); -- ptime->month = (png_byte)(ttime->tm_mon + 1); -- ptime->day = (png_byte)ttime->tm_mday; -- ptime->hour = (png_byte)ttime->tm_hour; -- ptime->minute = (png_byte)ttime->tm_min; -- ptime->second = (png_byte)ttime->tm_sec; --} -- --void PNGAPI --png_convert_from_time_t(png_timep ptime, time_t ttime) --{ -- struct tm *tbuf; -- -- png_debug(1, "in png_convert_from_time_t\n"); -- tbuf = gmtime(&ttime); -- png_convert_from_struct_tm(ptime, tbuf); --} --#endif --#endif -- --/* Initialize png_ptr structure, and allocate any memory needed */ --png_structp PNGAPI --png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr, -- png_error_ptr error_fn, png_error_ptr warn_fn) --{ --#ifdef PNG_USER_MEM_SUPPORTED -- return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn, -- warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL)); --} -- --/* Alternate initialize png_ptr structure, and allocate any memory needed */ --png_structp PNGAPI --png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, -- png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, -- png_malloc_ptr malloc_fn, png_free_ptr free_fn) --{ --#endif /* PNG_USER_MEM_SUPPORTED */ -- png_structp png_ptr; --#ifdef PNG_SETJMP_SUPPORTED --#ifdef USE_FAR_KEYWORD -- jmp_buf jmpbuf; --#endif --#endif -- int i; -- png_debug(1, "in png_create_write_struct\n"); --#ifdef PNG_USER_MEM_SUPPORTED -- png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, -- (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr); --#else -- png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); --#endif /* PNG_USER_MEM_SUPPORTED */ -- if (png_ptr == NULL) -- return (NULL); -- --#if !defined(PNG_1_0_X) --#ifdef PNG_ASSEMBLER_CODE_SUPPORTED -- png_init_mmx_flags(png_ptr); /* 1.2.0 addition */ --#endif --#endif /* PNG_1_0_X */ -- -- /* added at libpng-1.2.6 */ --#ifdef PNG_SET_USER_LIMITS_SUPPORTED -- png_ptr->user_width_max=PNG_USER_WIDTH_MAX; -- png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; --#endif -- --#ifdef PNG_SETJMP_SUPPORTED --#ifdef USE_FAR_KEYWORD -- if (setjmp(jmpbuf)) --#else -- if (setjmp(png_ptr->jmpbuf)) --#endif -- { -- png_free(png_ptr, png_ptr->zbuf); -- png_ptr->zbuf=NULL; -- png_destroy_struct(png_ptr); -- return (NULL); -- } --#ifdef USE_FAR_KEYWORD -- png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf)); --#endif --#endif -- --#ifdef PNG_USER_MEM_SUPPORTED -- png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); --#endif /* PNG_USER_MEM_SUPPORTED */ -- png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); -- -- i=0; -- do -- { -- if(user_png_ver[i] != png_libpng_ver[i]) -- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; -- } while (png_libpng_ver[i++]); -- -- if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) -- { -- /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so -- * we must recompile any applications that use any older library version. -- * For versions after libpng 1.0, we will be compatible, so we need -- * only check the first digit. -- */ -- if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || -- (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || -- (user_png_ver[0] == '0' && user_png_ver[2] < '9')) -- { --#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) -- char msg[80]; -- if (user_png_ver) -- { -- sprintf(msg, "Application was compiled with png.h from libpng-%.20s", -- user_png_ver); -- png_warning(png_ptr, msg); -- } -- sprintf(msg, "Application is running with png.c from libpng-%.20s", -- png_libpng_ver); -- png_warning(png_ptr, msg); --#endif --#ifdef PNG_ERROR_NUMBERS_SUPPORTED -- png_ptr->flags=0; --#endif -- png_error(png_ptr, -- "Incompatible libpng version in application and library"); -- } -- } -- -- /* initialize zbuf - compression buffer */ -- png_ptr->zbuf_size = PNG_ZBUF_SIZE; -- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, -- (png_uint_32)png_ptr->zbuf_size); -- -- png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL, -- png_flush_ptr_NULL); -- --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) -- png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT, -- 1, png_doublep_NULL, png_doublep_NULL); --#endif -- --#ifdef PNG_SETJMP_SUPPORTED --/* Applications that neglect to set up their own setjmp() and then encounter -- a png_error() will longjmp here. Since the jmpbuf is then meaningless we -- abort instead of returning. */ --#ifdef USE_FAR_KEYWORD -- if (setjmp(jmpbuf)) -- PNG_ABORT(); -- png_memcpy(png_ptr->jmpbuf,jmpbuf,png_sizeof(jmp_buf)); --#else -- if (setjmp(png_ptr->jmpbuf)) -- PNG_ABORT(); --#endif --#endif -- return (png_ptr); --} -- --/* Initialize png_ptr structure, and allocate any memory needed */ --#undef png_write_init --void PNGAPI --png_write_init(png_structp png_ptr) --{ -- /* We only come here via pre-1.0.7-compiled applications */ -- png_write_init_2(png_ptr, "1.0.6 or earlier", 0, 0); --} -- --void PNGAPI --png_write_init_2(png_structp png_ptr, png_const_charp user_png_ver, -- png_size_t png_struct_size, png_size_t png_info_size) --{ -- /* We only come here via pre-1.0.12-compiled applications */ --#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) -- if(png_sizeof(png_struct) > png_struct_size || -- png_sizeof(png_info) > png_info_size) -- { -- char msg[80]; -- png_ptr->warning_fn=NULL; -- if (user_png_ver) -- { -- sprintf(msg, "Application was compiled with png.h from libpng-%.20s", -- user_png_ver); -- png_warning(png_ptr, msg); -- } -- sprintf(msg, "Application is running with png.c from libpng-%.20s", -- png_libpng_ver); -- png_warning(png_ptr, msg); -- } --#endif -- if(png_sizeof(png_struct) > png_struct_size) -- { -- png_ptr->error_fn=NULL; --#ifdef PNG_ERROR_NUMBERS_SUPPORTED -- png_ptr->flags=0; --#endif -- png_error(png_ptr, -- "The png struct allocated by the application for writing is too small."); -- } -- if(png_sizeof(png_info) > png_info_size) -- { -- png_ptr->error_fn=NULL; --#ifdef PNG_ERROR_NUMBERS_SUPPORTED -- png_ptr->flags=0; --#endif -- png_error(png_ptr, -- "The info struct allocated by the application for writing is too small."); -- } -- png_write_init_3(&png_ptr, user_png_ver, png_struct_size); --} -- -- --void PNGAPI --png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver, -- png_size_t png_struct_size) --{ -- png_structp png_ptr=*ptr_ptr; --#ifdef PNG_SETJMP_SUPPORTED -- jmp_buf tmp_jmp; /* to save current jump buffer */ --#endif -- int i = 0; -- do -- { -- if (user_png_ver[i] != png_libpng_ver[i]) -- { --#ifdef PNG_LEGACY_SUPPORTED -- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; --#else -- png_ptr->warning_fn=NULL; -- png_warning(png_ptr, -- "Application uses deprecated png_write_init() and should be recompiled."); -- break; --#endif -- } -- } while (png_libpng_ver[i++]); -- -- png_debug(1, "in png_write_init_3\n"); -- --#ifdef PNG_SETJMP_SUPPORTED -- /* save jump buffer and error functions */ -- png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf)); --#endif -- -- if (png_sizeof(png_struct) > png_struct_size) -- { -- png_destroy_struct(png_ptr); -- png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); -- *ptr_ptr = png_ptr; -- } -- -- /* reset all variables to 0 */ -- png_memset(png_ptr, 0, png_sizeof (png_struct)); -- -- /* added at libpng-1.2.6 */ --#ifdef PNG_SET_USER_LIMITS_SUPPORTED -- png_ptr->user_width_max=PNG_USER_WIDTH_MAX; -- png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; --#endif -- --#if !defined(PNG_1_0_X) --#ifdef PNG_ASSEMBLER_CODE_SUPPORTED -- png_init_mmx_flags(png_ptr); /* 1.2.0 addition */ --#endif --#endif /* PNG_1_0_X */ -- --#ifdef PNG_SETJMP_SUPPORTED -- /* restore jump buffer */ -- png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf)); --#endif -- -- png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL, -- png_flush_ptr_NULL); -- -- /* initialize zbuf - compression buffer */ -- png_ptr->zbuf_size = PNG_ZBUF_SIZE; -- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, -- (png_uint_32)png_ptr->zbuf_size); -- --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) -- png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT, -- 1, png_doublep_NULL, png_doublep_NULL); --#endif --} -- --/* Write a few rows of image data. If the image is interlaced, -- * either you will have to write the 7 sub images, or, if you -- * have called png_set_interlace_handling(), you will have to -- * "write" the image seven times. -- */ --void PNGAPI --png_write_rows(png_structp png_ptr, png_bytepp row, -- png_uint_32 num_rows) --{ -- png_uint_32 i; /* row counter */ -- png_bytepp rp; /* row pointer */ -- -- png_debug(1, "in png_write_rows\n"); -- /* loop through the rows */ -- for (i = 0, rp = row; i < num_rows; i++, rp++) -- { -- png_write_row(png_ptr, *rp); -- } --} -- --/* Write the image. You only need to call this function once, even -- * if you are writing an interlaced image. -- */ --void PNGAPI --png_write_image(png_structp png_ptr, png_bytepp image) --{ -- png_uint_32 i; /* row index */ -- int pass, num_pass; /* pass variables */ -- png_bytepp rp; /* points to current row */ -- -- png_debug(1, "in png_write_image\n"); --#if defined(PNG_WRITE_INTERLACING_SUPPORTED) -- /* intialize interlace handling. If image is not interlaced, -- this will set pass to 1 */ -- num_pass = png_set_interlace_handling(png_ptr); --#else -- num_pass = 1; --#endif -- /* loop through passes */ -- for (pass = 0; pass < num_pass; pass++) -- { -- /* loop through image */ -- for (i = 0, rp = image; i < png_ptr->height; i++, rp++) -- { -- png_write_row(png_ptr, *rp); -- } -- } --} -- --/* called by user to write a row of image data */ --void PNGAPI --png_write_row(png_structp png_ptr, png_bytep row) --{ -- png_debug2(1, "in png_write_row (row %ld, pass %d)\n", -- png_ptr->row_number, png_ptr->pass); -- /* initialize transformations and other stuff if first time */ -- if (png_ptr->row_number == 0 && png_ptr->pass == 0) -- { -- /* make sure we wrote the header info */ -- if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) -- png_error(png_ptr, -- "png_write_info was never called before png_write_row."); -- -- /* check for transforms that have been set but were defined out */ --#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED) -- if (png_ptr->transformations & PNG_INVERT_MONO) -- png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined."); --#endif --#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED) -- if (png_ptr->transformations & PNG_FILLER) -- png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined."); --#endif --#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_PACKSWAP) -- png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined."); --#endif --#if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED) -- if (png_ptr->transformations & PNG_PACK) -- png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined."); --#endif --#if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED) -- if (png_ptr->transformations & PNG_SHIFT) -- png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined."); --#endif --#if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED) -- if (png_ptr->transformations & PNG_BGR) -- png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined."); --#endif --#if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_SWAP_BYTES) -- png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined."); --#endif -- -- png_write_start_row(png_ptr); -- } -- --#if defined(PNG_WRITE_INTERLACING_SUPPORTED) -- /* if interlaced and not interested in row, return */ -- if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) -- { -- switch (png_ptr->pass) -- { -- case 0: -- if (png_ptr->row_number & 0x07) -- { -- png_write_finish_row(png_ptr); -- return; -- } -- break; -- case 1: -- if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) -- { -- png_write_finish_row(png_ptr); -- return; -- } -- break; -- case 2: -- if ((png_ptr->row_number & 0x07) != 4) -- { -- png_write_finish_row(png_ptr); -- return; -- } -- break; -- case 3: -- if ((png_ptr->row_number & 0x03) || png_ptr->width < 3) -- { -- png_write_finish_row(png_ptr); -- return; -- } -- break; -- case 4: -- if ((png_ptr->row_number & 0x03) != 2) -- { -- png_write_finish_row(png_ptr); -- return; -- } -- break; -- case 5: -- if ((png_ptr->row_number & 0x01) || png_ptr->width < 2) -- { -- png_write_finish_row(png_ptr); -- return; -- } -- break; -- case 6: -- if (!(png_ptr->row_number & 0x01)) -- { -- png_write_finish_row(png_ptr); -- return; -- } -- break; -- } -- } --#endif -- -- /* set up row info for transformations */ -- png_ptr->row_info.color_type = png_ptr->color_type; -- png_ptr->row_info.width = png_ptr->usr_width; -- png_ptr->row_info.channels = png_ptr->usr_channels; -- png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth; -- png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth * -- png_ptr->row_info.channels); -- -- png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, -- png_ptr->row_info.width); -- -- png_debug1(3, "row_info->color_type = %d\n", png_ptr->row_info.color_type); -- png_debug1(3, "row_info->width = %lu\n", png_ptr->row_info.width); -- png_debug1(3, "row_info->channels = %d\n", png_ptr->row_info.channels); -- png_debug1(3, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth); -- png_debug1(3, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth); -- png_debug1(3, "row_info->rowbytes = %lu\n", png_ptr->row_info.rowbytes); -- -- /* Copy user's row into buffer, leaving room for filter byte. */ -- png_memcpy_check(png_ptr, png_ptr->row_buf + 1, row, -- png_ptr->row_info.rowbytes); -- --#if defined(PNG_WRITE_INTERLACING_SUPPORTED) -- /* handle interlacing */ -- if (png_ptr->interlaced && png_ptr->pass < 6 && -- (png_ptr->transformations & PNG_INTERLACE)) -- { -- png_do_write_interlace(&(png_ptr->row_info), -- png_ptr->row_buf + 1, png_ptr->pass); -- /* this should always get caught above, but still ... */ -- if (!(png_ptr->row_info.width)) -- { -- png_write_finish_row(png_ptr); -- return; -- } -- } --#endif -- -- /* handle other transformations */ -- if (png_ptr->transformations) -- png_do_write_transformations(png_ptr); -- --#if defined(PNG_MNG_FEATURES_SUPPORTED) -- /* Write filter_method 64 (intrapixel differencing) only if -- * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and -- * 2. Libpng did not write a PNG signature (this filter_method is only -- * used in PNG datastreams that are embedded in MNG datastreams) and -- * 3. The application called png_permit_mng_features with a mask that -- * included PNG_FLAG_MNG_FILTER_64 and -- * 4. The filter_method is 64 and -- * 5. The color_type is RGB or RGBA -- */ -- if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && -- (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) -- { -- /* Intrapixel differencing */ -- png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1); -- } --#endif -- -- /* Find a filter if necessary, filter the row and write it out. */ -- png_write_find_filter(png_ptr, &(png_ptr->row_info)); -- -- if (png_ptr->write_row_fn != NULL) -- (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); --} -- --#if defined(PNG_WRITE_FLUSH_SUPPORTED) --/* Set the automatic flush interval or 0 to turn flushing off */ --void PNGAPI --png_set_flush(png_structp png_ptr, int nrows) --{ -- png_debug(1, "in png_set_flush\n"); -- png_ptr->flush_dist = (nrows < 0 ? 0 : nrows); --} -- --/* flush the current output buffers now */ --void PNGAPI --png_write_flush(png_structp png_ptr) --{ -- int wrote_IDAT; -- -- png_debug(1, "in png_write_flush\n"); -- /* We have already written out all of the data */ -- if (png_ptr->row_number >= png_ptr->num_rows) -- return; -- -- do -- { -- int ret; -- -- /* compress the data */ -- ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH); -- wrote_IDAT = 0; -- -- /* check for compression errors */ -- if (ret != Z_OK) -- { -- if (png_ptr->zstream.msg != NULL) -- png_error(png_ptr, png_ptr->zstream.msg); -- else -- png_error(png_ptr, "zlib error"); -- } -- -- if (!(png_ptr->zstream.avail_out)) -- { -- /* write the IDAT and reset the zlib output buffer */ -- png_write_IDAT(png_ptr, png_ptr->zbuf, -- png_ptr->zbuf_size); -- png_ptr->zstream.next_out = png_ptr->zbuf; -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -- wrote_IDAT = 1; -- } -- } while(wrote_IDAT == 1); -- -- /* If there is any data left to be output, write it into a new IDAT */ -- if (png_ptr->zbuf_size != png_ptr->zstream.avail_out) -- { -- /* write the IDAT and reset the zlib output buffer */ -- png_write_IDAT(png_ptr, png_ptr->zbuf, -- png_ptr->zbuf_size - png_ptr->zstream.avail_out); -- png_ptr->zstream.next_out = png_ptr->zbuf; -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -- } -- png_ptr->flush_rows = 0; -- png_flush(png_ptr); --} --#endif /* PNG_WRITE_FLUSH_SUPPORTED */ -- --/* free all memory used by the write */ --void PNGAPI --png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr) --{ -- png_structp png_ptr = NULL; -- png_infop info_ptr = NULL; --#ifdef PNG_USER_MEM_SUPPORTED -- png_free_ptr free_fn = NULL; -- png_voidp mem_ptr = NULL; --#endif -- -- png_debug(1, "in png_destroy_write_struct\n"); -- if (png_ptr_ptr != NULL) -- { -- png_ptr = *png_ptr_ptr; --#ifdef PNG_USER_MEM_SUPPORTED -- free_fn = png_ptr->free_fn; -- mem_ptr = png_ptr->mem_ptr; --#endif -- } -- -- if (info_ptr_ptr != NULL) -- info_ptr = *info_ptr_ptr; -- -- if (info_ptr != NULL) -- { -- png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); -- --#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) -- if (png_ptr->num_chunk_list) -- { -- png_free(png_ptr, png_ptr->chunk_list); -- png_ptr->chunk_list=NULL; -- png_ptr->num_chunk_list=0; -- } --#endif -- --#ifdef PNG_USER_MEM_SUPPORTED -- png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn, -- (png_voidp)mem_ptr); --#else -- png_destroy_struct((png_voidp)info_ptr); --#endif -- *info_ptr_ptr = NULL; -- } -- -- if (png_ptr != NULL) -- { -- png_write_destroy(png_ptr); --#ifdef PNG_USER_MEM_SUPPORTED -- png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, -- (png_voidp)mem_ptr); --#else -- png_destroy_struct((png_voidp)png_ptr); --#endif -- *png_ptr_ptr = NULL; -- } --} -- -- --/* Free any memory used in png_ptr struct (old method) */ --void /* PRIVATE */ --png_write_destroy(png_structp png_ptr) --{ --#ifdef PNG_SETJMP_SUPPORTED -- jmp_buf tmp_jmp; /* save jump buffer */ --#endif -- png_error_ptr error_fn; -- png_error_ptr warning_fn; -- png_voidp error_ptr; --#ifdef PNG_USER_MEM_SUPPORTED -- png_free_ptr free_fn; --#endif -- -- png_debug(1, "in png_write_destroy\n"); -- /* free any memory zlib uses */ -- deflateEnd(&png_ptr->zstream); -- -- /* free our memory. png_free checks NULL for us. */ -- png_free(png_ptr, png_ptr->zbuf); -- png_free(png_ptr, png_ptr->row_buf); -- png_free(png_ptr, png_ptr->prev_row); -- png_free(png_ptr, png_ptr->sub_row); -- png_free(png_ptr, png_ptr->up_row); -- png_free(png_ptr, png_ptr->avg_row); -- png_free(png_ptr, png_ptr->paeth_row); -- --#if defined(PNG_TIME_RFC1123_SUPPORTED) -- png_free(png_ptr, png_ptr->time_buffer); --#endif -- --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) -- png_free(png_ptr, png_ptr->prev_filters); -- png_free(png_ptr, png_ptr->filter_weights); -- png_free(png_ptr, png_ptr->inv_filter_weights); -- png_free(png_ptr, png_ptr->filter_costs); -- png_free(png_ptr, png_ptr->inv_filter_costs); --#endif -- --#ifdef PNG_SETJMP_SUPPORTED -- /* reset structure */ -- png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof (jmp_buf)); --#endif -- -- error_fn = png_ptr->error_fn; -- warning_fn = png_ptr->warning_fn; -- error_ptr = png_ptr->error_ptr; --#ifdef PNG_USER_MEM_SUPPORTED -- free_fn = png_ptr->free_fn; --#endif -- -- png_memset(png_ptr, 0, png_sizeof (png_struct)); -- -- png_ptr->error_fn = error_fn; -- png_ptr->warning_fn = warning_fn; -- png_ptr->error_ptr = error_ptr; --#ifdef PNG_USER_MEM_SUPPORTED -- png_ptr->free_fn = free_fn; --#endif -- --#ifdef PNG_SETJMP_SUPPORTED -- png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof (jmp_buf)); --#endif --} -- --/* Allow the application to select one or more row filters to use. */ --void PNGAPI --png_set_filter(png_structp png_ptr, int method, int filters) --{ -- png_debug(1, "in png_set_filter\n"); --#if defined(PNG_MNG_FEATURES_SUPPORTED) -- if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && -- (method == PNG_INTRAPIXEL_DIFFERENCING)) -- method = PNG_FILTER_TYPE_BASE; --#endif -- if (method == PNG_FILTER_TYPE_BASE) -- { -- switch (filters & (PNG_ALL_FILTERS | 0x07)) -- { -- case 5: -- case 6: -- case 7: png_warning(png_ptr, "Unknown row filter for method 0"); -- case PNG_FILTER_VALUE_NONE: png_ptr->do_filter=PNG_FILTER_NONE; break; -- case PNG_FILTER_VALUE_SUB: png_ptr->do_filter=PNG_FILTER_SUB; break; -- case PNG_FILTER_VALUE_UP: png_ptr->do_filter=PNG_FILTER_UP; break; -- case PNG_FILTER_VALUE_AVG: png_ptr->do_filter=PNG_FILTER_AVG; break; -- case PNG_FILTER_VALUE_PAETH: png_ptr->do_filter=PNG_FILTER_PAETH;break; -- default: png_ptr->do_filter = (png_byte)filters; break; -- } -- -- /* If we have allocated the row_buf, this means we have already started -- * with the image and we should have allocated all of the filter buffers -- * that have been selected. If prev_row isn't already allocated, then -- * it is too late to start using the filters that need it, since we -- * will be missing the data in the previous row. If an application -- * wants to start and stop using particular filters during compression, -- * it should start out with all of the filters, and then add and -- * remove them after the start of compression. -- */ -- if (png_ptr->row_buf != NULL) -- { -- if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL) -- { -- png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, -- (png_ptr->rowbytes + 1)); -- png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB; -- } -- -- if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL) -- { -- if (png_ptr->prev_row == NULL) -- { -- png_warning(png_ptr, "Can't add Up filter after starting"); -- png_ptr->do_filter &= ~PNG_FILTER_UP; -- } -- else -- { -- png_ptr->up_row = (png_bytep)png_malloc(png_ptr, -- (png_ptr->rowbytes + 1)); -- png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; -- } -- } -- -- if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL) -- { -- if (png_ptr->prev_row == NULL) -- { -- png_warning(png_ptr, "Can't add Average filter after starting"); -- png_ptr->do_filter &= ~PNG_FILTER_AVG; -- } -- else -- { -- png_ptr->avg_row = (png_bytep)png_malloc(png_ptr, -- (png_ptr->rowbytes + 1)); -- png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG; -- } -- } -- -- if ((png_ptr->do_filter & PNG_FILTER_PAETH) && -- png_ptr->paeth_row == NULL) -- { -- if (png_ptr->prev_row == NULL) -- { -- png_warning(png_ptr, "Can't add Paeth filter after starting"); -- png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH); -- } -- else -- { -- png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr, -- (png_ptr->rowbytes + 1)); -- png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; -- } -- } -- -- if (png_ptr->do_filter == PNG_NO_FILTERS) -- png_ptr->do_filter = PNG_FILTER_NONE; -- } -- } -- else -- png_error(png_ptr, "Unknown custom filter method"); --} -- --/* This allows us to influence the way in which libpng chooses the "best" -- * filter for the current scanline. While the "minimum-sum-of-absolute- -- * differences metric is relatively fast and effective, there is some -- * question as to whether it can be improved upon by trying to keep the -- * filtered data going to zlib more consistent, hopefully resulting in -- * better compression. -- */ --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* GRR 970116 */ --void PNGAPI --png_set_filter_heuristics(png_structp png_ptr, int heuristic_method, -- int num_weights, png_doublep filter_weights, -- png_doublep filter_costs) --{ -- int i; -- -- png_debug(1, "in png_set_filter_heuristics\n"); -- if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST) -- { -- png_warning(png_ptr, "Unknown filter heuristic method"); -- return; -- } -- -- if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT) -- { -- heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED; -- } -- -- if (num_weights < 0 || filter_weights == NULL || -- heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED) -- { -- num_weights = 0; -- } -- -- png_ptr->num_prev_filters = (png_byte)num_weights; -- png_ptr->heuristic_method = (png_byte)heuristic_method; -- -- if (num_weights > 0) -- { -- if (png_ptr->prev_filters == NULL) -- { -- png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr, -- (png_uint_32)(png_sizeof(png_byte) * num_weights)); -- -- /* To make sure that the weighting starts out fairly */ -- for (i = 0; i < num_weights; i++) -- { -- png_ptr->prev_filters[i] = 255; -- } -- } -- -- if (png_ptr->filter_weights == NULL) -- { -- png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr, -- (png_uint_32)(png_sizeof(png_uint_16) * num_weights)); -- -- png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr, -- (png_uint_32)(png_sizeof(png_uint_16) * num_weights)); -- for (i = 0; i < num_weights; i++) -- { -- png_ptr->inv_filter_weights[i] = -- png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR; -- } -- } -- -- for (i = 0; i < num_weights; i++) -- { -- if (filter_weights[i] < 0.0) -- { -- png_ptr->inv_filter_weights[i] = -- png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR; -- } -- else -- { -- png_ptr->inv_filter_weights[i] = -- (png_uint_16)((double)PNG_WEIGHT_FACTOR*filter_weights[i]+0.5); -- png_ptr->filter_weights[i] = -- (png_uint_16)((double)PNG_WEIGHT_FACTOR/filter_weights[i]+0.5); -- } -- } -- } -- -- /* If, in the future, there are other filter methods, this would -- * need to be based on png_ptr->filter. -- */ -- if (png_ptr->filter_costs == NULL) -- { -- png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr, -- (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); -- -- png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr, -- (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); -- -- for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) -- { -- png_ptr->inv_filter_costs[i] = -- png_ptr->filter_costs[i] = PNG_COST_FACTOR; -- } -- } -- -- /* Here is where we set the relative costs of the different filters. We -- * should take the desired compression level into account when setting -- * the costs, so that Paeth, for instance, has a high relative cost at low -- * compression levels, while it has a lower relative cost at higher -- * compression settings. The filter types are in order of increasing -- * relative cost, so it would be possible to do this with an algorithm. -- */ -- for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) -- { -- if (filter_costs == NULL || filter_costs[i] < 0.0) -- { -- png_ptr->inv_filter_costs[i] = -- png_ptr->filter_costs[i] = PNG_COST_FACTOR; -- } -- else if (filter_costs[i] >= 1.0) -- { -- png_ptr->inv_filter_costs[i] = -- (png_uint_16)((double)PNG_COST_FACTOR / filter_costs[i] + 0.5); -- png_ptr->filter_costs[i] = -- (png_uint_16)((double)PNG_COST_FACTOR * filter_costs[i] + 0.5); -- } -- } --} --#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ -- --void PNGAPI --png_set_compression_level(png_structp png_ptr, int level) --{ -- png_debug(1, "in png_set_compression_level\n"); -- png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL; -- png_ptr->zlib_level = level; --} -- --void PNGAPI --png_set_compression_mem_level(png_structp png_ptr, int mem_level) --{ -- png_debug(1, "in png_set_compression_mem_level\n"); -- png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL; -- png_ptr->zlib_mem_level = mem_level; --} -- --void PNGAPI --png_set_compression_strategy(png_structp png_ptr, int strategy) --{ -- png_debug(1, "in png_set_compression_strategy\n"); -- png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY; -- png_ptr->zlib_strategy = strategy; --} -- --void PNGAPI --png_set_compression_window_bits(png_structp png_ptr, int window_bits) --{ -- if (window_bits > 15) -- png_warning(png_ptr, "Only compression windows <= 32k supported by PNG"); -- else if (window_bits < 8) -- png_warning(png_ptr, "Only compression windows >= 256 supported by PNG"); --#ifndef WBITS_8_OK -- /* avoid libpng bug with 256-byte windows */ -- if (window_bits == 8) -- { -- png_warning(png_ptr, "Compression window is being reset to 512"); -- window_bits=9; -- } --#endif -- png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS; -- png_ptr->zlib_window_bits = window_bits; --} -- --void PNGAPI --png_set_compression_method(png_structp png_ptr, int method) --{ -- png_debug(1, "in png_set_compression_method\n"); -- if (method != 8) -- png_warning(png_ptr, "Only compression method 8 is supported by PNG"); -- png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD; -- png_ptr->zlib_method = method; --} -- --void PNGAPI --png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn) --{ -- png_ptr->write_row_fn = write_row_fn; --} -- --#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) --void PNGAPI --png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr -- write_user_transform_fn) --{ -- png_debug(1, "in png_set_write_user_transform_fn\n"); -- png_ptr->transformations |= PNG_USER_TRANSFORM; -- png_ptr->write_user_transform_fn = write_user_transform_fn; --} --#endif -- -- --#if defined(PNG_INFO_IMAGE_SUPPORTED) --void PNGAPI --png_write_png(png_structp png_ptr, png_infop info_ptr, -- int transforms, voidp params) --{ --#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) -- /* invert the alpha channel from opacity to transparency */ -- if (transforms & PNG_TRANSFORM_INVERT_ALPHA) -- png_set_invert_alpha(png_ptr); --#endif -- -- /* Write the file header information. */ -- png_write_info(png_ptr, info_ptr); -- -- /* ------ these transformations don't touch the info structure ------- */ -- --#if defined(PNG_WRITE_INVERT_SUPPORTED) -- /* invert monochrome pixels */ -- if (transforms & PNG_TRANSFORM_INVERT_MONO) -- png_set_invert_mono(png_ptr); --#endif -- --#if defined(PNG_WRITE_SHIFT_SUPPORTED) -- /* Shift the pixels up to a legal bit depth and fill in -- * as appropriate to correctly scale the image. -- */ -- if ((transforms & PNG_TRANSFORM_SHIFT) -- && (info_ptr->valid & PNG_INFO_sBIT)) -- png_set_shift(png_ptr, &info_ptr->sig_bit); --#endif -- --#if defined(PNG_WRITE_PACK_SUPPORTED) -- /* pack pixels into bytes */ -- if (transforms & PNG_TRANSFORM_PACKING) -- png_set_packing(png_ptr); --#endif -- --#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) -- /* swap location of alpha bytes from ARGB to RGBA */ -- if (transforms & PNG_TRANSFORM_SWAP_ALPHA) -- png_set_swap_alpha(png_ptr); --#endif -- --#if defined(PNG_WRITE_FILLER_SUPPORTED) -- /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into -- * RGB (4 channels -> 3 channels). The second parameter is not used. -- */ -- if (transforms & PNG_TRANSFORM_STRIP_FILLER) -- png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); --#endif -- --#if defined(PNG_WRITE_BGR_SUPPORTED) -- /* flip BGR pixels to RGB */ -- if (transforms & PNG_TRANSFORM_BGR) -- png_set_bgr(png_ptr); --#endif -- --#if defined(PNG_WRITE_SWAP_SUPPORTED) -- /* swap bytes of 16-bit files to most significant byte first */ -- if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) -- png_set_swap(png_ptr); --#endif -- --#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) -- /* swap bits of 1, 2, 4 bit packed pixel formats */ -- if (transforms & PNG_TRANSFORM_PACKSWAP) -- png_set_packswap(png_ptr); --#endif -- -- /* ----------------------- end of transformations ------------------- */ -- -- /* write the bits */ -- if (info_ptr->valid & PNG_INFO_IDAT) -- png_write_image(png_ptr, info_ptr->row_pointers); -- -- /* It is REQUIRED to call this to finish writing the rest of the file */ -- png_write_end(png_ptr, info_ptr); -- -- if(transforms == 0 || params == NULL) -- /* quiet compiler warnings */ return; --} --#endif --#endif /* PNG_WRITE_SUPPORTED */ -diff --git a/thirdparty/libpng/pngwtran.c b/thirdparty/libpng/pngwtran.c -deleted file mode 100644 -index 94d8ecc..0000000 ---- a/thirdparty/libpng/pngwtran.c -+++ /dev/null -@@ -1,563 +0,0 @@ -- --/* pngwtran.c - transforms the data in a row for PNG writers -- * -- * libpng version 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- */ -- --#define PNG_INTERNAL --#include "png.h" --#ifdef PNG_WRITE_SUPPORTED -- --/* Transform the data according to the user's wishes. The order of -- * transformations is significant. -- */ --void /* PRIVATE */ --png_do_write_transformations(png_structp png_ptr) --{ -- png_debug(1, "in png_do_write_transformations\n"); -- -- if (png_ptr == NULL) -- return; -- --#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) -- if (png_ptr->transformations & PNG_USER_TRANSFORM) -- if(png_ptr->write_user_transform_fn != NULL) -- (*(png_ptr->write_user_transform_fn)) /* user write transform function */ -- (png_ptr, /* png_ptr */ -- &(png_ptr->row_info), /* row_info: */ -- /* png_uint_32 width; width of row */ -- /* png_uint_32 rowbytes; number of bytes in row */ -- /* png_byte color_type; color type of pixels */ -- /* png_byte bit_depth; bit depth of samples */ -- /* png_byte channels; number of channels (1-4) */ -- /* png_byte pixel_depth; bits per pixel (depth*channels) */ -- png_ptr->row_buf + 1); /* start of pixel data for row */ --#endif --#if defined(PNG_WRITE_FILLER_SUPPORTED) -- if (png_ptr->transformations & PNG_FILLER) -- png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, -- png_ptr->flags); --#endif --#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_PACKSWAP) -- png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif --#if defined(PNG_WRITE_PACK_SUPPORTED) -- if (png_ptr->transformations & PNG_PACK) -- png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1, -- (png_uint_32)png_ptr->bit_depth); --#endif --#if defined(PNG_WRITE_SWAP_SUPPORTED) -- if (png_ptr->transformations & PNG_SWAP_BYTES) -- png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif --#if defined(PNG_WRITE_SHIFT_SUPPORTED) -- if (png_ptr->transformations & PNG_SHIFT) -- png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1, -- &(png_ptr->shift)); --#endif --#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) -- if (png_ptr->transformations & PNG_INVERT_ALPHA) -- png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif --#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) -- if (png_ptr->transformations & PNG_SWAP_ALPHA) -- png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif --#if defined(PNG_WRITE_BGR_SUPPORTED) -- if (png_ptr->transformations & PNG_BGR) -- png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif --#if defined(PNG_WRITE_INVERT_SUPPORTED) -- if (png_ptr->transformations & PNG_INVERT_MONO) -- png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1); --#endif --} -- --#if defined(PNG_WRITE_PACK_SUPPORTED) --/* Pack pixels into bytes. Pass the true bit depth in bit_depth. The -- * row_info bit depth should be 8 (one pixel per byte). The channels -- * should be 1 (this only happens on grayscale and paletted images). -- */ --void /* PRIVATE */ --png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth) --{ -- png_debug(1, "in png_do_pack\n"); -- if (row_info->bit_depth == 8 && --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- row != NULL && row_info != NULL && --#endif -- row_info->channels == 1) -- { -- switch ((int)bit_depth) -- { -- case 1: -- { -- png_bytep sp, dp; -- int mask, v; -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- -- sp = row; -- dp = row; -- mask = 0x80; -- v = 0; -- -- for (i = 0; i < row_width; i++) -- { -- if (*sp != 0) -- v |= mask; -- sp++; -- if (mask > 1) -- mask >>= 1; -- else -- { -- mask = 0x80; -- *dp = (png_byte)v; -- dp++; -- v = 0; -- } -- } -- if (mask != 0x80) -- *dp = (png_byte)v; -- break; -- } -- case 2: -- { -- png_bytep sp, dp; -- int shift, v; -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- -- sp = row; -- dp = row; -- shift = 6; -- v = 0; -- for (i = 0; i < row_width; i++) -- { -- png_byte value; -- -- value = (png_byte)(*sp & 0x03); -- v |= (value << shift); -- if (shift == 0) -- { -- shift = 6; -- *dp = (png_byte)v; -- dp++; -- v = 0; -- } -- else -- shift -= 2; -- sp++; -- } -- if (shift != 6) -- *dp = (png_byte)v; -- break; -- } -- case 4: -- { -- png_bytep sp, dp; -- int shift, v; -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- -- sp = row; -- dp = row; -- shift = 4; -- v = 0; -- for (i = 0; i < row_width; i++) -- { -- png_byte value; -- -- value = (png_byte)(*sp & 0x0f); -- v |= (value << shift); -- -- if (shift == 0) -- { -- shift = 4; -- *dp = (png_byte)v; -- dp++; -- v = 0; -- } -- else -- shift -= 4; -- -- sp++; -- } -- if (shift != 4) -- *dp = (png_byte)v; -- break; -- } -- } -- row_info->bit_depth = (png_byte)bit_depth; -- row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels); -- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, -- row_info->width); -- } --} --#endif -- --#if defined(PNG_WRITE_SHIFT_SUPPORTED) --/* Shift pixel values to take advantage of whole range. Pass the -- * true number of bits in bit_depth. The row should be packed -- * according to row_info->bit_depth. Thus, if you had a row of -- * bit depth 4, but the pixels only had values from 0 to 7, you -- * would pass 3 as bit_depth, and this routine would translate the -- * data to 0 to 15. -- */ --void /* PRIVATE */ --png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth) --{ -- png_debug(1, "in png_do_shift\n"); --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- if (row != NULL && row_info != NULL && --#else -- if ( --#endif -- row_info->color_type != PNG_COLOR_TYPE_PALETTE) -- { -- int shift_start[4], shift_dec[4]; -- int channels = 0; -- -- if (row_info->color_type & PNG_COLOR_MASK_COLOR) -- { -- shift_start[channels] = row_info->bit_depth - bit_depth->red; -- shift_dec[channels] = bit_depth->red; -- channels++; -- shift_start[channels] = row_info->bit_depth - bit_depth->green; -- shift_dec[channels] = bit_depth->green; -- channels++; -- shift_start[channels] = row_info->bit_depth - bit_depth->blue; -- shift_dec[channels] = bit_depth->blue; -- channels++; -- } -- else -- { -- shift_start[channels] = row_info->bit_depth - bit_depth->gray; -- shift_dec[channels] = bit_depth->gray; -- channels++; -- } -- if (row_info->color_type & PNG_COLOR_MASK_ALPHA) -- { -- shift_start[channels] = row_info->bit_depth - bit_depth->alpha; -- shift_dec[channels] = bit_depth->alpha; -- channels++; -- } -- -- /* with low row depths, could only be grayscale, so one channel */ -- if (row_info->bit_depth < 8) -- { -- png_bytep bp = row; -- png_uint_32 i; -- png_byte mask; -- png_uint_32 row_bytes = row_info->rowbytes; -- -- if (bit_depth->gray == 1 && row_info->bit_depth == 2) -- mask = 0x55; -- else if (row_info->bit_depth == 4 && bit_depth->gray == 3) -- mask = 0x11; -- else -- mask = 0xff; -- -- for (i = 0; i < row_bytes; i++, bp++) -- { -- png_uint_16 v; -- int j; -- -- v = *bp; -- *bp = 0; -- for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0]) -- { -- if (j > 0) -- *bp |= (png_byte)((v << j) & 0xff); -- else -- *bp |= (png_byte)((v >> (-j)) & mask); -- } -- } -- } -- else if (row_info->bit_depth == 8) -- { -- png_bytep bp = row; -- png_uint_32 i; -- png_uint_32 istop = channels * row_info->width; -- -- for (i = 0; i < istop; i++, bp++) -- { -- -- png_uint_16 v; -- int j; -- int c = (int)(i%channels); -- -- v = *bp; -- *bp = 0; -- for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c]) -- { -- if (j > 0) -- *bp |= (png_byte)((v << j) & 0xff); -- else -- *bp |= (png_byte)((v >> (-j)) & 0xff); -- } -- } -- } -- else -- { -- png_bytep bp; -- png_uint_32 i; -- png_uint_32 istop = channels * row_info->width; -- -- for (bp = row, i = 0; i < istop; i++) -- { -- int c = (int)(i%channels); -- png_uint_16 value, v; -- int j; -- -- v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1)); -- value = 0; -- for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c]) -- { -- if (j > 0) -- value |= (png_uint_16)((v << j) & (png_uint_16)0xffff); -- else -- value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff); -- } -- *bp++ = (png_byte)(value >> 8); -- *bp++ = (png_byte)(value & 0xff); -- } -- } -- } --} --#endif -- --#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) --void /* PRIVATE */ --png_do_write_swap_alpha(png_row_infop row_info, png_bytep row) --{ -- png_debug(1, "in png_do_write_swap_alpha\n"); --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- if (row != NULL && row_info != NULL) --#endif -- { -- if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- { -- /* This converts from ARGB to RGBA */ -- if (row_info->bit_depth == 8) -- { -- png_bytep sp, dp; -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- for (i = 0, sp = dp = row; i < row_width; i++) -- { -- png_byte save = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = save; -- } -- } -- /* This converts from AARRGGBB to RRGGBBAA */ -- else -- { -- png_bytep sp, dp; -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- -- for (i = 0, sp = dp = row; i < row_width; i++) -- { -- png_byte save[2]; -- save[0] = *(sp++); -- save[1] = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = save[0]; -- *(dp++) = save[1]; -- } -- } -- } -- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) -- { -- /* This converts from AG to GA */ -- if (row_info->bit_depth == 8) -- { -- png_bytep sp, dp; -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- -- for (i = 0, sp = dp = row; i < row_width; i++) -- { -- png_byte save = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = save; -- } -- } -- /* This converts from AAGG to GGAA */ -- else -- { -- png_bytep sp, dp; -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- -- for (i = 0, sp = dp = row; i < row_width; i++) -- { -- png_byte save[2]; -- save[0] = *(sp++); -- save[1] = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = save[0]; -- *(dp++) = save[1]; -- } -- } -- } -- } --} --#endif -- --#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) --void /* PRIVATE */ --png_do_write_invert_alpha(png_row_infop row_info, png_bytep row) --{ -- png_debug(1, "in png_do_write_invert_alpha\n"); --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- if (row != NULL && row_info != NULL) --#endif -- { -- if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- { -- /* This inverts the alpha channel in RGBA */ -- if (row_info->bit_depth == 8) -- { -- png_bytep sp, dp; -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- for (i = 0, sp = dp = row; i < row_width; i++) -- { -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = (png_byte)(255 - *(sp++)); -- } -- } -- /* This inverts the alpha channel in RRGGBBAA */ -- else -- { -- png_bytep sp, dp; -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- -- for (i = 0, sp = dp = row; i < row_width; i++) -- { -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = (png_byte)(255 - *(sp++)); -- *(dp++) = (png_byte)(255 - *(sp++)); -- } -- } -- } -- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) -- { -- /* This inverts the alpha channel in GA */ -- if (row_info->bit_depth == 8) -- { -- png_bytep sp, dp; -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- -- for (i = 0, sp = dp = row; i < row_width; i++) -- { -- *(dp++) = *(sp++); -- *(dp++) = (png_byte)(255 - *(sp++)); -- } -- } -- /* This inverts the alpha channel in GGAA */ -- else -- { -- png_bytep sp, dp; -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- -- for (i = 0, sp = dp = row; i < row_width; i++) -- { -- *(dp++) = *(sp++); -- *(dp++) = *(sp++); -- *(dp++) = (png_byte)(255 - *(sp++)); -- *(dp++) = (png_byte)(255 - *(sp++)); -- } -- } -- } -- } --} --#endif -- --#if defined(PNG_MNG_FEATURES_SUPPORTED) --/* undoes intrapixel differencing */ --void /* PRIVATE */ --png_do_write_intrapixel(png_row_infop row_info, png_bytep row) --{ -- png_debug(1, "in png_do_write_intrapixel\n"); -- if ( --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- row != NULL && row_info != NULL && --#endif -- (row_info->color_type & PNG_COLOR_MASK_COLOR)) -- { -- int bytes_per_pixel; -- png_uint_32 row_width = row_info->width; -- if (row_info->bit_depth == 8) -- { -- png_bytep rp; -- png_uint_32 i; -- -- if (row_info->color_type == PNG_COLOR_TYPE_RGB) -- bytes_per_pixel = 3; -- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- bytes_per_pixel = 4; -- else -- return; -- -- for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) -- { -- *(rp) = (png_byte)((*rp - *(rp+1))&0xff); -- *(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff); -- } -- } -- else if (row_info->bit_depth == 16) -- { -- png_bytep rp; -- png_uint_32 i; -- -- if (row_info->color_type == PNG_COLOR_TYPE_RGB) -- bytes_per_pixel = 6; -- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) -- bytes_per_pixel = 8; -- else -- return; -- -- for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) -- { -- png_uint_32 s0 = (*(rp ) << 8) | *(rp+1); -- png_uint_32 s1 = (*(rp+2) << 8) | *(rp+3); -- png_uint_32 s2 = (*(rp+4) << 8) | *(rp+5); -- png_uint_32 red = (png_uint_32)((s0-s1) & 0xffffL); -- png_uint_32 blue = (png_uint_32)((s2-s1) & 0xffffL); -- *(rp ) = (png_byte)((red >> 8) & 0xff); -- *(rp+1) = (png_byte)(red & 0xff); -- *(rp+4) = (png_byte)((blue >> 8) & 0xff); -- *(rp+5) = (png_byte)(blue & 0xff); -- } -- } -- } --} --#endif /* PNG_MNG_FEATURES_SUPPORTED */ --#endif /* PNG_WRITE_SUPPORTED */ -diff --git a/thirdparty/libpng/pngwutil.c b/thirdparty/libpng/pngwutil.c -deleted file mode 100644 -index 17938d2..0000000 ---- a/thirdparty/libpng/pngwutil.c -+++ /dev/null -@@ -1,2726 +0,0 @@ -- --/* pngwutil.c - utilities to write a PNG file -- * -- * libpng version 1.2.7 - September 12, 2004 -- * For conditions of distribution and use, see copyright notice in png.h -- * Copyright (c) 1998-2004 Glenn Randers-Pehrson -- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) -- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) -- */ -- --#define PNG_INTERNAL --#include "png.h" --#ifdef PNG_WRITE_SUPPORTED -- --/* Place a 32-bit number into a buffer in PNG byte order. We work -- * with unsigned numbers for convenience, although one supported -- * ancillary chunk uses signed (two's complement) numbers. -- */ --void /* PRIVATE */ --png_save_uint_32(png_bytep buf, png_uint_32 i) --{ -- buf[0] = (png_byte)((i >> 24) & 0xff); -- buf[1] = (png_byte)((i >> 16) & 0xff); -- buf[2] = (png_byte)((i >> 8) & 0xff); -- buf[3] = (png_byte)(i & 0xff); --} -- --#if defined(PNG_WRITE_pCAL_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED) --/* The png_save_int_32 function assumes integers are stored in two's -- * complement format. If this isn't the case, then this routine needs to -- * be modified to write data in two's complement format. -- */ --void /* PRIVATE */ --png_save_int_32(png_bytep buf, png_int_32 i) --{ -- buf[0] = (png_byte)((i >> 24) & 0xff); -- buf[1] = (png_byte)((i >> 16) & 0xff); -- buf[2] = (png_byte)((i >> 8) & 0xff); -- buf[3] = (png_byte)(i & 0xff); --} --#endif -- --/* Place a 16-bit number into a buffer in PNG byte order. -- * The parameter is declared unsigned int, not png_uint_16, -- * just to avoid potential problems on pre-ANSI C compilers. -- */ --void /* PRIVATE */ --png_save_uint_16(png_bytep buf, unsigned int i) --{ -- buf[0] = (png_byte)((i >> 8) & 0xff); -- buf[1] = (png_byte)(i & 0xff); --} -- --/* Write a PNG chunk all at once. The type is an array of ASCII characters -- * representing the chunk name. The array must be at least 4 bytes in -- * length, and does not need to be null terminated. To be safe, pass the -- * pre-defined chunk names here, and if you need a new one, define it -- * where the others are defined. The length is the length of the data. -- * All the data must be present. If that is not possible, use the -- * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end() -- * functions instead. -- */ --void PNGAPI --png_write_chunk(png_structp png_ptr, png_bytep chunk_name, -- png_bytep data, png_size_t length) --{ -- png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length); -- png_write_chunk_data(png_ptr, data, length); -- png_write_chunk_end(png_ptr); --} -- --/* Write the start of a PNG chunk. The type is the chunk type. -- * The total_length is the sum of the lengths of all the data you will be -- * passing in png_write_chunk_data(). -- */ --void PNGAPI --png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name, -- png_uint_32 length) --{ -- png_byte buf[4]; -- png_debug2(0, "Writing %s chunk (%lu bytes)\n", chunk_name, length); -- -- /* write the length */ -- png_save_uint_32(buf, length); -- png_write_data(png_ptr, buf, (png_size_t)4); -- -- /* write the chunk name */ -- png_write_data(png_ptr, chunk_name, (png_size_t)4); -- /* reset the crc and run it over the chunk name */ -- png_reset_crc(png_ptr); -- png_calculate_crc(png_ptr, chunk_name, (png_size_t)4); --} -- --/* Write the data of a PNG chunk started with png_write_chunk_start(). -- * Note that multiple calls to this function are allowed, and that the -- * sum of the lengths from these calls *must* add up to the total_length -- * given to png_write_chunk_start(). -- */ --void PNGAPI --png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length) --{ -- /* write the data, and run the CRC over it */ -- if (data != NULL && length > 0) -- { -- png_calculate_crc(png_ptr, data, length); -- png_write_data(png_ptr, data, length); -- } --} -- --/* Finish a chunk started with png_write_chunk_start(). */ --void PNGAPI --png_write_chunk_end(png_structp png_ptr) --{ -- png_byte buf[4]; -- -- /* write the crc */ -- png_save_uint_32(buf, png_ptr->crc); -- -- png_write_data(png_ptr, buf, (png_size_t)4); --} -- --/* Simple function to write the signature. If we have already written -- * the magic bytes of the signature, or more likely, the PNG stream is -- * being embedded into another stream and doesn't need its own signature, -- * we should call png_set_sig_bytes() to tell libpng how many of the -- * bytes have already been written. -- */ --void /* PRIVATE */ --png_write_sig(png_structp png_ptr) --{ -- png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; -- /* write the rest of the 8 byte signature */ -- png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes], -- (png_size_t)8 - png_ptr->sig_bytes); -- if(png_ptr->sig_bytes < 3) -- png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; --} -- --#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED) --/* -- * This pair of functions encapsulates the operation of (a) compressing a -- * text string, and (b) issuing it later as a series of chunk data writes. -- * The compression_state structure is shared context for these functions -- * set up by the caller in order to make the whole mess thread-safe. -- */ -- --typedef struct --{ -- char *input; /* the uncompressed input data */ -- int input_len; /* its length */ -- int num_output_ptr; /* number of output pointers used */ -- int max_output_ptr; /* size of output_ptr */ -- png_charpp output_ptr; /* array of pointers to output */ --} compression_state; -- --/* compress given text into storage in the png_ptr structure */ --static int /* PRIVATE */ --png_text_compress(png_structp png_ptr, -- png_charp text, png_size_t text_len, int compression, -- compression_state *comp) --{ -- int ret; -- -- comp->num_output_ptr = comp->max_output_ptr = 0; -- comp->output_ptr = NULL; -- comp->input = NULL; -- -- /* we may just want to pass the text right through */ -- if (compression == PNG_TEXT_COMPRESSION_NONE) -- { -- comp->input = text; -- comp->input_len = text_len; -- return((int)text_len); -- } -- -- if (compression >= PNG_TEXT_COMPRESSION_LAST) -- { --#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) -- char msg[50]; -- sprintf(msg, "Unknown compression type %d", compression); -- png_warning(png_ptr, msg); --#else -- png_warning(png_ptr, "Unknown compression type"); --#endif -- } -- -- /* We can't write the chunk until we find out how much data we have, -- * which means we need to run the compressor first and save the -- * output. This shouldn't be a problem, as the vast majority of -- * comments should be reasonable, but we will set up an array of -- * malloc'd pointers to be sure. -- * -- * If we knew the application was well behaved, we could simplify this -- * greatly by assuming we can always malloc an output buffer large -- * enough to hold the compressed text ((1001 * text_len / 1000) + 12) -- * and malloc this directly. The only time this would be a bad idea is -- * if we can't malloc more than 64K and we have 64K of random input -- * data, or if the input string is incredibly large (although this -- * wouldn't cause a failure, just a slowdown due to swapping). -- */ -- -- /* set up the compression buffers */ -- png_ptr->zstream.avail_in = (uInt)text_len; -- png_ptr->zstream.next_in = (Bytef *)text; -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -- png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf; -- -- /* this is the same compression loop as in png_write_row() */ -- do -- { -- /* compress the data */ -- ret = deflate(&png_ptr->zstream, Z_NO_FLUSH); -- if (ret != Z_OK) -- { -- /* error */ -- if (png_ptr->zstream.msg != NULL) -- png_error(png_ptr, png_ptr->zstream.msg); -- else -- png_error(png_ptr, "zlib error"); -- } -- /* check to see if we need more room */ -- if (!png_ptr->zstream.avail_out && png_ptr->zstream.avail_in) -- { -- /* make sure the output array has room */ -- if (comp->num_output_ptr >= comp->max_output_ptr) -- { -- int old_max; -- -- old_max = comp->max_output_ptr; -- comp->max_output_ptr = comp->num_output_ptr + 4; -- if (comp->output_ptr != NULL) -- { -- png_charpp old_ptr; -- -- old_ptr = comp->output_ptr; -- comp->output_ptr = (png_charpp)png_malloc(png_ptr, -- (png_uint_32)(comp->max_output_ptr * -- png_sizeof (png_charpp))); -- png_memcpy(comp->output_ptr, old_ptr, old_max -- * png_sizeof (png_charp)); -- png_free(png_ptr, old_ptr); -- } -- else -- comp->output_ptr = (png_charpp)png_malloc(png_ptr, -- (png_uint_32)(comp->max_output_ptr * -- png_sizeof (png_charp))); -- } -- -- /* save the data */ -- comp->output_ptr[comp->num_output_ptr] = (png_charp)png_malloc(png_ptr, -- (png_uint_32)png_ptr->zbuf_size); -- png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf, -- png_ptr->zbuf_size); -- comp->num_output_ptr++; -- -- /* and reset the buffer */ -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -- png_ptr->zstream.next_out = png_ptr->zbuf; -- } -- /* continue until we don't have any more to compress */ -- } while (png_ptr->zstream.avail_in); -- -- /* finish the compression */ -- do -- { -- /* tell zlib we are finished */ -- ret = deflate(&png_ptr->zstream, Z_FINISH); -- -- if (ret == Z_OK) -- { -- /* check to see if we need more room */ -- if (!(png_ptr->zstream.avail_out)) -- { -- /* check to make sure our output array has room */ -- if (comp->num_output_ptr >= comp->max_output_ptr) -- { -- int old_max; -- -- old_max = comp->max_output_ptr; -- comp->max_output_ptr = comp->num_output_ptr + 4; -- if (comp->output_ptr != NULL) -- { -- png_charpp old_ptr; -- -- old_ptr = comp->output_ptr; -- /* This could be optimized to realloc() */ -- comp->output_ptr = (png_charpp)png_malloc(png_ptr, -- (png_uint_32)(comp->max_output_ptr * -- png_sizeof (png_charpp))); -- png_memcpy(comp->output_ptr, old_ptr, -- old_max * png_sizeof (png_charp)); -- png_free(png_ptr, old_ptr); -- } -- else -- comp->output_ptr = (png_charpp)png_malloc(png_ptr, -- (png_uint_32)(comp->max_output_ptr * -- png_sizeof (png_charp))); -- } -- -- /* save off the data */ -- comp->output_ptr[comp->num_output_ptr] = -- (png_charp)png_malloc(png_ptr, (png_uint_32)png_ptr->zbuf_size); -- png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf, -- png_ptr->zbuf_size); -- comp->num_output_ptr++; -- -- /* and reset the buffer pointers */ -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -- png_ptr->zstream.next_out = png_ptr->zbuf; -- } -- } -- else if (ret != Z_STREAM_END) -- { -- /* we got an error */ -- if (png_ptr->zstream.msg != NULL) -- png_error(png_ptr, png_ptr->zstream.msg); -- else -- png_error(png_ptr, "zlib error"); -- } -- } while (ret != Z_STREAM_END); -- -- /* text length is number of buffers plus last buffer */ -- text_len = png_ptr->zbuf_size * comp->num_output_ptr; -- if (png_ptr->zstream.avail_out < png_ptr->zbuf_size) -- text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out; -- -- return((int)text_len); --} -- --/* ship the compressed text out via chunk writes */ --static void /* PRIVATE */ --png_write_compressed_data_out(png_structp png_ptr, compression_state *comp) --{ -- int i; -- -- /* handle the no-compression case */ -- if (comp->input) -- { -- png_write_chunk_data(png_ptr, (png_bytep)comp->input, -- (png_size_t)comp->input_len); -- return; -- } -- -- /* write saved output buffers, if any */ -- for (i = 0; i < comp->num_output_ptr; i++) -- { -- png_write_chunk_data(png_ptr,(png_bytep)comp->output_ptr[i], -- png_ptr->zbuf_size); -- png_free(png_ptr, comp->output_ptr[i]); -- comp->output_ptr[i]=NULL; -- } -- if (comp->max_output_ptr != 0) -- png_free(png_ptr, comp->output_ptr); -- comp->output_ptr=NULL; -- /* write anything left in zbuf */ -- if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size) -- png_write_chunk_data(png_ptr, png_ptr->zbuf, -- png_ptr->zbuf_size - png_ptr->zstream.avail_out); -- -- /* reset zlib for another zTXt/iTXt or the image data */ -- deflateReset(&png_ptr->zstream); -- --} --#endif -- --/* Write the IHDR chunk, and update the png_struct with the necessary -- * information. Note that the rest of this code depends upon this -- * information being correct. -- */ --void /* PRIVATE */ --png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, -- int bit_depth, int color_type, int compression_type, int filter_type, -- int interlace_type) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_IHDR; --#endif -- png_byte buf[13]; /* buffer to store the IHDR info */ -- -- png_debug(1, "in png_write_IHDR\n"); -- /* Check that we have valid input data from the application info */ -- switch (color_type) -- { -- case PNG_COLOR_TYPE_GRAY: -- switch (bit_depth) -- { -- case 1: -- case 2: -- case 4: -- case 8: -- case 16: png_ptr->channels = 1; break; -- default: png_error(png_ptr,"Invalid bit depth for grayscale image"); -- } -- break; -- case PNG_COLOR_TYPE_RGB: -- if (bit_depth != 8 && bit_depth != 16) -- png_error(png_ptr, "Invalid bit depth for RGB image"); -- png_ptr->channels = 3; -- break; -- case PNG_COLOR_TYPE_PALETTE: -- switch (bit_depth) -- { -- case 1: -- case 2: -- case 4: -- case 8: png_ptr->channels = 1; break; -- default: png_error(png_ptr, "Invalid bit depth for paletted image"); -- } -- break; -- case PNG_COLOR_TYPE_GRAY_ALPHA: -- if (bit_depth != 8 && bit_depth != 16) -- png_error(png_ptr, "Invalid bit depth for grayscale+alpha image"); -- png_ptr->channels = 2; -- break; -- case PNG_COLOR_TYPE_RGB_ALPHA: -- if (bit_depth != 8 && bit_depth != 16) -- png_error(png_ptr, "Invalid bit depth for RGBA image"); -- png_ptr->channels = 4; -- break; -- default: -- png_error(png_ptr, "Invalid image color type specified"); -- } -- -- if (compression_type != PNG_COMPRESSION_TYPE_BASE) -- { -- png_warning(png_ptr, "Invalid compression type specified"); -- compression_type = PNG_COMPRESSION_TYPE_BASE; -- } -- -- /* Write filter_method 64 (intrapixel differencing) only if -- * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and -- * 2. Libpng did not write a PNG signature (this filter_method is only -- * used in PNG datastreams that are embedded in MNG datastreams) and -- * 3. The application called png_permit_mng_features with a mask that -- * included PNG_FLAG_MNG_FILTER_64 and -- * 4. The filter_method is 64 and -- * 5. The color_type is RGB or RGBA -- */ -- if ( --#if defined(PNG_MNG_FEATURES_SUPPORTED) -- !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && -- ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) && -- (color_type == PNG_COLOR_TYPE_RGB || -- color_type == PNG_COLOR_TYPE_RGB_ALPHA) && -- (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) && --#endif -- filter_type != PNG_FILTER_TYPE_BASE) -- { -- png_warning(png_ptr, "Invalid filter type specified"); -- filter_type = PNG_FILTER_TYPE_BASE; -- } -- --#ifdef PNG_WRITE_INTERLACING_SUPPORTED -- if (interlace_type != PNG_INTERLACE_NONE && -- interlace_type != PNG_INTERLACE_ADAM7) -- { -- png_warning(png_ptr, "Invalid interlace type specified"); -- interlace_type = PNG_INTERLACE_ADAM7; -- } --#else -- interlace_type=PNG_INTERLACE_NONE; --#endif -- -- /* save off the relevent information */ -- png_ptr->bit_depth = (png_byte)bit_depth; -- png_ptr->color_type = (png_byte)color_type; -- png_ptr->interlaced = (png_byte)interlace_type; --#if defined(PNG_MNG_FEATURES_SUPPORTED) -- png_ptr->filter_type = (png_byte)filter_type; --#endif -- png_ptr->compression_type = (png_byte)compression_type; -- png_ptr->width = width; -- png_ptr->height = height; -- -- png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels); -- png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width); -- /* set the usr info, so any transformations can modify it */ -- png_ptr->usr_width = png_ptr->width; -- png_ptr->usr_bit_depth = png_ptr->bit_depth; -- png_ptr->usr_channels = png_ptr->channels; -- -- /* pack the header information into the buffer */ -- png_save_uint_32(buf, width); -- png_save_uint_32(buf + 4, height); -- buf[8] = (png_byte)bit_depth; -- buf[9] = (png_byte)color_type; -- buf[10] = (png_byte)compression_type; -- buf[11] = (png_byte)filter_type; -- buf[12] = (png_byte)interlace_type; -- -- /* write the chunk */ -- png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13); -- -- /* initialize zlib with PNG info */ -- png_ptr->zstream.zalloc = png_zalloc; -- png_ptr->zstream.zfree = png_zfree; -- png_ptr->zstream.opaque = (voidpf)png_ptr; -- if (!(png_ptr->do_filter)) -- { -- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE || -- png_ptr->bit_depth < 8) -- png_ptr->do_filter = PNG_FILTER_NONE; -- else -- png_ptr->do_filter = PNG_ALL_FILTERS; -- } -- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY)) -- { -- if (png_ptr->do_filter != PNG_FILTER_NONE) -- png_ptr->zlib_strategy = Z_FILTERED; -- else -- png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY; -- } -- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL)) -- png_ptr->zlib_level = Z_DEFAULT_COMPRESSION; -- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL)) -- png_ptr->zlib_mem_level = 8; -- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS)) -- png_ptr->zlib_window_bits = 15; -- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD)) -- png_ptr->zlib_method = 8; -- deflateInit2(&png_ptr->zstream, png_ptr->zlib_level, -- png_ptr->zlib_method, png_ptr->zlib_window_bits, -- png_ptr->zlib_mem_level, png_ptr->zlib_strategy); -- png_ptr->zstream.next_out = png_ptr->zbuf; -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -- -- png_ptr->mode = PNG_HAVE_IHDR; --} -- --/* write the palette. We are careful not to trust png_color to be in the -- * correct order for PNG, so people can redefine it to any convenient -- * structure. -- */ --void /* PRIVATE */ --png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_PLTE; --#endif -- png_uint_32 i; -- png_colorp pal_ptr; -- png_byte buf[3]; -- -- png_debug(1, "in png_write_PLTE\n"); -- if (( --#if defined(PNG_MNG_FEATURES_SUPPORTED) -- !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) && --#endif -- num_pal == 0) || num_pal > 256) -- { -- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) -- { -- png_error(png_ptr, "Invalid number of colors in palette"); -- } -- else -- { -- png_warning(png_ptr, "Invalid number of colors in palette"); -- return; -- } -- } -- -- if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR)) -- { -- png_warning(png_ptr, -- "Ignoring request to write a PLTE chunk in grayscale PNG"); -- return; -- } -- -- png_ptr->num_palette = (png_uint_16)num_pal; -- png_debug1(3, "num_palette = %d\n", png_ptr->num_palette); -- -- png_write_chunk_start(png_ptr, (png_bytep)png_PLTE, num_pal * 3); --#ifndef PNG_NO_POINTER_INDEXING -- for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++) -- { -- buf[0] = pal_ptr->red; -- buf[1] = pal_ptr->green; -- buf[2] = pal_ptr->blue; -- png_write_chunk_data(png_ptr, buf, (png_size_t)3); -- } --#else -- /* This is a little slower but some buggy compilers need to do this instead */ -- pal_ptr=palette; -- for (i = 0; i < num_pal; i++) -- { -- buf[0] = pal_ptr[i].red; -- buf[1] = pal_ptr[i].green; -- buf[2] = pal_ptr[i].blue; -- png_write_chunk_data(png_ptr, buf, (png_size_t)3); -- } --#endif -- png_write_chunk_end(png_ptr); -- png_ptr->mode |= PNG_HAVE_PLTE; --} -- --/* write an IDAT chunk */ --void /* PRIVATE */ --png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_IDAT; --#endif -- png_debug(1, "in png_write_IDAT\n"); -- -- /* Optimize the CMF field in the zlib stream. */ -- /* This hack of the zlib stream is compliant to the stream specification. */ -- if (!(png_ptr->mode & PNG_HAVE_IDAT) && -- png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE) -- { -- unsigned int z_cmf = data[0]; /* zlib compression method and flags */ -- if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70) -- { -- /* Avoid memory underflows and multiplication overflows. */ -- /* The conditions below are practically always satisfied; -- however, they still must be checked. */ -- if (length >= 2 && -- png_ptr->height < 16384 && png_ptr->width < 16384) -- { -- png_uint_32 uncompressed_idat_size = png_ptr->height * -- ((png_ptr->width * -- png_ptr->channels * png_ptr->bit_depth + 15) >> 3); -- unsigned int z_cinfo = z_cmf >> 4; -- unsigned int half_z_window_size = 1 << (z_cinfo + 7); -- while (uncompressed_idat_size <= half_z_window_size && -- half_z_window_size >= 256) -- { -- z_cinfo--; -- half_z_window_size >>= 1; -- } -- z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4); -- if (data[0] != (png_byte)z_cmf) -- { -- data[0] = (png_byte)z_cmf; -- data[1] &= 0xe0; -- data[1] += (png_byte)(0x1f - ((z_cmf << 8) + data[1]) % 0x1f); -- } -- } -- } -- else -- png_error(png_ptr, -- "Invalid zlib compression method or flags in IDAT"); -- } -- -- png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length); -- png_ptr->mode |= PNG_HAVE_IDAT; --} -- --/* write an IEND chunk */ --void /* PRIVATE */ --png_write_IEND(png_structp png_ptr) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_IEND; --#endif -- png_debug(1, "in png_write_IEND\n"); -- png_write_chunk(png_ptr, (png_bytep)png_IEND, png_bytep_NULL, -- (png_size_t)0); -- png_ptr->mode |= PNG_HAVE_IEND; --} -- --#if defined(PNG_WRITE_gAMA_SUPPORTED) --/* write a gAMA chunk */ --#ifdef PNG_FLOATING_POINT_SUPPORTED --void /* PRIVATE */ --png_write_gAMA(png_structp png_ptr, double file_gamma) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_gAMA; --#endif -- png_uint_32 igamma; -- png_byte buf[4]; -- -- png_debug(1, "in png_write_gAMA\n"); -- /* file_gamma is saved in 1/100,000ths */ -- igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5); -- png_save_uint_32(buf, igamma); -- png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4); --} --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED --void /* PRIVATE */ --png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_gAMA; --#endif -- png_byte buf[4]; -- -- png_debug(1, "in png_write_gAMA\n"); -- /* file_gamma is saved in 1/100,000ths */ -- png_save_uint_32(buf, (png_uint_32)file_gamma); -- png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4); --} --#endif --#endif -- --#if defined(PNG_WRITE_sRGB_SUPPORTED) --/* write a sRGB chunk */ --void /* PRIVATE */ --png_write_sRGB(png_structp png_ptr, int srgb_intent) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_sRGB; --#endif -- png_byte buf[1]; -- -- png_debug(1, "in png_write_sRGB\n"); -- if(srgb_intent >= PNG_sRGB_INTENT_LAST) -- png_warning(png_ptr, -- "Invalid sRGB rendering intent specified"); -- buf[0]=(png_byte)srgb_intent; -- png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1); --} --#endif -- --#if defined(PNG_WRITE_iCCP_SUPPORTED) --/* write an iCCP chunk */ --void /* PRIVATE */ --png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type, -- png_charp profile, int profile_len) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_iCCP; --#endif -- png_size_t name_len; -- png_charp new_name; -- compression_state comp; -- -- png_debug(1, "in png_write_iCCP\n"); -- if (name == NULL || (name_len = png_check_keyword(png_ptr, name, -- &new_name)) == 0) -- { -- png_warning(png_ptr, "Empty keyword in iCCP chunk"); -- return; -- } -- -- if (compression_type != PNG_COMPRESSION_TYPE_BASE) -- png_warning(png_ptr, "Unknown compression type in iCCP chunk"); -- -- if (profile == NULL) -- profile_len = 0; -- -- if (profile_len) -- profile_len = png_text_compress(png_ptr, profile, (png_size_t)profile_len, -- PNG_COMPRESSION_TYPE_BASE, &comp); -- -- /* make sure we include the NULL after the name and the compression type */ -- png_write_chunk_start(png_ptr, (png_bytep)png_iCCP, -- (png_uint_32)name_len+profile_len+2); -- new_name[name_len+1]=0x00; -- png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 2); -- -- if (profile_len) -- png_write_compressed_data_out(png_ptr, &comp); -- -- png_write_chunk_end(png_ptr); -- png_free(png_ptr, new_name); --} --#endif -- --#if defined(PNG_WRITE_sPLT_SUPPORTED) --/* write a sPLT chunk */ --void /* PRIVATE */ --png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_sPLT; --#endif -- png_size_t name_len; -- png_charp new_name; -- png_byte entrybuf[10]; -- int entry_size = (spalette->depth == 8 ? 6 : 10); -- int palette_size = entry_size * spalette->nentries; -- png_sPLT_entryp ep; --#ifdef PNG_NO_POINTER_INDEXING -- int i; --#endif -- -- png_debug(1, "in png_write_sPLT\n"); -- if (spalette->name == NULL || (name_len = png_check_keyword(png_ptr, -- spalette->name, &new_name))==0) -- { -- png_warning(png_ptr, "Empty keyword in sPLT chunk"); -- return; -- } -- -- /* make sure we include the NULL after the name */ -- png_write_chunk_start(png_ptr, (png_bytep)png_sPLT, -- (png_uint_32)(name_len + 2 + palette_size)); -- png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 1); -- png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, 1); -- -- /* loop through each palette entry, writing appropriately */ --#ifndef PNG_NO_POINTER_INDEXING -- for (ep = spalette->entries; epentries+spalette->nentries; ep++) -- { -- if (spalette->depth == 8) -- { -- entrybuf[0] = (png_byte)ep->red; -- entrybuf[1] = (png_byte)ep->green; -- entrybuf[2] = (png_byte)ep->blue; -- entrybuf[3] = (png_byte)ep->alpha; -- png_save_uint_16(entrybuf + 4, ep->frequency); -- } -- else -- { -- png_save_uint_16(entrybuf + 0, ep->red); -- png_save_uint_16(entrybuf + 2, ep->green); -- png_save_uint_16(entrybuf + 4, ep->blue); -- png_save_uint_16(entrybuf + 6, ep->alpha); -- png_save_uint_16(entrybuf + 8, ep->frequency); -- } -- png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size); -- } --#else -- ep=spalette->entries; -- for (i=0; i>spalette->nentries; i++) -- { -- if (spalette->depth == 8) -- { -- entrybuf[0] = (png_byte)ep[i].red; -- entrybuf[1] = (png_byte)ep[i].green; -- entrybuf[2] = (png_byte)ep[i].blue; -- entrybuf[3] = (png_byte)ep[i].alpha; -- png_save_uint_16(entrybuf + 4, ep[i].frequency); -- } -- else -- { -- png_save_uint_16(entrybuf + 0, ep[i].red); -- png_save_uint_16(entrybuf + 2, ep[i].green); -- png_save_uint_16(entrybuf + 4, ep[i].blue); -- png_save_uint_16(entrybuf + 6, ep[i].alpha); -- png_save_uint_16(entrybuf + 8, ep[i].frequency); -- } -- png_write_chunk_data(png_ptr, entrybuf, entry_size); -- } --#endif -- -- png_write_chunk_end(png_ptr); -- png_free(png_ptr, new_name); --} --#endif -- --#if defined(PNG_WRITE_sBIT_SUPPORTED) --/* write the sBIT chunk */ --void /* PRIVATE */ --png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_sBIT; --#endif -- png_byte buf[4]; -- png_size_t size; -- -- png_debug(1, "in png_write_sBIT\n"); -- /* make sure we don't depend upon the order of PNG_COLOR_8 */ -- if (color_type & PNG_COLOR_MASK_COLOR) -- { -- png_byte maxbits; -- -- maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 : -- png_ptr->usr_bit_depth); -- if (sbit->red == 0 || sbit->red > maxbits || -- sbit->green == 0 || sbit->green > maxbits || -- sbit->blue == 0 || sbit->blue > maxbits) -- { -- png_warning(png_ptr, "Invalid sBIT depth specified"); -- return; -- } -- buf[0] = sbit->red; -- buf[1] = sbit->green; -- buf[2] = sbit->blue; -- size = 3; -- } -- else -- { -- if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth) -- { -- png_warning(png_ptr, "Invalid sBIT depth specified"); -- return; -- } -- buf[0] = sbit->gray; -- size = 1; -- } -- -- if (color_type & PNG_COLOR_MASK_ALPHA) -- { -- if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth) -- { -- png_warning(png_ptr, "Invalid sBIT depth specified"); -- return; -- } -- buf[size++] = sbit->alpha; -- } -- -- png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size); --} --#endif -- --#if defined(PNG_WRITE_cHRM_SUPPORTED) --/* write the cHRM chunk */ --#ifdef PNG_FLOATING_POINT_SUPPORTED --void /* PRIVATE */ --png_write_cHRM(png_structp png_ptr, double white_x, double white_y, -- double red_x, double red_y, double green_x, double green_y, -- double blue_x, double blue_y) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_cHRM; --#endif -- png_byte buf[32]; -- png_uint_32 itemp; -- -- png_debug(1, "in png_write_cHRM\n"); -- /* each value is saved in 1/100,000ths */ -- if (white_x < 0 || white_x > 0.8 || white_y < 0 || white_y > 0.8 || -- white_x + white_y > 1.0) -- { -- png_warning(png_ptr, "Invalid cHRM white point specified"); --#if !defined(PNG_NO_CONSOLE_IO) -- fprintf(stderr,"white_x=%f, white_y=%f\n",white_x, white_y); --#endif -- return; -- } -- itemp = (png_uint_32)(white_x * 100000.0 + 0.5); -- png_save_uint_32(buf, itemp); -- itemp = (png_uint_32)(white_y * 100000.0 + 0.5); -- png_save_uint_32(buf + 4, itemp); -- -- if (red_x < 0 || red_x > 0.8 || red_y < 0 || red_y > 0.8 || -- red_x + red_y > 1.0) -- { -- png_warning(png_ptr, "Invalid cHRM red point specified"); -- return; -- } -- itemp = (png_uint_32)(red_x * 100000.0 + 0.5); -- png_save_uint_32(buf + 8, itemp); -- itemp = (png_uint_32)(red_y * 100000.0 + 0.5); -- png_save_uint_32(buf + 12, itemp); -- -- if (green_x < 0 || green_x > 0.8 || green_y < 0 || green_y > 0.8 || -- green_x + green_y > 1.0) -- { -- png_warning(png_ptr, "Invalid cHRM green point specified"); -- return; -- } -- itemp = (png_uint_32)(green_x * 100000.0 + 0.5); -- png_save_uint_32(buf + 16, itemp); -- itemp = (png_uint_32)(green_y * 100000.0 + 0.5); -- png_save_uint_32(buf + 20, itemp); -- -- if (blue_x < 0 || blue_x > 0.8 || blue_y < 0 || blue_y > 0.8 || -- blue_x + blue_y > 1.0) -- { -- png_warning(png_ptr, "Invalid cHRM blue point specified"); -- return; -- } -- itemp = (png_uint_32)(blue_x * 100000.0 + 0.5); -- png_save_uint_32(buf + 24, itemp); -- itemp = (png_uint_32)(blue_y * 100000.0 + 0.5); -- png_save_uint_32(buf + 28, itemp); -- -- png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32); --} --#endif --#ifdef PNG_FIXED_POINT_SUPPORTED --void /* PRIVATE */ --png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x, -- png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y, -- png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x, -- png_fixed_point blue_y) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_cHRM; --#endif -- png_byte buf[32]; -- -- png_debug(1, "in png_write_cHRM\n"); -- /* each value is saved in 1/100,000ths */ -- if (white_x > 80000L || white_y > 80000L || white_x + white_y > 100000L) -- { -- png_warning(png_ptr, "Invalid fixed cHRM white point specified"); --#if !defined(PNG_NO_CONSOLE_IO) -- fprintf(stderr,"white_x=%ld, white_y=%ld\n",white_x, white_y); --#endif -- return; -- } -- png_save_uint_32(buf, (png_uint_32)white_x); -- png_save_uint_32(buf + 4, (png_uint_32)white_y); -- -- if (red_x > 80000L || red_y > 80000L || red_x + red_y > 100000L) -- { -- png_warning(png_ptr, "Invalid cHRM fixed red point specified"); -- return; -- } -- png_save_uint_32(buf + 8, (png_uint_32)red_x); -- png_save_uint_32(buf + 12, (png_uint_32)red_y); -- -- if (green_x > 80000L || green_y > 80000L || green_x + green_y > 100000L) -- { -- png_warning(png_ptr, "Invalid fixed cHRM green point specified"); -- return; -- } -- png_save_uint_32(buf + 16, (png_uint_32)green_x); -- png_save_uint_32(buf + 20, (png_uint_32)green_y); -- -- if (blue_x > 80000L || blue_y > 80000L || blue_x + blue_y > 100000L) -- { -- png_warning(png_ptr, "Invalid fixed cHRM blue point specified"); -- return; -- } -- png_save_uint_32(buf + 24, (png_uint_32)blue_x); -- png_save_uint_32(buf + 28, (png_uint_32)blue_y); -- -- png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32); --} --#endif --#endif -- --#if defined(PNG_WRITE_tRNS_SUPPORTED) --/* write the tRNS chunk */ --void /* PRIVATE */ --png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran, -- int num_trans, int color_type) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_tRNS; --#endif -- png_byte buf[6]; -- -- png_debug(1, "in png_write_tRNS\n"); -- if (color_type == PNG_COLOR_TYPE_PALETTE) -- { -- if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette) -- { -- png_warning(png_ptr,"Invalid number of transparent colors specified"); -- return; -- } -- /* write the chunk out as it is */ -- png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans, (png_size_t)num_trans); -- } -- else if (color_type == PNG_COLOR_TYPE_GRAY) -- { -- /* one 16 bit value */ -- if(tran->gray >= (1 << png_ptr->bit_depth)) -- { -- png_warning(png_ptr, -- "Ignoring attempt to write tRNS chunk out-of-range for bit_depth"); -- return; -- } -- png_save_uint_16(buf, tran->gray); -- png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2); -- } -- else if (color_type == PNG_COLOR_TYPE_RGB) -- { -- /* three 16 bit values */ -- png_save_uint_16(buf, tran->red); -- png_save_uint_16(buf + 2, tran->green); -- png_save_uint_16(buf + 4, tran->blue); -- if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) -- { -- png_warning(png_ptr, -- "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8"); -- return; -- } -- png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6); -- } -- else -- { -- png_warning(png_ptr, "Can't write tRNS with an alpha channel"); -- } --} --#endif -- --#if defined(PNG_WRITE_bKGD_SUPPORTED) --/* write the background chunk */ --void /* PRIVATE */ --png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_bKGD; --#endif -- png_byte buf[6]; -- -- png_debug(1, "in png_write_bKGD\n"); -- if (color_type == PNG_COLOR_TYPE_PALETTE) -- { -- if ( --#if defined(PNG_MNG_FEATURES_SUPPORTED) -- (png_ptr->num_palette || -- (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) && --#endif -- back->index > png_ptr->num_palette) -- { -- png_warning(png_ptr, "Invalid background palette index"); -- return; -- } -- buf[0] = back->index; -- png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1); -- } -- else if (color_type & PNG_COLOR_MASK_COLOR) -- { -- png_save_uint_16(buf, back->red); -- png_save_uint_16(buf + 2, back->green); -- png_save_uint_16(buf + 4, back->blue); -- if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) -- { -- png_warning(png_ptr, -- "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8"); -- return; -- } -- png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6); -- } -- else -- { -- if(back->gray >= (1 << png_ptr->bit_depth)) -- { -- png_warning(png_ptr, -- "Ignoring attempt to write bKGD chunk out-of-range for bit_depth"); -- return; -- } -- png_save_uint_16(buf, back->gray); -- png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2); -- } --} --#endif -- --#if defined(PNG_WRITE_hIST_SUPPORTED) --/* write the histogram */ --void /* PRIVATE */ --png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_hIST; --#endif -- int i; -- png_byte buf[3]; -- -- png_debug(1, "in png_write_hIST\n"); -- if (num_hist > (int)png_ptr->num_palette) -- { -- png_debug2(3, "num_hist = %d, num_palette = %d\n", num_hist, -- png_ptr->num_palette); -- png_warning(png_ptr, "Invalid number of histogram entries specified"); -- return; -- } -- -- png_write_chunk_start(png_ptr, (png_bytep)png_hIST, (png_uint_32)(num_hist * 2)); -- for (i = 0; i < num_hist; i++) -- { -- png_save_uint_16(buf, hist[i]); -- png_write_chunk_data(png_ptr, buf, (png_size_t)2); -- } -- png_write_chunk_end(png_ptr); --} --#endif -- --#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ -- defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) --/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification, -- * and if invalid, correct the keyword rather than discarding the entire -- * chunk. The PNG 1.0 specification requires keywords 1-79 characters in -- * length, forbids leading or trailing whitespace, multiple internal spaces, -- * and the non-break space (0x80) from ISO 8859-1. Returns keyword length. -- * -- * The new_key is allocated to hold the corrected keyword and must be freed -- * by the calling routine. This avoids problems with trying to write to -- * static keywords without having to have duplicate copies of the strings. -- */ --png_size_t /* PRIVATE */ --png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key) --{ -- png_size_t key_len; -- png_charp kp, dp; -- int kflag; -- int kwarn=0; -- -- png_debug(1, "in png_check_keyword\n"); -- *new_key = NULL; -- -- if (key == NULL || (key_len = png_strlen(key)) == 0) -- { -- png_warning(png_ptr, "zero length keyword"); -- return ((png_size_t)0); -- } -- -- png_debug1(2, "Keyword to be checked is '%s'\n", key); -- -- *new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2)); -- if (*new_key == NULL) -- { -- png_warning(png_ptr, "Out of memory while procesing keyword"); -- return ((png_size_t)0); -- } -- -- /* Replace non-printing characters with a blank and print a warning */ -- for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++) -- { -- if (*kp < 0x20 || (*kp > 0x7E && (png_byte)*kp < 0xA1)) -- { --#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) -- char msg[40]; -- -- sprintf(msg, "invalid keyword character 0x%02X", *kp); -- png_warning(png_ptr, msg); --#else -- png_warning(png_ptr, "invalid character in keyword"); --#endif -- *dp = ' '; -- } -- else -- { -- *dp = *kp; -- } -- } -- *dp = '\0'; -- -- /* Remove any trailing white space. */ -- kp = *new_key + key_len - 1; -- if (*kp == ' ') -- { -- png_warning(png_ptr, "trailing spaces removed from keyword"); -- -- while (*kp == ' ') -- { -- *(kp--) = '\0'; -- key_len--; -- } -- } -- -- /* Remove any leading white space. */ -- kp = *new_key; -- if (*kp == ' ') -- { -- png_warning(png_ptr, "leading spaces removed from keyword"); -- -- while (*kp == ' ') -- { -- kp++; -- key_len--; -- } -- } -- -- png_debug1(2, "Checking for multiple internal spaces in '%s'\n", kp); -- -- /* Remove multiple internal spaces. */ -- for (kflag = 0, dp = *new_key; *kp != '\0'; kp++) -- { -- if (*kp == ' ' && kflag == 0) -- { -- *(dp++) = *kp; -- kflag = 1; -- } -- else if (*kp == ' ') -- { -- key_len--; -- kwarn=1; -- } -- else -- { -- *(dp++) = *kp; -- kflag = 0; -- } -- } -- *dp = '\0'; -- if(kwarn) -- png_warning(png_ptr, "extra interior spaces removed from keyword"); -- -- if (key_len == 0) -- { -- png_free(png_ptr, *new_key); -- *new_key=NULL; -- png_warning(png_ptr, "Zero length keyword"); -- } -- -- if (key_len > 79) -- { -- png_warning(png_ptr, "keyword length must be 1 - 79 characters"); -- new_key[79] = '\0'; -- key_len = 79; -- } -- -- return (key_len); --} --#endif -- --#if defined(PNG_WRITE_tEXt_SUPPORTED) --/* write a tEXt chunk */ --void /* PRIVATE */ --png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text, -- png_size_t text_len) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_tEXt; --#endif -- png_size_t key_len; -- png_charp new_key; -- -- png_debug(1, "in png_write_tEXt\n"); -- if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0) -- { -- png_warning(png_ptr, "Empty keyword in tEXt chunk"); -- return; -- } -- -- if (text == NULL || *text == '\0') -- text_len = 0; -- else -- text_len = png_strlen(text); -- -- /* make sure we include the 0 after the key */ -- png_write_chunk_start(png_ptr, (png_bytep)png_tEXt, (png_uint_32)key_len+text_len+1); -- /* -- * We leave it to the application to meet PNG-1.0 requirements on the -- * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of -- * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them. -- * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. -- */ -- png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1); -- if (text_len) -- png_write_chunk_data(png_ptr, (png_bytep)text, text_len); -- -- png_write_chunk_end(png_ptr); -- png_free(png_ptr, new_key); --} --#endif -- --#if defined(PNG_WRITE_zTXt_SUPPORTED) --/* write a compressed text chunk */ --void /* PRIVATE */ --png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text, -- png_size_t text_len, int compression) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_zTXt; --#endif -- png_size_t key_len; -- char buf[1]; -- png_charp new_key; -- compression_state comp; -- -- png_debug(1, "in png_write_zTXt\n"); -- -- if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0) -- { -- png_warning(png_ptr, "Empty keyword in zTXt chunk"); -- return; -- } -- -- if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE) -- { -- png_write_tEXt(png_ptr, new_key, text, (png_size_t)0); -- png_free(png_ptr, new_key); -- return; -- } -- -- text_len = png_strlen(text); -- -- png_free(png_ptr, new_key); -- -- /* compute the compressed data; do it now for the length */ -- text_len = png_text_compress(png_ptr, text, text_len, compression, -- &comp); -- -- /* write start of chunk */ -- png_write_chunk_start(png_ptr, (png_bytep)png_zTXt, (png_uint_32) -- (key_len+text_len+2)); -- /* write key */ -- png_write_chunk_data(png_ptr, (png_bytep)key, key_len + 1); -- buf[0] = (png_byte)compression; -- /* write compression */ -- png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1); -- /* write the compressed data */ -- png_write_compressed_data_out(png_ptr, &comp); -- -- /* close the chunk */ -- png_write_chunk_end(png_ptr); --} --#endif -- --#if defined(PNG_WRITE_iTXt_SUPPORTED) --/* write an iTXt chunk */ --void /* PRIVATE */ --png_write_iTXt(png_structp png_ptr, int compression, png_charp key, -- png_charp lang, png_charp lang_key, png_charp text) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_iTXt; --#endif -- png_size_t lang_len, key_len, lang_key_len, text_len; -- png_charp new_lang, new_key; -- png_byte cbuf[2]; -- compression_state comp; -- -- png_debug(1, "in png_write_iTXt\n"); -- -- if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0) -- { -- png_warning(png_ptr, "Empty keyword in iTXt chunk"); -- return; -- } -- if (lang == NULL || (lang_len = png_check_keyword(png_ptr, lang, &new_lang))==0) -- { -- png_warning(png_ptr, "Empty language field in iTXt chunk"); -- new_lang = NULL; -- lang_len = 0; -- } -- -- if (lang_key == NULL) -- lang_key_len = 0; -- else -- lang_key_len = png_strlen(lang_key); -- -- if (text == NULL) -- text_len = 0; -- else -- text_len = png_strlen(text); -- -- /* compute the compressed data; do it now for the length */ -- text_len = png_text_compress(png_ptr, text, text_len, compression-2, -- &comp); -- -- -- /* make sure we include the compression flag, the compression byte, -- * and the NULs after the key, lang, and lang_key parts */ -- -- png_write_chunk_start(png_ptr, (png_bytep)png_iTXt, -- (png_uint_32)( -- 5 /* comp byte, comp flag, terminators for key, lang and lang_key */ -- + key_len -- + lang_len -- + lang_key_len -- + text_len)); -- -- /* -- * We leave it to the application to meet PNG-1.0 requirements on the -- * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of -- * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them. -- * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. -- */ -- png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1); -- -- /* set the compression flag */ -- if (compression == PNG_ITXT_COMPRESSION_NONE || \ -- compression == PNG_TEXT_COMPRESSION_NONE) -- cbuf[0] = 0; -- else /* compression == PNG_ITXT_COMPRESSION_zTXt */ -- cbuf[0] = 1; -- /* set the compression method */ -- cbuf[1] = 0; -- png_write_chunk_data(png_ptr, cbuf, 2); -- -- cbuf[0] = 0; -- png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf), lang_len + 1); -- png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf), lang_key_len + 1); -- png_write_compressed_data_out(png_ptr, &comp); -- -- png_write_chunk_end(png_ptr); -- png_free(png_ptr, new_key); -- if (new_lang) -- png_free(png_ptr, new_lang); --} --#endif -- --#if defined(PNG_WRITE_oFFs_SUPPORTED) --/* write the oFFs chunk */ --void /* PRIVATE */ --png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset, -- int unit_type) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_oFFs; --#endif -- png_byte buf[9]; -- -- png_debug(1, "in png_write_oFFs\n"); -- if (unit_type >= PNG_OFFSET_LAST) -- png_warning(png_ptr, "Unrecognized unit type for oFFs chunk"); -- -- png_save_int_32(buf, x_offset); -- png_save_int_32(buf + 4, y_offset); -- buf[8] = (png_byte)unit_type; -- -- png_write_chunk(png_ptr, (png_bytep)png_oFFs, buf, (png_size_t)9); --} --#endif -- --#if defined(PNG_WRITE_pCAL_SUPPORTED) --/* write the pCAL chunk (described in the PNG extensions document) */ --void /* PRIVATE */ --png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0, -- png_int_32 X1, int type, int nparams, png_charp units, png_charpp params) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_pCAL; --#endif -- png_size_t purpose_len, units_len, total_len; -- png_uint_32p params_len; -- png_byte buf[10]; -- png_charp new_purpose; -- int i; -- -- png_debug1(1, "in png_write_pCAL (%d parameters)\n", nparams); -- if (type >= PNG_EQUATION_LAST) -- png_warning(png_ptr, "Unrecognized equation type for pCAL chunk"); -- -- purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1; -- png_debug1(3, "pCAL purpose length = %d\n", (int)purpose_len); -- units_len = png_strlen(units) + (nparams == 0 ? 0 : 1); -- png_debug1(3, "pCAL units length = %d\n", (int)units_len); -- total_len = purpose_len + units_len + 10; -- -- params_len = (png_uint_32p)png_malloc(png_ptr, (png_uint_32)(nparams -- *png_sizeof(png_uint_32))); -- -- /* Find the length of each parameter, making sure we don't count the -- null terminator for the last parameter. */ -- for (i = 0; i < nparams; i++) -- { -- params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1); -- png_debug2(3, "pCAL parameter %d length = %lu\n", i, params_len[i]); -- total_len += (png_size_t)params_len[i]; -- } -- -- png_debug1(3, "pCAL total length = %d\n", (int)total_len); -- png_write_chunk_start(png_ptr, (png_bytep)png_pCAL, (png_uint_32)total_len); -- png_write_chunk_data(png_ptr, (png_bytep)new_purpose, purpose_len); -- png_save_int_32(buf, X0); -- png_save_int_32(buf + 4, X1); -- buf[8] = (png_byte)type; -- buf[9] = (png_byte)nparams; -- png_write_chunk_data(png_ptr, buf, (png_size_t)10); -- png_write_chunk_data(png_ptr, (png_bytep)units, (png_size_t)units_len); -- -- png_free(png_ptr, new_purpose); -- -- for (i = 0; i < nparams; i++) -- { -- png_write_chunk_data(png_ptr, (png_bytep)params[i], -- (png_size_t)params_len[i]); -- } -- -- png_free(png_ptr, params_len); -- png_write_chunk_end(png_ptr); --} --#endif -- --#if defined(PNG_WRITE_sCAL_SUPPORTED) --/* write the sCAL chunk */ --#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) --void /* PRIVATE */ --png_write_sCAL(png_structp png_ptr, int unit, double width,double height) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_sCAL; --#endif -- png_size_t total_len; -- char wbuf[32], hbuf[32]; -- png_byte bunit = unit; -- -- png_debug(1, "in png_write_sCAL\n"); -- --#if defined(_WIN32_WCE) --/* sprintf() function is not supported on WindowsCE */ -- { -- wchar_t wc_buf[32]; -- swprintf(wc_buf, TEXT("%12.12e"), width); -- WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, wbuf, 32, NULL, NULL); -- swprintf(wc_buf, TEXT("%12.12e"), height); -- WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, hbuf, 32, NULL, NULL); -- } --#else -- sprintf(wbuf, "%12.12e", width); -- sprintf(hbuf, "%12.12e", height); --#endif -- total_len = 1 + png_strlen(wbuf)+1 + png_strlen(hbuf); -- -- png_debug1(3, "sCAL total length = %d\n", (int)total_len); -- png_write_chunk_start(png_ptr, (png_bytep)png_sCAL, (png_uint_32)total_len); -- png_write_chunk_data(png_ptr, (png_bytep)&bunit, 1); -- png_write_chunk_data(png_ptr, (png_bytep)wbuf, png_strlen(wbuf)+1); -- png_write_chunk_data(png_ptr, (png_bytep)hbuf, png_strlen(hbuf)); -- -- png_write_chunk_end(png_ptr); --} --#else --#ifdef PNG_FIXED_POINT_SUPPORTED --void /* PRIVATE */ --png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width, -- png_charp height) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_sCAL; --#endif -- png_size_t total_len; -- char wbuf[32], hbuf[32]; -- png_byte bunit = unit; -- -- png_debug(1, "in png_write_sCAL_s\n"); -- -- png_strcpy(wbuf,(const char *)width); -- png_strcpy(hbuf,(const char *)height); -- total_len = 1 + png_strlen(wbuf)+1 + png_strlen(hbuf); -- -- png_debug1(3, "sCAL total length = %d\n", total_len); -- png_write_chunk_start(png_ptr, (png_bytep)png_sCAL, (png_uint_32)total_len); -- png_write_chunk_data(png_ptr, (png_bytep)&bunit, 1); -- png_write_chunk_data(png_ptr, (png_bytep)wbuf, png_strlen(wbuf)+1); -- png_write_chunk_data(png_ptr, (png_bytep)hbuf, png_strlen(hbuf)); -- -- png_write_chunk_end(png_ptr); --} --#endif --#endif --#endif -- --#if defined(PNG_WRITE_pHYs_SUPPORTED) --/* write the pHYs chunk */ --void /* PRIVATE */ --png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit, -- png_uint_32 y_pixels_per_unit, -- int unit_type) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_pHYs; --#endif -- png_byte buf[9]; -- -- png_debug(1, "in png_write_pHYs\n"); -- if (unit_type >= PNG_RESOLUTION_LAST) -- png_warning(png_ptr, "Unrecognized unit type for pHYs chunk"); -- -- png_save_uint_32(buf, x_pixels_per_unit); -- png_save_uint_32(buf + 4, y_pixels_per_unit); -- buf[8] = (png_byte)unit_type; -- -- png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9); --} --#endif -- --#if defined(PNG_WRITE_tIME_SUPPORTED) --/* Write the tIME chunk. Use either png_convert_from_struct_tm() -- * or png_convert_from_time_t(), or fill in the structure yourself. -- */ --void /* PRIVATE */ --png_write_tIME(png_structp png_ptr, png_timep mod_time) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- PNG_tIME; --#endif -- png_byte buf[7]; -- -- png_debug(1, "in png_write_tIME\n"); -- if (mod_time->month > 12 || mod_time->month < 1 || -- mod_time->day > 31 || mod_time->day < 1 || -- mod_time->hour > 23 || mod_time->second > 60) -- { -- png_warning(png_ptr, "Invalid time specified for tIME chunk"); -- return; -- } -- -- png_save_uint_16(buf, mod_time->year); -- buf[2] = mod_time->month; -- buf[3] = mod_time->day; -- buf[4] = mod_time->hour; -- buf[5] = mod_time->minute; -- buf[6] = mod_time->second; -- -- png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7); --} --#endif -- --/* initializes the row writing capability of libpng */ --void /* PRIVATE */ --png_write_start_row(png_structp png_ptr) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ -- -- /* start of interlace block */ -- int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; -- -- /* offset to next interlace block */ -- int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; -- -- /* start of interlace block in the y direction */ -- int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; -- -- /* offset to next interlace block in the y direction */ -- int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; --#endif -- -- png_size_t buf_size; -- -- png_debug(1, "in png_write_start_row\n"); -- buf_size = (png_size_t)(PNG_ROWBYTES( -- png_ptr->usr_channels*png_ptr->usr_bit_depth,png_ptr->width)+1); -- -- /* set up row buffer */ -- png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size); -- png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE; -- -- /* set up filtering buffer, if using this filter */ -- if (png_ptr->do_filter & PNG_FILTER_SUB) -- { -- png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, -- (png_ptr->rowbytes + 1)); -- png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB; -- } -- -- /* We only need to keep the previous row if we are using one of these. */ -- if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) -- { -- /* set up previous row buffer */ -- png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size); -- png_memset(png_ptr->prev_row, 0, buf_size); -- -- if (png_ptr->do_filter & PNG_FILTER_UP) -- { -- png_ptr->up_row = (png_bytep )png_malloc(png_ptr, -- (png_ptr->rowbytes + 1)); -- png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; -- } -- -- if (png_ptr->do_filter & PNG_FILTER_AVG) -- { -- png_ptr->avg_row = (png_bytep)png_malloc(png_ptr, -- (png_ptr->rowbytes + 1)); -- png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG; -- } -- -- if (png_ptr->do_filter & PNG_FILTER_PAETH) -- { -- png_ptr->paeth_row = (png_bytep )png_malloc(png_ptr, -- (png_ptr->rowbytes + 1)); -- png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; -- } -- } -- --#ifdef PNG_WRITE_INTERLACING_SUPPORTED -- /* if interlaced, we need to set up width and height of pass */ -- if (png_ptr->interlaced) -- { -- if (!(png_ptr->transformations & PNG_INTERLACE)) -- { -- png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 - -- png_pass_ystart[0]) / png_pass_yinc[0]; -- png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 - -- png_pass_start[0]) / png_pass_inc[0]; -- } -- else -- { -- png_ptr->num_rows = png_ptr->height; -- png_ptr->usr_width = png_ptr->width; -- } -- } -- else --#endif -- { -- png_ptr->num_rows = png_ptr->height; -- png_ptr->usr_width = png_ptr->width; -- } -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -- png_ptr->zstream.next_out = png_ptr->zbuf; --} -- --/* Internal use only. Called when finished processing a row of data. */ --void /* PRIVATE */ --png_write_finish_row(png_structp png_ptr) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ -- -- /* start of interlace block */ -- int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; -- -- /* offset to next interlace block */ -- int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; -- -- /* start of interlace block in the y direction */ -- int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; -- -- /* offset to next interlace block in the y direction */ -- int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; --#endif -- -- int ret; -- -- png_debug(1, "in png_write_finish_row\n"); -- /* next row */ -- png_ptr->row_number++; -- -- /* see if we are done */ -- if (png_ptr->row_number < png_ptr->num_rows) -- return; -- --#ifdef PNG_WRITE_INTERLACING_SUPPORTED -- /* if interlaced, go to next pass */ -- if (png_ptr->interlaced) -- { -- png_ptr->row_number = 0; -- if (png_ptr->transformations & PNG_INTERLACE) -- { -- png_ptr->pass++; -- } -- else -- { -- /* loop until we find a non-zero width or height pass */ -- do -- { -- png_ptr->pass++; -- if (png_ptr->pass >= 7) -- break; -- png_ptr->usr_width = (png_ptr->width + -- png_pass_inc[png_ptr->pass] - 1 - -- png_pass_start[png_ptr->pass]) / -- png_pass_inc[png_ptr->pass]; -- png_ptr->num_rows = (png_ptr->height + -- png_pass_yinc[png_ptr->pass] - 1 - -- png_pass_ystart[png_ptr->pass]) / -- png_pass_yinc[png_ptr->pass]; -- if (png_ptr->transformations & PNG_INTERLACE) -- break; -- } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0); -- -- } -- -- /* reset the row above the image for the next pass */ -- if (png_ptr->pass < 7) -- { -- if (png_ptr->prev_row != NULL) -- png_memset(png_ptr->prev_row, 0, -- (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels* -- png_ptr->usr_bit_depth,png_ptr->width))+1); -- return; -- } -- } --#endif -- -- /* if we get here, we've just written the last row, so we need -- to flush the compressor */ -- do -- { -- /* tell the compressor we are done */ -- ret = deflate(&png_ptr->zstream, Z_FINISH); -- /* check for an error */ -- if (ret == Z_OK) -- { -- /* check to see if we need more room */ -- if (!(png_ptr->zstream.avail_out)) -- { -- png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); -- png_ptr->zstream.next_out = png_ptr->zbuf; -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -- } -- } -- else if (ret != Z_STREAM_END) -- { -- if (png_ptr->zstream.msg != NULL) -- png_error(png_ptr, png_ptr->zstream.msg); -- else -- png_error(png_ptr, "zlib error"); -- } -- } while (ret != Z_STREAM_END); -- -- /* write any extra space */ -- if (png_ptr->zstream.avail_out < png_ptr->zbuf_size) -- { -- png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size - -- png_ptr->zstream.avail_out); -- } -- -- deflateReset(&png_ptr->zstream); --} -- --#if defined(PNG_WRITE_INTERLACING_SUPPORTED) --/* Pick out the correct pixels for the interlace pass. -- * The basic idea here is to go through the row with a source -- * pointer and a destination pointer (sp and dp), and copy the -- * correct pixels for the pass. As the row gets compacted, -- * sp will always be >= dp, so we should never overwrite anything. -- * See the default: case for the easiest code to understand. -- */ --void /* PRIVATE */ --png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) --{ --#ifdef PNG_USE_LOCAL_ARRAYS -- /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ -- -- /* start of interlace block */ -- int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; -- -- /* offset to next interlace block */ -- int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; --#endif -- -- png_debug(1, "in png_do_write_interlace\n"); -- /* we don't have to do anything on the last pass (6) */ --#if defined(PNG_USELESS_TESTS_SUPPORTED) -- if (row != NULL && row_info != NULL && pass < 6) --#else -- if (pass < 6) --#endif -- { -- /* each pixel depth is handled separately */ -- switch (row_info->pixel_depth) -- { -- case 1: -- { -- png_bytep sp; -- png_bytep dp; -- int shift; -- int d; -- int value; -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- -- dp = row; -- d = 0; -- shift = 7; -- for (i = png_pass_start[pass]; i < row_width; -- i += png_pass_inc[pass]) -- { -- sp = row + (png_size_t)(i >> 3); -- value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01; -- d |= (value << shift); -- -- if (shift == 0) -- { -- shift = 7; -- *dp++ = (png_byte)d; -- d = 0; -- } -- else -- shift--; -- -- } -- if (shift != 7) -- *dp = (png_byte)d; -- break; -- } -- case 2: -- { -- png_bytep sp; -- png_bytep dp; -- int shift; -- int d; -- int value; -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- -- dp = row; -- shift = 6; -- d = 0; -- for (i = png_pass_start[pass]; i < row_width; -- i += png_pass_inc[pass]) -- { -- sp = row + (png_size_t)(i >> 2); -- value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03; -- d |= (value << shift); -- -- if (shift == 0) -- { -- shift = 6; -- *dp++ = (png_byte)d; -- d = 0; -- } -- else -- shift -= 2; -- } -- if (shift != 6) -- *dp = (png_byte)d; -- break; -- } -- case 4: -- { -- png_bytep sp; -- png_bytep dp; -- int shift; -- int d; -- int value; -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- -- dp = row; -- shift = 4; -- d = 0; -- for (i = png_pass_start[pass]; i < row_width; -- i += png_pass_inc[pass]) -- { -- sp = row + (png_size_t)(i >> 1); -- value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f; -- d |= (value << shift); -- -- if (shift == 0) -- { -- shift = 4; -- *dp++ = (png_byte)d; -- d = 0; -- } -- else -- shift -= 4; -- } -- if (shift != 4) -- *dp = (png_byte)d; -- break; -- } -- default: -- { -- png_bytep sp; -- png_bytep dp; -- png_uint_32 i; -- png_uint_32 row_width = row_info->width; -- png_size_t pixel_bytes; -- -- /* start at the beginning */ -- dp = row; -- /* find out how many bytes each pixel takes up */ -- pixel_bytes = (row_info->pixel_depth >> 3); -- /* loop through the row, only looking at the pixels that -- matter */ -- for (i = png_pass_start[pass]; i < row_width; -- i += png_pass_inc[pass]) -- { -- /* find out where the original pixel is */ -- sp = row + (png_size_t)i * pixel_bytes; -- /* move the pixel */ -- if (dp != sp) -- png_memcpy(dp, sp, pixel_bytes); -- /* next pixel */ -- dp += pixel_bytes; -- } -- break; -- } -- } -- /* set new row width */ -- row_info->width = (row_info->width + -- png_pass_inc[pass] - 1 - -- png_pass_start[pass]) / -- png_pass_inc[pass]; -- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, -- row_info->width); -- } --} --#endif -- --/* This filters the row, chooses which filter to use, if it has not already -- * been specified by the application, and then writes the row out with the -- * chosen filter. -- */ --#define PNG_MAXSUM (~((png_uint_32)0) >> 1) --#define PNG_HISHIFT 10 --#define PNG_LOMASK ((png_uint_32)0xffffL) --#define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT)) --void /* PRIVATE */ --png_write_find_filter(png_structp png_ptr, png_row_infop row_info) --{ -- png_bytep prev_row, best_row, row_buf; -- png_uint_32 mins, bpp; -- png_byte filter_to_do = png_ptr->do_filter; -- png_uint_32 row_bytes = row_info->rowbytes; --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) -- int num_p_filters = (int)png_ptr->num_prev_filters; --#endif -- -- png_debug(1, "in png_write_find_filter\n"); -- /* find out how many bytes offset each pixel is */ -- bpp = (row_info->pixel_depth + 7) >> 3; -- -- prev_row = png_ptr->prev_row; -- best_row = row_buf = png_ptr->row_buf; -- mins = PNG_MAXSUM; -- -- /* The prediction method we use is to find which method provides the -- * smallest value when summing the absolute values of the distances -- * from zero, using anything >= 128 as negative numbers. This is known -- * as the "minimum sum of absolute differences" heuristic. Other -- * heuristics are the "weighted minimum sum of absolute differences" -- * (experimental and can in theory improve compression), and the "zlib -- * predictive" method (not implemented yet), which does test compressions -- * of lines using different filter methods, and then chooses the -- * (series of) filter(s) that give minimum compressed data size (VERY -- * computationally expensive). -- * -- * GRR 980525: consider also -- * (1) minimum sum of absolute differences from running average (i.e., -- * keep running sum of non-absolute differences & count of bytes) -- * [track dispersion, too? restart average if dispersion too large?] -- * (1b) minimum sum of absolute differences from sliding average, probably -- * with window size <= deflate window (usually 32K) -- * (2) minimum sum of squared differences from zero or running average -- * (i.e., ~ root-mean-square approach) -- */ -- -- -- /* We don't need to test the 'no filter' case if this is the only filter -- * that has been chosen, as it doesn't actually do anything to the data. -- */ -- if ((filter_to_do & PNG_FILTER_NONE) && -- filter_to_do != PNG_FILTER_NONE) -- { -- png_bytep rp; -- png_uint_32 sum = 0; -- png_uint_32 i; -- int v; -- -- for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++) -- { -- v = *rp; -- sum += (v < 128) ? v : 256 - v; -- } -- --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) -- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) -- { -- png_uint_32 sumhi, sumlo; -- int j; -- sumlo = sum & PNG_LOMASK; -- sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */ -- -- /* Reduce the sum if we match any of the previous rows */ -- for (j = 0; j < num_p_filters; j++) -- { -- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE) -- { -- sumlo = (sumlo * png_ptr->filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- sumhi = (sumhi * png_ptr->filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- } -- } -- -- /* Factor in the cost of this filter (this is here for completeness, -- * but it makes no sense to have a "cost" for the NONE filter, as -- * it has the minimum possible computational cost - none). -- */ -- sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >> -- PNG_COST_SHIFT; -- sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >> -- PNG_COST_SHIFT; -- -- if (sumhi > PNG_HIMASK) -- sum = PNG_MAXSUM; -- else -- sum = (sumhi << PNG_HISHIFT) + sumlo; -- } --#endif -- mins = sum; -- } -- -- /* sub filter */ -- if (filter_to_do == PNG_FILTER_SUB) -- /* it's the only filter so no testing is needed */ -- { -- png_bytep rp, lp, dp; -- png_uint_32 i; -- for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp; -- i++, rp++, dp++) -- { -- *dp = *rp; -- } -- for (lp = row_buf + 1; i < row_bytes; -- i++, rp++, lp++, dp++) -- { -- *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); -- } -- best_row = png_ptr->sub_row; -- } -- -- else if (filter_to_do & PNG_FILTER_SUB) -- { -- png_bytep rp, dp, lp; -- png_uint_32 sum = 0, lmins = mins; -- png_uint_32 i; -- int v; -- --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) -- /* We temporarily increase the "minimum sum" by the factor we -- * would reduce the sum of this filter, so that we can do the -- * early exit comparison without scaling the sum each time. -- */ -- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) -- { -- int j; -- png_uint_32 lmhi, lmlo; -- lmlo = lmins & PNG_LOMASK; -- lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; -- -- for (j = 0; j < num_p_filters; j++) -- { -- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB) -- { -- lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- } -- } -- -- lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> -- PNG_COST_SHIFT; -- lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> -- PNG_COST_SHIFT; -- -- if (lmhi > PNG_HIMASK) -- lmins = PNG_MAXSUM; -- else -- lmins = (lmhi << PNG_HISHIFT) + lmlo; -- } --#endif -- -- for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp; -- i++, rp++, dp++) -- { -- v = *dp = *rp; -- -- sum += (v < 128) ? v : 256 - v; -- } -- for (lp = row_buf + 1; i < row_bytes; -- i++, rp++, lp++, dp++) -- { -- v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); -- -- sum += (v < 128) ? v : 256 - v; -- -- if (sum > lmins) /* We are already worse, don't continue. */ -- break; -- } -- --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) -- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) -- { -- int j; -- png_uint_32 sumhi, sumlo; -- sumlo = sum & PNG_LOMASK; -- sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; -- -- for (j = 0; j < num_p_filters; j++) -- { -- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB) -- { -- sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- } -- } -- -- sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> -- PNG_COST_SHIFT; -- sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> -- PNG_COST_SHIFT; -- -- if (sumhi > PNG_HIMASK) -- sum = PNG_MAXSUM; -- else -- sum = (sumhi << PNG_HISHIFT) + sumlo; -- } --#endif -- -- if (sum < mins) -- { -- mins = sum; -- best_row = png_ptr->sub_row; -- } -- } -- -- /* up filter */ -- if (filter_to_do == PNG_FILTER_UP) -- { -- png_bytep rp, dp, pp; -- png_uint_32 i; -- -- for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1, -- pp = prev_row + 1; i < row_bytes; -- i++, rp++, pp++, dp++) -- { -- *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff); -- } -- best_row = png_ptr->up_row; -- } -- -- else if (filter_to_do & PNG_FILTER_UP) -- { -- png_bytep rp, dp, pp; -- png_uint_32 sum = 0, lmins = mins; -- png_uint_32 i; -- int v; -- -- --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) -- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) -- { -- int j; -- png_uint_32 lmhi, lmlo; -- lmlo = lmins & PNG_LOMASK; -- lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; -- -- for (j = 0; j < num_p_filters; j++) -- { -- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP) -- { -- lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- } -- } -- -- lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >> -- PNG_COST_SHIFT; -- lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >> -- PNG_COST_SHIFT; -- -- if (lmhi > PNG_HIMASK) -- lmins = PNG_MAXSUM; -- else -- lmins = (lmhi << PNG_HISHIFT) + lmlo; -- } --#endif -- -- for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1, -- pp = prev_row + 1; i < row_bytes; i++) -- { -- v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); -- -- sum += (v < 128) ? v : 256 - v; -- -- if (sum > lmins) /* We are already worse, don't continue. */ -- break; -- } -- --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) -- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) -- { -- int j; -- png_uint_32 sumhi, sumlo; -- sumlo = sum & PNG_LOMASK; -- sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; -- -- for (j = 0; j < num_p_filters; j++) -- { -- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP) -- { -- sumlo = (sumlo * png_ptr->filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- sumhi = (sumhi * png_ptr->filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- } -- } -- -- sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >> -- PNG_COST_SHIFT; -- sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >> -- PNG_COST_SHIFT; -- -- if (sumhi > PNG_HIMASK) -- sum = PNG_MAXSUM; -- else -- sum = (sumhi << PNG_HISHIFT) + sumlo; -- } --#endif -- -- if (sum < mins) -- { -- mins = sum; -- best_row = png_ptr->up_row; -- } -- } -- -- /* avg filter */ -- if (filter_to_do == PNG_FILTER_AVG) -- { -- png_bytep rp, dp, pp, lp; -- png_uint_32 i; -- for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1, -- pp = prev_row + 1; i < bpp; i++) -- { -- *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); -- } -- for (lp = row_buf + 1; i < row_bytes; i++) -- { -- *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) -- & 0xff); -- } -- best_row = png_ptr->avg_row; -- } -- -- else if (filter_to_do & PNG_FILTER_AVG) -- { -- png_bytep rp, dp, pp, lp; -- png_uint_32 sum = 0, lmins = mins; -- png_uint_32 i; -- int v; -- --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) -- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) -- { -- int j; -- png_uint_32 lmhi, lmlo; -- lmlo = lmins & PNG_LOMASK; -- lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; -- -- for (j = 0; j < num_p_filters; j++) -- { -- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG) -- { -- lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- } -- } -- -- lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >> -- PNG_COST_SHIFT; -- lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >> -- PNG_COST_SHIFT; -- -- if (lmhi > PNG_HIMASK) -- lmins = PNG_MAXSUM; -- else -- lmins = (lmhi << PNG_HISHIFT) + lmlo; -- } --#endif -- -- for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1, -- pp = prev_row + 1; i < bpp; i++) -- { -- v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); -- -- sum += (v < 128) ? v : 256 - v; -- } -- for (lp = row_buf + 1; i < row_bytes; i++) -- { -- v = *dp++ = -- (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff); -- -- sum += (v < 128) ? v : 256 - v; -- -- if (sum > lmins) /* We are already worse, don't continue. */ -- break; -- } -- --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) -- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) -- { -- int j; -- png_uint_32 sumhi, sumlo; -- sumlo = sum & PNG_LOMASK; -- sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; -- -- for (j = 0; j < num_p_filters; j++) -- { -- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE) -- { -- sumlo = (sumlo * png_ptr->filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- sumhi = (sumhi * png_ptr->filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- } -- } -- -- sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >> -- PNG_COST_SHIFT; -- sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >> -- PNG_COST_SHIFT; -- -- if (sumhi > PNG_HIMASK) -- sum = PNG_MAXSUM; -- else -- sum = (sumhi << PNG_HISHIFT) + sumlo; -- } --#endif -- -- if (sum < mins) -- { -- mins = sum; -- best_row = png_ptr->avg_row; -- } -- } -- -- /* Paeth filter */ -- if (filter_to_do == PNG_FILTER_PAETH) -- { -- png_bytep rp, dp, pp, cp, lp; -- png_uint_32 i; -- for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1, -- pp = prev_row + 1; i < bpp; i++) -- { -- *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); -- } -- -- for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++) -- { -- int a, b, c, pa, pb, pc, p; -- -- b = *pp++; -- c = *cp++; -- a = *lp++; -- -- p = b - c; -- pc = a - c; -- --#ifdef PNG_USE_ABS -- pa = abs(p); -- pb = abs(pc); -- pc = abs(p + pc); --#else -- pa = p < 0 ? -p : p; -- pb = pc < 0 ? -pc : pc; -- pc = (p + pc) < 0 ? -(p + pc) : p + pc; --#endif -- -- p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; -- -- *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); -- } -- best_row = png_ptr->paeth_row; -- } -- -- else if (filter_to_do & PNG_FILTER_PAETH) -- { -- png_bytep rp, dp, pp, cp, lp; -- png_uint_32 sum = 0, lmins = mins; -- png_uint_32 i; -- int v; -- --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) -- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) -- { -- int j; -- png_uint_32 lmhi, lmlo; -- lmlo = lmins & PNG_LOMASK; -- lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; -- -- for (j = 0; j < num_p_filters; j++) -- { -- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH) -- { -- lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- } -- } -- -- lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >> -- PNG_COST_SHIFT; -- lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >> -- PNG_COST_SHIFT; -- -- if (lmhi > PNG_HIMASK) -- lmins = PNG_MAXSUM; -- else -- lmins = (lmhi << PNG_HISHIFT) + lmlo; -- } --#endif -- -- for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1, -- pp = prev_row + 1; i < bpp; i++) -- { -- v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); -- -- sum += (v < 128) ? v : 256 - v; -- } -- -- for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++) -- { -- int a, b, c, pa, pb, pc, p; -- -- b = *pp++; -- c = *cp++; -- a = *lp++; -- --#ifndef PNG_SLOW_PAETH -- p = b - c; -- pc = a - c; --#ifdef PNG_USE_ABS -- pa = abs(p); -- pb = abs(pc); -- pc = abs(p + pc); --#else -- pa = p < 0 ? -p : p; -- pb = pc < 0 ? -pc : pc; -- pc = (p + pc) < 0 ? -(p + pc) : p + pc; --#endif -- p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; --#else /* PNG_SLOW_PAETH */ -- p = a + b - c; -- pa = abs(p - a); -- pb = abs(p - b); -- pc = abs(p - c); -- if (pa <= pb && pa <= pc) -- p = a; -- else if (pb <= pc) -- p = b; -- else -- p = c; --#endif /* PNG_SLOW_PAETH */ -- -- v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); -- -- sum += (v < 128) ? v : 256 - v; -- -- if (sum > lmins) /* We are already worse, don't continue. */ -- break; -- } -- --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) -- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) -- { -- int j; -- png_uint_32 sumhi, sumlo; -- sumlo = sum & PNG_LOMASK; -- sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; -- -- for (j = 0; j < num_p_filters; j++) -- { -- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH) -- { -- sumlo = (sumlo * png_ptr->filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- sumhi = (sumhi * png_ptr->filter_weights[j]) >> -- PNG_WEIGHT_SHIFT; -- } -- } -- -- sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >> -- PNG_COST_SHIFT; -- sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >> -- PNG_COST_SHIFT; -- -- if (sumhi > PNG_HIMASK) -- sum = PNG_MAXSUM; -- else -- sum = (sumhi << PNG_HISHIFT) + sumlo; -- } --#endif -- -- if (sum < mins) -- { -- best_row = png_ptr->paeth_row; -- } -- } -- -- /* Do the actual writing of the filtered row data from the chosen filter. */ -- -- png_write_filtered_row(png_ptr, best_row); -- --#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) -- /* Save the type of filter we picked this time for future calculations */ -- if (png_ptr->num_prev_filters > 0) -- { -- int j; -- for (j = 1; j < num_p_filters; j++) -- { -- png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1]; -- } -- png_ptr->prev_filters[j] = best_row[0]; -- } --#endif --} -- -- --/* Do the actual writing of a previously filtered row. */ --void /* PRIVATE */ --png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row) --{ -- png_debug(1, "in png_write_filtered_row\n"); -- png_debug1(2, "filter = %d\n", filtered_row[0]); -- /* set up the zlib input buffer */ -- -- png_ptr->zstream.next_in = filtered_row; -- png_ptr->zstream.avail_in = (uInt)png_ptr->row_info.rowbytes + 1; -- /* repeat until we have compressed all the data */ -- do -- { -- int ret; /* return of zlib */ -- -- /* compress the data */ -- ret = deflate(&png_ptr->zstream, Z_NO_FLUSH); -- /* check for compression errors */ -- if (ret != Z_OK) -- { -- if (png_ptr->zstream.msg != NULL) -- png_error(png_ptr, png_ptr->zstream.msg); -- else -- png_error(png_ptr, "zlib error"); -- } -- -- /* see if it is time to write another IDAT */ -- if (!(png_ptr->zstream.avail_out)) -- { -- /* write the IDAT and reset the zlib output buffer */ -- png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); -- png_ptr->zstream.next_out = png_ptr->zbuf; -- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; -- } -- /* repeat until all data has been compressed */ -- } while (png_ptr->zstream.avail_in); -- -- /* swap the current and previous rows */ -- if (png_ptr->prev_row != NULL) -- { -- png_bytep tptr; -- -- tptr = png_ptr->prev_row; -- png_ptr->prev_row = png_ptr->row_buf; -- png_ptr->row_buf = tptr; -- } -- -- /* finish row - updates counters and flushes zlib if last row */ -- png_write_finish_row(png_ptr); -- --#if defined(PNG_WRITE_FLUSH_SUPPORTED) -- png_ptr->flush_rows++; -- -- if (png_ptr->flush_dist > 0 && -- png_ptr->flush_rows >= png_ptr->flush_dist) -- { -- png_write_flush(png_ptr); -- } --#endif --} --#endif /* PNG_WRITE_SUPPORTED */ -diff --git a/thirdparty/minizip/CMakeLists.txt b/thirdparty/minizip/CMakeLists.txt -deleted file mode 100644 -index 5f4d0af..0000000 ---- a/thirdparty/minizip/CMakeLists.txt -+++ /dev/null -@@ -1,20 +0,0 @@ --project(minizip) -- --# Create the list of source files --aux_source_directory( . source_files ) -- --# Define _UNICODE (use wide-char encoding) --add_definitions(-D_UNICODE -D_CRT_SECURE_NO_DEPRECATE /wd4127 /wd4131 /wd4100 /wd4189 /wd4244) -- --# Add include dir --include_directories( ${CMAKE_SOURCE_DIR}/thirdparty/zlib ) -- --fix_default_compiler_settings_() -- --# Add library build target --add_library(minizip STATIC ${source_files}) -- --# Add linker input libraries --target_link_libraries(minizip zlib) -- --set_target_properties(minizip PROPERTIES DEBUG_POSTFIX d ) -\ No newline at end of file -diff --git a/thirdparty/minizip/MiniZip64_Changes.txt b/thirdparty/minizip/MiniZip64_Changes.txt -deleted file mode 100644 -index 13a1bd9..0000000 ---- a/thirdparty/minizip/MiniZip64_Changes.txt -+++ /dev/null -@@ -1,6 +0,0 @@ -- --MiniZip 1.1 was derrived from MiniZip at version 1.01f -- --Change in 1.0 (Okt 2009) -- - **TODO - Add history** -- -diff --git a/thirdparty/minizip/MiniZip64_info.txt b/thirdparty/minizip/MiniZip64_info.txt -deleted file mode 100644 -index 57d7152..0000000 ---- a/thirdparty/minizip/MiniZip64_info.txt -+++ /dev/null -@@ -1,74 +0,0 @@ --MiniZip - Copyright (c) 1998-2010 - by Gilles Vollant - version 1.1 64 bits from Mathias Svensson -- --Introduction ----------------------- --MiniZip 1.1 is built from MiniZip 1.0 by Gilles Vollant ( http://www.winimage.com/zLibDll/minizip.html ) -- --When adding ZIP64 support into minizip it would result into risk of breaking compatibility with minizip 1.0. --All possible work was done for compatibility. -- -- --Background ----------------------- --When adding ZIP64 support Mathias Svensson found that Even Rouault have added ZIP64 --support for unzip.c into minizip for a open source project called gdal ( http://www.gdal.org/ ) -- --That was used as a starting point. And after that ZIP64 support was added to zip.c --some refactoring and code cleanup was also done. -- -- --Changed from MiniZip 1.0 to MiniZip 1.1 ----------------------------------------- --* Added ZIP64 support for unzip ( by Even Rouault ) --* Added ZIP64 support for zip ( by Mathias Svensson ) --* Reverted some changed that Even Rouault did. --* Bunch of patches received from Gulles Vollant that he received for MiniZip from various users. --* Added unzip patch for BZIP Compression method (patch create by Daniel Borca) --* Added BZIP Compress method for zip --* Did some refactoring and code cleanup -- -- --Credits -- -- Gilles Vollant - Original MiniZip author -- Even Rouault - ZIP64 unzip Support -- Daniel Borca - BZip Compression method support in unzip -- Mathias Svensson - ZIP64 zip support -- Mathias Svensson - BZip Compression method support in zip -- -- Resources -- -- ZipLayout http://result42.com/projects/ZipFileLayout -- Command line tool for Windows that shows the layout and information of the headers in a zip archive. -- Used when debugging and validating the creation of zip files using MiniZip64 -- -- -- ZIP App Note http://www.pkware.com/documents/casestudies/APPNOTE.TXT -- Zip File specification -- -- --Notes. -- * To be able to use BZip compression method in zip64.c or unzip64.c the BZIP2 lib is needed and HAVE_BZIP2 need to be defined. -- --License ------------------------------------------------------------ -- Condition of use and distribution are the same than zlib : -- -- This software is provided 'as-is', without any express or implied -- warranty. In no event will the authors be held liable for any damages -- arising from the use of this software. -- -- Permission is granted to anyone to use this software for any purpose, -- including commercial applications, and to alter it and redistribute it -- freely, subject to the following restrictions: -- -- 1. The origin of this software must not be misrepresented; you must not -- claim that you wrote the original software. If you use this software -- in a product, an acknowledgment in the product documentation would be -- appreciated but is not required. -- 2. Altered source versions must be plainly marked as such, and must not be -- misrepresented as being the original software. -- 3. This notice may not be removed or altered from any source distribution. -- ------------------------------------------------------------ -- -diff --git a/thirdparty/minizip/crypt.h b/thirdparty/minizip/crypt.h -deleted file mode 100644 -index a01d08d..0000000 ---- a/thirdparty/minizip/crypt.h -+++ /dev/null -@@ -1,131 +0,0 @@ --/* crypt.h -- base code for crypt/uncrypt ZIPfile -- -- -- Version 1.01e, February 12th, 2005 -- -- Copyright (C) 1998-2005 Gilles Vollant -- -- This code is a modified version of crypting code in Infozip distribution -- -- 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). -- -- If you don't need crypting in your application, just define symbols -- NOCRYPT and NOUNCRYPT. -- -- This code support the "Traditional PKWARE Encryption". -- -- The new AES encryption added on Zip format by Winzip (see the page -- http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong -- Encryption is not supported. --*/ -- --#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) -- --/*********************************************************************** -- * Return the next byte in the pseudo-random sequence -- */ --static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab) --{ -- unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an -- * unpredictable manner on 16-bit systems; not a problem -- * with any known compiler so far, though */ -- -- temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2; -- return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); --} -- --/*********************************************************************** -- * Update the encryption keys with the next byte of plain text -- */ --static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c) --{ -- (*(pkeys+0)) = CRC32((*(pkeys+0)), c); -- (*(pkeys+1)) += (*(pkeys+0)) & 0xff; -- (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1; -- { -- register int keyshift = (int)((*(pkeys+1)) >> 24); -- (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift); -- } -- return c; --} -- -- --/*********************************************************************** -- * Initialize the encryption keys and the random header according to -- * the given password. -- */ --static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab) --{ -- *(pkeys+0) = 305419896L; -- *(pkeys+1) = 591751049L; -- *(pkeys+2) = 878082192L; -- while (*passwd != '\0') { -- update_keys(pkeys,pcrc_32_tab,(int)*passwd); -- passwd++; -- } --} -- --#define zdecode(pkeys,pcrc_32_tab,c) \ -- (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab))) -- --#define zencode(pkeys,pcrc_32_tab,c,t) \ -- (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c)) -- --#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED -- --#define RAND_HEAD_LEN 12 -- /* "last resort" source for second part of crypt seed pattern */ --# ifndef ZCR_SEED2 --# define ZCR_SEED2 3141592654UL /* use PI as default pattern */ --# endif -- --static int crypthead(const char* passwd, /* password string */ -- unsigned char* buf, /* where to write header */ -- int bufSize, -- unsigned long* pkeys, -- const unsigned long* pcrc_32_tab, -- unsigned long crcForCrypting) --{ -- int n; /* index in random header */ -- int t; /* temporary */ -- int c; /* random byte */ -- unsigned char header[RAND_HEAD_LEN-2]; /* random header */ -- static unsigned calls = 0; /* ensure different random header each time */ -- -- if (bufSize> 7) & 0xff; -- header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t); -- } -- /* Encrypt random header (last two bytes is high word of crc) */ -- init_keys(passwd, pkeys, pcrc_32_tab); -- for (n = 0; n < RAND_HEAD_LEN-2; n++) -- { -- buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t); -- } -- buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t); -- buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t); -- return n; --} -- --#endif -diff --git a/thirdparty/minizip/ioapi.c b/thirdparty/minizip/ioapi.c -deleted file mode 100644 -index 7f25460..0000000 ---- a/thirdparty/minizip/ioapi.c -+++ /dev/null -@@ -1,236 +0,0 @@ --/* 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)) -- #define _CRT_SECURE_NO_WARNINGS --#endif -- --#include "ioapi.h" --#include "tchar.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) == ((uLong)-1)) -- 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; -- wchar_t* mode_fopen = NULL; -- if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) -- mode_fopen = _T("rb"); -- else -- if (mode & ZLIB_FILEFUNC_MODE_EXISTING) -- mode_fopen = _T("r+b"); -- else -- if (mode & ZLIB_FILEFUNC_MODE_CREATE) -- mode_fopen = L"wb"; -- -- if ((filename!=NULL) && (mode_fopen != NULL)) -- file = _wfopen((wchar_t*)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 = ftello64((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(fseeko64((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/thirdparty/minizip/ioapi.h b/thirdparty/minizip/ioapi.h -deleted file mode 100644 -index be98b97..0000000 ---- a/thirdparty/minizip/ioapi.h -+++ /dev/null -@@ -1,200 +0,0 @@ --/* 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)) -- -- // 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 --#include --#include "zlib.h" -- --#if defined(USE_FILE32API) --#define fopen64 _tfopen --#define ftello64 ftell --#define fseeko64 fseek --#else --#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 -- #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 -- -- --#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/thirdparty/minizip/iowin32.c b/thirdparty/minizip/iowin32.c -deleted file mode 100644 -index 6a2a883..0000000 ---- a/thirdparty/minizip/iowin32.c -+++ /dev/null -@@ -1,389 +0,0 @@ --/* 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 -- --#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 -- --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); -- -- if ((filename!=NULL) && (dwDesiredAccess != 0)) -- hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); -- -- 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); -- -- if ((filename!=NULL) && (dwDesiredAccess != 0)) -- hFile = CreateFileA((LPCSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); -- -- 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); -- -- if ((filename!=NULL) && (dwDesiredAccess != 0)) -- hFile = CreateFileW((LPCWSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); -- -- 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); -- -- if ((filename!=NULL) && (dwDesiredAccess != 0)) -- hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); -- -- 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; --} -- --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) -- { -- DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT); -- if (dwSet == INVALID_SET_FILE_POINTER) -- { -- DWORD dwErr = GetLastError(); -- ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; -- ret = -1; -- } -- else -- ret=(long)dwSet; -- } -- 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 li; -- li.QuadPart = 0; -- li.u.LowPart = SetFilePointer(hFile, li.u.LowPart, &li.u.HighPart, FILE_CURRENT); -- if ( (li.LowPart == 0xFFFFFFFF) && (GetLastError() != NO_ERROR)) -- { -- DWORD dwErr = GetLastError(); -- ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; -- ret = (ZPOS64_T)-1; -- } -- else -- ret=li.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) -- { -- DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod); -- if (dwSet == INVALID_SET_FILE_POINTER) -- { -- 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* li = (LARGE_INTEGER*)&offset; -- DWORD dwSet = SetFilePointer(hFile, li->u.LowPart, &li->u.HighPart, dwMoveMethod); -- if (dwSet == INVALID_SET_FILE_POINTER) -- { -- 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/thirdparty/minizip/iowin32.h b/thirdparty/minizip/iowin32.h -deleted file mode 100644 -index 0ca0969..0000000 ---- a/thirdparty/minizip/iowin32.h -+++ /dev/null -@@ -1,28 +0,0 @@ --/* 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 -- -- --#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/thirdparty/minizip/minizip_vs2010.vcxproj b/thirdparty/minizip/minizip_vs2010.vcxproj -deleted file mode 100644 -index 6173484..0000000 ---- a/thirdparty/minizip/minizip_vs2010.vcxproj -+++ /dev/null -@@ -1,238 +0,0 @@ -- -- -- -- -- Debug -- Win32 -- -- -- Debug -- x64 -- -- -- Release LIB -- Win32 -- -- -- Release LIB -- x64 -- -- -- Release -- Win32 -- -- -- Release -- x64 -- -- -- -- {C610F50E-1013-46F0-AE20-4E918654B40F} -- minizip -- Win32Proj -- minizip -- -- -- -- StaticLibrary -- Unicode -- true -- -- -- StaticLibrary -- Unicode -- true -- -- -- StaticLibrary -- Unicode -- true -- -- -- StaticLibrary -- Unicode -- true -- -- -- StaticLibrary -- Unicode -- -- -- StaticLibrary -- Unicode -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- <_ProjectFileVersion>10.0.30319.1 -- $(SolutionDir)thirdparty\lib\ -- $(SolutionDir)thirdparty\lib\$(Platform)\ -- $(Configuration)\ -- $(SolutionDir)\thirdparty\lib\ -- $(SolutionDir)\thirdparty\lib\$(Platform)\ -- $(Configuration)\ -- $(SolutionDir)\thirdparty\lib\ -- $(SolutionDir)\thirdparty\lib\$(Platform)\ -- $(Configuration)\ -- $(Configuration)\ -- AllRules.ruleset -- AllRules.ruleset -- -- -- -- -- AllRules.ruleset -- AllRules.ruleset -- -- -- -- -- AllRules.ruleset -- AllRules.ruleset -- -- -- -- -- minizipd -- minizipd -- minizip -- minizip -- minizip -- minizip -- -- -- -- Disabled -- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) -- WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions) -- EnableFastChecks -- MultiThreadedDebugDLL -- -- -- Level3 -- EditAndContinue -- 4133;4996;%(DisableSpecificWarnings) -- true -- -- -- -- -- -- Disabled -- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) -- _WIN64;_DEBUG;_LIB;%(PreprocessorDefinitions) -- EnableFastChecks -- MultiThreadedDebugDLL -- -- -- Level3 -- ProgramDatabase -- 4133;4996;%(DisableSpecificWarnings) -- true -- -- -- -- -- -- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) -- WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) -- MultiThreadedDLL -- -- -- Level3 -- ProgramDatabase -- 4133;4996;%(DisableSpecificWarnings) -- MinSpace -- Size -- true -- -- -- -- -- -- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) -- WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) -- MultiThreadedDLL -- -- -- Level3 -- ProgramDatabase -- 4133;4996;%(DisableSpecificWarnings) -- MinSpace -- Size -- true -- -- -- -- -- -- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) -- WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) -- MultiThreaded -- -- -- Level3 -- ProgramDatabase -- 4133;4996;%(DisableSpecificWarnings) -- MinSpace -- Size -- true -- -- -- -- -- -- $(SolutionDir)thirdparty\zlib;%(AdditionalIncludeDirectories) -- WIN64;NDEBUG;_LIB;%(PreprocessorDefinitions) -- MultiThreaded -- -- -- Level3 -- ProgramDatabase -- 4133;4996;%(DisableSpecificWarnings) -- true -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -\ No newline at end of file -diff --git a/thirdparty/minizip/mztools.c b/thirdparty/minizip/mztools.c -deleted file mode 100644 -index f9092e6..0000000 ---- a/thirdparty/minizip/mztools.c -+++ /dev/null -@@ -1,281 +0,0 @@ --/* -- Additional tools for Minizip -- Code: Xavier Roche '2004 -- License: Same as ZLIB (www.gzip.org) --*/ -- --/* Code */ --#include --#include --#include --#include "zlib.h" --#include "unzip.h" -- --#define READ_8(adr) ((unsigned char)*(adr)) --#define READ_16(adr) ( READ_8(adr) | (READ_8(adr+1) << 8) ) --#define READ_32(adr) ( READ_16(adr) | (READ_16((adr)+2) << 16) ) -- --#define WRITE_8(buff, n) do { \ -- *((unsigned char*)(buff)) = (unsigned char) ((n) & 0xff); \ --} while(0) --#define WRITE_16(buff, n) do { \ -- WRITE_8((unsigned char*)(buff), n); \ -- WRITE_8(((unsigned char*)(buff)) + 1, (n) >> 8); \ --} while(0) --#define WRITE_32(buff, n) do { \ -- WRITE_16((unsigned char*)(buff), (n) & 0xffff); \ -- WRITE_16((unsigned char*)(buff) + 2, (n) >> 16); \ --} while(0) -- --extern int ZEXPORT unzRepair(file, fileOut, fileOutTmp, nRecovered, bytesRecovered) --const char* file; --const char* fileOut; --const char* fileOutTmp; --uLong* nRecovered; --uLong* bytesRecovered; --{ -- int err = Z_OK; -- FILE* fpZip = fopen(file, "rb"); -- FILE* fpOut = fopen(fileOut, "wb"); -- FILE* fpOutCD = fopen(fileOutTmp, "wb"); -- if (fpZip != NULL && fpOut != NULL) { -- int entries = 0; -- uLong totalBytes = 0; -- char header[30]; -- char filename[256]; -- char extra[1024]; -- int offset = 0; -- int offsetCD = 0; -- while ( fread(header, 1, 30, fpZip) == 30 ) { -- int currentOffset = offset; -- -- /* File entry */ -- if (READ_32(header) == 0x04034b50) { -- unsigned int version = READ_16(header + 4); -- unsigned int gpflag = READ_16(header + 6); -- unsigned int method = READ_16(header + 8); -- unsigned int filetime = READ_16(header + 10); -- unsigned int filedate = READ_16(header + 12); -- unsigned int crc = READ_32(header + 14); /* crc */ -- unsigned int cpsize = READ_32(header + 18); /* compressed size */ -- unsigned int uncpsize = READ_32(header + 22); /* uncompressed sz */ -- unsigned int fnsize = READ_16(header + 26); /* file name length */ -- unsigned int extsize = READ_16(header + 28); /* extra field length */ -- filename[0] = extra[0] = '\0'; -- -- /* Header */ -- if (fwrite(header, 1, 30, fpOut) == 30) { -- offset += 30; -- } else { -- err = Z_ERRNO; -- break; -- } -- -- /* Filename */ -- if (fnsize > 0) { -- if (fread(filename, 1, fnsize, fpZip) == fnsize) { -- if (fwrite(filename, 1, fnsize, fpOut) == fnsize) { -- offset += fnsize; -- } else { -- err = Z_ERRNO; -- break; -- } -- } else { -- err = Z_ERRNO; -- break; -- } -- } else { -- err = Z_STREAM_ERROR; -- break; -- } -- -- /* Extra field */ -- if (extsize > 0) { -- if (fread(extra, 1, extsize, fpZip) == extsize) { -- if (fwrite(extra, 1, extsize, fpOut) == extsize) { -- offset += extsize; -- } else { -- err = Z_ERRNO; -- break; -- } -- } else { -- err = Z_ERRNO; -- break; -- } -- } -- -- /* Data */ -- { -- int dataSize = cpsize; -- if (dataSize == 0) { -- dataSize = uncpsize; -- } -- if (dataSize > 0) { -- char* data = malloc(dataSize); -- if (data != NULL) { -- if ((int)fread(data, 1, dataSize, fpZip) == dataSize) { -- if ((int)fwrite(data, 1, dataSize, fpOut) == dataSize) { -- offset += dataSize; -- totalBytes += dataSize; -- } else { -- err = Z_ERRNO; -- } -- } else { -- err = Z_ERRNO; -- } -- free(data); -- if (err != Z_OK) { -- break; -- } -- } else { -- err = Z_MEM_ERROR; -- break; -- } -- } -- } -- -- /* Central directory entry */ -- { -- char header[46]; -- char* comment = ""; -- int comsize = (int) strlen(comment); -- WRITE_32(header, 0x02014b50); -- WRITE_16(header + 4, version); -- WRITE_16(header + 6, version); -- WRITE_16(header + 8, gpflag); -- WRITE_16(header + 10, method); -- WRITE_16(header + 12, filetime); -- WRITE_16(header + 14, filedate); -- WRITE_32(header + 16, crc); -- WRITE_32(header + 20, cpsize); -- WRITE_32(header + 24, uncpsize); -- WRITE_16(header + 28, fnsize); -- WRITE_16(header + 30, extsize); -- WRITE_16(header + 32, comsize); -- WRITE_16(header + 34, 0); /* disk # */ -- WRITE_16(header + 36, 0); /* int attrb */ -- WRITE_32(header + 38, 0); /* ext attrb */ -- WRITE_32(header + 42, currentOffset); -- /* Header */ -- if (fwrite(header, 1, 46, fpOutCD) == 46) { -- offsetCD += 46; -- -- /* Filename */ -- if (fnsize > 0) { -- if (fwrite(filename, 1, fnsize, fpOutCD) == fnsize) { -- offsetCD += fnsize; -- } else { -- err = Z_ERRNO; -- break; -- } -- } else { -- err = Z_STREAM_ERROR; -- break; -- } -- -- /* Extra field */ -- if (extsize > 0) { -- if (fwrite(extra, 1, extsize, fpOutCD) == extsize) { -- offsetCD += extsize; -- } else { -- err = Z_ERRNO; -- break; -- } -- } -- -- /* Comment field */ -- if (comsize > 0) { -- if ((int)fwrite(comment, 1, comsize, fpOutCD) == comsize) { -- offsetCD += comsize; -- } else { -- err = Z_ERRNO; -- break; -- } -- } -- -- -- } else { -- err = Z_ERRNO; -- break; -- } -- } -- -- /* Success */ -- entries++; -- -- } else { -- break; -- } -- } -- -- /* Final central directory */ -- { -- int entriesZip = entries; -- char header[22]; -- char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools"; -- int comsize = (int) strlen(comment); -- if (entriesZip > 0xffff) { -- entriesZip = 0xffff; -- } -- WRITE_32(header, 0x06054b50); -- WRITE_16(header + 4, 0); /* disk # */ -- WRITE_16(header + 6, 0); /* disk # */ -- WRITE_16(header + 8, entriesZip); /* hack */ -- WRITE_16(header + 10, entriesZip); /* hack */ -- WRITE_32(header + 12, offsetCD); /* size of CD */ -- WRITE_32(header + 16, offset); /* offset to CD */ -- WRITE_16(header + 20, comsize); /* comment */ -- -- /* Header */ -- if (fwrite(header, 1, 22, fpOutCD) == 22) { -- -- /* Comment field */ -- if (comsize > 0) { -- if ((int)fwrite(comment, 1, comsize, fpOutCD) != comsize) { -- err = Z_ERRNO; -- } -- } -- -- } else { -- err = Z_ERRNO; -- } -- } -- -- /* Final merge (file + central directory) */ -- fclose(fpOutCD); -- if (err == Z_OK) { -- fpOutCD = fopen(fileOutTmp, "rb"); -- if (fpOutCD != NULL) { -- int nRead; -- char buffer[8192]; -- while ( (nRead = (int)fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) { -- if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) { -- err = Z_ERRNO; -- break; -- } -- } -- fclose(fpOutCD); -- } -- } -- -- /* Close */ -- fclose(fpZip); -- fclose(fpOut); -- -- /* Wipe temporary file */ -- (void)remove(fileOutTmp); -- -- /* Number of recovered entries */ -- if (err == Z_OK) { -- if (nRecovered != NULL) { -- *nRecovered = entries; -- } -- if (bytesRecovered != NULL) { -- *bytesRecovered = totalBytes; -- } -- } -- } else { -- err = Z_STREAM_ERROR; -- } -- return err; --} -diff --git a/thirdparty/minizip/mztools.h b/thirdparty/minizip/mztools.h -deleted file mode 100644 -index 88b3459..0000000 ---- a/thirdparty/minizip/mztools.h -+++ /dev/null -@@ -1,31 +0,0 @@ --/* -- Additional tools for Minizip -- Code: Xavier Roche '2004 -- License: Same as ZLIB (www.gzip.org) --*/ -- --#ifndef _zip_tools_H --#define _zip_tools_H -- --#ifdef __cplusplus --extern "C" { --#endif -- --#ifndef _ZLIB_H --#include "zlib.h" --#endif -- --#include "unzip.h" -- --/* Repair a ZIP file (missing central directory) -- file: file to recover -- fileOut: output file after recovery -- fileOutTmp: temporary file name used for recovery --*/ --extern int ZEXPORT unzRepair(const char* file, -- const char* fileOut, -- const char* fileOutTmp, -- uLong* nRecovered, -- uLong* bytesRecovered); -- --#endif -diff --git a/thirdparty/minizip/unzip.c b/thirdparty/minizip/unzip.c -deleted file mode 100644 -index 38a5c06..0000000 ---- a/thirdparty/minizip/unzip.c -+++ /dev/null -@@ -1,2125 +0,0 @@ --/* 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 --#include --#include -- --#ifndef NOUNCRYPT -- #define NOUNCRYPT --#endif -- --#include "zlib.h" --#include "unzip.h" -- --#ifdef STDC --# include --# include --# include --#endif --#ifdef NO_ERRNO_H -- extern int errno; --#else --# include --#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 unsigned long* 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 (c1c2) -- 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 (uBackReaduMaxBack) -- 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 (uBackReaduMaxBack) -- 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_pospfile_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_filename0) && (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_extraz_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 == (ZPOS64_T)(unsigned long)-1) -- { -- if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK) -- err=UNZ_ERRNO; -- } -- -- if(file_info.compressed_size == (ZPOS64_T)(unsigned long)-1) -- { -- if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK) -- err=UNZ_ERRNO; -- } -- -- if(file_info_internal.offset_curfile == (ZPOS64_T)(unsigned long)-1) -- { -- /* 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 == (unsigned long)-1) -- { -- /* 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_commentz_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 unzipStringFileNameCompare -- -- 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; -- case 2 : *level = 9; break; -- } -- } -- -- if ((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; -- -- pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc; -- pfile_in_zip_read_info->crc32=0; -- pfile_in_zip_read_info->total_out_64=0; -- pfile_in_zip_read_info->compression_method = s->cur_file_info.compression_method; -- pfile_in_zip_read_info->filestream=s->filestream; -- pfile_in_zip_read_info->z_filefunc=s->z_filefunc; -- pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile; -- -- pfile_in_zip_read_info->stream.total_out = 0; -- -- if ((s->cur_file_info.compression_method==Z_BZIP2ED) && (!raw)) -- { --#ifdef HAVE_BZIP2 -- pfile_in_zip_read_info->bstream.bzalloc = (void *(*) (void *, int, int))0; -- pfile_in_zip_read_info->bstream.bzfree = (free_func)0; -- pfile_in_zip_read_info->bstream.opaque = (voidpf)0; -- pfile_in_zip_read_info->bstream.state = (voidpf)0; -- -- pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; -- pfile_in_zip_read_info->stream.zfree = (free_func)0; -- pfile_in_zip_read_info->stream.opaque = (voidpf)0; -- pfile_in_zip_read_info->stream.next_in = (voidpf)0; -- pfile_in_zip_read_info->stream.avail_in = 0; -- -- err=BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0); -- if (err == Z_OK) -- pfile_in_zip_read_info->stream_initialised=Z_BZIP2ED; -- else -- { -- TRYFREE(pfile_in_zip_read_info); -- return err; -- } --#else -- pfile_in_zip_read_info->raw=1; --#endif -- } -- else if ((s->cur_file_info.compression_method==Z_DEFLATED) && (!raw)) -- { -- pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; -- pfile_in_zip_read_info->stream.zfree = (free_func)0; -- pfile_in_zip_read_info->stream.opaque = (voidpf)0; -- pfile_in_zip_read_info->stream.next_in = 0; -- pfile_in_zip_read_info->stream.avail_in = 0; -- -- err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS); -- if (err == Z_OK) -- pfile_in_zip_read_info->stream_initialised=Z_DEFLATED; -- else -- { -- TRYFREE(pfile_in_zip_read_info); -- return err; -- } -- /* windowBits is passed < 0 to tell that there is no zlib header. -- * Note that in this case inflate *requires* an extra "dummy" byte -- * after the compressed stream in order to complete decompression and -- * return Z_STREAM_END. -- * In unzip, i don't wait absolutely Z_STREAM_END because I known the -- * size of both compressed and uncompressed data -- */ -- } -- pfile_in_zip_read_info->rest_read_compressed = -- s->cur_file_info.compressed_size ; -- pfile_in_zip_read_info->rest_read_uncompressed = -- s->cur_file_info.uncompressed_size ; -- -- -- pfile_in_zip_read_info->pos_in_zipfile = -- s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + -- iSizeVar; -- -- pfile_in_zip_read_info->stream.avail_in = (uInt)0; -- -- s->pfile_in_zip_read = pfile_in_zip_read_info; -- s->encrypted = 0; -- --# ifndef NOUNCRYPT -- if (password != NULL) -- { -- int i; -- s->pcrc_32_tab = get_crc_table(); -- init_keys(password,s->keys,s->pcrc_32_tab); -- if (ZSEEK64(s->z_filefunc, s->filestream, -- s->pfile_in_zip_read->pos_in_zipfile + -- s->pfile_in_zip_read->byte_before_the_zipfile, -- SEEK_SET)!=0) -- return UNZ_INTERNALERROR; -- if(ZREAD64(s->z_filefunc, s->filestream,source, 12)<12) -- return UNZ_INTERNALERROR; -- -- for (i = 0; i<12; i++) -- zdecode(s->keys,s->pcrc_32_tab,source[i]); -- -- s->pfile_in_zip_read->pos_in_zipfile+=12; -- s->encrypted=1; -- } --# endif -- -- -- return UNZ_OK; --} -- --extern int ZEXPORT unzOpenCurrentFile (unzFile file) --{ -- return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL); --} -- --extern int ZEXPORT unzOpenCurrentFilePassword (unzFile file, const char* password) --{ -- return unzOpenCurrentFile3(file, NULL, NULL, 0, password); --} -- --extern int ZEXPORT unzOpenCurrentFile2 (unzFile file, int* method, int* level, int raw) --{ -- return unzOpenCurrentFile3(file, method, level, raw, NULL); --} -- --/** Addition for GDAL : START */ -- --extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64( unzFile file) --{ -- unz64_s* s; -- file_in_zip64_read_info_s* pfile_in_zip_read_info; -- s=(unz64_s*)file; -- if (file==NULL) -- return 0; //UNZ_PARAMERROR; -- pfile_in_zip_read_info=s->pfile_in_zip_read; -- if (pfile_in_zip_read_info==NULL) -- return 0; //UNZ_PARAMERROR; -- return pfile_in_zip_read_info->pos_in_zipfile + -- pfile_in_zip_read_info->byte_before_the_zipfile; --} -- --/** Addition for GDAL : END */ -- --/* -- Read bytes from the current file. -- buf contain buffer where data must be copied -- len the size of buf. -- -- return the number of byte copied if somes bytes are copied -- return 0 if the end of file was reached -- return <0 with error code if there is an error -- (UNZ_ERRNO for IO error, or zLib error for uncompress error) --*/ --extern int ZEXPORT unzReadCurrentFile (unzFile file, voidp buf, unsigned len) --{ -- int err=UNZ_OK; -- uInt iRead = 0; -- unz64_s* s; -- file_in_zip64_read_info_s* pfile_in_zip_read_info; -- if (file==NULL) -- return UNZ_PARAMERROR; -- s=(unz64_s*)file; -- pfile_in_zip_read_info=s->pfile_in_zip_read; -- -- if (pfile_in_zip_read_info==NULL) -- return UNZ_PARAMERROR; -- -- -- if ((pfile_in_zip_read_info->read_buffer == NULL)) -- return UNZ_END_OF_LIST_OF_FILE; -- if (len==0) -- return 0; -- -- pfile_in_zip_read_info->stream.next_out = (Bytef*)buf; -- -- pfile_in_zip_read_info->stream.avail_out = (uInt)len; -- -- if ((len>pfile_in_zip_read_info->rest_read_uncompressed) && -- (!(pfile_in_zip_read_info->raw))) -- pfile_in_zip_read_info->stream.avail_out = -- (uInt)pfile_in_zip_read_info->rest_read_uncompressed; -- -- if ((len>pfile_in_zip_read_info->rest_read_compressed+ -- pfile_in_zip_read_info->stream.avail_in) && -- (pfile_in_zip_read_info->raw)) -- pfile_in_zip_read_info->stream.avail_out = -- (uInt)pfile_in_zip_read_info->rest_read_compressed+ -- pfile_in_zip_read_info->stream.avail_in; -- -- while (pfile_in_zip_read_info->stream.avail_out>0) -- { -- if ((pfile_in_zip_read_info->stream.avail_in==0) && -- (pfile_in_zip_read_info->rest_read_compressed>0)) -- { -- uInt uReadThis = UNZ_BUFSIZE; -- if (pfile_in_zip_read_info->rest_read_compressedrest_read_compressed; -- if (uReadThis == 0) -- return UNZ_EOF; -- if (ZSEEK64(pfile_in_zip_read_info->z_filefunc, -- pfile_in_zip_read_info->filestream, -- pfile_in_zip_read_info->pos_in_zipfile + -- pfile_in_zip_read_info->byte_before_the_zipfile, -- ZLIB_FILEFUNC_SEEK_SET)!=0) -- return UNZ_ERRNO; -- if (ZREAD64(pfile_in_zip_read_info->z_filefunc, -- pfile_in_zip_read_info->filestream, -- pfile_in_zip_read_info->read_buffer, -- uReadThis)!=uReadThis) -- return UNZ_ERRNO; -- -- --# ifndef NOUNCRYPT -- if(s->encrypted) -- { -- uInt i; -- for(i=0;iread_buffer[i] = -- zdecode(s->keys,s->pcrc_32_tab, -- pfile_in_zip_read_info->read_buffer[i]); -- } --# endif -- -- -- pfile_in_zip_read_info->pos_in_zipfile += uReadThis; -- -- pfile_in_zip_read_info->rest_read_compressed-=uReadThis; -- -- pfile_in_zip_read_info->stream.next_in = -- (Bytef*)pfile_in_zip_read_info->read_buffer; -- pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis; -- } -- -- if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw)) -- { -- uInt uDoCopy,i ; -- -- if ((pfile_in_zip_read_info->stream.avail_in == 0) && -- (pfile_in_zip_read_info->rest_read_compressed == 0)) -- return (iRead==0) ? UNZ_EOF : iRead; -- -- if (pfile_in_zip_read_info->stream.avail_out < -- pfile_in_zip_read_info->stream.avail_in) -- uDoCopy = pfile_in_zip_read_info->stream.avail_out ; -- else -- uDoCopy = pfile_in_zip_read_info->stream.avail_in ; -- -- for (i=0;istream.next_out+i) = -- *(pfile_in_zip_read_info->stream.next_in+i); -- -- pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uDoCopy; -- -- pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, -- pfile_in_zip_read_info->stream.next_out, -- uDoCopy); -- pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy; -- pfile_in_zip_read_info->stream.avail_in -= uDoCopy; -- pfile_in_zip_read_info->stream.avail_out -= uDoCopy; -- pfile_in_zip_read_info->stream.next_out += uDoCopy; -- pfile_in_zip_read_info->stream.next_in += uDoCopy; -- pfile_in_zip_read_info->stream.total_out += uDoCopy; -- iRead += uDoCopy; -- } -- else if (pfile_in_zip_read_info->compression_method==Z_BZIP2ED) -- { --#ifdef HAVE_BZIP2 -- uLong uTotalOutBefore,uTotalOutAfter; -- const Bytef *bufBefore; -- uLong uOutThis; -- -- pfile_in_zip_read_info->bstream.next_in = (char*)pfile_in_zip_read_info->stream.next_in; -- pfile_in_zip_read_info->bstream.avail_in = pfile_in_zip_read_info->stream.avail_in; -- pfile_in_zip_read_info->bstream.total_in_lo32 = pfile_in_zip_read_info->stream.total_in; -- pfile_in_zip_read_info->bstream.total_in_hi32 = 0; -- pfile_in_zip_read_info->bstream.next_out = (char*)pfile_in_zip_read_info->stream.next_out; -- pfile_in_zip_read_info->bstream.avail_out = pfile_in_zip_read_info->stream.avail_out; -- pfile_in_zip_read_info->bstream.total_out_lo32 = pfile_in_zip_read_info->stream.total_out; -- pfile_in_zip_read_info->bstream.total_out_hi32 = 0; -- -- uTotalOutBefore = pfile_in_zip_read_info->bstream.total_out_lo32; -- bufBefore = (const Bytef *)pfile_in_zip_read_info->bstream.next_out; -- -- err=BZ2_bzDecompress(&pfile_in_zip_read_info->bstream); -- -- uTotalOutAfter = pfile_in_zip_read_info->bstream.total_out_lo32; -- uOutThis = uTotalOutAfter-uTotalOutBefore; -- -- pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis; -- -- pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,bufBefore, (uInt)(uOutThis)); -- pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis; -- iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); -- -- pfile_in_zip_read_info->stream.next_in = (Bytef*)pfile_in_zip_read_info->bstream.next_in; -- pfile_in_zip_read_info->stream.avail_in = pfile_in_zip_read_info->bstream.avail_in; -- pfile_in_zip_read_info->stream.total_in = pfile_in_zip_read_info->bstream.total_in_lo32; -- pfile_in_zip_read_info->stream.next_out = (Bytef*)pfile_in_zip_read_info->bstream.next_out; -- pfile_in_zip_read_info->stream.avail_out = pfile_in_zip_read_info->bstream.avail_out; -- pfile_in_zip_read_info->stream.total_out = pfile_in_zip_read_info->bstream.total_out_lo32; -- -- if (err==BZ_STREAM_END) -- return (iRead==0) ? UNZ_EOF : iRead; -- if (err!=BZ_OK) -- break; --#endif -- } // end Z_BZIP2ED -- else -- { -- ZPOS64_T uTotalOutBefore,uTotalOutAfter; -- const Bytef *bufBefore; -- ZPOS64_T uOutThis; -- int flush=Z_SYNC_FLUSH; -- -- uTotalOutBefore = pfile_in_zip_read_info->stream.total_out; -- bufBefore = pfile_in_zip_read_info->stream.next_out; -- -- /* -- if ((pfile_in_zip_read_info->rest_read_uncompressed == -- pfile_in_zip_read_info->stream.avail_out) && -- (pfile_in_zip_read_info->rest_read_compressed == 0)) -- flush = Z_FINISH; -- */ -- err=inflate(&pfile_in_zip_read_info->stream,flush); -- -- if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL)) -- err = Z_DATA_ERROR; -- -- uTotalOutAfter = pfile_in_zip_read_info->stream.total_out; -- uOutThis = uTotalOutAfter-uTotalOutBefore; -- -- pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis; -- -- pfile_in_zip_read_info->crc32 = -- crc32(pfile_in_zip_read_info->crc32,bufBefore, -- (uInt)(uOutThis)); -- -- pfile_in_zip_read_info->rest_read_uncompressed -= -- uOutThis; -- -- iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); -- -- if (err==Z_STREAM_END) -- return (iRead==0) ? UNZ_EOF : iRead; -- if (err!=Z_OK) -- break; -- } -- } -- -- if (err==Z_OK) -- return iRead; -- return err; --} -- -- --/* -- Give the current position in uncompressed data --*/ --extern z_off_t ZEXPORT unztell (unzFile file) --{ -- unz64_s* s; -- file_in_zip64_read_info_s* pfile_in_zip_read_info; -- if (file==NULL) -- return UNZ_PARAMERROR; -- s=(unz64_s*)file; -- pfile_in_zip_read_info=s->pfile_in_zip_read; -- -- if (pfile_in_zip_read_info==NULL) -- return UNZ_PARAMERROR; -- -- return (z_off_t)pfile_in_zip_read_info->stream.total_out; --} -- --extern ZPOS64_T ZEXPORT unztell64 (unzFile file) --{ -- -- unz64_s* s; -- file_in_zip64_read_info_s* pfile_in_zip_read_info; -- if (file==NULL) -- return (ZPOS64_T)-1; -- s=(unz64_s*)file; -- pfile_in_zip_read_info=s->pfile_in_zip_read; -- -- if (pfile_in_zip_read_info==NULL) -- return (ZPOS64_T)-1; -- -- return pfile_in_zip_read_info->total_out_64; --} -- -- --/* -- return 1 if the end of file was reached, 0 elsewhere --*/ --extern int ZEXPORT unzeof (unzFile file) --{ -- unz64_s* s; -- file_in_zip64_read_info_s* pfile_in_zip_read_info; -- if (file==NULL) -- return UNZ_PARAMERROR; -- s=(unz64_s*)file; -- pfile_in_zip_read_info=s->pfile_in_zip_read; -- -- if (pfile_in_zip_read_info==NULL) -- return UNZ_PARAMERROR; -- -- if (pfile_in_zip_read_info->rest_read_uncompressed == 0) -- return 1; -- else -- return 0; --} -- -- -- --/* --Read extra field from the current file (opened by unzOpenCurrentFile) --This is the local-header version of the extra field (sometimes, there is --more info in the local-header version than in the central-header) -- -- if buf==NULL, it return the size of the local extra field that can be read -- -- if buf!=NULL, len is the size of the buffer, the extra header is copied in -- buf. -- the return value is the number of bytes copied in buf, or (if <0) -- the error code --*/ --extern int ZEXPORT unzGetLocalExtrafield (unzFile file, voidp buf, unsigned len) --{ -- unz64_s* s; -- file_in_zip64_read_info_s* pfile_in_zip_read_info; -- uInt read_now; -- ZPOS64_T size_to_read; -- -- if (file==NULL) -- return UNZ_PARAMERROR; -- s=(unz64_s*)file; -- pfile_in_zip_read_info=s->pfile_in_zip_read; -- -- if (pfile_in_zip_read_info==NULL) -- return UNZ_PARAMERROR; -- -- size_to_read = (pfile_in_zip_read_info->size_local_extrafield - -- pfile_in_zip_read_info->pos_local_extrafield); -- -- if (buf==NULL) -- return (int)size_to_read; -- -- if (len>size_to_read) -- read_now = (uInt)size_to_read; -- else -- read_now = (uInt)len ; -- -- if (read_now==0) -- return 0; -- -- if (ZSEEK64(pfile_in_zip_read_info->z_filefunc, -- pfile_in_zip_read_info->filestream, -- pfile_in_zip_read_info->offset_local_extrafield + -- pfile_in_zip_read_info->pos_local_extrafield, -- ZLIB_FILEFUNC_SEEK_SET)!=0) -- return UNZ_ERRNO; -- -- if (ZREAD64(pfile_in_zip_read_info->z_filefunc, -- pfile_in_zip_read_info->filestream, -- buf,read_now)!=read_now) -- return UNZ_ERRNO; -- -- return (int)read_now; --} -- --/* -- Close the file in zip opened with unzipOpenCurrentFile -- Return UNZ_CRCERROR if all the file was read but the CRC is not good --*/ --extern int ZEXPORT unzCloseCurrentFile (unzFile file) --{ -- int err=UNZ_OK; -- -- unz64_s* s; -- file_in_zip64_read_info_s* pfile_in_zip_read_info; -- if (file==NULL) -- return UNZ_PARAMERROR; -- s=(unz64_s*)file; -- pfile_in_zip_read_info=s->pfile_in_zip_read; -- -- if (pfile_in_zip_read_info==NULL) -- return UNZ_PARAMERROR; -- -- -- if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) && -- (!pfile_in_zip_read_info->raw)) -- { -- if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait) -- err=UNZ_CRCERROR; -- } -- -- -- TRYFREE(pfile_in_zip_read_info->read_buffer); -- pfile_in_zip_read_info->read_buffer = NULL; -- if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED) -- inflateEnd(&pfile_in_zip_read_info->stream); --#ifdef HAVE_BZIP2 -- else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED) -- BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream); --#endif -- -- -- pfile_in_zip_read_info->stream_initialised = 0; -- TRYFREE(pfile_in_zip_read_info); -- -- s->pfile_in_zip_read=NULL; -- -- return err; --} -- -- --/* -- Get the global comment string of the ZipFile, in the szComment buffer. -- uSizeBuf is the size of the szComment buffer. -- return the number of byte copied or an error code <0 --*/ --extern int ZEXPORT unzGetGlobalComment (unzFile file, char * szComment, uLong uSizeBuf) --{ -- unz64_s* s; -- uLong uReadThis ; -- if (file==NULL) -- return (int)UNZ_PARAMERROR; -- s=(unz64_s*)file; -- -- uReadThis = uSizeBuf; -- if (uReadThis>s->gi.size_comment) -- uReadThis = s->gi.size_comment; -- -- if (ZSEEK64(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0) -- return UNZ_ERRNO; -- -- if (uReadThis>0) -- { -- *szComment='\0'; -- if (ZREAD64(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis) -- return UNZ_ERRNO; -- } -- -- if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment)) -- *(szComment+s->gi.size_comment)='\0'; -- return (int)uReadThis; --} -- --/* Additions by RX '2004 */ --extern ZPOS64_T ZEXPORT unzGetOffset64(unzFile file) --{ -- unz64_s* s; -- -- if (file==NULL) -- return 0; //UNZ_PARAMERROR; -- s=(unz64_s*)file; -- if (!s->current_file_ok) -- return 0; -- if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff) -- if (s->num_file==s->gi.number_entry) -- return 0; -- return s->pos_in_central_dir; --} -- --extern uLong ZEXPORT unzGetOffset (unzFile file) --{ -- ZPOS64_T offset64; -- -- if (file==NULL) -- return 0; //UNZ_PARAMERROR; -- offset64 = unzGetOffset64(file); -- return (uLong)offset64; --} -- --extern int ZEXPORT unzSetOffset64(unzFile file, ZPOS64_T pos) --{ -- unz64_s* s; -- int err; -- -- if (file==NULL) -- return UNZ_PARAMERROR; -- s=(unz64_s*)file; -- -- s->pos_in_central_dir = pos; -- s->num_file = s->gi.number_entry; /* hack */ -- 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; --} -- --extern int ZEXPORT unzSetOffset (unzFile file, uLong pos) --{ -- return unzSetOffset64(file,pos); --} -diff --git a/thirdparty/minizip/unzip.h b/thirdparty/minizip/unzip.h -deleted file mode 100644 -index 3183968..0000000 ---- a/thirdparty/minizip/unzip.h -+++ /dev/null -@@ -1,437 +0,0 @@ --/* unzip.h -- 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 -- -- --------------------------------------------------------------------------------- -- -- Condition of use and distribution are the same than zlib : -- -- This software is provided 'as-is', without any express or implied -- warranty. In no event will the authors be held liable for any damages -- arising from the use of this software. -- -- Permission is granted to anyone to use this software for any purpose, -- including commercial applications, and to alter it and redistribute it -- freely, subject to the following restrictions: -- -- 1. The origin of this software must not be misrepresented; you must not -- claim that you wrote the original software. If you use this software -- in a product, an acknowledgment in the product documentation would be -- appreciated but is not required. -- 2. Altered source versions must be plainly marked as such, and must not be -- misrepresented as being the original software. -- 3. This notice may not be removed or altered from any source distribution. -- -- --------------------------------------------------------------------------------- -- -- Changes -- -- See header of unzip64.c -- --*/ -- --#ifndef _unz64_H --#define _unz64_H -- --#ifdef __cplusplus --extern "C" { --#endif -- --#ifndef _ZLIB_H --#include "zlib.h" --#endif -- --#ifndef _ZLIBIOAPI_H --#include "ioapi.h" --#endif -- --#ifdef HAVE_BZIP2 --#include "bzlib.h" --#endif -- --#define Z_BZIP2ED 12 -- --#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP) --/* like the STRICT of WIN32, we define a pointer that cannot be converted -- from (void*) without cast */ --typedef struct TagunzFile__ { int unused; } unzFile__; --typedef unzFile__ *unzFile; --#else --typedef voidp unzFile; --#endif -- -- --#define UNZ_OK (0) --#define UNZ_END_OF_LIST_OF_FILE (-100) --#define UNZ_ERRNO (Z_ERRNO) --#define UNZ_EOF (0) --#define UNZ_PARAMERROR (-102) --#define UNZ_BADZIPFILE (-103) --#define UNZ_INTERNALERROR (-104) --#define UNZ_CRCERROR (-105) -- --/* tm_unz contain date/time info */ --typedef struct tm_unz_s --{ -- uInt tm_sec; /* seconds after the minute - [0,59] */ -- uInt tm_min; /* minutes after the hour - [0,59] */ -- uInt tm_hour; /* hours since midnight - [0,23] */ -- uInt tm_mday; /* day of the month - [1,31] */ -- uInt tm_mon; /* months since January - [0,11] */ -- uInt tm_year; /* years - [1980..2044] */ --} tm_unz; -- --/* unz_global_info structure contain global data about the ZIPfile -- These data comes from the end of central dir */ --typedef struct unz_global_info64_s --{ -- ZPOS64_T number_entry; /* total number of entries in -- the central dir on this disk */ -- uLong size_comment; /* size of the global comment of the zipfile */ --} unz_global_info64; -- --typedef struct unz_global_info_s --{ -- uLong number_entry; /* total number of entries in -- the central dir on this disk */ -- uLong size_comment; /* size of the global comment of the zipfile */ --} unz_global_info; -- --/* unz_file_info contain information about a file in the zipfile */ --typedef struct unz_file_info64_s --{ -- uLong version; /* version made by 2 bytes */ -- uLong version_needed; /* version needed to extract 2 bytes */ -- uLong flag; /* general purpose bit flag 2 bytes */ -- uLong compression_method; /* compression method 2 bytes */ -- uLong dosDate; /* last mod file date in Dos fmt 4 bytes */ -- uLong crc; /* crc-32 4 bytes */ -- ZPOS64_T compressed_size; /* compressed size 8 bytes */ -- ZPOS64_T uncompressed_size; /* uncompressed size 8 bytes */ -- uLong size_filename; /* filename length 2 bytes */ -- uLong size_file_extra; /* extra field length 2 bytes */ -- uLong size_file_comment; /* file comment length 2 bytes */ -- -- uLong disk_num_start; /* disk number start 2 bytes */ -- uLong internal_fa; /* internal file attributes 2 bytes */ -- uLong external_fa; /* external file attributes 4 bytes */ -- -- tm_unz tmu_date; --} unz_file_info64; -- --typedef struct unz_file_info_s --{ -- uLong version; /* version made by 2 bytes */ -- uLong version_needed; /* version needed to extract 2 bytes */ -- uLong flag; /* general purpose bit flag 2 bytes */ -- uLong compression_method; /* compression method 2 bytes */ -- uLong dosDate; /* last mod file date in Dos fmt 4 bytes */ -- uLong crc; /* crc-32 4 bytes */ -- uLong compressed_size; /* compressed size 4 bytes */ -- uLong uncompressed_size; /* uncompressed size 4 bytes */ -- uLong size_filename; /* filename length 2 bytes */ -- uLong size_file_extra; /* extra field length 2 bytes */ -- uLong size_file_comment; /* file comment length 2 bytes */ -- -- uLong disk_num_start; /* disk number start 2 bytes */ -- uLong internal_fa; /* internal file attributes 2 bytes */ -- uLong external_fa; /* external file attributes 4 bytes */ -- -- tm_unz tmu_date; --} unz_file_info; -- --extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1, -- const char* fileName2, -- int iCaseSensitivity)); --/* -- 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 unzFile ZEXPORT unzOpen OF((const char *path)); --extern unzFile ZEXPORT unzOpen64 OF((const void *path)); --/* -- Open a Zip file. path contain the full pathname (by example, -- on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer -- "zlib/zlib113.zip". -- If the zipfile cannot be opened (file don'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. -- the "64" function take a const void* pointer, because the path is just the -- value passed to the open64_file_func callback. -- Under Windows, if UNICODE is defined, using fill_fopen64_filefunc, the path -- is a pointer to a wide unicode string (LPCTSTR is LPCWSTR), so const char* -- does not describe the reality --*/ -- -- --extern unzFile ZEXPORT unzOpen2 OF((const char *path, -- zlib_filefunc_def* pzlib_filefunc_def)); --/* -- Open a Zip file, like unzOpen, but provide a set of file low level API -- for read/write the zip file (see ioapi.h) --*/ -- --extern unzFile ZEXPORT unzOpen2_64 OF((const void *path, -- zlib_filefunc64_def* pzlib_filefunc_def)); --/* -- Open a Zip file, like unz64Open, but provide a set of file low level API -- for read/write the zip file (see ioapi.h) --*/ -- --extern int ZEXPORT unzClose OF((unzFile file)); --/* -- Close a ZipFile opened with unzipOpen. -- If there is files inside the .Zip opened with unzOpenCurrentFile (see later), -- these files MUST be closed with unzipCloseCurrentFile before call unzipClose. -- return UNZ_OK if there is no problem. */ -- --extern int ZEXPORT unzGetGlobalInfo OF((unzFile file, -- unz_global_info *pglobal_info)); -- --extern int ZEXPORT unzGetGlobalInfo64 OF((unzFile file, -- unz_global_info64 *pglobal_info)); --/* -- 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 unzGetGlobalComment OF((unzFile file, -- char *szComment, -- uLong uSizeBuf)); --/* -- Get the global comment string of the ZipFile, in the szComment buffer. -- uSizeBuf is the size of the szComment buffer. -- return the number of byte copied or an error code <0 --*/ -- -- --/***************************************************************************/ --/* Unzip package allow you browse the directory of the zipfile */ -- --extern int ZEXPORT unzGoToFirstFile OF((unzFile file)); --/* -- Set the current file of the zipfile to the first file. -- return UNZ_OK if there is no problem --*/ -- --extern int ZEXPORT unzGoToNextFile OF((unzFile file)); --/* -- 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 unzLocateFile OF((unzFile file, -- const char *szFileName, -- int iCaseSensitivity)); --/* -- 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 --*/ -- -- --/* ****************************************** */ --/* Ryan supplied functions */ --/* unz_file_info contain information about a file in the zipfile */ --typedef struct unz_file_pos_s --{ -- uLong pos_in_zip_directory; /* offset in zip file directory */ -- uLong num_of_file; /* # of file */ --} unz_file_pos; -- --extern int ZEXPORT unzGetFilePos( -- unzFile file, -- unz_file_pos* file_pos); -- --extern int ZEXPORT unzGoToFilePos( -- unzFile file, -- unz_file_pos* file_pos); -- --typedef struct unz64_file_pos_s --{ -- ZPOS64_T pos_in_zip_directory; /* offset in zip file directory */ -- ZPOS64_T num_of_file; /* # of file */ --} unz64_file_pos; -- --extern int ZEXPORT unzGetFilePos64( -- unzFile file, -- unz64_file_pos* file_pos); -- --extern int ZEXPORT unzGoToFilePos64( -- unzFile file, -- const unz64_file_pos* file_pos); -- --/* ****************************************** */ -- --extern int ZEXPORT unzGetCurrentFileInfo64 OF((unzFile file, -- unz_file_info64 *pfile_info, -- char *szFileName, -- uLong fileNameBufferSize, -- void *extraField, -- uLong extraFieldBufferSize, -- char *szComment, -- uLong commentBufferSize)); -- --extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file, -- unz_file_info *pfile_info, -- char *szFileName, -- uLong fileNameBufferSize, -- void *extraField, -- uLong extraFieldBufferSize, -- char *szComment, -- uLong commentBufferSize)); --/* -- Get Info about the current file -- if pfile_info!=NULL, the *pfile_info structure will contain somes info about -- the current file -- if szFileName!=NULL, the filemane string will be copied in szFileName -- (fileNameBufferSize is the size of the buffer) -- if extraField!=NULL, the extra field information will be copied in extraField -- (extraFieldBufferSize is the size of the buffer). -- This is the Central-header version of the extra field -- if szComment!=NULL, the comment string of the file will be copied in szComment -- (commentBufferSize is the size of the buffer) --*/ -- -- --/** Addition for GDAL : START */ -- --extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64 OF((unzFile file)); -- --/** Addition for GDAL : END */ -- -- --/***************************************************************************/ --/* for reading the content of the current zipfile, you can open it, read data -- from it, and close it (you can close it before reading all the file) -- */ -- --extern int ZEXPORT unzOpenCurrentFile OF((unzFile file)); --/* -- Open for reading data the current file in the zipfile. -- If there is no error, the return value is UNZ_OK. --*/ -- --extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file, -- const char* password)); --/* -- Open for reading data the current file in the zipfile. -- password is a crypting password -- If there is no error, the return value is UNZ_OK. --*/ -- --extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file, -- int* method, -- int* level, -- int raw)); --/* -- Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) -- if raw==1 -- *method will receive method of compression, *level will receive level of -- compression -- note : you can set level parameter as NULL (if you did not want known level, -- but you CANNOT set method parameter as NULL --*/ -- --extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file, -- int* method, -- int* level, -- int raw, -- const char* password)); --/* -- Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) -- if raw==1 -- *method will receive method of compression, *level will receive level of -- compression -- note : you can set level parameter as NULL (if you did not want known level, -- but you CANNOT set method parameter as NULL --*/ -- -- --extern int ZEXPORT unzCloseCurrentFile OF((unzFile file)); --/* -- Close the file in zip opened with unzOpenCurrentFile -- Return UNZ_CRCERROR if all the file was read but the CRC is not good --*/ -- --extern int ZEXPORT unzReadCurrentFile OF((unzFile file, -- voidp buf, -- unsigned len)); --/* -- Read bytes from the current file (opened by unzOpenCurrentFile) -- buf contain buffer where data must be copied -- len the size of buf. -- -- return the number of byte copied if somes bytes are copied -- return 0 if the end of file was reached -- return <0 with error code if there is an error -- (UNZ_ERRNO for IO error, or zLib error for uncompress error) --*/ -- --extern z_off_t ZEXPORT unztell OF((unzFile file)); -- --extern ZPOS64_T ZEXPORT unztell64 OF((unzFile file)); --/* -- Give the current position in uncompressed data --*/ -- --extern int ZEXPORT unzeof OF((unzFile file)); --/* -- return 1 if the end of file was reached, 0 elsewhere --*/ -- --extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file, -- voidp buf, -- unsigned len)); --/* -- Read extra field from the current file (opened by unzOpenCurrentFile) -- This is the local-header version of the extra field (sometimes, there is -- more info in the local-header version than in the central-header) -- -- if buf==NULL, it return the size of the local extra field -- -- if buf!=NULL, len is the size of the buffer, the extra header is copied in -- buf. -- the return value is the number of bytes copied in buf, or (if <0) -- the error code --*/ -- --/***************************************************************************/ -- --/* Get the current file offset */ --extern ZPOS64_T ZEXPORT unzGetOffset64 (unzFile file); --extern uLong ZEXPORT unzGetOffset (unzFile file); -- --/* Set the current file offset */ --extern int ZEXPORT unzSetOffset64 (unzFile file, ZPOS64_T pos); --extern int ZEXPORT unzSetOffset (unzFile file, uLong pos); -- -- -- --#ifdef __cplusplus --} --#endif -- --#endif /* _unz64_H */ -diff --git a/thirdparty/minizip/zip.c b/thirdparty/minizip/zip.c -deleted file mode 100644 -index 3c34fc8..0000000 ---- a/thirdparty/minizip/zip.c -+++ /dev/null -@@ -1,2004 +0,0 @@ --/* zip.c -- IO on .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 for Zip64 support -- Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) -- -- For more info read MiniZip_info.txt -- -- Changes -- Oct-2009 - Mathias Svensson - Remove old C style function prototypes -- Oct-2009 - Mathias Svensson - Added Zip64 Support when creating new file archives -- Oct-2009 - Mathias Svensson - Did some code cleanup and refactoring to get better overview of some functions. -- Oct-2009 - Mathias Svensson - Added zipRemoveExtraInfoBlock to strip extra field data from its ZIP64 data -- It is used when recreting zip archive with RAW when deleting items from a zip. -- ZIP64 data is automaticly added to items that needs it, and existing ZIP64 data need to be removed. -- Oct-2009 - Mathias Svensson - Added support for BZIP2 as compression mode (bzip2 lib is required) -- Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer -- --*/ -- -- --#include --#include --#include --#include --#include "zlib.h" --#include "zip.h" -- --#ifdef STDC --# include --# include --# include --#endif --#ifdef NO_ERRNO_H -- extern int errno; --#else --# include --#endif -- -- --#ifndef local --# define local static --#endif --/* compile with -Dlocal if your debugger can't find static symbols */ -- --#ifndef VERSIONMADEBY --# define VERSIONMADEBY (0x0) /* platform depedent */ --#endif -- --#ifndef Z_BUFSIZE --#define Z_BUFSIZE (64*1024) //(16384) --#endif -- --#ifndef Z_MAXFILENAMEINZIP --#define Z_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) --*/ -- --/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ -- -- --// NOT sure that this work on ALL platform --#define MAKEULONG64(a, b) ((ZPOS64_T)(((unsigned long)(a)) | ((ZPOS64_T)((unsigned long)(b))) << 32)) -- --#ifndef SEEK_CUR --#define SEEK_CUR 1 --#endif -- --#ifndef SEEK_END --#define SEEK_END 2 --#endif -- --#ifndef SEEK_SET --#define SEEK_SET 0 --#endif -- --#ifndef DEF_MEM_LEVEL --#if MAX_MEM_LEVEL >= 8 --# define DEF_MEM_LEVEL 8 --#else --# define DEF_MEM_LEVEL MAX_MEM_LEVEL --#endif --#endif --const char zip_copyright[] =" zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; -- -- --#define SIZEDATA_INDATABLOCK (4096-(4*4)) -- --#define LOCALHEADERMAGIC (0x04034b50) --#define CENTRALHEADERMAGIC (0x02014b50) --#define ENDHEADERMAGIC (0x06054b50) --#define ZIP64ENDHEADERMAGIC (0x6064b50) --#define ZIP64ENDLOCHEADERMAGIC (0x7064b50) -- --#define FLAG_LOCALHEADER_OFFSET (0x06) --#define CRC_LOCALHEADER_OFFSET (0x0e) -- --#define SIZECENTRALHEADER (0x2e) /* 46 */ -- --typedef struct linkedlist_datablock_internal_s --{ -- struct linkedlist_datablock_internal_s* next_datablock; -- uLong avail_in_this_block; -- uLong filled_in_this_block; -- uLong unused; /* for future use and alignement */ -- unsigned char data[SIZEDATA_INDATABLOCK]; --} linkedlist_datablock_internal; -- --typedef struct linkedlist_data_s --{ -- linkedlist_datablock_internal* first_block; -- linkedlist_datablock_internal* last_block; --} linkedlist_data; -- -- --typedef struct --{ -- z_stream stream; /* zLib stream structure for inflate */ --#ifdef HAVE_BZIP2 -- bz_stream bstream; /* bzLib stream structure for bziped */ --#endif -- -- int stream_initialised; /* 1 is stream is initialised */ -- uInt pos_in_buffered_data; /* last written byte in buffered_data */ -- -- ZPOS64_T pos_local_header; /* offset of the local header of the file -- currenty writing */ -- char* central_header; /* central header data for the current file */ -- uLong size_centralExtra; -- uLong size_centralheader; /* size of the central header for cur file */ -- uLong size_centralExtraFree; /* Extra bytes allocated to the centralheader but that are not used */ -- uLong flag; /* flag of the file currently writing */ -- -- int method; /* compression method of file currenty wr.*/ -- int raw; /* 1 for directly writing raw data */ -- Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/ -- uLong dosDate; -- uLong crc32; -- int encrypt; -- int zip64; /* Add ZIP64 extened information in the extra field */ -- ZPOS64_T pos_zip64extrainfo; -- ZPOS64_T totalCompressedData; -- ZPOS64_T totalUncompressedData; --#ifndef NOCRYPT -- unsigned long keys[3]; /* keys defining the pseudo-random sequence */ -- const unsigned long* pcrc_32_tab; -- int crypt_header_size; --#endif --} curfile64_info; -- --typedef struct --{ -- zlib_filefunc64_32_def z_filefunc; -- voidpf filestream; /* io structore of the zipfile */ -- linkedlist_data central_dir;/* datablock with central dir in construction*/ -- int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/ -- curfile64_info ci; /* info on the file curretly writing */ -- -- ZPOS64_T begin_pos; /* position of the beginning of the zipfile */ -- ZPOS64_T add_position_when_writting_offset; -- ZPOS64_T number_entry; -- --#ifndef NO_ADDFILEINEXISTINGZIP -- char *globalcomment; --#endif -- --} zip64_internal; -- -- --#ifndef NOCRYPT --#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED --#include "crypt.h" --#endif -- --local linkedlist_datablock_internal* allocate_new_datablock() --{ -- linkedlist_datablock_internal* ldi; -- ldi = (linkedlist_datablock_internal*) -- ALLOC(sizeof(linkedlist_datablock_internal)); -- if (ldi!=NULL) -- { -- ldi->next_datablock = NULL ; -- ldi->filled_in_this_block = 0 ; -- ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ; -- } -- return ldi; --} -- --local void free_datablock(linkedlist_datablock_internal* ldi) --{ -- while (ldi!=NULL) -- { -- linkedlist_datablock_internal* ldinext = ldi->next_datablock; -- TRYFREE(ldi); -- ldi = ldinext; -- } --} -- --local void init_linkedlist(linkedlist_data* ll) --{ -- ll->first_block = ll->last_block = NULL; --} -- --local void free_linkedlist(linkedlist_data* ll) --{ -- free_datablock(ll->first_block); -- ll->first_block = ll->last_block = NULL; --} -- -- --local int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len) --{ -- linkedlist_datablock_internal* ldi; -- const unsigned char* from_copy; -- -- if (ll==NULL) -- return ZIP_INTERNALERROR; -- -- if (ll->last_block == NULL) -- { -- ll->first_block = ll->last_block = allocate_new_datablock(); -- if (ll->first_block == NULL) -- return ZIP_INTERNALERROR; -- } -- -- ldi = ll->last_block; -- from_copy = (unsigned char*)buf; -- -- while (len>0) -- { -- uInt copy_this; -- uInt i; -- unsigned char* to_copy; -- -- if (ldi->avail_in_this_block==0) -- { -- ldi->next_datablock = allocate_new_datablock(); -- if (ldi->next_datablock == NULL) -- return ZIP_INTERNALERROR; -- ldi = ldi->next_datablock ; -- ll->last_block = ldi; -- } -- -- if (ldi->avail_in_this_block < len) -- copy_this = (uInt)ldi->avail_in_this_block; -- else -- copy_this = (uInt)len; -- -- to_copy = &(ldi->data[ldi->filled_in_this_block]); -- -- for (i=0;ifilled_in_this_block += copy_this; -- ldi->avail_in_this_block -= copy_this; -- from_copy += copy_this ; -- len -= copy_this; -- } -- return ZIP_OK; --} -- -- -- --/****************************************************************************/ -- --#ifndef NO_ADDFILEINEXISTINGZIP --/* =========================================================================== -- Inputs a long in LSB order to the given file -- nbByte == 1, 2 ,4 or 8 (byte, short or long, ZPOS64_T) --*/ -- --local int zip64local_putValue OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte)); --local int zip64local_putValue (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte) --{ -- unsigned char buf[8]; -- int n; -- for (n = 0; n < nbByte; n++) -- { -- buf[n] = (unsigned char)(x & 0xff); -- x >>= 8; -- } -- if (x != 0) -- { /* data overflow - hack for ZIP64 (X Roche) */ -- for (n = 0; n < nbByte; n++) -- { -- buf[n] = 0xff; -- } -- } -- -- if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte) -- return ZIP_ERRNO; -- else -- return ZIP_OK; --} -- --local void zip64local_putValue_inmemory OF((void* dest, ZPOS64_T x, int nbByte)); --local void zip64local_putValue_inmemory (void* dest, ZPOS64_T x, int nbByte) --{ -- unsigned char* buf=(unsigned char*)dest; -- int n; -- for (n = 0; n < nbByte; n++) { -- buf[n] = (unsigned char)(x & 0xff); -- x >>= 8; -- } -- -- if (x != 0) -- { /* data overflow - hack for ZIP64 */ -- for (n = 0; n < nbByte; n++) -- { -- buf[n] = 0xff; -- } -- } --} -- --/****************************************************************************/ -- -- --local uLong zip64local_TmzDateToDosDate(const tm_zip* ptm) --{ -- uLong year = (uLong)ptm->tm_year; -- if (year>=1980) -- year-=1980; -- else if (year>=80) -- year-=80; -- return -- (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) | -- ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour)); --} -- -- --/****************************************************************************/ -- --local int zip64local_getByte OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi)); -- --local int zip64local_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 ZIP_OK; -- } -- else -- { -- if (ZERROR64(*pzlib_filefunc_def,filestream)) -- return ZIP_ERRNO; -- else -- return ZIP_EOF; -- } --} -- -- --/* =========================================================================== -- Reads a long in LSB order from the given gz_stream. Sets --*/ --local int zip64local_getShort OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX)); -- --local int zip64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX) --{ -- uLong x ; -- int i = 0; -- int err; -- -- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); -- x = (uLong)i; -- -- if (err==ZIP_OK) -- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); -- x += ((uLong)i)<<8; -- -- if (err==ZIP_OK) -- *pX = x; -- else -- *pX = 0; -- return err; --} -- --local int zip64local_getLong OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX)); -- --local int zip64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX) --{ -- uLong x ; -- int i = 0; -- int err; -- -- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); -- x = (uLong)i; -- -- if (err==ZIP_OK) -- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); -- x += ((uLong)i)<<8; -- -- if (err==ZIP_OK) -- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); -- x += ((uLong)i)<<16; -- -- if (err==ZIP_OK) -- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); -- x += ((uLong)i)<<24; -- -- if (err==ZIP_OK) -- *pX = x; -- else -- *pX = 0; -- return err; --} -- --local int zip64local_getLong64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX)); -- -- --local int zip64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX) --{ -- ZPOS64_T x; -- int i = 0; -- int err; -- -- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); -- x = (ZPOS64_T)i; -- -- if (err==ZIP_OK) -- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); -- x += ((ZPOS64_T)i)<<8; -- -- if (err==ZIP_OK) -- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); -- x += ((ZPOS64_T)i)<<16; -- -- if (err==ZIP_OK) -- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); -- x += ((ZPOS64_T)i)<<24; -- -- if (err==ZIP_OK) -- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); -- x += ((ZPOS64_T)i)<<32; -- -- if (err==ZIP_OK) -- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); -- x += ((ZPOS64_T)i)<<40; -- -- if (err==ZIP_OK) -- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); -- x += ((ZPOS64_T)i)<<48; -- -- if (err==ZIP_OK) -- err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); -- x += ((ZPOS64_T)i)<<56; -- -- if (err==ZIP_OK) -- *pX = x; -- else -- *pX = 0; -- -- return err; --} -- --#ifndef BUFREADCOMMENT --#define BUFREADCOMMENT (0x400) --#endif --/* -- Locate the Central directory of a zipfile (at the end, just before -- the global comment) --*/ --local ZPOS64_T zip64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)); -- --local ZPOS64_T zip64local_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 (uBackReaduMaxBack) -- 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 End of Zip64 Central directory locator and from there find the CD of a zipfile (at the end, just before --the global comment) --*/ --local ZPOS64_T zip64local_SearchCentralDir64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)); -- --local ZPOS64_T zip64local_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 (uBackReaduMaxBack) -- 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;) -- { -- // Signature "0x07064b50" Zip64 end of central directory locater -- 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 (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) -- return 0; -- -- /* number of the disk with the start of the zip64 end of central directory */ -- if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) -- return 0; -- if (uL != 0) -- return 0; -- -- /* relative offset of the zip64 end of central directory record */ -- if (zip64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=ZIP_OK) -- return 0; -- -- /* total number of disks */ -- if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) -- return 0; -- if (uL != 1) -- return 0; -- -- /* Goto Zip64 end of central directory record */ -- if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0) -- return 0; -- -- /* the signature */ -- if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) -- return 0; -- -- if (uL != 0x06064b50) // signature of 'Zip64 end of central directory' -- return 0; -- -- return relativeOffset; --} -- --int LoadCentralDirectoryRecord(zip64_internal* pziinit) --{ -- int err=ZIP_OK; -- ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ -- -- ZPOS64_T size_central_dir; /* size of the central directory */ -- ZPOS64_T offset_central_dir; /* offset of start of central directory */ -- 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; -- ZPOS64_T number_entry_CD; /* total number of entries in -- the central dir -- (same than number_entry on nospan) */ -- uLong VersionMadeBy; -- uLong VersionNeeded; -- uLong size_comment; -- -- int hasZIP64Record = 0; -- -- // check first if we find a ZIP64 record -- central_pos = zip64local_SearchCentralDir64(&pziinit->z_filefunc,pziinit->filestream); -- if(central_pos > 0) -- { -- hasZIP64Record = 1; -- } -- else if(central_pos == 0) -- { -- central_pos = zip64local_SearchCentralDir(&pziinit->z_filefunc,pziinit->filestream); -- } -- --/* disable to allow appending to empty ZIP archive -- if (central_pos==0) -- err=ZIP_ERRNO; --*/ -- -- if(hasZIP64Record) -- { -- ZPOS64_T sizeEndOfCentralDirectory; -- if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) -- err=ZIP_ERRNO; -- -- /* the signature, already checked */ -- if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK) -- err=ZIP_ERRNO; -- -- /* size of zip64 end of central directory record */ -- if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &sizeEndOfCentralDirectory)!=ZIP_OK) -- err=ZIP_ERRNO; -- -- /* version made by */ -- if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionMadeBy)!=ZIP_OK) -- err=ZIP_ERRNO; -- -- /* version needed to extract */ -- if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionNeeded)!=ZIP_OK) -- err=ZIP_ERRNO; -- -- /* number of this disk */ -- if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK) -- err=ZIP_ERRNO; -- -- /* number of the disk with the start of the central directory */ -- if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK) -- err=ZIP_ERRNO; -- -- /* total number of entries in the central directory on this disk */ -- if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &number_entry)!=ZIP_OK) -- err=ZIP_ERRNO; -- -- /* total number of entries in the central directory */ -- if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&number_entry_CD)!=ZIP_OK) -- err=ZIP_ERRNO; -- -- if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0)) -- err=ZIP_BADZIPFILE; -- -- /* size of the central directory */ -- if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&size_central_dir)!=ZIP_OK) -- err=ZIP_ERRNO; -- -- /* offset of start of central directory with respect to the -- starting disk number */ -- if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&offset_central_dir)!=ZIP_OK) -- err=ZIP_ERRNO; -- -- // TODO.. -- // read the comment from the standard central header. -- size_comment = 0; -- } -- else -- { -- // Read End of central Directory info -- if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) -- err=ZIP_ERRNO; -- -- /* the signature, already checked */ -- if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK) -- err=ZIP_ERRNO; -- -- /* number of this disk */ -- if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK) -- err=ZIP_ERRNO; -- -- /* number of the disk with the start of the central directory */ -- if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK) -- err=ZIP_ERRNO; -- -- /* total number of entries in the central dir on this disk */ -- number_entry = 0; -- if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) -- err=ZIP_ERRNO; -- else -- number_entry = uL; -- -- /* total number of entries in the central dir */ -- number_entry_CD = 0; -- if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) -- err=ZIP_ERRNO; -- else -- number_entry_CD = uL; -- -- if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0)) -- err=ZIP_BADZIPFILE; -- -- /* size of the central directory */ -- size_central_dir = 0; -- if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) -- err=ZIP_ERRNO; -- else -- size_central_dir = uL; -- -- /* offset of start of central directory with respect to the starting disk number */ -- offset_central_dir = 0; -- if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) -- err=ZIP_ERRNO; -- else -- offset_central_dir = uL; -- -- -- /* zipfile global comment length */ -- if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &size_comment)!=ZIP_OK) -- err=ZIP_ERRNO; -- } -- -- if ((central_posz_filefunc, pziinit->filestream); -- return ZIP_ERRNO; -- } -- -- if (size_comment>0) -- { -- pziinit->globalcomment = (char*)ALLOC(size_comment+1); -- if (pziinit->globalcomment) -- { -- size_comment = ZREAD64(pziinit->z_filefunc, pziinit->filestream, pziinit->globalcomment,size_comment); -- pziinit->globalcomment[size_comment]=0; -- } -- } -- -- byte_before_the_zipfile = central_pos - (offset_central_dir+size_central_dir); -- pziinit->add_position_when_writting_offset = byte_before_the_zipfile; -- -- { -- ZPOS64_T size_central_dir_to_read = size_central_dir; -- size_t buf_size = SIZEDATA_INDATABLOCK; -- void* buf_read = (void*)ALLOC(buf_size); -- if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0) -- err=ZIP_ERRNO; -- -- while ((size_central_dir_to_read>0) && (err==ZIP_OK)) -- { -- ZPOS64_T read_this = SIZEDATA_INDATABLOCK; -- if (read_this > size_central_dir_to_read) -- read_this = size_central_dir_to_read; -- -- if (ZREAD64(pziinit->z_filefunc, pziinit->filestream,buf_read,(uLong)read_this) != read_this) -- err=ZIP_ERRNO; -- -- if (err==ZIP_OK) -- err = add_data_in_datablock(&pziinit->central_dir,buf_read, (uLong)read_this); -- -- size_central_dir_to_read-=read_this; -- } -- TRYFREE(buf_read); -- } -- pziinit->begin_pos = byte_before_the_zipfile; -- pziinit->number_entry = number_entry_CD; -- -- if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET) != 0) -- err=ZIP_ERRNO; -- -- return err; --} -- -- --#endif /* !NO_ADDFILEINEXISTINGZIP*/ -- -- --/************************************************************/ --extern zipFile ZEXPORT zipOpen3 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_32_def* pzlib_filefunc64_32_def) --{ -- zip64_internal ziinit; -- zip64_internal* zi; -- int err=ZIP_OK; -- -- ziinit.z_filefunc.zseek32_file = NULL; -- ziinit.z_filefunc.ztell32_file = NULL; -- if (pzlib_filefunc64_32_def==NULL) -- fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64); -- else -- ziinit.z_filefunc = *pzlib_filefunc64_32_def; -- -- ziinit.filestream = ZOPEN64(ziinit.z_filefunc, -- pathname, -- (append == APPEND_STATUS_CREATE) ? -- (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) : -- (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING)); -- -- if (ziinit.filestream == NULL) -- return NULL; -- -- if (append == APPEND_STATUS_CREATEAFTER) -- ZSEEK64(ziinit.z_filefunc,ziinit.filestream,0,SEEK_END); -- -- ziinit.begin_pos = ZTELL64(ziinit.z_filefunc,ziinit.filestream); -- ziinit.in_opened_file_inzip = 0; -- ziinit.ci.stream_initialised = 0; -- ziinit.number_entry = 0; -- ziinit.add_position_when_writting_offset = 0; -- init_linkedlist(&(ziinit.central_dir)); -- -- -- -- zi = (zip64_internal*)ALLOC(sizeof(zip64_internal)); -- if (zi==NULL) -- { -- ZCLOSE64(ziinit.z_filefunc,ziinit.filestream); -- return NULL; -- } -- -- /* now we add file in a zipfile */ --# ifndef NO_ADDFILEINEXISTINGZIP -- ziinit.globalcomment = NULL; -- if (append == APPEND_STATUS_ADDINZIP) -- { -- // Read and Cache Central Directory Records -- err = LoadCentralDirectoryRecord(&ziinit); -- } -- -- if (globalcomment) -- { -- *globalcomment = ziinit.globalcomment; -- } --# endif /* !NO_ADDFILEINEXISTINGZIP*/ -- -- if (err != ZIP_OK) -- { --# ifndef NO_ADDFILEINEXISTINGZIP -- TRYFREE(ziinit.globalcomment); --# endif /* !NO_ADDFILEINEXISTINGZIP*/ -- TRYFREE(zi); -- return NULL; -- } -- else -- { -- *zi = ziinit; -- return (zipFile)zi; -- } --} -- --extern zipFile ZEXPORT zipOpen2 (const char *pathname, int append, zipcharpc* globalcomment, 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 zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill); -- } -- else -- return zipOpen3(pathname, append, globalcomment, NULL); --} -- --extern zipFile ZEXPORT zipOpen2_64 (const void *pathname, int append, zipcharpc* globalcomment, 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 zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill); -- } -- else -- return zipOpen3(pathname, append, globalcomment, NULL); --} -- -- -- --extern zipFile ZEXPORT zipOpen (const char* pathname, int append) --{ -- return zipOpen3((const void*)pathname,append,NULL,NULL); --} -- --extern zipFile ZEXPORT zipOpen64 (const void* pathname, int append) --{ -- return zipOpen3(pathname,append,NULL,NULL); --} -- --int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt size_extrafield_local, const void* extrafield_local) --{ -- /* write the local header */ -- int err; -- uInt size_filename = (uInt)strlen(filename); -- uInt size_extrafield = size_extrafield_local; -- -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC, 4); -- -- if (err==ZIP_OK) -- { -- if(zi->ci.zip64) -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);/* version needed to extract */ -- else -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */ -- } -- -- if (err==ZIP_OK) -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2); -- -- if (err==ZIP_OK) -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2); -- -- if (err==ZIP_OK) -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4); -- -- // CRC / Compressed size / Uncompressed size will be filled in later and rewritten later -- if (err==ZIP_OK) -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */ -- if (err==ZIP_OK) -- { -- if(zi->ci.zip64) -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* compressed size, unknown */ -- else -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */ -- } -- if (err==ZIP_OK) -- { -- if(zi->ci.zip64) -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* uncompressed size, unknown */ -- else -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */ -- } -- -- if (err==ZIP_OK) -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2); -- -- if(zi->ci.zip64) -- { -- size_extrafield += 20; -- } -- -- if (err==ZIP_OK) -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield,2); -- -- if ((err==ZIP_OK) && (size_filename > 0)) -- { -- if (ZWRITE64(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename) -- err = ZIP_ERRNO; -- } -- -- if ((err==ZIP_OK) && (size_extrafield_local > 0)) -- { -- if (ZWRITE64(zi->z_filefunc, zi->filestream, extrafield_local, size_extrafield_local) != size_extrafield_local) -- err = ZIP_ERRNO; -- } -- -- -- if ((err==ZIP_OK) && (zi->ci.zip64)) -- { -- // write the Zip64 extended info -- short HeaderID = 1; -- short DataSize = 16; -- ZPOS64_T CompressedSize = 0; -- ZPOS64_T UncompressedSize = 0; -- -- // Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file) -- zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream); -- -- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)HeaderID,2); -- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)DataSize,2); -- -- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8); -- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8); -- } -- -- return err; --} -- --/* -- NOTE. -- When writing RAW the ZIP64 extended information in extrafield_local and extrafield_global needs to be stripped -- before calling this function it can be done with zipRemoveExtraInfoBlock -- -- It is not done here because then we need to realloc a new buffer since parameters are 'const' and I want to minimize -- unnecessary allocations. -- */ --extern int ZEXPORT zipOpenNewFileInZip4_64 (zipFile file, const char* filename, const zip_fileinfo* zipfi, -- const void* extrafield_local, uInt size_extrafield_local, -- const void* extrafield_global, uInt size_extrafield_global, -- const char* comment, int method, int level, int raw, -- int windowBits,int memLevel, int strategy, -- const char* password, uLong crcForCrypting, -- uLong versionMadeBy, uLong flagBase, int zip64) --{ -- zip64_internal* zi; -- uInt size_filename; -- uInt size_comment; -- uInt i; -- int err = ZIP_OK; -- --# ifdef NOCRYPT -- if (password != NULL) -- return ZIP_PARAMERROR; --# endif -- -- if (file == NULL) -- return ZIP_PARAMERROR; -- --#ifdef HAVE_BZIP2 -- if ((method!=0) && (method!=Z_DEFLATED) && (method!=Z_BZIP2ED)) -- return ZIP_PARAMERROR; --#else -- if ((method!=0) && (method!=Z_DEFLATED)) -- return ZIP_PARAMERROR; --#endif -- -- zi = (zip64_internal*)file; -- -- if (zi->in_opened_file_inzip == 1) -- { -- err = zipCloseFileInZip (file); -- if (err != ZIP_OK) -- return err; -- } -- -- if (filename==NULL) -- filename="-"; -- -- if (comment==NULL) -- size_comment = 0; -- else -- size_comment = (uInt)strlen(comment); -- -- size_filename = (uInt)strlen(filename); -- -- if (zipfi == NULL) -- zi->ci.dosDate = 0; -- else -- { -- if (zipfi->dosDate != 0) -- zi->ci.dosDate = zipfi->dosDate; -- else -- zi->ci.dosDate = zip64local_TmzDateToDosDate(&zipfi->tmz_date); -- } -- -- zi->ci.flag = flagBase; -- if ((level==8) || (level==9)) -- zi->ci.flag |= 2; -- if ((level==2)) -- zi->ci.flag |= 4; -- if ((level==1)) -- zi->ci.flag |= 6; -- if (password != NULL) -- zi->ci.flag |= 1; -- -- zi->ci.crc32 = 0; -- zi->ci.method = method; -- zi->ci.encrypt = 0; -- zi->ci.stream_initialised = 0; -- zi->ci.pos_in_buffered_data = 0; -- zi->ci.raw = raw; -- zi->ci.pos_local_header = ZTELL64(zi->z_filefunc,zi->filestream); -- -- zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global + size_comment; -- zi->ci.size_centralExtraFree = 32; // Extra space we have reserved in case we need to add ZIP64 extra info data -- -- zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader + zi->ci.size_centralExtraFree); -- -- zi->ci.size_centralExtra = size_extrafield_global; -- zip64local_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4); -- /* version info */ -- zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)versionMadeBy,2); -- zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2); -- zip64local_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2); -- zip64local_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2); -- zip64local_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4); -- zip64local_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/ -- zip64local_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/ -- zip64local_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/ -- zip64local_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2); -- zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2); -- zip64local_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2); -- zip64local_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/ -- -- if (zipfi==NULL) -- zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2); -- else -- zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2); -- -- if (zipfi==NULL) -- zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4); -- else -- zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4); -- -- if(zi->ci.pos_local_header >= 0xffffffff) -- zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)0xffffffff,4); -- else -- zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header - zi->add_position_when_writting_offset,4); -- -- for (i=0;ici.central_header+SIZECENTRALHEADER+i) = *(filename+i); -- -- for (i=0;ici.central_header+SIZECENTRALHEADER+size_filename+i) = -- *(((const char*)extrafield_global)+i); -- -- for (i=0;ici.central_header+SIZECENTRALHEADER+size_filename+ -- size_extrafield_global+i) = *(comment+i); -- if (zi->ci.central_header == NULL) -- return ZIP_INTERNALERROR; -- -- zi->ci.zip64 = zip64; -- zi->ci.totalCompressedData = 0; -- zi->ci.totalUncompressedData = 0; -- zi->ci.pos_zip64extrainfo = 0; -- -- err = Write_LocalFileHeader(zi, filename, size_extrafield_local, extrafield_local); -- --#ifdef HAVE_BZIP2 -- zi->ci.bstream.avail_in = (uInt)0; -- zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE; -- zi->ci.bstream.next_out = (char*)zi->ci.buffered_data; -- zi->ci.bstream.total_in_hi32 = 0; -- zi->ci.bstream.total_in_lo32 = 0; -- zi->ci.bstream.total_out_hi32 = 0; -- zi->ci.bstream.total_out_lo32 = 0; --#endif -- -- zi->ci.stream.avail_in = (uInt)0; -- zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; -- zi->ci.stream.next_out = zi->ci.buffered_data; -- zi->ci.stream.total_in = 0; -- zi->ci.stream.total_out = 0; -- zi->ci.stream.data_type = Z_BINARY; -- --#ifdef HAVE_BZIP2 -- if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED || zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) --#else -- if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) --#endif -- { -- if(zi->ci.method == Z_DEFLATED) -- { -- zi->ci.stream.zalloc = (alloc_func)0; -- zi->ci.stream.zfree = (free_func)0; -- zi->ci.stream.opaque = (voidpf)0; -- -- if (windowBits>0) -- windowBits = -windowBits; -- -- err = deflateInit2(&zi->ci.stream, level, Z_DEFLATED, windowBits, memLevel, strategy); -- -- if (err==Z_OK) -- zi->ci.stream_initialised = Z_DEFLATED; -- } -- else if(zi->ci.method == Z_BZIP2ED) -- { --#ifdef HAVE_BZIP2 -- // Init BZip stuff here -- zi->ci.bstream.bzalloc = 0; -- zi->ci.bstream.bzfree = 0; -- zi->ci.bstream.opaque = (voidpf)0; -- -- err = BZ2_bzCompressInit(&zi->ci.bstream, level, 0,35); -- if(err == BZ_OK) -- zi->ci.stream_initialised = Z_BZIP2ED; --#endif -- } -- -- } -- --# ifndef NOCRYPT -- zi->ci.crypt_header_size = 0; -- if ((err==Z_OK) && (password != NULL)) -- { -- unsigned char bufHead[RAND_HEAD_LEN]; -- unsigned int sizeHead; -- zi->ci.encrypt = 1; -- zi->ci.pcrc_32_tab = get_crc_table(); -- /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/ -- -- sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting); -- zi->ci.crypt_header_size = sizeHead; -- -- if (ZWRITE64(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead) -- err = ZIP_ERRNO; -- } --# endif -- -- if (err==Z_OK) -- zi->in_opened_file_inzip = 1; -- return err; --} -- --extern int ZEXPORT zipOpenNewFileInZip4 (zipFile file, const char* filename, const zip_fileinfo* zipfi, -- const void* extrafield_local, uInt size_extrafield_local, -- const void* extrafield_global, uInt size_extrafield_global, -- const char* comment, int method, int level, int raw, -- int windowBits,int memLevel, int strategy, -- const char* password, uLong crcForCrypting, -- uLong versionMadeBy, uLong flagBase) --{ -- return zipOpenNewFileInZip4_64 (file, filename, zipfi, -- extrafield_local, size_extrafield_local, -- extrafield_global, size_extrafield_global, -- comment, method, level, raw, -- windowBits, memLevel, strategy, -- password, crcForCrypting, versionMadeBy, flagBase, 0); --} -- --extern int ZEXPORT zipOpenNewFileInZip3 (zipFile file, const char* filename, const zip_fileinfo* zipfi, -- const void* extrafield_local, uInt size_extrafield_local, -- const void* extrafield_global, uInt size_extrafield_global, -- const char* comment, int method, int level, int raw, -- int windowBits,int memLevel, int strategy, -- const char* password, uLong crcForCrypting) --{ -- return zipOpenNewFileInZip4_64 (file, filename, zipfi, -- extrafield_local, size_extrafield_local, -- extrafield_global, size_extrafield_global, -- comment, method, level, raw, -- windowBits, memLevel, strategy, -- password, crcForCrypting, VERSIONMADEBY, 0, 0); --} -- --extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char* filename, const zip_fileinfo* zipfi, -- const void* extrafield_local, uInt size_extrafield_local, -- const void* extrafield_global, uInt size_extrafield_global, -- const char* comment, int method, int level, int raw, -- int windowBits,int memLevel, int strategy, -- const char* password, uLong crcForCrypting, int zip64) --{ -- return zipOpenNewFileInZip4_64 (file, filename, zipfi, -- extrafield_local, size_extrafield_local, -- extrafield_global, size_extrafield_global, -- comment, method, level, raw, -- windowBits, memLevel, strategy, -- password, crcForCrypting, VERSIONMADEBY, 0, zip64); --} -- --extern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char* filename, const zip_fileinfo* zipfi, -- const void* extrafield_local, uInt size_extrafield_local, -- const void* extrafield_global, uInt size_extrafield_global, -- const char* comment, int method, int level, int raw) --{ -- return zipOpenNewFileInZip4_64 (file, filename, zipfi, -- extrafield_local, size_extrafield_local, -- extrafield_global, size_extrafield_global, -- comment, method, level, raw, -- -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, -- NULL, 0, VERSIONMADEBY, 0, 0); --} -- --extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char* filename, const zip_fileinfo* zipfi, -- const void* extrafield_local, uInt size_extrafield_local, -- const void* extrafield_global, uInt size_extrafield_global, -- const char* comment, int method, int level, int raw, int zip64) --{ -- return zipOpenNewFileInZip4_64 (file, filename, zipfi, -- extrafield_local, size_extrafield_local, -- extrafield_global, size_extrafield_global, -- comment, method, level, raw, -- -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, -- NULL, 0, VERSIONMADEBY, 0, zip64); --} -- --extern int ZEXPORT zipOpenNewFileInZip64 (zipFile file, const char* filename, const zip_fileinfo* zipfi, -- const void* extrafield_local, uInt size_extrafield_local, -- const void*extrafield_global, uInt size_extrafield_global, -- const char* comment, int method, int level, int zip64) --{ -- return zipOpenNewFileInZip4_64 (file, filename, zipfi, -- extrafield_local, size_extrafield_local, -- extrafield_global, size_extrafield_global, -- comment, method, level, 0, -- -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, -- NULL, 0, VERSIONMADEBY, 0, zip64); --} -- --extern int ZEXPORT zipOpenNewFileInZip (zipFile file, const char* filename, const zip_fileinfo* zipfi, -- const void* extrafield_local, uInt size_extrafield_local, -- const void*extrafield_global, uInt size_extrafield_global, -- const char* comment, int method, int level) --{ -- return zipOpenNewFileInZip4_64 (file, filename, zipfi, -- extrafield_local, size_extrafield_local, -- extrafield_global, size_extrafield_global, -- comment, method, level, 0, -- -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, -- NULL, 0, VERSIONMADEBY, 0, 0); --} -- --local int zip64FlushWriteBuffer(zip64_internal* zi) --{ -- int err=ZIP_OK; -- -- if (zi->ci.encrypt != 0) -- { --#ifndef NOCRYPT -- uInt i; -- int t; -- for (i=0;ici.pos_in_buffered_data;i++) -- zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, zi->ci.buffered_data[i],t); --#endif -- } -- -- if (ZWRITE64(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) != zi->ci.pos_in_buffered_data) -- err = ZIP_ERRNO; -- -- zi->ci.totalCompressedData += zi->ci.pos_in_buffered_data; -- --#ifdef HAVE_BZIP2 -- if(zi->ci.method == Z_BZIP2ED) -- { -- zi->ci.totalUncompressedData += zi->ci.bstream.total_in_lo32; -- zi->ci.bstream.total_in_lo32 = 0; -- zi->ci.bstream.total_in_hi32 = 0; -- } -- else --#endif -- { -- zi->ci.totalUncompressedData += zi->ci.stream.total_in; -- zi->ci.stream.total_in = 0; -- } -- -- -- zi->ci.pos_in_buffered_data = 0; -- -- return err; --} -- --extern int ZEXPORT zipWriteInFileInZip (zipFile file,const void* buf,unsigned int len) --{ -- zip64_internal* zi; -- int err=ZIP_OK; -- -- if (file == NULL) -- return ZIP_PARAMERROR; -- zi = (zip64_internal*)file; -- -- if (zi->in_opened_file_inzip == 0) -- return ZIP_PARAMERROR; -- -- zi->ci.crc32 = crc32(zi->ci.crc32,buf,(uInt)len); -- --#ifdef HAVE_BZIP2 -- if(zi->ci.method == Z_BZIP2ED && (!zi->ci.raw)) -- { -- zi->ci.bstream.next_in = (void*)buf; -- zi->ci.bstream.avail_in = len; -- err = BZ_RUN_OK; -- -- while ((err==BZ_RUN_OK) && (zi->ci.bstream.avail_in>0)) -- { -- if (zi->ci.bstream.avail_out == 0) -- { -- if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) -- err = ZIP_ERRNO; -- zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE; -- zi->ci.bstream.next_out = (char*)zi->ci.buffered_data; -- } -- -- -- if(err != BZ_RUN_OK) -- break; -- -- if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) -- { -- uLong uTotalOutBefore_lo = zi->ci.bstream.total_out_lo32; --// uLong uTotalOutBefore_hi = zi->ci.bstream.total_out_hi32; -- err=BZ2_bzCompress(&zi->ci.bstream, BZ_RUN); -- -- zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore_lo) ; -- } -- } -- -- if(err == BZ_RUN_OK) -- err = ZIP_OK; -- } -- else --#endif -- { -- zi->ci.stream.next_in = (Bytef*)buf; -- zi->ci.stream.avail_in = len; -- -- while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0)) -- { -- if (zi->ci.stream.avail_out == 0) -- { -- if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) -- err = ZIP_ERRNO; -- zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; -- zi->ci.stream.next_out = zi->ci.buffered_data; -- } -- -- -- if(err != ZIP_OK) -- break; -- -- if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) -- { -- uLong uTotalOutBefore = zi->ci.stream.total_out; -- err=deflate(&zi->ci.stream, Z_NO_FLUSH); -- if(uTotalOutBefore > zi->ci.stream.total_out) -- { -- int bBreak = 0; -- bBreak++; -- } -- -- zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; -- } -- else -- { -- uInt copy_this,i; -- if (zi->ci.stream.avail_in < zi->ci.stream.avail_out) -- copy_this = zi->ci.stream.avail_in; -- else -- copy_this = zi->ci.stream.avail_out; -- -- for (i = 0; i < copy_this; i++) -- *(((char*)zi->ci.stream.next_out)+i) = -- *(((const char*)zi->ci.stream.next_in)+i); -- { -- zi->ci.stream.avail_in -= copy_this; -- zi->ci.stream.avail_out-= copy_this; -- zi->ci.stream.next_in+= copy_this; -- zi->ci.stream.next_out+= copy_this; -- zi->ci.stream.total_in+= copy_this; -- zi->ci.stream.total_out+= copy_this; -- zi->ci.pos_in_buffered_data += copy_this; -- } -- } -- }// while(...) -- } -- -- return err; --} -- --extern int ZEXPORT zipCloseFileInZipRaw (zipFile file, uLong uncompressed_size, uLong crc32) --{ -- return zipCloseFileInZipRaw64 (file, uncompressed_size, crc32); --} -- --extern int ZEXPORT zipCloseFileInZipRaw64 (zipFile file, ZPOS64_T uncompressed_size, uLong crc32) --{ -- zip64_internal* zi; -- ZPOS64_T compressed_size; -- uLong invalidValue = 0xffffffff; -- short datasize = 0; -- int err=ZIP_OK; -- -- if (file == NULL) -- return ZIP_PARAMERROR; -- zi = (zip64_internal*)file; -- -- if (zi->in_opened_file_inzip == 0) -- return ZIP_PARAMERROR; -- zi->ci.stream.avail_in = 0; -- -- if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) -- { -- while (err==ZIP_OK) -- { -- uLong uTotalOutBefore; -- if (zi->ci.stream.avail_out == 0) -- { -- if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) -- err = ZIP_ERRNO; -- zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; -- zi->ci.stream.next_out = zi->ci.buffered_data; -- } -- uTotalOutBefore = zi->ci.stream.total_out; -- err=deflate(&zi->ci.stream, Z_FINISH); -- zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; -- } -- } -- else if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) -- { --#ifdef HAVE_BZIP2 -- err = BZ_FINISH_OK; -- while (err==BZ_FINISH_OK) -- { -- uLong uTotalOutBefore; -- if (zi->ci.bstream.avail_out == 0) -- { -- if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO) -- err = ZIP_ERRNO; -- zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE; -- zi->ci.bstream.next_out = (char*)zi->ci.buffered_data; -- } -- uTotalOutBefore = zi->ci.bstream.total_out_lo32; -- err=BZ2_bzCompress(&zi->ci.bstream, BZ_FINISH); -- if(err == BZ_STREAM_END) -- err = Z_STREAM_END; -- -- zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore); -- } -- -- if(err == BZ_FINISH_OK) -- err = ZIP_OK; --#endif -- } -- -- if (err==Z_STREAM_END) -- err=ZIP_OK; /* this is normal */ -- -- if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK)) -- { -- if (zip64FlushWriteBuffer(zi)==ZIP_ERRNO) -- err = ZIP_ERRNO; -- } -- -- if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) -- { -- int tmp_err = deflateEnd(&zi->ci.stream); -- if (err == ZIP_OK) -- err = tmp_err; -- zi->ci.stream_initialised = 0; -- } --#ifdef HAVE_BZIP2 -- else if((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw)) -- { -- int tmperr = BZ2_bzCompressEnd(&zi->ci.bstream); -- if (err==ZIP_OK) -- err = tmperr; -- zi->ci.stream_initialised = 0; -- } --#endif -- -- if (!zi->ci.raw) -- { -- crc32 = (uLong)zi->ci.crc32; -- uncompressed_size = zi->ci.totalUncompressedData; -- } -- compressed_size = zi->ci.totalCompressedData; -- --# ifndef NOCRYPT -- compressed_size += zi->ci.crypt_header_size; --# endif -- -- // update Current Item crc and sizes, -- if(compressed_size >= 0xffffffff || uncompressed_size >= 0xffffffff || zi->ci.pos_local_header >= 0xffffffff) -- { -- /*version Made by*/ -- zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)45,2); -- /*version needed*/ -- zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)45,2); -- -- } -- -- zip64local_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/ -- -- -- if(compressed_size >= 0xffffffff) -- zip64local_putValue_inmemory(zi->ci.central_header+20, invalidValue,4); /*compr size*/ -- else -- zip64local_putValue_inmemory(zi->ci.central_header+20, compressed_size,4); /*compr size*/ -- -- /// set internal file attributes field -- if (zi->ci.stream.data_type == Z_ASCII) -- zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2); -- -- if(uncompressed_size >= 0xffffffff) -- zip64local_putValue_inmemory(zi->ci.central_header+24, invalidValue,4); /*uncompr size*/ -- else -- zip64local_putValue_inmemory(zi->ci.central_header+24, uncompressed_size,4); /*uncompr size*/ -- -- // Add ZIP64 extra info field for uncompressed size -- if(uncompressed_size >= 0xffffffff) -- datasize += 8; -- -- // Add ZIP64 extra info field for compressed size -- if(compressed_size >= 0xffffffff) -- datasize += 8; -- -- // Add ZIP64 extra info field for relative offset to local file header of current file -- if(zi->ci.pos_local_header >= 0xffffffff) -- datasize += 8; -- -- if(datasize > 0) -- { -- char* p = NULL; -- -- if((uLong)(datasize + 4) > zi->ci.size_centralExtraFree) -- { -- // we can not write more data to the buffer that we have room for. -- return ZIP_BADZIPFILE; -- } -- -- p = zi->ci.central_header + zi->ci.size_centralheader; -- -- // Add Extra Information Header for 'ZIP64 information' -- zip64local_putValue_inmemory(p, 0x0001, 2); // HeaderID -- p += 2; -- zip64local_putValue_inmemory(p, datasize, 2); // DataSize -- p += 2; -- -- if(uncompressed_size >= 0xffffffff) -- { -- zip64local_putValue_inmemory(p, uncompressed_size, 8); -- p += 8; -- } -- -- if(compressed_size >= 0xffffffff) -- { -- zip64local_putValue_inmemory(p, compressed_size, 8); -- p += 8; -- } -- -- if(zi->ci.pos_local_header >= 0xffffffff) -- { -- zip64local_putValue_inmemory(p, zi->ci.pos_local_header, 8); -- p += 8; -- } -- -- // Update how much extra free space we got in the memory buffer -- // and increase the centralheader size so the new ZIP64 fields are included -- // ( 4 below is the size of HeaderID and DataSize field ) -- zi->ci.size_centralExtraFree -= datasize + 4; -- zi->ci.size_centralheader += datasize + 4; -- -- // Update the extra info size field -- zi->ci.size_centralExtra += datasize + 4; -- zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)zi->ci.size_centralExtra,2); -- } -- -- if (err==ZIP_OK) -- err = add_data_in_datablock(&zi->central_dir, zi->ci.central_header, (uLong)zi->ci.size_centralheader); -- -- free(zi->ci.central_header); -- -- if (err==ZIP_OK) -- { -- // Update the LocalFileHeader with the new values. -- -- ZPOS64_T cur_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream); -- -- if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0) -- err = ZIP_ERRNO; -- -- if (err==ZIP_OK) -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */ -- -- if(uncompressed_size >= 0xffffffff) -- { -- if(zi->ci.pos_zip64extrainfo > 0) -- { -- // Update the size in the ZIP64 extended field. -- if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_zip64extrainfo + 4,ZLIB_FILEFUNC_SEEK_SET)!=0) -- err = ZIP_ERRNO; -- -- if (err==ZIP_OK) /* compressed size, unknown */ -- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, uncompressed_size, 8); -- -- if (err==ZIP_OK) /* uncompressed size, unknown */ -- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, compressed_size, 8); -- } -- } -- else -- { -- if (err==ZIP_OK) /* compressed size, unknown */ -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4); -- -- if (err==ZIP_OK) /* uncompressed size, unknown */ -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4); -- } -- -- if (ZSEEK64(zi->z_filefunc,zi->filestream, cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0) -- err = ZIP_ERRNO; -- } -- -- zi->number_entry ++; -- zi->in_opened_file_inzip = 0; -- -- return err; --} -- --extern int ZEXPORT zipCloseFileInZip (zipFile file) --{ -- return zipCloseFileInZipRaw (file,0,0); --} -- --int Write_Zip64EndOfCentralDirectoryLocator(zip64_internal* zi, ZPOS64_T zip64eocd_pos_inzip) --{ -- int err = ZIP_OK; -- ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writting_offset; -- -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDLOCHEADERMAGIC,4); -- -- /*num disks*/ -- if (err==ZIP_OK) /* number of the disk with the start of the central directory */ -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); -- -- /*relative offset*/ -- if (err==ZIP_OK) /* Relative offset to the Zip64EndOfCentralDirectory */ -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream, pos,8); -- -- /*total disks*/ /* Do not support spawning of disk so always say 1 here*/ -- if (err==ZIP_OK) /* number of the disk with the start of the central directory */ -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)1,4); -- -- return err; --} -- --int Write_Zip64EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip) --{ -- int err = ZIP_OK; -- -- uLong Zip64DataSize = 44; -- -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDHEADERMAGIC,4); -- -- if (err==ZIP_OK) /* size of this 'zip64 end of central directory' */ -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)Zip64DataSize,8); // why ZPOS64_T of this ? -- -- if (err==ZIP_OK) /* version made by */ -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2); -- -- if (err==ZIP_OK) /* version needed */ -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2); -- -- if (err==ZIP_OK) /* number of this disk */ -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); -- -- if (err==ZIP_OK) /* number of the disk with the start of the central directory */ -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); -- -- if (err==ZIP_OK) /* total number of entries in the central dir on this disk */ -- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8); -- -- if (err==ZIP_OK) /* total number of entries in the central dir */ -- err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8); -- -- if (err==ZIP_OK) /* size of the central directory */ -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)size_centraldir,8); -- -- if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */ -- { -- ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset; -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (ZPOS64_T)pos,8); -- } -- return err; --} --int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip) --{ -- int err = ZIP_OK; -- -- /*signature*/ -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4); -- -- if (err==ZIP_OK) /* number of this disk */ -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); -- -- if (err==ZIP_OK) /* number of the disk with the start of the central directory */ -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); -- -- if (err==ZIP_OK) /* total number of entries in the central dir on this disk */ -- { -- { -- if(zi->number_entry >= 0xFFFF) -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record -- else -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); -- } -- } -- -- if (err==ZIP_OK) /* total number of entries in the central dir */ -- { -- if(zi->number_entry >= 0xFFFF) -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record -- else -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); -- } -- -- if (err==ZIP_OK) /* size of the central directory */ -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4); -- -- if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */ -- { -- ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset; -- if(pos >= 0xffffffff) -- { -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)0xffffffff,4); -- } -- else -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4); -- } -- -- return err; --} -- --int Write_GlobalComment(zip64_internal* zi, const char* global_comment) --{ -- int err = ZIP_OK; -- uInt size_global_comment = 0; -- -- if(global_comment != NULL) -- size_global_comment = (uInt)strlen(global_comment); -- -- err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2); -- -- if (err == ZIP_OK && size_global_comment > 0) -- { -- if (ZWRITE64(zi->z_filefunc,zi->filestream, global_comment, size_global_comment) != size_global_comment) -- err = ZIP_ERRNO; -- } -- return err; --} -- --extern int ZEXPORT zipClose (zipFile file, const char* global_comment) --{ -- zip64_internal* zi; -- int err = 0; -- uLong size_centraldir = 0; -- ZPOS64_T centraldir_pos_inzip; -- ZPOS64_T pos; -- -- if (file == NULL) -- return ZIP_PARAMERROR; -- -- zi = (zip64_internal*)file; -- -- if (zi->in_opened_file_inzip == 1) -- { -- err = zipCloseFileInZip (file); -- } -- --#ifndef NO_ADDFILEINEXISTINGZIP -- if (global_comment==NULL) -- global_comment = zi->globalcomment; --#endif -- -- centraldir_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream); -- -- if (err==ZIP_OK) -- { -- linkedlist_datablock_internal* ldi = zi->central_dir.first_block; -- while (ldi!=NULL) -- { -- if ((err==ZIP_OK) && (ldi->filled_in_this_block>0)) -- { -- if (ZWRITE64(zi->z_filefunc,zi->filestream, ldi->data, ldi->filled_in_this_block) != ldi->filled_in_this_block) -- err = ZIP_ERRNO; -- } -- -- size_centraldir += ldi->filled_in_this_block; -- ldi = ldi->next_datablock; -- } -- } -- free_linkedlist(&(zi->central_dir)); -- -- pos = centraldir_pos_inzip - zi->add_position_when_writting_offset; -- if(pos >= 0xffffffff) -- { -- ZPOS64_T Zip64EOCDpos = ZTELL64(zi->z_filefunc,zi->filestream); -- Write_Zip64EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip); -- -- Write_Zip64EndOfCentralDirectoryLocator(zi, Zip64EOCDpos); -- } -- -- if (err==ZIP_OK) -- err = Write_EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip); -- -- if(err == ZIP_OK) -- err = Write_GlobalComment(zi, global_comment); -- -- if (ZCLOSE64(zi->z_filefunc,zi->filestream) != 0) -- if (err == ZIP_OK) -- err = ZIP_ERRNO; -- --#ifndef NO_ADDFILEINEXISTINGZIP -- TRYFREE(zi->globalcomment); --#endif -- TRYFREE(zi); -- -- return err; --} -- --extern int ZEXPORT zipRemoveExtraInfoBlock (char* pData, int* dataLen, short sHeader) --{ -- char* p = pData; -- int size = 0; -- char* pNewHeader; -- char* pTmp; -- short header; -- short dataSize; -- -- int retVal = ZIP_OK; -- -- if(pData == NULL || *dataLen < 4) -- return ZIP_PARAMERROR; -- -- pNewHeader = (char*)ALLOC(*dataLen); -- pTmp = pNewHeader; -- -- while(p < (pData + *dataLen)) -- { -- header = *(short*)p; -- dataSize = *(((short*)p)+1); -- -- if( header == sHeader ) // Header found. -- { -- p += dataSize + 4; // skip it. do not copy to temp buffer -- } -- else -- { -- // Extra Info block should not be removed, So copy it to the temp buffer. -- memcpy(pTmp, p, dataSize + 4); -- p += dataSize + 4; -- size += dataSize + 4; -- } -- -- } -- -- if(size < *dataLen) -- { -- // clean old extra info block. -- memset(pData,0, *dataLen); -- -- // copy the new extra info block over the old -- if(size > 0) -- memcpy(pData, pNewHeader, size); -- -- // set the new extra info size -- *dataLen = size; -- -- retVal = ZIP_OK; -- } -- else -- retVal = ZIP_ERRNO; -- -- TRYFREE(pNewHeader); -- -- return retVal; --} -diff --git a/thirdparty/minizip/zip.h b/thirdparty/minizip/zip.h -deleted file mode 100644 -index 8aaebb6..0000000 ---- a/thirdparty/minizip/zip.h -+++ /dev/null -@@ -1,362 +0,0 @@ --/* zip.h -- IO on .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 for Zip64 support -- Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) -- -- For more info read MiniZip_info.txt -- -- --------------------------------------------------------------------------- -- -- Condition of use and distribution are the same than zlib : -- -- This software is provided 'as-is', without any express or implied -- warranty. In no event will the authors be held liable for any damages -- arising from the use of this software. -- -- Permission is granted to anyone to use this software for any purpose, -- including commercial applications, and to alter it and redistribute it -- freely, subject to the following restrictions: -- -- 1. The origin of this software must not be misrepresented; you must not -- claim that you wrote the original software. If you use this software -- in a product, an acknowledgment in the product documentation would be -- appreciated but is not required. -- 2. Altered source versions must be plainly marked as such, and must not be -- misrepresented as being the original software. -- 3. This notice may not be removed or altered from any source distribution. -- -- --------------------------------------------------------------------------- -- -- Changes -- -- See header of zip.h -- --*/ -- --#ifndef _zip12_H --#define _zip12_H -- --#ifdef __cplusplus --extern "C" { --#endif -- --//#define HAVE_BZIP2 -- --#ifndef _ZLIB_H --#include "zlib.h" --#endif -- --#ifndef _ZLIBIOAPI_H --#include "ioapi.h" --#endif -- --#ifdef HAVE_BZIP2 --#include "bzlib.h" --#endif -- --#define Z_BZIP2ED 12 -- --#if defined(STRICTZIP) || defined(STRICTZIPUNZIP) --/* like the STRICT of WIN32, we define a pointer that cannot be converted -- from (void*) without cast */ --typedef struct TagzipFile__ { int unused; } zipFile__; --typedef zipFile__ *zipFile; --#else --typedef voidp zipFile; --#endif -- --#define ZIP_OK (0) --#define ZIP_EOF (0) --#define ZIP_ERRNO (Z_ERRNO) --#define ZIP_PARAMERROR (-102) --#define ZIP_BADZIPFILE (-103) --#define ZIP_INTERNALERROR (-104) -- --#ifndef DEF_MEM_LEVEL --# if MAX_MEM_LEVEL >= 8 --# define DEF_MEM_LEVEL 8 --# else --# define DEF_MEM_LEVEL MAX_MEM_LEVEL --# endif --#endif --/* default memLevel */ -- --/* tm_zip contain date/time info */ --typedef struct tm_zip_s --{ -- uInt tm_sec; /* seconds after the minute - [0,59] */ -- uInt tm_min; /* minutes after the hour - [0,59] */ -- uInt tm_hour; /* hours since midnight - [0,23] */ -- uInt tm_mday; /* day of the month - [1,31] */ -- uInt tm_mon; /* months since January - [0,11] */ -- uInt tm_year; /* years - [1980..2044] */ --} tm_zip; -- --typedef struct --{ -- tm_zip tmz_date; /* date in understandable format */ -- uLong dosDate; /* if dos_date == 0, tmu_date is used */ --/* uLong flag; */ /* general purpose bit flag 2 bytes */ -- -- uLong internal_fa; /* internal file attributes 2 bytes */ -- uLong external_fa; /* external file attributes 4 bytes */ --} zip_fileinfo; -- --typedef const char* zipcharpc; -- -- --#define APPEND_STATUS_CREATE (0) --#define APPEND_STATUS_CREATEAFTER (1) --#define APPEND_STATUS_ADDINZIP (2) -- --extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append)); --extern zipFile ZEXPORT zipOpen64 OF((const void *pathname, int append)); --/* -- Create a zipfile. -- pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on -- an Unix computer "zlib/zlib113.zip". -- if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip -- will be created at the end of the file. -- (useful if the file contain a self extractor code) -- if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will -- add files in existing zip (be sure you don't add file that doesn't exist) -- If the zipfile cannot be opened, the return value is NULL. -- Else, the return value is a zipFile Handle, usable with other function -- of this zip package. --*/ -- --/* Note : there is no delete function into a zipfile. -- If you want delete file into a zipfile, you must open a zipfile, and create another -- Of couse, you can use RAW reading and writing to copy the file you did not want delte --*/ -- --extern zipFile ZEXPORT zipOpen2 OF((const char *pathname, -- int append, -- zipcharpc* globalcomment, -- zlib_filefunc_def* pzlib_filefunc_def)); -- --extern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname, -- int append, -- zipcharpc* globalcomment, -- zlib_filefunc64_def* pzlib_filefunc_def)); -- --extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file, -- const char* filename, -- const zip_fileinfo* zipfi, -- const void* extrafield_local, -- uInt size_extrafield_local, -- const void* extrafield_global, -- uInt size_extrafield_global, -- const char* comment, -- int method, -- int level)); -- --extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file, -- const char* filename, -- const zip_fileinfo* zipfi, -- const void* extrafield_local, -- uInt size_extrafield_local, -- const void* extrafield_global, -- uInt size_extrafield_global, -- const char* comment, -- int method, -- int level, -- int zip64)); -- --/* -- Open a file in the ZIP for writing. -- filename : the filename in zip (if NULL, '-' without quote will be used -- *zipfi contain supplemental information -- if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local -- contains the extrafield data the the local header -- if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global -- contains the extrafield data the the local header -- if comment != NULL, comment contain the comment string -- method contain the compression method (0 for store, Z_DEFLATED for deflate) -- level contain the level of compression (can be Z_DEFAULT_COMPRESSION) -- zip64 is set to 1 if a zip64 extended information block should be added to the local file header. -- this MUST be '1' if the uncompressed size is >= 0xffffffff. -- --*/ -- -- --extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file, -- const char* filename, -- const zip_fileinfo* zipfi, -- const void* extrafield_local, -- uInt size_extrafield_local, -- const void* extrafield_global, -- uInt size_extrafield_global, -- const char* comment, -- int method, -- int level, -- int raw)); -- -- --extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file, -- const char* filename, -- const zip_fileinfo* zipfi, -- const void* extrafield_local, -- uInt size_extrafield_local, -- const void* extrafield_global, -- uInt size_extrafield_global, -- const char* comment, -- int method, -- int level, -- int raw, -- int zip64)); --/* -- Same than zipOpenNewFileInZip, except if raw=1, we write raw file -- */ -- --extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file, -- const char* filename, -- const zip_fileinfo* zipfi, -- const void* extrafield_local, -- uInt size_extrafield_local, -- const void* extrafield_global, -- uInt size_extrafield_global, -- const char* comment, -- int method, -- int level, -- int raw, -- int windowBits, -- int memLevel, -- int strategy, -- const char* password, -- uLong crcForCrypting)); -- --extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file, -- const char* filename, -- const zip_fileinfo* zipfi, -- const void* extrafield_local, -- uInt size_extrafield_local, -- const void* extrafield_global, -- uInt size_extrafield_global, -- const char* comment, -- int method, -- int level, -- int raw, -- int windowBits, -- int memLevel, -- int strategy, -- const char* password, -- uLong crcForCrypting, -- int zip64 -- )); -- --/* -- Same than zipOpenNewFileInZip2, except -- windowBits,memLevel,,strategy : see parameter strategy in deflateInit2 -- password : crypting password (NULL for no crypting) -- crcForCrypting : crc of file to compress (needed for crypting) -- */ -- --extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file, -- const char* filename, -- const zip_fileinfo* zipfi, -- const void* extrafield_local, -- uInt size_extrafield_local, -- const void* extrafield_global, -- uInt size_extrafield_global, -- const char* comment, -- int method, -- int level, -- int raw, -- int windowBits, -- int memLevel, -- int strategy, -- const char* password, -- uLong crcForCrypting, -- uLong versionMadeBy, -- uLong flagBase -- )); -- -- --extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file, -- const char* filename, -- const zip_fileinfo* zipfi, -- const void* extrafield_local, -- uInt size_extrafield_local, -- const void* extrafield_global, -- uInt size_extrafield_global, -- const char* comment, -- int method, -- int level, -- int raw, -- int windowBits, -- int memLevel, -- int strategy, -- const char* password, -- uLong crcForCrypting, -- uLong versionMadeBy, -- uLong flagBase, -- int zip64 -- )); --/* -- Same than zipOpenNewFileInZip4, except -- versionMadeBy : value for Version made by field -- flag : value for flag field (compression level info will be added) -- */ -- -- --extern int ZEXPORT zipWriteInFileInZip OF((zipFile file, -- const void* buf, -- unsigned len)); --/* -- Write data in the zipfile --*/ -- --extern int ZEXPORT zipCloseFileInZip OF((zipFile file)); --/* -- Close the current file in the zipfile --*/ -- --extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file, -- uLong uncompressed_size, -- uLong crc32)); -- --extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file, -- ZPOS64_T uncompressed_size, -- uLong crc32)); -- --/* -- Close the current file in the zipfile, for file opened with -- parameter raw=1 in zipOpenNewFileInZip2 -- uncompressed_size and crc32 are value for the uncompressed size --*/ -- --extern int ZEXPORT zipClose OF((zipFile file, -- const char* global_comment)); --/* -- Close the zipfile --*/ -- -- --extern int ZEXPORT zipRemoveExtraInfoBlock OF((char* pData, int* dataLen, short sHeader)); --/* -- zipRemoveExtraInfoBlock - Added by Mathias Svensson -- -- Remove extra information block from a extra information data for the local file header or central directory header -- -- It is needed to remove ZIP64 extra information blocks when before data is written if using RAW mode. -- -- 0x0001 is the signature header for the ZIP64 extra information blocks -- -- usage. -- Remove ZIP64 Extra information from a central director extra field data -- zipRemoveExtraInfoBlock(pCenDirExtraFieldData, &nCenDirExtraFieldDataLen, 0x0001); -- -- Remove ZIP64 Extra information from a Local File Header extra field data -- zipRemoveExtraInfoBlock(pLocalHeaderExtraFieldData, &nLocalHeaderExtraFieldDataLen, 0x0001); --*/ -- --#ifdef __cplusplus --} --#endif -- --#endif /* _zip64_H */ -diff --git a/thirdparty/zlib/CMakeLists.txt b/thirdparty/zlib/CMakeLists.txt -deleted file mode 100644 -index a4eae3d..0000000 ---- a/thirdparty/zlib/CMakeLists.txt -+++ /dev/null -@@ -1,14 +0,0 @@ --project(zlib) -- --# Create the list of source files --aux_source_directory( . source_files ) -- --# Define _UNICODE (use wide-char encoding) --add_definitions(-D_UNICODE -D_CRT_SECURE_NO_DEPRECATE /wd4996 /wd4131 /wd4244 /wd4127) -- --fix_default_compiler_settings_() -- --# Add library build target --add_library(zlib STATIC ${source_files}) -- --set_target_properties(zlib PROPERTIES DEBUG_POSTFIX d ) -\ No newline at end of file -diff --git a/thirdparty/zlib/ChangeLog b/thirdparty/zlib/ChangeLog -deleted file mode 100644 -index f310bb0..0000000 ---- a/thirdparty/zlib/ChangeLog -+++ /dev/null -@@ -1,1208 +0,0 @@ -- -- ChangeLog file for zlib -- --Changes in 1.2.5 (19 Apr 2010) --- Disable visibility attribute in win32/Makefile.gcc [Bar-Lev] --- Default to libdir as sharedlibdir in configure [Nieder] --- Update copyright dates on modified source files --- Update trees.c to be able to generate modified trees.h --- Exit configure for MinGW, suggesting win32/Makefile.gcc -- --Changes in 1.2.4.5 (18 Apr 2010) --- Set sharedlibdir in configure [Torok] --- Set LDFLAGS in Makefile.in [Bar-Lev] --- Avoid mkdir objs race condition in Makefile.in [Bowler] --- Add ZLIB_INTERNAL in front of internal inter-module functions and arrays --- Define ZLIB_INTERNAL to hide internal functions and arrays for GNU C --- Don't use hidden attribute when it is a warning generator (e.g. Solaris) -- --Changes in 1.2.4.4 (18 Apr 2010) --- Fix CROSS_PREFIX executable testing, CHOST extract, mingw* [Torok] --- Undefine _LARGEFILE64_SOURCE in zconf.h if it is zero, but not if empty --- Try to use bash or ksh regardless of functionality of /bin/sh --- Fix configure incompatibility with NetBSD sh --- Remove attempt to run under bash or ksh since have better NetBSD fix --- Fix win32/Makefile.gcc for MinGW [Bar-Lev] --- Add diagnostic messages when using CROSS_PREFIX in configure --- Added --sharedlibdir option to configure [Weigelt] --- Use hidden visibility attribute when available [Frysinger] -- --Changes in 1.2.4.3 (10 Apr 2010) --- Only use CROSS_PREFIX in configure for ar and ranlib if they exist --- Use CROSS_PREFIX for nm [Bar-Lev] --- Assume _LARGEFILE64_SOURCE defined is equivalent to true --- Avoid use of undefined symbols in #if with && and || --- Make *64 prototypes in gzguts.h consistent with functions --- Add -shared load option for MinGW in configure [Bowler] --- Move z_off64_t to public interface, use instead of off64_t --- Remove ! from shell test in configure (not portable to Solaris) --- Change +0 macro tests to -0 for possibly increased portability -- --Changes in 1.2.4.2 (9 Apr 2010) --- Add consistent carriage returns to readme.txt's in masmx86 and masmx64 --- Really provide prototypes for *64 functions when building without LFS --- Only define unlink() in minigzip.c if unistd.h not included --- Update README to point to contrib/vstudio project files --- Move projects/vc6 to old/ and remove projects/ --- Include stdlib.h in minigzip.c for setmode() definition under WinCE --- Clean up assembler builds in win32/Makefile.msc [Rowe] --- Include sys/types.h for Microsoft for off_t definition --- Fix memory leak on error in gz_open() --- Symbolize nm as $NM in configure [Weigelt] --- Use TEST_LDSHARED instead of LDSHARED to link test programs [Weigelt] --- Add +0 to _FILE_OFFSET_BITS and _LFS64_LARGEFILE in case not defined --- Fix bug in gzeof() to take into account unused input data --- Avoid initialization of structures with variables in puff.c --- Updated win32/README-WIN32.txt [Rowe] -- --Changes in 1.2.4.1 (28 Mar 2010) --- Remove the use of [a-z] constructs for sed in configure [gentoo 310225] --- Remove $(SHAREDLIB) from LIBS in Makefile.in [Creech] --- Restore "for debugging" comment on sprintf() in gzlib.c --- Remove fdopen for MVS from gzguts.h --- Put new README-WIN32.txt in win32 [Rowe] --- Add check for shell to configure and invoke another shell if needed --- Fix big fat stinking bug in gzseek() on uncompressed files --- Remove vestigial F_OPEN64 define in zutil.h --- Set and check the value of _LARGEFILE_SOURCE and _LARGEFILE64_SOURCE --- Avoid errors on non-LFS systems when applications define LFS macros --- Set EXE to ".exe" in configure for MINGW [Kahle] --- Match crc32() in crc32.c exactly to the prototype in zlib.h [Sherrill] --- Add prefix for cross-compilation in win32/makefile.gcc [Bar-Lev] --- Add DLL install in win32/makefile.gcc [Bar-Lev] --- Allow Linux* or linux* from uname in configure [Bar-Lev] --- Allow ldconfig to be redefined in configure and Makefile.in [Bar-Lev] --- Add cross-compilation prefixes to configure [Bar-Lev] --- Match type exactly in gz_load() invocation in gzread.c --- Match type exactly of zcalloc() in zutil.c to zlib.h alloc_func --- Provide prototypes for *64 functions when building zlib without LFS --- Don't use -lc when linking shared library on MinGW --- Remove errno.h check in configure and vestigial errno code in zutil.h -- --Changes in 1.2.4 (14 Mar 2010) --- Fix VER3 extraction in configure for no fourth subversion --- Update zlib.3, add docs to Makefile.in to make .pdf out of it --- Add zlib.3.pdf to distribution --- Don't set error code in gzerror() if passed pointer is NULL --- Apply destination directory fixes to CMakeLists.txt [Lowman] --- Move #cmakedefine's to a new zconf.in.cmakein --- Restore zconf.h for builds that don't use configure or cmake --- Add distclean to dummy Makefile for convenience --- Update and improve INDEX, README, and FAQ --- Update CMakeLists.txt for the return of zconf.h [Lowman] --- Update contrib/vstudio/vc9 and vc10 [Vollant] --- Change libz.dll.a back to libzdll.a in win32/Makefile.gcc --- Apply license and readme changes to contrib/asm686 [Raiter] --- Check file name lengths and add -c option in minigzip.c [Li] --- Update contrib/amd64 and contrib/masmx86/ [Vollant] --- Avoid use of "eof" parameter in trees.c to not shadow library variable --- Update make_vms.com for removal of zlibdefs.h [Zinser] --- Update assembler code and vstudio projects in contrib [Vollant] --- Remove outdated assembler code contrib/masm686 and contrib/asm586 --- Remove old vc7 and vc8 from contrib/vstudio --- Update win32/Makefile.msc, add ZLIB_VER_SUBREVISION [Rowe] --- Fix memory leaks in gzclose_r() and gzclose_w(), file leak in gz_open() --- Add contrib/gcc_gvmat64 for longest_match and inflate_fast [Vollant] --- Remove *64 functions from win32/zlib.def (they're not 64-bit yet) --- Fix bug in void-returning vsprintf() case in gzwrite.c --- Fix name change from inflate.h in contrib/inflate86/inffas86.c --- Check if temporary file exists before removing in make_vms.com [Zinser] --- Fix make install and uninstall for --static option --- Fix usage of _MSC_VER in gzguts.h and zutil.h [Truta] --- Update readme.txt in contrib/masmx64 and masmx86 to assemble -- --Changes in 1.2.3.9 (21 Feb 2010) --- Expunge gzio.c --- Move as400 build information to old --- Fix updates in contrib/minizip and contrib/vstudio --- Add const to vsnprintf test in configure to avoid warnings [Weigelt] --- Delete zconf.h (made by configure) [Weigelt] --- Change zconf.in.h to zconf.h.in per convention [Weigelt] --- Check for NULL buf in gzgets() --- Return empty string for gzgets() with len == 1 (like fgets()) --- Fix description of gzgets() in zlib.h for end-of-file, NULL return --- Update minizip to 1.1 [Vollant] --- Avoid MSVC loss of data warnings in gzread.c, gzwrite.c --- Note in zlib.h that gzerror() should be used to distinguish from EOF --- Remove use of snprintf() from gzlib.c --- Fix bug in gzseek() --- Update contrib/vstudio, adding vc9 and vc10 [Kuno, Vollant] --- Fix zconf.h generation in CMakeLists.txt [Lowman] --- Improve comments in zconf.h where modified by configure -- --Changes in 1.2.3.8 (13 Feb 2010) --- Clean up text files (tabs, trailing whitespace, etc.) [Oberhumer] --- Use z_off64_t in gz_zero() and gz_skip() to match state->skip --- Avoid comparison problem when sizeof(int) == sizeof(z_off64_t) --- Revert to Makefile.in from 1.2.3.6 (live with the clutter) --- Fix missing error return in gzflush(), add zlib.h note --- Add *64 functions to zlib.map [Levin] --- Fix signed/unsigned comparison in gz_comp() --- Use SFLAGS when testing shared linking in configure --- Add --64 option to ./configure to use -m64 with gcc --- Fix ./configure --help to correctly name options --- Have make fail if a test fails [Levin] --- Avoid buffer overrun in contrib/masmx64/gvmat64.asm [Simpson] --- Remove assembler object files from contrib -- --Changes in 1.2.3.7 (24 Jan 2010) --- Always gzopen() with O_LARGEFILE if available --- Fix gzdirect() to work immediately after gzopen() or gzdopen() --- Make gzdirect() more precise when the state changes while reading --- Improve zlib.h documentation in many places --- Catch memory allocation failure in gz_open() --- Complete close operation if seek forward in gzclose_w() fails --- Return Z_ERRNO from gzclose_r() if close() fails --- Return Z_STREAM_ERROR instead of EOF for gzclose() being passed NULL --- Return zero for gzwrite() errors to match zlib.h description --- Return -1 on gzputs() error to match zlib.h description --- Add zconf.in.h to allow recovery from configure modification [Weigelt] --- Fix static library permissions in Makefile.in [Weigelt] --- Avoid warnings in configure tests that hide functionality [Weigelt] --- Add *BSD and DragonFly to Linux case in configure [gentoo 123571] --- Change libzdll.a to libz.dll.a in win32/Makefile.gcc [gentoo 288212] --- Avoid access of uninitialized data for first inflateReset2 call [Gomes] --- Keep object files in subdirectories to reduce the clutter somewhat --- Remove default Makefile and zlibdefs.h, add dummy Makefile --- Add new external functions to Z_PREFIX, remove duplicates, z_z_ -> z_ --- Remove zlibdefs.h completely -- modify zconf.h instead -- --Changes in 1.2.3.6 (17 Jan 2010) --- Avoid void * arithmetic in gzread.c and gzwrite.c --- Make compilers happier with const char * for gz_error message --- Avoid unused parameter warning in inflate.c --- Avoid signed-unsigned comparison warning in inflate.c --- Indent #pragma's for traditional C --- Fix usage of strwinerror() in glib.c, change to gz_strwinerror() --- Correct email address in configure for system options --- Update make_vms.com and add make_vms.com to contrib/minizip [Zinser] --- Update zlib.map [Brown] --- Fix Makefile.in for Solaris 10 make of example64 and minizip64 [Torok] --- Apply various fixes to CMakeLists.txt [Lowman] --- Add checks on len in gzread() and gzwrite() --- Add error message for no more room for gzungetc() --- Remove zlib version check in gzwrite() --- Defer compression of gzprintf() result until need to --- Use snprintf() in gzdopen() if available --- Remove USE_MMAP configuration determination (only used by minigzip) --- Remove examples/pigz.c (available separately) --- Update examples/gun.c to 1.6 -- --Changes in 1.2.3.5 (8 Jan 2010) --- Add space after #if in zutil.h for some compilers --- Fix relatively harmless bug in deflate_fast() [Exarevsky] --- Fix same problem in deflate_slow() --- Add $(SHAREDLIBV) to LIBS in Makefile.in [Brown] --- Add deflate_rle() for faster Z_RLE strategy run-length encoding --- Add deflate_huff() for faster Z_HUFFMAN_ONLY encoding --- Change name of "write" variable in inffast.c to avoid library collisions --- Fix premature EOF from gzread() in gzio.c [Brown] --- Use zlib header window size if windowBits is 0 in inflateInit2() --- Remove compressBound() call in deflate.c to avoid linking compress.o --- Replace use of errno in gz* with functions, support WinCE [Alves] --- Provide alternative to perror() in minigzip.c for WinCE [Alves] --- Don't use _vsnprintf on later versions of MSVC [Lowman] --- Add CMake build script and input file [Lowman] --- Update contrib/minizip to 1.1 [Svensson, Vollant] --- Moved nintendods directory from contrib to . --- Replace gzio.c with a new set of routines with the same functionality --- Add gzbuffer(), gzoffset(), gzclose_r(), gzclose_w() as part of above --- Update contrib/minizip to 1.1b --- Change gzeof() to return 0 on error instead of -1 to agree with zlib.h -- --Changes in 1.2.3.4 (21 Dec 2009) --- Use old school .SUFFIXES in Makefile.in for FreeBSD compatibility --- Update comments in configure and Makefile.in for default --shared --- Fix test -z's in configure [Marquess] --- Build examplesh and minigzipsh when not testing --- Change NULL's to Z_NULL's in deflate.c and in comments in zlib.h --- Import LDFLAGS from the environment in configure --- Fix configure to populate SFLAGS with discovered CFLAGS options --- Adapt make_vms.com to the new Makefile.in [Zinser] --- Add zlib2ansi script for C++ compilation [Marquess] --- Add _FILE_OFFSET_BITS=64 test to make test (when applicable) --- Add AMD64 assembler code for longest match to contrib [Teterin] --- Include options from $SFLAGS when doing $LDSHARED --- Simplify 64-bit file support by introducing z_off64_t type --- Make shared object files in objs directory to work around old Sun cc --- Use only three-part version number for Darwin shared compiles --- Add rc option to ar in Makefile.in for when ./configure not run --- Add -WI,-rpath,. to LDFLAGS for OSF 1 V4* --- Set LD_LIBRARYN32_PATH for SGI IRIX shared compile --- Protect against _FILE_OFFSET_BITS being defined when compiling zlib --- Rename Makefile.in targets allstatic to static and allshared to shared --- Fix static and shared Makefile.in targets to be independent --- Correct error return bug in gz_open() by setting state [Brown] --- Put spaces before ;;'s in configure for better sh compatibility --- Add pigz.c (parallel implementation of gzip) to examples/ --- Correct constant in crc32.c to UL [Leventhal] --- Reject negative lengths in crc32_combine() --- Add inflateReset2() function to work like inflateEnd()/inflateInit2() --- Include sys/types.h for _LARGEFILE64_SOURCE [Brown] --- Correct typo in doc/algorithm.txt [Janik] --- Fix bug in adler32_combine() [Zhu] --- Catch missing-end-of-block-code error in all inflates and in puff -- Assures that random input to inflate eventually results in an error --- Added enough.c (calculation of ENOUGH for inftrees.h) to examples/ --- Update ENOUGH and its usage to reflect discovered bounds --- Fix gzerror() error report on empty input file [Brown] --- Add ush casts in trees.c to avoid pedantic runtime errors --- Fix typo in zlib.h uncompress() description [Reiss] --- Correct inflate() comments with regard to automatic header detection --- Remove deprecation comment on Z_PARTIAL_FLUSH (it stays) --- Put new version of gzlog (2.0) in examples with interruption recovery --- Add puff compile option to permit invalid distance-too-far streams --- Add puff TEST command options, ability to read piped input --- Prototype the *64 functions in zlib.h when _FILE_OFFSET_BITS == 64, but -- _LARGEFILE64_SOURCE not defined --- Fix Z_FULL_FLUSH to truly erase the past by resetting s->strstart --- Fix deflateSetDictionary() to use all 32K for output consistency --- Remove extraneous #define MIN_LOOKAHEAD in deflate.c (in deflate.h) --- Clear bytes after deflate lookahead to avoid use of uninitialized data --- Change a limit in inftrees.c to be more transparent to Coverity Prevent --- Update win32/zlib.def with exported symbols from zlib.h --- Correct spelling error in zlib.h [Willem] --- Allow Z_BLOCK for deflate() to force a new block --- Allow negative bits in inflatePrime() to delete existing bit buffer --- Add Z_TREES flush option to inflate() to return at end of trees --- Add inflateMark() to return current state information for random access --- Add Makefile for NintendoDS to contrib [Costa] --- Add -w in configure compile tests to avoid spurious warnings [Beucler] --- Fix typos in zlib.h comments for deflateSetDictionary() --- Fix EOF detection in transparent gzread() [Maier] -- --Changes in 1.2.3.3 (2 October 2006) --- Make --shared the default for configure, add a --static option --- Add compile option to permit invalid distance-too-far streams --- Add inflateUndermine() function which is required to enable above --- Remove use of "this" variable name for C++ compatibility [Marquess] --- Add testing of shared library in make test, if shared library built --- Use ftello() and fseeko() if available instead of ftell() and fseek() --- Provide two versions of all functions that use the z_off_t type for -- binary compatibility -- a normal version and a 64-bit offset version, -- per the Large File Support Extension when _LARGEFILE64_SOURCE is -- defined; use the 64-bit versions by default when _FILE_OFFSET_BITS -- is defined to be 64 --- Add a --uname= option to configure to perhaps help with cross-compiling -- --Changes in 1.2.3.2 (3 September 2006) --- Turn off silly Borland warnings [Hay] --- Use off64_t and define _LARGEFILE64_SOURCE when present --- Fix missing dependency on inffixed.h in Makefile.in --- Rig configure --shared to build both shared and static [Teredesai, Truta] --- Remove zconf.in.h and instead create a new zlibdefs.h file --- Fix contrib/minizip/unzip.c non-encrypted after encrypted [Vollant] --- Add treebuild.xml (see http://treebuild.metux.de/) [Weigelt] -- --Changes in 1.2.3.1 (16 August 2006) --- Add watcom directory with OpenWatcom make files [Daniel] --- Remove #undef of FAR in zconf.in.h for MVS [Fedtke] --- Update make_vms.com [Zinser] --- Use -fPIC for shared build in configure [Teredesai, Nicholson] --- Use only major version number for libz.so on IRIX and OSF1 [Reinholdtsen] --- Use fdopen() (not _fdopen()) for Interix in zutil.h [BŠck] --- Add some FAQ entries about the contrib directory --- Update the MVS question in the FAQ --- Avoid extraneous reads after EOF in gzio.c [Brown] --- Correct spelling of "successfully" in gzio.c [Randers-Pehrson] --- Add comments to zlib.h about gzerror() usage [Brown] --- Set extra flags in gzip header in gzopen() like deflate() does --- Make configure options more compatible with double-dash conventions -- [Weigelt] --- Clean up compilation under Solaris SunStudio cc [Rowe, Reinholdtsen] --- Fix uninstall target in Makefile.in [Truta] --- Add pkgconfig support [Weigelt] --- Use $(DESTDIR) macro in Makefile.in [Reinholdtsen, Weigelt] --- Replace set_data_type() with a more accurate detect_data_type() in -- trees.c, according to the txtvsbin.txt document [Truta] --- Swap the order of #include and #include "zlib.h" in -- gzio.c, example.c and minigzip.c [Truta] --- Shut up annoying VS2005 warnings about standard C deprecation [Rowe, -- Truta] (where?) --- Fix target "clean" from win32/Makefile.bor [Truta] --- Create .pdb and .manifest files in win32/makefile.msc [Ziegler, Rowe] --- Update zlib www home address in win32/DLL_FAQ.txt [Truta] --- Update contrib/masmx86/inffas32.asm for VS2005 [Vollant, Van Wassenhove] --- Enable browse info in the "Debug" and "ASM Debug" configurations in -- the Visual C++ 6 project, and set (non-ASM) "Debug" as default [Truta] --- Add pkgconfig support [Weigelt] --- Add ZLIB_VER_MAJOR, ZLIB_VER_MINOR and ZLIB_VER_REVISION in zlib.h, -- for use in win32/zlib1.rc [Polushin, Rowe, Truta] --- Add a document that explains the new text detection scheme to -- doc/txtvsbin.txt [Truta] --- Add rfc1950.txt, rfc1951.txt and rfc1952.txt to doc/ [Truta] --- Move algorithm.txt into doc/ [Truta] --- Synchronize FAQ with website --- Fix compressBound(), was low for some pathological cases [Fearnley] --- Take into account wrapper variations in deflateBound() --- Set examples/zpipe.c input and output to binary mode for Windows --- Update examples/zlib_how.html with new zpipe.c (also web site) --- Fix some warnings in examples/gzlog.c and examples/zran.c (it seems -- that gcc became pickier in 4.0) --- Add zlib.map for Linux: "All symbols from zlib-1.1.4 remain -- un-versioned, the patch adds versioning only for symbols introduced in -- zlib-1.2.0 or later. It also declares as local those symbols which are -- not designed to be exported." [Levin] --- Update Z_PREFIX list in zconf.in.h, add --zprefix option to configure --- Do not initialize global static by default in trees.c, add a response -- NO_INIT_GLOBAL_POINTERS to initialize them if needed [Marquess] --- Don't use strerror() in gzio.c under WinCE [Yakimov] --- Don't use errno.h in zutil.h under WinCE [Yakimov] --- Move arguments for AR to its usage to allow replacing ar [Marot] --- Add HAVE_VISIBILITY_PRAGMA in zconf.in.h for Mozilla [Randers-Pehrson] --- Improve inflateInit() and inflateInit2() documentation --- Fix structure size comment in inflate.h --- Change configure help option from --h* to --help [Santos] -- --Changes in 1.2.3 (18 July 2005) --- Apply security vulnerability fixes to contrib/infback9 as well --- Clean up some text files (carriage returns, trailing space) --- Update testzlib, vstudio, masmx64, and masmx86 in contrib [Vollant] -- --Changes in 1.2.2.4 (11 July 2005) --- Add inflatePrime() function for starting inflation at bit boundary --- Avoid some Visual C warnings in deflate.c --- Avoid more silly Visual C warnings in inflate.c and inftrees.c for 64-bit -- compile --- Fix some spelling errors in comments [Betts] --- Correct inflateInit2() error return documentation in zlib.h --- Add zran.c example of compressed data random access to examples -- directory, shows use of inflatePrime() --- Fix cast for assignments to strm->state in inflate.c and infback.c --- Fix zlibCompileFlags() in zutil.c to use 1L for long shifts [Oberhumer] --- Move declarations of gf2 functions to right place in crc32.c [Oberhumer] --- Add cast in trees.c t avoid a warning [Oberhumer] --- Avoid some warnings in fitblk.c, gun.c, gzjoin.c in examples [Oberhumer] --- Update make_vms.com [Zinser] --- Initialize state->write in inflateReset() since copied in inflate_fast() --- Be more strict on incomplete code sets in inflate_table() and increase -- ENOUGH and MAXD -- this repairs a possible security vulnerability for -- invalid inflate input. Thanks to Tavis Ormandy and Markus Oberhumer for -- discovering the vulnerability and providing test cases. --- Add ia64 support to configure for HP-UX [Smith] --- Add error return to gzread() for format or i/o error [Levin] --- Use malloc.h for OS/2 [Necasek] -- --Changes in 1.2.2.3 (27 May 2005) --- Replace 1U constants in inflate.c and inftrees.c for 64-bit compile --- Typecast fread() return values in gzio.c [Vollant] --- Remove trailing space in minigzip.c outmode (VC++ can't deal with it) --- Fix crc check bug in gzread() after gzungetc() [Heiner] --- Add the deflateTune() function to adjust internal compression parameters --- Add a fast gzip decompressor, gun.c, to examples (use of inflateBack) --- Remove an incorrect assertion in examples/zpipe.c --- Add C++ wrapper in infback9.h [Donais] --- Fix bug in inflateCopy() when decoding fixed codes --- Note in zlib.h how much deflateSetDictionary() actually uses --- Remove USE_DICT_HEAD in deflate.c (would mess up inflate if used) --- Add _WIN32_WCE to define WIN32 in zconf.in.h [Spencer] --- Don't include stderr.h or errno.h for _WIN32_WCE in zutil.h [Spencer] --- Add gzdirect() function to indicate transparent reads --- Update contrib/minizip [Vollant] --- Fix compilation of deflate.c when both ASMV and FASTEST [Oberhumer] --- Add casts in crc32.c to avoid warnings [Oberhumer] --- Add contrib/masmx64 [Vollant] --- Update contrib/asm586, asm686, masmx86, testzlib, vstudio [Vollant] -- --Changes in 1.2.2.2 (30 December 2004) --- Replace structure assignments in deflate.c and inflate.c with zmemcpy to -- avoid implicit memcpy calls (portability for no-library compilation) --- Increase sprintf() buffer size in gzdopen() to allow for large numbers --- Add INFLATE_STRICT to check distances against zlib header --- Improve WinCE errno handling and comments [Chang] --- Remove comment about no gzip header processing in FAQ --- Add Z_FIXED strategy option to deflateInit2() to force fixed trees --- Add updated make_vms.com [Coghlan], update README --- Create a new "examples" directory, move gzappend.c there, add zpipe.c, -- fitblk.c, gzlog.[ch], gzjoin.c, and zlib_how.html. --- Add FAQ entry and comments in deflate.c on uninitialized memory access --- Add Solaris 9 make options in configure [Gilbert] --- Allow strerror() usage in gzio.c for STDC --- Fix DecompressBuf in contrib/delphi/ZLib.pas [ManChesTer] --- Update contrib/masmx86/inffas32.asm and gvmat32.asm [Vollant] --- Use z_off_t for adler32_combine() and crc32_combine() lengths --- Make adler32() much faster for small len --- Use OS_CODE in deflate() default gzip header -- --Changes in 1.2.2.1 (31 October 2004) --- Allow inflateSetDictionary() call for raw inflate --- Fix inflate header crc check bug for file names and comments --- Add deflateSetHeader() and gz_header structure for custom gzip headers --- Add inflateGetheader() to retrieve gzip headers --- Add crc32_combine() and adler32_combine() functions --- Add alloc_func, free_func, in_func, out_func to Z_PREFIX list --- Use zstreamp consistently in zlib.h (inflate_back functions) --- Remove GUNZIP condition from definition of inflate_mode in inflate.h -- and in contrib/inflate86/inffast.S [Truta, Anderson] --- Add support for AMD64 in contrib/inflate86/inffas86.c [Anderson] --- Update projects/README.projects and projects/visualc6 [Truta] --- Update win32/DLL_FAQ.txt [Truta] --- Avoid warning under NO_GZCOMPRESS in gzio.c; fix typo [Truta] --- Deprecate Z_ASCII; use Z_TEXT instead [Truta] --- Use a new algorithm for setting strm->data_type in trees.c [Truta] --- Do not define an exit() prototype in zutil.c unless DEBUG defined --- Remove prototype of exit() from zutil.c, example.c, minigzip.c [Truta] --- Add comment in zlib.h for Z_NO_FLUSH parameter to deflate() --- Fix Darwin build version identification [Peterson] -- --Changes in 1.2.2 (3 October 2004) --- Update zlib.h comments on gzip in-memory processing --- Set adler to 1 in inflateReset() to support Java test suite [Walles] --- Add contrib/dotzlib [Ravn] --- Update win32/DLL_FAQ.txt [Truta] --- Update contrib/minizip [Vollant] --- Move contrib/visual-basic.txt to old/ [Truta] --- Fix assembler builds in projects/visualc6/ [Truta] -- --Changes in 1.2.1.2 (9 September 2004) --- Update INDEX file --- Fix trees.c to update strm->data_type (no one ever noticed!) --- Fix bug in error case in inflate.c, infback.c, and infback9.c [Brown] --- Add "volatile" to crc table flag declaration (for DYNAMIC_CRC_TABLE) --- Add limited multitasking protection to DYNAMIC_CRC_TABLE --- Add NO_vsnprintf for VMS in zutil.h [Mozilla] --- Don't declare strerror() under VMS [Mozilla] --- Add comment to DYNAMIC_CRC_TABLE to use get_crc_table() to initialize --- Update contrib/ada [Anisimkov] --- Update contrib/minizip [Vollant] --- Fix configure to not hardcode directories for Darwin [Peterson] --- Fix gzio.c to not return error on empty files [Brown] --- Fix indentation; update version in contrib/delphi/ZLib.pas and -- contrib/pascal/zlibpas.pas [Truta] --- Update mkasm.bat in contrib/masmx86 [Truta] --- Update contrib/untgz [Truta] --- Add projects/README.projects [Truta] --- Add project for MS Visual C++ 6.0 in projects/visualc6 [Cadieux, Truta] --- Update win32/DLL_FAQ.txt [Truta] --- Update list of Z_PREFIX symbols in zconf.h [Randers-Pehrson, Truta] --- Remove an unnecessary assignment to curr in inftrees.c [Truta] --- Add OS/2 to exe builds in configure [Poltorak] --- Remove err dummy parameter in zlib.h [Kientzle] -- --Changes in 1.2.1.1 (9 January 2004) --- Update email address in README --- Several FAQ updates --- Fix a big fat bug in inftrees.c that prevented decoding valid -- dynamic blocks with only literals and no distance codes -- -- Thanks to "Hot Emu" for the bug report and sample file --- Add a note to puff.c on no distance codes case. -- --Changes in 1.2.1 (17 November 2003) --- Remove a tab in contrib/gzappend/gzappend.c --- Update some interfaces in contrib for new zlib functions --- Update zlib version number in some contrib entries --- Add Windows CE definition for ptrdiff_t in zutil.h [Mai, Truta] --- Support shared libraries on Hurd and KFreeBSD [Brown] --- Fix error in NO_DIVIDE option of adler32.c -- --Changes in 1.2.0.8 (4 November 2003) --- Update version in contrib/delphi/ZLib.pas and contrib/pascal/zlibpas.pas --- Add experimental NO_DIVIDE #define in adler32.c -- - Possibly faster on some processors (let me know if it is) --- Correct Z_BLOCK to not return on first inflate call if no wrap --- Fix strm->data_type on inflate() return to correctly indicate EOB --- Add deflatePrime() function for appending in the middle of a byte --- Add contrib/gzappend for an example of appending to a stream --- Update win32/DLL_FAQ.txt [Truta] --- Delete Turbo C comment in README [Truta] --- Improve some indentation in zconf.h [Truta] --- Fix infinite loop on bad input in configure script [Church] --- Fix gzeof() for concatenated gzip files [Johnson] --- Add example to contrib/visual-basic.txt [Michael B.] --- Add -p to mkdir's in Makefile.in [vda] --- Fix configure to properly detect presence or lack of printf functions --- Add AS400 support [Monnerat] --- Add a little Cygwin support [Wilson] -- --Changes in 1.2.0.7 (21 September 2003) --- Correct some debug formats in contrib/infback9 --- Cast a type in a debug statement in trees.c --- Change search and replace delimiter in configure from % to # [Beebe] --- Update contrib/untgz to 0.2 with various fixes [Truta] --- Add build support for Amiga [Nikl] --- Remove some directories in old that have been updated to 1.2 --- Add dylib building for Mac OS X in configure and Makefile.in --- Remove old distribution stuff from Makefile --- Update README to point to DLL_FAQ.txt, and add comment on Mac OS X --- Update links in README -- --Changes in 1.2.0.6 (13 September 2003) --- Minor FAQ updates --- Update contrib/minizip to 1.00 [Vollant] --- Remove test of gz functions in example.c when GZ_COMPRESS defined [Truta] --- Update POSTINC comment for 68060 [Nikl] --- Add contrib/infback9 with deflate64 decoding (unsupported) --- For MVS define NO_vsnprintf and undefine FAR [van Burik] --- Add pragma for fdopen on MVS [van Burik] -- --Changes in 1.2.0.5 (8 September 2003) --- Add OF to inflateBackEnd() declaration in zlib.h --- Remember start when using gzdopen in the middle of a file --- Use internal off_t counters in gz* functions to properly handle seeks --- Perform more rigorous check for distance-too-far in inffast.c --- Add Z_BLOCK flush option to return from inflate at block boundary --- Set strm->data_type on return from inflate -- - Indicate bits unused, if at block boundary, and if in last block --- Replace size_t with ptrdiff_t in crc32.c, and check for correct size --- Add condition so old NO_DEFLATE define still works for compatibility --- FAQ update regarding the Windows DLL [Truta] --- INDEX update: add qnx entry, remove aix entry [Truta] --- Install zlib.3 into mandir [Wilson] --- Move contrib/zlib_dll_FAQ.txt to win32/DLL_FAQ.txt; update [Truta] --- Adapt the zlib interface to the new DLL convention guidelines [Truta] --- Introduce ZLIB_WINAPI macro to allow the export of functions using -- the WINAPI calling convention, for Visual Basic [Vollant, Truta] --- Update msdos and win32 scripts and makefiles [Truta] --- Export symbols by name, not by ordinal, in win32/zlib.def [Truta] --- Add contrib/ada [Anisimkov] --- Move asm files from contrib/vstudio/vc70_32 to contrib/asm386 [Truta] --- Rename contrib/asm386 to contrib/masmx86 [Truta, Vollant] --- Add contrib/masm686 [Truta] --- Fix offsets in contrib/inflate86 and contrib/masmx86/inffas32.asm -- [Truta, Vollant] --- Update contrib/delphi; rename to contrib/pascal; add example [Truta] --- Remove contrib/delphi2; add a new contrib/delphi [Truta] --- Avoid inclusion of the nonstandard in contrib/iostream, -- and fix some method prototypes [Truta] --- Fix the ZCR_SEED2 constant to avoid warnings in contrib/minizip -- [Truta] --- Avoid the use of backslash (\) in contrib/minizip [Vollant] --- Fix file time handling in contrib/untgz; update makefiles [Truta] --- Update contrib/vstudio/vc70_32 to comply with the new DLL guidelines -- [Vollant] --- Remove contrib/vstudio/vc15_16 [Vollant] --- Rename contrib/vstudio/vc70_32 to contrib/vstudio/vc7 [Truta] --- Update README.contrib [Truta] --- Invert the assignment order of match_head and s->prev[...] in -- INSERT_STRING [Truta] --- Compare TOO_FAR with 32767 instead of 32768, to avoid 16-bit warnings -- [Truta] --- Compare function pointers with 0, not with NULL or Z_NULL [Truta] --- Fix prototype of syncsearch in inflate.c [Truta] --- Introduce ASMINF macro to be enabled when using an ASM implementation -- of inflate_fast [Truta] --- Change NO_DEFLATE to NO_GZCOMPRESS [Truta] --- Modify test_gzio in example.c to take a single file name as a -- parameter [Truta] --- Exit the example.c program if gzopen fails [Truta] --- Add type casts around strlen in example.c [Truta] --- Remove casting to sizeof in minigzip.c; give a proper type -- to the variable compared with SUFFIX_LEN [Truta] --- Update definitions of STDC and STDC99 in zconf.h [Truta] --- Synchronize zconf.h with the new Windows DLL interface [Truta] --- Use SYS16BIT instead of __32BIT__ to distinguish between -- 16- and 32-bit platforms [Truta] --- Use far memory allocators in small 16-bit memory models for -- Turbo C [Truta] --- Add info about the use of ASMV, ASMINF and ZLIB_WINAPI in -- zlibCompileFlags [Truta] --- Cygwin has vsnprintf [Wilson] --- In Windows16, OS_CODE is 0, as in MSDOS [Truta] --- In Cygwin, OS_CODE is 3 (Unix), not 11 (Windows32) [Wilson] -- --Changes in 1.2.0.4 (10 August 2003) --- Minor FAQ updates --- Be more strict when checking inflateInit2's windowBits parameter --- Change NO_GUNZIP compile option to NO_GZIP to cover deflate as well --- Add gzip wrapper option to deflateInit2 using windowBits --- Add updated QNX rule in configure and qnx directory [Bonnefoy] --- Make inflate distance-too-far checks more rigorous --- Clean up FAR usage in inflate --- Add casting to sizeof() in gzio.c and minigzip.c -- --Changes in 1.2.0.3 (19 July 2003) --- Fix silly error in gzungetc() implementation [Vollant] --- Update contrib/minizip and contrib/vstudio [Vollant] --- Fix printf format in example.c --- Correct cdecl support in zconf.in.h [Anisimkov] --- Minor FAQ updates -- --Changes in 1.2.0.2 (13 July 2003) --- Add ZLIB_VERNUM in zlib.h for numerical preprocessor comparisons --- Attempt to avoid warnings in crc32.c for pointer-int conversion --- Add AIX to configure, remove aix directory [Bakker] --- Add some casts to minigzip.c --- Improve checking after insecure sprintf() or vsprintf() calls --- Remove #elif's from crc32.c --- Change leave label to inf_leave in inflate.c and infback.c to avoid -- library conflicts --- Remove inflate gzip decoding by default--only enable gzip decoding by -- special request for stricter backward compatibility --- Add zlibCompileFlags() function to return compilation information --- More typecasting in deflate.c to avoid warnings --- Remove leading underscore from _Capital #defines [Truta] --- Fix configure to link shared library when testing --- Add some Windows CE target adjustments [Mai] --- Remove #define ZLIB_DLL in zconf.h [Vollant] --- Add zlib.3 [Rodgers] --- Update RFC URL in deflate.c and algorithm.txt [Mai] --- Add zlib_dll_FAQ.txt to contrib [Truta] --- Add UL to some constants [Truta] --- Update minizip and vstudio [Vollant] --- Remove vestigial NEED_DUMMY_RETURN from zconf.in.h --- Expand use of NO_DUMMY_DECL to avoid all dummy structures --- Added iostream3 to contrib [Schwardt] --- Replace rewind() with fseek() for WinCE [Truta] --- Improve setting of zlib format compression level flags -- - Report 0 for huffman and rle strategies and for level == 0 or 1 -- - Report 2 only for level == 6 --- Only deal with 64K limit when necessary at compile time [Truta] --- Allow TOO_FAR check to be turned off at compile time [Truta] --- Add gzclearerr() function [Souza] --- Add gzungetc() function -- --Changes in 1.2.0.1 (17 March 2003) --- Add Z_RLE strategy for run-length encoding [Truta] -- - When Z_RLE requested, restrict matches to distance one -- - Update zlib.h, minigzip.c, gzopen(), gzdopen() for Z_RLE --- Correct FASTEST compilation to allow level == 0 --- Clean up what gets compiled for FASTEST --- Incorporate changes to zconf.in.h [Vollant] -- - Refine detection of Turbo C need for dummy returns -- - Refine ZLIB_DLL compilation -- - Include additional header file on VMS for off_t typedef --- Try to use _vsnprintf where it supplants vsprintf [Vollant] --- Add some casts in inffast.c --- Enchance comments in zlib.h on what happens if gzprintf() tries to -- write more than 4095 bytes before compression --- Remove unused state from inflateBackEnd() --- Remove exit(0) from minigzip.c, example.c --- Get rid of all those darn tabs --- Add "check" target to Makefile.in that does the same thing as "test" --- Add "mostlyclean" and "maintainer-clean" targets to Makefile.in --- Update contrib/inflate86 [Anderson] --- Update contrib/testzlib, contrib/vstudio, contrib/minizip [Vollant] --- Add msdos and win32 directories with makefiles [Truta] --- More additions and improvements to the FAQ -- --Changes in 1.2.0 (9 March 2003) --- New and improved inflate code -- - About 20% faster -- - Does not allocate 32K window unless and until needed -- - Automatically detects and decompresses gzip streams -- - Raw inflate no longer needs an extra dummy byte at end -- - Added inflateBack functions using a callback interface--even faster -- than inflate, useful for file utilities (gzip, zip) -- - Added inflateCopy() function to record state for random access on -- externally generated deflate streams (e.g. in gzip files) -- - More readable code (I hope) --- New and improved crc32() -- - About 50% faster, thanks to suggestions from Rodney Brown --- Add deflateBound() and compressBound() functions --- Fix memory leak in deflateInit2() --- Permit setting dictionary for raw deflate (for parallel deflate) --- Fix const declaration for gzwrite() --- Check for some malloc() failures in gzio.c --- Fix bug in gzopen() on single-byte file 0x1f --- Fix bug in gzread() on concatenated file with 0x1f at end of buffer -- and next buffer doesn't start with 0x8b --- Fix uncompress() to return Z_DATA_ERROR on truncated input --- Free memory at end of example.c --- Remove MAX #define in trees.c (conflicted with some libraries) --- Fix static const's in deflate.c, gzio.c, and zutil.[ch] --- Declare malloc() and free() in gzio.c if STDC not defined --- Use malloc() instead of calloc() in zutil.c if int big enough --- Define STDC for AIX --- Add aix/ with approach for compiling shared library on AIX --- Add HP-UX support for shared libraries in configure --- Add OpenUNIX support for shared libraries in configure --- Use $cc instead of gcc to build shared library --- Make prefix directory if needed when installing --- Correct Macintosh avoidance of typedef Byte in zconf.h --- Correct Turbo C memory allocation when under Linux --- Use libz.a instead of -lz in Makefile (assure use of compiled library) --- Update configure to check for snprintf or vsnprintf functions and their -- return value, warn during make if using an insecure function --- Fix configure problem with compile-time knowledge of HAVE_UNISTD_H that -- is lost when library is used--resolution is to build new zconf.h --- Documentation improvements (in zlib.h): -- - Document raw deflate and inflate -- - Update RFCs URL -- - Point out that zlib and gzip formats are different -- - Note that Z_BUF_ERROR is not fatal -- - Document string limit for gzprintf() and possible buffer overflow -- - Note requirement on avail_out when flushing -- - Note permitted values of flush parameter of inflate() --- Add some FAQs (and even answers) to the FAQ --- Add contrib/inflate86/ for x86 faster inflate --- Add contrib/blast/ for PKWare Data Compression Library decompression --- Add contrib/puff/ simple inflate for deflate format description -- --Changes in 1.1.4 (11 March 2002) --- ZFREE was repeated on same allocation on some error conditions. -- This creates a security problem described in -- http://www.zlib.org/advisory-2002-03-11.txt --- Returned incorrect error (Z_MEM_ERROR) on some invalid data --- Avoid accesses before window for invalid distances with inflate window -- less than 32K. --- force windowBits > 8 to avoid a bug in the encoder for a window size -- of 256 bytes. (A complete fix will be available in 1.1.5). -- --Changes in 1.1.3 (9 July 1998) --- fix "an inflate input buffer bug that shows up on rare but persistent -- occasions" (Mark) --- fix gzread and gztell for concatenated .gz files (Didier Le Botlan) --- fix gzseek(..., SEEK_SET) in write mode --- fix crc check after a gzeek (Frank Faubert) --- fix miniunzip when the last entry in a zip file is itself a zip file -- (J Lillge) --- add contrib/asm586 and contrib/asm686 (Brian Raiter) -- See http://www.muppetlabs.com/~breadbox/software/assembly.html --- add support for Delphi 3 in contrib/delphi (Bob Dellaca) --- add support for C++Builder 3 and Delphi 3 in contrib/delphi2 (Davide Moretti) --- do not exit prematurely in untgz if 0 at start of block (Magnus Holmgren) --- use macro EXTERN instead of extern to support DLL for BeOS (Sander Stoks) --- added a FAQ file -- --- Support gzdopen on Mac with Metrowerks (Jason Linhart) --- Do not redefine Byte on Mac (Brad Pettit & Jason Linhart) --- define SEEK_END too if SEEK_SET is not defined (Albert Chin-A-Young) --- avoid some warnings with Borland C (Tom Tanner) --- fix a problem in contrib/minizip/zip.c for 16-bit MSDOS (Gilles Vollant) --- emulate utime() for WIN32 in contrib/untgz (Gilles Vollant) --- allow several arguments to configure (Tim Mooney, Frodo Looijaard) --- use libdir and includedir in Makefile.in (Tim Mooney) --- support shared libraries on OSF1 V4 (Tim Mooney) --- remove so_locations in "make clean" (Tim Mooney) --- fix maketree.c compilation error (Glenn, Mark) --- Python interface to zlib now in Python 1.5 (Jeremy Hylton) --- new Makefile.riscos (Rich Walker) --- initialize static descriptors in trees.c for embedded targets (Nick Smith) --- use "foo-gz" in example.c for RISCOS and VMS (Nick Smith) --- add the OS/2 files in Makefile.in too (Andrew Zabolotny) --- fix fdopen and halloc macros for Microsoft C 6.0 (Tom Lane) --- fix maketree.c to allow clean compilation of inffixed.h (Mark) --- fix parameter check in deflateCopy (Gunther Nikl) --- cleanup trees.c, use compressed_len only in debug mode (Christian Spieler) --- Many portability patches by Christian Spieler: -- . zutil.c, zutil.h: added "const" for zmem* -- . Make_vms.com: fixed some typos -- . Make_vms.com: msdos/Makefile.*: removed zutil.h from some dependency lists -- . msdos/Makefile.msc: remove "default rtl link library" info from obj files -- . msdos/Makefile.*: use model-dependent name for the built zlib library -- . msdos/Makefile.emx, nt/Makefile.emx, nt/Makefile.gcc: -- new makefiles, for emx (DOS/OS2), emx&rsxnt and mingw32 (Windows 9x / NT) --- use define instead of typedef for Bytef also for MSC small/medium (Tom Lane) --- replace __far with _far for better portability (Christian Spieler, Tom Lane) --- fix test for errno.h in configure (Tim Newsham) -- --Changes in 1.1.2 (19 March 98) --- added contrib/minzip, mini zip and unzip based on zlib (Gilles Vollant) -- See http://www.winimage.com/zLibDll/unzip.html --- preinitialize the inflate tables for fixed codes, to make the code -- completely thread safe (Mark) --- some simplifications and slight speed-up to the inflate code (Mark) --- fix gzeof on non-compressed files (Allan Schrum) --- add -std1 option in configure for OSF1 to fix gzprintf (Martin Mokrejs) --- use default value of 4K for Z_BUFSIZE for 16-bit MSDOS (Tim Wegner + Glenn) --- added os2/Makefile.def and os2/zlib.def (Andrew Zabolotny) --- add shared lib support for UNIX_SV4.2MP (MATSUURA Takanori) --- do not wrap extern "C" around system includes (Tom Lane) --- mention zlib binding for TCL in README (Andreas Kupries) --- added amiga/Makefile.pup for Amiga powerUP SAS/C PPC (Andreas Kleinert) --- allow "make install prefix=..." even after configure (Glenn Randers-Pehrson) --- allow "configure --prefix $HOME" (Tim Mooney) --- remove warnings in example.c and gzio.c (Glenn Randers-Pehrson) --- move Makefile.sas to amiga/Makefile.sas -- --Changes in 1.1.1 (27 Feb 98) --- fix macros _tr_tally_* in deflate.h for debug mode (Glenn Randers-Pehrson) --- remove block truncation heuristic which had very marginal effect for zlib -- (smaller lit_bufsize than in gzip 1.2.4) and degraded a little the -- compression ratio on some files. This also allows inlining _tr_tally for -- matches in deflate_slow. --- added msdos/Makefile.w32 for WIN32 Microsoft Visual C++ (Bob Frazier) -- --Changes in 1.1.0 (24 Feb 98) --- do not return STREAM_END prematurely in inflate (John Bowler) --- revert to the zlib 1.0.8 inflate to avoid the gcc 2.8.0 bug (Jeremy Buhler) --- compile with -DFASTEST to get compression code optimized for speed only --- in minigzip, try mmap'ing the input file first (Miguel Albrecht) --- increase size of I/O buffers in minigzip.c and gzio.c (not a big gain -- on Sun but significant on HP) -- --- add a pointer to experimental unzip library in README (Gilles Vollant) --- initialize variable gcc in configure (Chris Herborth) -- --Changes in 1.0.9 (17 Feb 1998) --- added gzputs and gzgets functions --- do not clear eof flag in gzseek (Mark Diekhans) --- fix gzseek for files in transparent mode (Mark Diekhans) --- do not assume that vsprintf returns the number of bytes written (Jens Krinke) --- replace EXPORT with ZEXPORT to avoid conflict with other programs --- added compress2 in zconf.h, zlib.def, zlib.dnt --- new asm code from Gilles Vollant in contrib/asm386 --- simplify the inflate code (Mark): -- . Replace ZALLOC's in huft_build() with single ZALLOC in inflate_blocks_new() -- . ZALLOC the length list in inflate_trees_fixed() instead of using stack -- . ZALLOC the value area for huft_build() instead of using stack -- . Simplify Z_FINISH check in inflate() -- --- Avoid gcc 2.8.0 comparison bug a little differently than zlib 1.0.8 --- in inftrees.c, avoid cc -O bug on HP (Farshid Elahi) --- in zconf.h move the ZLIB_DLL stuff earlier to avoid problems with -- the declaration of FAR (Gilles VOllant) --- install libz.so* with mode 755 (executable) instead of 644 (Marc Lehmann) --- read_buf buf parameter of type Bytef* instead of charf* --- zmemcpy parameters are of type Bytef*, not charf* (Joseph Strout) --- do not redeclare unlink in minigzip.c for WIN32 (John Bowler) --- fix check for presence of directories in "make install" (Ian Willis) -- --Changes in 1.0.8 (27 Jan 1998) --- fixed offsets in contrib/asm386/gvmat32.asm (Gilles Vollant) --- fix gzgetc and gzputc for big endian systems (Markus Oberhumer) --- added compress2() to allow setting the compression level --- include sys/types.h to get off_t on some systems (Marc Lehmann & QingLong) --- use constant arrays for the static trees in trees.c instead of computing -- them at run time (thanks to Ken Raeburn for this suggestion). To create -- trees.h, compile with GEN_TREES_H and run "make test". --- check return code of example in "make test" and display result --- pass minigzip command line options to file_compress --- simplifying code of inflateSync to avoid gcc 2.8 bug -- --- support CC="gcc -Wall" in configure -s (QingLong) --- avoid a flush caused by ftell in gzopen for write mode (Ken Raeburn) --- fix test for shared library support to avoid compiler warnings --- zlib.lib -> zlib.dll in msdos/zlib.rc (Gilles Vollant) --- check for TARGET_OS_MAC in addition to MACOS (Brad Pettit) --- do not use fdopen for Metrowerks on Mac (Brad Pettit)) --- add checks for gzputc and gzputc in example.c --- avoid warnings in gzio.c and deflate.c (Andreas Kleinert) --- use const for the CRC table (Ken Raeburn) --- fixed "make uninstall" for shared libraries --- use Tracev instead of Trace in infblock.c --- in example.c use correct compressed length for test_sync --- suppress +vnocompatwarnings in configure for HPUX (not always supported) -- --Changes in 1.0.7 (20 Jan 1998) --- fix gzseek which was broken in write mode --- return error for gzseek to negative absolute position --- fix configure for Linux (Chun-Chung Chen) --- increase stack space for MSC (Tim Wegner) --- get_crc_table and inflateSyncPoint are EXPORTed (Gilles Vollant) --- define EXPORTVA for gzprintf (Gilles Vollant) --- added man page zlib.3 (Rick Rodgers) --- for contrib/untgz, fix makedir() and improve Makefile -- --- check gzseek in write mode in example.c --- allocate extra buffer for seeks only if gzseek is actually called --- avoid signed/unsigned comparisons (Tim Wegner, Gilles Vollant) --- add inflateSyncPoint in zconf.h --- fix list of exported functions in nt/zlib.dnt and mdsos/zlib.def -- --Changes in 1.0.6 (19 Jan 1998) --- add functions gzprintf, gzputc, gzgetc, gztell, gzeof, gzseek, gzrewind and -- gzsetparams (thanks to Roland Giersig and Kevin Ruland for some of this code) --- Fix a deflate bug occurring only with compression level 0 (thanks to -- Andy Buckler for finding this one). --- In minigzip, pass transparently also the first byte for .Z files. --- return Z_BUF_ERROR instead of Z_OK if output buffer full in uncompress() --- check Z_FINISH in inflate (thanks to Marc Schluper) --- Implement deflateCopy (thanks to Adam Costello) --- make static libraries by default in configure, add --shared option. --- move MSDOS or Windows specific files to directory msdos --- suppress the notion of partial flush to simplify the interface -- (but the symbol Z_PARTIAL_FLUSH is kept for compatibility with 1.0.4) --- suppress history buffer provided by application to simplify the interface -- (this feature was not implemented anyway in 1.0.4) --- next_in and avail_in must be initialized before calling inflateInit or -- inflateInit2 --- add EXPORT in all exported functions (for Windows DLL) --- added Makefile.nt (thanks to Stephen Williams) --- added the unsupported "contrib" directory: -- contrib/asm386/ by Gilles Vollant -- 386 asm code replacing longest_match(). -- contrib/iostream/ by Kevin Ruland -- A C++ I/O streams interface to the zlib gz* functions -- contrib/iostream2/ by Tyge Løvset -- Another C++ I/O streams interface -- contrib/untgz/ by "Pedro A. Aranda Guti\irrez" -- A very simple tar.gz file extractor using zlib -- contrib/visual-basic.txt by Carlos Rios -- How to use compress(), uncompress() and the gz* functions from VB. --- pass params -f (filtered data), -h (huffman only), -1 to -9 (compression -- level) in minigzip (thanks to Tom Lane) -- --- use const for rommable constants in deflate --- added test for gzseek and gztell in example.c --- add undocumented function inflateSyncPoint() (hack for Paul Mackerras) --- add undocumented function zError to convert error code to string -- (for Tim Smithers) --- Allow compilation of gzio with -DNO_DEFLATE to avoid the compression code. --- Use default memcpy for Symantec MSDOS compiler. --- Add EXPORT keyword for check_func (needed for Windows DLL) --- add current directory to LD_LIBRARY_PATH for "make test" --- create also a link for libz.so.1 --- added support for FUJITSU UXP/DS (thanks to Toshiaki Nomura) --- use $(SHAREDLIB) instead of libz.so in Makefile.in (for HPUX) --- added -soname for Linux in configure (Chun-Chung Chen, --- assign numbers to the exported functions in zlib.def (for Windows DLL) --- add advice in zlib.h for best usage of deflateSetDictionary --- work around compiler bug on Atari (cast Z_NULL in call of s->checkfn) --- allow compilation with ANSI keywords only enabled for TurboC in large model --- avoid "versionString"[0] (Borland bug) --- add NEED_DUMMY_RETURN for Borland --- use variable z_verbose for tracing in debug mode (L. Peter Deutsch). --- allow compilation with CC --- defined STDC for OS/2 (David Charlap) --- limit external names to 8 chars for MVS (Thomas Lund) --- in minigzip.c, use static buffers only for 16-bit systems --- fix suffix check for "minigzip -d foo.gz" --- do not return an error for the 2nd of two consecutive gzflush() (Felix Lee) --- use _fdopen instead of fdopen for MSC >= 6.0 (Thomas Fanslau) --- added makelcc.bat for lcc-win32 (Tom St Denis) --- in Makefile.dj2, use copy and del instead of install and rm (Frank Donahoe) --- Avoid expanded $Id$. Use "rcs -kb" or "cvs admin -kb" to avoid Id expansion. --- check for unistd.h in configure (for off_t) --- remove useless check parameter in inflate_blocks_free --- avoid useless assignment of s->check to itself in inflate_blocks_new --- do not flush twice in gzclose (thanks to Ken Raeburn) --- rename FOPEN as F_OPEN to avoid clash with /usr/include/sys/file.h --- use NO_ERRNO_H instead of enumeration of operating systems with errno.h --- work around buggy fclose on pipes for HP/UX --- support zlib DLL with BORLAND C++ 5.0 (thanks to Glenn Randers-Pehrson) --- fix configure if CC is already equal to gcc -- --Changes in 1.0.5 (3 Jan 98) --- Fix inflate to terminate gracefully when fed corrupted or invalid data --- Use const for rommable constants in inflate --- Eliminate memory leaks on error conditions in inflate --- Removed some vestigial code in inflate --- Update web address in README -- --Changes in 1.0.4 (24 Jul 96) --- In very rare conditions, deflate(s, Z_FINISH) could fail to produce an EOF -- bit, so the decompressor could decompress all the correct data but went -- on to attempt decompressing extra garbage data. This affected minigzip too. --- zlibVersion and gzerror return const char* (needed for DLL) --- port to RISCOS (no fdopen, no multiple dots, no unlink, no fileno) --- use z_error only for DEBUG (avoid problem with DLLs) -- --Changes in 1.0.3 (2 Jul 96) --- use z_streamp instead of z_stream *, which is now a far pointer in MSDOS -- small and medium models; this makes the library incompatible with previous -- versions for these models. (No effect in large model or on other systems.) --- return OK instead of BUF_ERROR if previous deflate call returned with -- avail_out as zero but there is nothing to do --- added memcmp for non STDC compilers --- define NO_DUMMY_DECL for more Mac compilers (.h files merged incorrectly) --- define __32BIT__ if __386__ or i386 is defined (pb. with Watcom and SCO) --- better check for 16-bit mode MSC (avoids problem with Symantec) -- --Changes in 1.0.2 (23 May 96) --- added Windows DLL support --- added a function zlibVersion (for the DLL support) --- fixed declarations using Bytef in infutil.c (pb with MSDOS medium model) --- Bytef is define's instead of typedef'd only for Borland C --- avoid reading uninitialized memory in example.c --- mention in README that the zlib format is now RFC1950 --- updated Makefile.dj2 --- added algorithm.doc -- --Changes in 1.0.1 (20 May 96) [1.0 skipped to avoid confusion] --- fix array overlay in deflate.c which sometimes caused bad compressed data --- fix inflate bug with empty stored block --- fix MSDOS medium model which was broken in 0.99 --- fix deflateParams() which could generated bad compressed data. --- Bytef is define'd instead of typedef'ed (work around Borland bug) --- added an INDEX file --- new makefiles for DJGPP (Makefile.dj2), 32-bit Borland (Makefile.b32), -- Watcom (Makefile.wat), Amiga SAS/C (Makefile.sas) --- speed up adler32 for modern machines without auto-increment --- added -ansi for IRIX in configure --- static_init_done in trees.c is an int --- define unlink as delete for VMS --- fix configure for QNX --- add configure branch for SCO and HPUX --- avoid many warnings (unused variables, dead assignments, etc...) --- no fdopen for BeOS --- fix the Watcom fix for 32 bit mode (define FAR as empty) --- removed redefinition of Byte for MKWERKS --- work around an MWKERKS bug (incorrect merge of all .h files) -- --Changes in 0.99 (27 Jan 96) --- allow preset dictionary shared between compressor and decompressor --- allow compression level 0 (no compression) --- add deflateParams in zlib.h: allow dynamic change of compression level -- and compression strategy. --- test large buffers and deflateParams in example.c --- add optional "configure" to build zlib as a shared library --- suppress Makefile.qnx, use configure instead --- fixed deflate for 64-bit systems (detected on Cray) --- fixed inflate_blocks for 64-bit systems (detected on Alpha) --- declare Z_DEFLATED in zlib.h (possible parameter for deflateInit2) --- always return Z_BUF_ERROR when deflate() has nothing to do --- deflateInit and inflateInit are now macros to allow version checking --- prefix all global functions and types with z_ with -DZ_PREFIX --- make falloc completely reentrant (inftrees.c) --- fixed very unlikely race condition in ct_static_init --- free in reverse order of allocation to help memory manager --- use zlib-1.0/* instead of zlib/* inside the tar.gz --- make zlib warning-free with "gcc -O3 -Wall -Wwrite-strings -Wpointer-arith -- -Wconversion -Wstrict-prototypes -Wmissing-prototypes" --- allow gzread on concatenated .gz files --- deflateEnd now returns Z_DATA_ERROR if it was premature --- deflate is finally (?) fully deterministic (no matches beyond end of input) --- Document Z_SYNC_FLUSH --- add uninstall in Makefile --- Check for __cpluplus in zlib.h --- Better test in ct_align for partial flush --- avoid harmless warnings for Borland C++ --- initialize hash_head in deflate.c --- avoid warning on fdopen (gzio.c) for HP cc -Aa --- include stdlib.h for STDC compilers --- include errno.h for Cray --- ignore error if ranlib doesn't exist --- call ranlib twice for NeXTSTEP --- use exec_prefix instead of prefix for libz.a --- renamed ct_* as _tr_* to avoid conflict with applications --- clear z->msg in inflateInit2 before any error return --- initialize opaque in example.c, gzio.c, deflate.c and inflate.c --- fixed typo in zconf.h (_GNUC__ => __GNUC__) --- check for WIN32 in zconf.h and zutil.c (avoid farmalloc in 32-bit mode) --- fix typo in Make_vms.com (f$trnlnm -> f$getsyi) --- in fcalloc, normalize pointer if size > 65520 bytes --- don't use special fcalloc for 32 bit Borland C++ --- use STDC instead of __GO32__ to avoid redeclaring exit, calloc, etc... --- use Z_BINARY instead of BINARY --- document that gzclose after gzdopen will close the file --- allow "a" as mode in gzopen. --- fix error checking in gzread --- allow skipping .gz extra-field on pipes --- added reference to Perl interface in README --- put the crc table in FAR data (I dislike more and more the medium model :) --- added get_crc_table --- added a dimension to all arrays (Borland C can't count). --- workaround Borland C bug in declaration of inflate_codes_new & inflate_fast --- guard against multiple inclusion of *.h (for precompiled header on Mac) --- Watcom C pretends to be Microsoft C small model even in 32 bit mode. --- don't use unsized arrays to avoid silly warnings by Visual C++: -- warning C4746: 'inflate_mask' : unsized array treated as '__far' -- (what's wrong with far data in far model?). --- define enum out of inflate_blocks_state to allow compilation with C++ -- --Changes in 0.95 (16 Aug 95) --- fix MSDOS small and medium model (now easier to adapt to any compiler) --- inlined send_bits --- fix the final (:-) bug for deflate with flush (output was correct but -- not completely flushed in rare occasions). --- default window size is same for compression and decompression -- (it's now sufficient to set MAX_WBITS in zconf.h). --- voidp -> voidpf and voidnp -> voidp (for consistency with other -- typedefs and because voidnp was not near in large model). -- --Changes in 0.94 (13 Aug 95) --- support MSDOS medium model --- fix deflate with flush (could sometimes generate bad output) --- fix deflateReset (zlib header was incorrectly suppressed) --- added support for VMS --- allow a compression level in gzopen() --- gzflush now calls fflush --- For deflate with flush, flush even if no more input is provided. --- rename libgz.a as libz.a --- avoid complex expression in infcodes.c triggering Turbo C bug --- work around a problem with gcc on Alpha (in INSERT_STRING) --- don't use inline functions (problem with some gcc versions) --- allow renaming of Byte, uInt, etc... with #define. --- avoid warning about (unused) pointer before start of array in deflate.c --- avoid various warnings in gzio.c, example.c, infblock.c, adler32.c, zutil.c --- avoid reserved word 'new' in trees.c -- --Changes in 0.93 (25 June 95) --- temporarily disable inline functions --- make deflate deterministic --- give enough lookahead for PARTIAL_FLUSH --- Set binary mode for stdin/stdout in minigzip.c for OS/2 --- don't even use signed char in inflate (not portable enough) --- fix inflate memory leak for segmented architectures -- --Changes in 0.92 (3 May 95) --- don't assume that char is signed (problem on SGI) --- Clear bit buffer when starting a stored block --- no memcpy on Pyramid --- suppressed inftest.c --- optimized fill_window, put longest_match inline for gcc --- optimized inflate on stored blocks. --- untabify all sources to simplify patches -- --Changes in 0.91 (2 May 95) --- Default MEM_LEVEL is 8 (not 9 for Unix) as documented in zlib.h --- Document the memory requirements in zconf.h --- added "make install" --- fix sync search logic in inflateSync --- deflate(Z_FULL_FLUSH) now works even if output buffer too short --- after inflateSync, don't scare people with just "lo world" --- added support for DJGPP -- --Changes in 0.9 (1 May 95) --- don't assume that zalloc clears the allocated memory (the TurboC bug -- was Mark's bug after all :) --- let again gzread copy uncompressed data unchanged (was working in 0.71) --- deflate(Z_FULL_FLUSH), inflateReset and inflateSync are now fully implemented --- added a test of inflateSync in example.c --- moved MAX_WBITS to zconf.h because users might want to change that. --- document explicitly that zalloc(64K) on MSDOS must return a normalized -- pointer (zero offset) --- added Makefiles for Microsoft C, Turbo C, Borland C++ --- faster crc32() -- --Changes in 0.8 (29 April 95) --- added fast inflate (inffast.c) --- deflate(Z_FINISH) now returns Z_STREAM_END when done. Warning: this -- is incompatible with previous versions of zlib which returned Z_OK. --- work around a TurboC compiler bug (bad code for b << 0, see infutil.h) -- (actually that was not a compiler bug, see 0.81 above) --- gzread no longer reads one extra byte in certain cases --- In gzio destroy(), don't reference a freed structure --- avoid many warnings for MSDOS --- avoid the ERROR symbol which is used by MS Windows -- --Changes in 0.71 (14 April 95) --- Fixed more MSDOS compilation problems :( There is still a bug with -- TurboC large model. -- --Changes in 0.7 (14 April 95) --- Added full inflate support. --- Simplified the crc32() interface. The pre- and post-conditioning -- (one's complement) is now done inside crc32(). WARNING: this is -- incompatible with previous versions; see zlib.h for the new usage. -- --Changes in 0.61 (12 April 95) --- workaround for a bug in TurboC. example and minigzip now work on MSDOS. -- --Changes in 0.6 (11 April 95) --- added minigzip.c --- added gzdopen to reopen a file descriptor as gzFile --- added transparent reading of non-gziped files in gzread. --- fixed bug in gzread (don't read crc as data) --- fixed bug in destroy (gzio.c) (don't return Z_STREAM_END for gzclose). --- don't allocate big arrays in the stack (for MSDOS) --- fix some MSDOS compilation problems -- --Changes in 0.5: --- do real compression in deflate.c. Z_PARTIAL_FLUSH is supported but -- not yet Z_FULL_FLUSH. --- support decompression but only in a single step (forced Z_FINISH) --- added opaque object for zalloc and zfree. --- added deflateReset and inflateReset --- added a variable zlib_version for consistency checking. --- renamed the 'filter' parameter of deflateInit2 as 'strategy'. -- Added Z_FILTERED and Z_HUFFMAN_ONLY constants. -- --Changes in 0.4: --- avoid "zip" everywhere, use zlib instead of ziplib. --- suppress Z_BLOCK_FLUSH, interpret Z_PARTIAL_FLUSH as block flush -- if compression method == 8. --- added adler32 and crc32 --- renamed deflateOptions as deflateInit2, call one or the other but not both --- added the method parameter for deflateInit2. --- added inflateInit2 --- simplied considerably deflateInit and inflateInit by not supporting -- user-provided history buffer. This is supported only in deflateInit2 -- and inflateInit2. -- --Changes in 0.3: --- prefix all macro names with Z_ --- use Z_FINISH instead of deflateEnd to finish compression. --- added Z_HUFFMAN_ONLY --- added gzerror() -diff --git a/thirdparty/zlib/FAQ b/thirdparty/zlib/FAQ -deleted file mode 100644 -index 1a22750..0000000 ---- a/thirdparty/zlib/FAQ -+++ /dev/null -@@ -1,366 +0,0 @@ -- -- Frequently Asked Questions about zlib -- -- --If your question is not there, please check the zlib home page --http://zlib.net/ which may have more recent information. --The lastest zlib FAQ is at http://zlib.net/zlib_faq.html -- -- -- 1. Is zlib Y2K-compliant? -- -- Yes. zlib doesn't handle dates. -- -- 2. Where can I get a Windows DLL version? -- -- The zlib sources can be compiled without change to produce a DLL. See the -- file win32/DLL_FAQ.txt in the zlib distribution. Pointers to the -- precompiled DLL are found in the zlib web site at http://zlib.net/ . -- -- 3. Where can I get a Visual Basic interface to zlib? -- -- See -- * http://marknelson.us/1997/01/01/zlib-engine/ -- * win32/DLL_FAQ.txt in the zlib distribution -- -- 4. compress() returns Z_BUF_ERROR. -- -- Make sure that before the call of compress(), the length of the compressed -- buffer is equal to the available size of the compressed buffer and not -- zero. For Visual Basic, check that this parameter is passed by reference -- ("as any"), not by value ("as long"). -- -- 5. deflate() or inflate() returns Z_BUF_ERROR. -- -- Before making the call, make sure that avail_in and avail_out are not zero. -- When setting the parameter flush equal to Z_FINISH, also make sure that -- avail_out is big enough to allow processing all pending input. Note that a -- Z_BUF_ERROR is not fatal--another call to deflate() or inflate() can be -- made with more input or output space. A Z_BUF_ERROR may in fact be -- unavoidable depending on how the functions are used, since it is not -- possible to tell whether or not there is more output pending when -- strm.avail_out returns with zero. See http://zlib.net/zlib_how.html for a -- heavily annotated example. -- -- 6. Where's the zlib documentation (man pages, etc.)? -- -- It's in zlib.h . Examples of zlib usage are in the files example.c and -- minigzip.c, with more in examples/ . -- -- 7. Why don't you use GNU autoconf or libtool or ...? -- -- Because we would like to keep zlib as a very small and simple package. -- zlib is rather portable and doesn't need much configuration. -- -- 8. I found a bug in zlib. -- -- Most of the time, such problems are due to an incorrect usage of zlib. -- Please try to reproduce the problem with a small program and send the -- corresponding source to us at zlib@gzip.org . Do not send multi-megabyte -- data files without prior agreement. -- -- 9. Why do I get "undefined reference to gzputc"? -- -- If "make test" produces something like -- -- example.o(.text+0x154): undefined reference to `gzputc' -- -- check that you don't have old files libz.* in /usr/lib, /usr/local/lib or -- /usr/X11R6/lib. Remove any old versions, then do "make install". -- --10. I need a Delphi interface to zlib. -- -- See the contrib/delphi directory in the zlib distribution. -- --11. Can zlib handle .zip archives? -- -- Not by itself, no. See the directory contrib/minizip in the zlib -- distribution. -- --12. Can zlib handle .Z files? -- -- No, sorry. You have to spawn an uncompress or gunzip subprocess, or adapt -- the code of uncompress on your own. -- --13. How can I make a Unix shared library? -- -- make clean -- ./configure -s -- make -- --14. How do I install a shared zlib library on Unix? -- -- After the above, then: -- -- make install -- -- However, many flavors of Unix come with a shared zlib already installed. -- Before going to the trouble of compiling a shared version of zlib and -- trying to install it, you may want to check if it's already there! If you -- can #include , it's there. The -lz option will probably link to -- it. You can check the version at the top of zlib.h or with the -- ZLIB_VERSION symbol defined in zlib.h . -- --15. I have a question about OttoPDF. -- -- We are not the authors of OttoPDF. The real author is on the OttoPDF web -- site: Joel Hainley, jhainley@myndkryme.com. -- --16. Can zlib decode Flate data in an Adobe PDF file? -- -- Yes. See http://www.pdflib.com/ . To modify PDF forms, see -- http://sourceforge.net/projects/acroformtool/ . -- --17. Why am I getting this "register_frame_info not found" error on Solaris? -- -- After installing zlib 1.1.4 on Solaris 2.6, running applications using zlib -- generates an error such as: -- -- ld.so.1: rpm: fatal: relocation error: file /usr/local/lib/libz.so: -- symbol __register_frame_info: referenced symbol not found -- -- The symbol __register_frame_info is not part of zlib, it is generated by -- the C compiler (cc or gcc). You must recompile applications using zlib -- which have this problem. This problem is specific to Solaris. See -- http://www.sunfreeware.com for Solaris versions of zlib and applications -- using zlib. -- --18. Why does gzip give an error on a file I make with compress/deflate? -- -- The compress and deflate functions produce data in the zlib format, which -- is different and incompatible with the gzip format. The gz* functions in -- zlib on the other hand use the gzip format. Both the zlib and gzip formats -- use the same compressed data format internally, but have different headers -- and trailers around the compressed data. -- --19. Ok, so why are there two different formats? -- -- The gzip format was designed to retain the directory information about a -- single file, such as the name and last modification date. The zlib format -- on the other hand was designed for in-memory and communication channel -- applications, and has a much more compact header and trailer and uses a -- faster integrity check than gzip. -- --20. Well that's nice, but how do I make a gzip file in memory? -- -- You can request that deflate write the gzip format instead of the zlib -- format using deflateInit2(). You can also request that inflate decode the -- gzip format using inflateInit2(). Read zlib.h for more details. -- --21. Is zlib thread-safe? -- -- Yes. However any library routines that zlib uses and any application- -- provided memory allocation routines must also be thread-safe. zlib's gz* -- functions use stdio library routines, and most of zlib's functions use the -- library memory allocation routines by default. zlib's *Init* functions -- allow for the application to provide custom memory allocation routines. -- -- Of course, you should only operate on any given zlib or gzip stream from a -- single thread at a time. -- --22. Can I use zlib in my commercial application? -- -- Yes. Please read the license in zlib.h. -- --23. Is zlib under the GNU license? -- -- No. Please read the license in zlib.h. -- --24. The license says that altered source versions must be "plainly marked". So -- what exactly do I need to do to meet that requirement? -- -- You need to change the ZLIB_VERSION and ZLIB_VERNUM #defines in zlib.h. In -- particular, the final version number needs to be changed to "f", and an -- identification string should be appended to ZLIB_VERSION. Version numbers -- x.x.x.f are reserved for modifications to zlib by others than the zlib -- maintainers. For example, if the version of the base zlib you are altering -- is "1.2.3.4", then in zlib.h you should change ZLIB_VERNUM to 0x123f, and -- ZLIB_VERSION to something like "1.2.3.f-zachary-mods-v3". You can also -- update the version strings in deflate.c and inftrees.c. -- -- For altered source distributions, you should also note the origin and -- nature of the changes in zlib.h, as well as in ChangeLog and README, along -- with the dates of the alterations. The origin should include at least your -- name (or your company's name), and an email address to contact for help or -- issues with the library. -- -- Note that distributing a compiled zlib library along with zlib.h and -- zconf.h is also a source distribution, and so you should change -- ZLIB_VERSION and ZLIB_VERNUM and note the origin and nature of the changes -- in zlib.h as you would for a full source distribution. -- --25. Will zlib work on a big-endian or little-endian architecture, and can I -- exchange compressed data between them? -- -- Yes and yes. -- --26. Will zlib work on a 64-bit machine? -- -- Yes. It has been tested on 64-bit machines, and has no dependence on any -- data types being limited to 32-bits in length. If you have any -- difficulties, please provide a complete problem report to zlib@gzip.org -- --27. Will zlib decompress data from the PKWare Data Compression Library? -- -- No. The PKWare DCL uses a completely different compressed data format than -- does PKZIP and zlib. However, you can look in zlib's contrib/blast -- directory for a possible solution to your problem. -- --28. Can I access data randomly in a compressed stream? -- -- No, not without some preparation. If when compressing you periodically use -- Z_FULL_FLUSH, carefully write all the pending data at those points, and -- keep an index of those locations, then you can start decompression at those -- points. You have to be careful to not use Z_FULL_FLUSH too often, since it -- can significantly degrade compression. Alternatively, you can scan a -- deflate stream once to generate an index, and then use that index for -- random access. See examples/zran.c . -- --29. Does zlib work on MVS, OS/390, CICS, etc.? -- -- It has in the past, but we have not heard of any recent evidence. There -- were working ports of zlib 1.1.4 to MVS, but those links no longer work. -- If you know of recent, successful applications of zlib on these operating -- systems, please let us know. Thanks. -- --30. Is there some simpler, easier to read version of inflate I can look at to -- understand the deflate format? -- -- First off, you should read RFC 1951. Second, yes. Look in zlib's -- contrib/puff directory. -- --31. Does zlib infringe on any patents? -- -- As far as we know, no. In fact, that was originally the whole point behind -- zlib. Look here for some more information: -- -- http://www.gzip.org/#faq11 -- --32. Can zlib work with greater than 4 GB of data? -- -- Yes. inflate() and deflate() will process any amount of data correctly. -- Each call of inflate() or deflate() is limited to input and output chunks -- of the maximum value that can be stored in the compiler's "unsigned int" -- type, but there is no limit to the number of chunks. Note however that the -- strm.total_in and strm_total_out counters may be limited to 4 GB. These -- counters are provided as a convenience and are not used internally by -- inflate() or deflate(). The application can easily set up its own counters -- updated after each call of inflate() or deflate() to count beyond 4 GB. -- compress() and uncompress() may be limited to 4 GB, since they operate in a -- single call. gzseek() and gztell() may be limited to 4 GB depending on how -- zlib is compiled. See the zlibCompileFlags() function in zlib.h. -- -- The word "may" appears several times above since there is a 4 GB limit only -- if the compiler's "long" type is 32 bits. If the compiler's "long" type is -- 64 bits, then the limit is 16 exabytes. -- --33. Does zlib have any security vulnerabilities? -- -- The only one that we are aware of is potentially in gzprintf(). If zlib is -- compiled to use sprintf() or vsprintf(), then there is no protection -- against a buffer overflow of an 8K string space (or other value as set by -- gzbuffer()), other than the caller of gzprintf() assuring that the output -- will not exceed 8K. On the other hand, if zlib is compiled to use -- snprintf() or vsnprintf(), which should normally be the case, then there is -- no vulnerability. The ./configure script will display warnings if an -- insecure variation of sprintf() will be used by gzprintf(). Also the -- zlibCompileFlags() function will return information on what variant of -- sprintf() is used by gzprintf(). -- -- If you don't have snprintf() or vsnprintf() and would like one, you can -- find a portable implementation here: -- -- http://www.ijs.si/software/snprintf/ -- -- Note that you should be using the most recent version of zlib. Versions -- 1.1.3 and before were subject to a double-free vulnerability, and versions -- 1.2.1 and 1.2.2 were subject to an access exception when decompressing -- invalid compressed data. -- --34. Is there a Java version of zlib? -- -- Probably what you want is to use zlib in Java. zlib is already included -- as part of the Java SDK in the java.util.zip package. If you really want -- a version of zlib written in the Java language, look on the zlib home -- page for links: http://zlib.net/ . -- --35. I get this or that compiler or source-code scanner warning when I crank it -- up to maximally-pedantic. Can't you guys write proper code? -- -- Many years ago, we gave up attempting to avoid warnings on every compiler -- in the universe. It just got to be a waste of time, and some compilers -- were downright silly as well as contradicted each other. So now, we simply -- make sure that the code always works. -- --36. Valgrind (or some similar memory access checker) says that deflate is -- performing a conditional jump that depends on an uninitialized value. -- Isn't that a bug? -- -- No. That is intentional for performance reasons, and the output of deflate -- is not affected. This only started showing up recently since zlib 1.2.x -- uses malloc() by default for allocations, whereas earlier versions used -- calloc(), which zeros out the allocated memory. Even though the code was -- correct, versions 1.2.4 and later was changed to not stimulate these -- checkers. -- --37. Will zlib read the (insert any ancient or arcane format here) compressed -- data format? -- -- Probably not. Look in the comp.compression FAQ for pointers to various -- formats and associated software. -- --38. How can I encrypt/decrypt zip files with zlib? -- -- zlib doesn't support encryption. The original PKZIP encryption is very -- weak and can be broken with freely available programs. To get strong -- encryption, use GnuPG, http://www.gnupg.org/ , which already includes zlib -- compression. For PKZIP compatible "encryption", look at -- http://www.info-zip.org/ -- --39. What's the difference between the "gzip" and "deflate" HTTP 1.1 encodings? -- -- "gzip" is the gzip format, and "deflate" is the zlib format. They should -- probably have called the second one "zlib" instead to avoid confusion with -- the raw deflate compressed data format. While the HTTP 1.1 RFC 2616 -- correctly points to the zlib specification in RFC 1950 for the "deflate" -- transfer encoding, there have been reports of servers and browsers that -- incorrectly produce or expect raw deflate data per the deflate -- specficiation in RFC 1951, most notably Microsoft. So even though the -- "deflate" transfer encoding using the zlib format would be the more -- efficient approach (and in fact exactly what the zlib format was designed -- for), using the "gzip" transfer encoding is probably more reliable due to -- an unfortunate choice of name on the part of the HTTP 1.1 authors. -- -- Bottom line: use the gzip format for HTTP 1.1 encoding. -- --40. Does zlib support the new "Deflate64" format introduced by PKWare? -- -- No. PKWare has apparently decided to keep that format proprietary, since -- they have not documented it as they have previous compression formats. In -- any case, the compression improvements are so modest compared to other more -- modern approaches, that it's not worth the effort to implement. -- --41. I'm having a problem with the zip functions in zlib, can you help? -- -- There are no zip functions in zlib. You are probably using minizip by -- Giles Vollant, which is found in the contrib directory of zlib. It is not -- part of zlib. In fact none of the stuff in contrib is part of zlib. The -- files in there are not supported by the zlib authors. You need to contact -- the authors of the respective contribution for help. -- --42. The match.asm code in contrib is under the GNU General Public License. -- Since it's part of zlib, doesn't that mean that all of zlib falls under the -- GNU GPL? -- -- No. The files in contrib are not part of zlib. They were contributed by -- other authors and are provided as a convenience to the user within the zlib -- distribution. Each item in contrib has its own license. -- --43. Is zlib subject to export controls? What is its ECCN? -- -- zlib is not subject to export controls, and so is classified as EAR99. -- --44. Can you please sign these lengthy legal documents and fax them back to us -- so that we can use your software in our product? -- -- No. Go away. Shoo. -diff --git a/thirdparty/zlib/README b/thirdparty/zlib/README -deleted file mode 100644 -index d4219bf..0000000 ---- a/thirdparty/zlib/README -+++ /dev/null -@@ -1,115 +0,0 @@ --ZLIB DATA COMPRESSION LIBRARY -- --zlib 1.2.5 is a general purpose data compression library. All the code is --thread safe. The data format used by the zlib library is described by RFCs --(Request for Comments) 1950 to 1952 in the files --http://www.ietf.org/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate format) --and rfc1952.txt (gzip format). -- --All functions of the compression library are documented in the file zlib.h --(volunteer to write man pages welcome, contact zlib@gzip.org). A usage example --of the library is given in the file example.c which also tests that the library --is working correctly. Another example is given in the file minigzip.c. The --compression library itself is composed of all source files except example.c and --minigzip.c. -- --To compile all files and run the test program, follow the instructions given at --the top of Makefile.in. In short "./configure; make test", and if that goes --well, "make install" should work for most flavors of Unix. For Windows, use one --of the special makefiles in win32/ or contrib/vstudio/ . For VMS, use --make_vms.com. -- --Questions about zlib should be sent to , or to Gilles Vollant -- for the Windows DLL version. The zlib home page is --http://zlib.net/ . Before reporting a problem, please check this site to --verify that you have the latest version of zlib; otherwise get the latest --version and check whether the problem still exists or not. -- --PLEASE read the zlib FAQ http://zlib.net/zlib_faq.html before asking for help. -- --Mark Nelson wrote an article about zlib for the Jan. 1997 --issue of Dr. Dobb's Journal; a copy of the article is available at --http://marknelson.us/1997/01/01/zlib-engine/ . -- --The changes made in version 1.2.5 are documented in the file ChangeLog. -- --Unsupported third party contributions are provided in directory contrib/ . -- --zlib is available in Java using the java.util.zip package, documented at --http://java.sun.com/developer/technicalArticles/Programming/compression/ . -- --A Perl interface to zlib written by Paul Marquess is available --at CPAN (Comprehensive Perl Archive Network) sites, including --http://search.cpan.org/~pmqs/IO-Compress-Zlib/ . -- --A Python interface to zlib written by A.M. Kuchling is --available in Python 1.5 and later versions, see --http://www.python.org/doc/lib/module-zlib.html . -- --zlib is built into tcl: http://wiki.tcl.tk/4610 . -- --An experimental package to read and write files in .zip format, written on top --of zlib by Gilles Vollant , is available in the --contrib/minizip directory of zlib. -- -- --Notes for some targets: -- --- For Windows DLL versions, please see win32/DLL_FAQ.txt -- --- For 64-bit Irix, deflate.c must be compiled without any optimization. With -- -O, one libpng test fails. The test works in 32 bit mode (with the -n32 -- compiler flag). The compiler bug has been reported to SGI. -- --- zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1 it works -- when compiled with cc. -- --- On Digital Unix 4.0D (formely OSF/1) on AlphaServer, the cc option -std1 is -- necessary to get gzprintf working correctly. This is done by configure. -- --- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works with -- other compilers. Use "make test" to check your compiler. -- --- gzdopen is not supported on RISCOS or BEOS. -- --- For PalmOs, see http://palmzlib.sourceforge.net/ -- -- --Acknowledgments: -- -- The deflate format used by zlib was defined by Phil Katz. The deflate and -- zlib specifications were written by L. Peter Deutsch. Thanks to all the -- people who reported problems and suggested various improvements in zlib; they -- are too numerous to cite here. -- --Copyright notice: -- -- (C) 1995-2010 Jean-loup Gailly and Mark Adler -- -- This software is provided 'as-is', without any express or implied -- warranty. In no event will the authors be held liable for any damages -- arising from the use of this software. -- -- Permission is granted to anyone to use this software for any purpose, -- including commercial applications, and to alter it and redistribute it -- freely, subject to the following restrictions: -- -- 1. The origin of this software must not be misrepresented; you must not -- claim that you wrote the original software. If you use this software -- in a product, an acknowledgment in the product documentation would be -- appreciated but is not required. -- 2. Altered source versions must be plainly marked as such, and must not be -- misrepresented as being the original software. -- 3. This notice may not be removed or altered from any source distribution. -- -- Jean-loup Gailly Mark Adler -- jloup@gzip.org madler@alumni.caltech.edu -- --If you use the zlib library in a product, we would appreciate *not* receiving --lengthy legal documents to sign. The sources are provided for free but without --warranty of any kind. The library has been entirely written by Jean-loup --Gailly and Mark Adler; it does not include third-party code. -- --If you redistribute modified sources, we would appreciate that you include in --the file ChangeLog history information documenting your changes. Please read --the FAQ for more information on the distribution of modified source versions. -diff --git a/thirdparty/zlib/adler32.c b/thirdparty/zlib/adler32.c -deleted file mode 100644 -index 65ad6a5..0000000 ---- a/thirdparty/zlib/adler32.c -+++ /dev/null -@@ -1,169 +0,0 @@ --/* adler32.c -- compute the Adler-32 checksum of a data stream -- * Copyright (C) 1995-2007 Mark Adler -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* @(#) $Id$ */ -- --#include "zutil.h" -- --#define local static -- --local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2); -- --#define BASE 65521UL /* largest prime smaller than 65536 */ --#define NMAX 5552 --/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ -- --#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} --#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); --#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); --#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); --#define DO16(buf) DO8(buf,0); DO8(buf,8); -- --/* use NO_DIVIDE if your processor does not do division in hardware */ --#ifdef NO_DIVIDE --# define MOD(a) \ -- do { \ -- if (a >= (BASE << 16)) a -= (BASE << 16); \ -- if (a >= (BASE << 15)) a -= (BASE << 15); \ -- if (a >= (BASE << 14)) a -= (BASE << 14); \ -- if (a >= (BASE << 13)) a -= (BASE << 13); \ -- if (a >= (BASE << 12)) a -= (BASE << 12); \ -- if (a >= (BASE << 11)) a -= (BASE << 11); \ -- if (a >= (BASE << 10)) a -= (BASE << 10); \ -- if (a >= (BASE << 9)) a -= (BASE << 9); \ -- if (a >= (BASE << 8)) a -= (BASE << 8); \ -- if (a >= (BASE << 7)) a -= (BASE << 7); \ -- if (a >= (BASE << 6)) a -= (BASE << 6); \ -- if (a >= (BASE << 5)) a -= (BASE << 5); \ -- if (a >= (BASE << 4)) a -= (BASE << 4); \ -- if (a >= (BASE << 3)) a -= (BASE << 3); \ -- if (a >= (BASE << 2)) a -= (BASE << 2); \ -- if (a >= (BASE << 1)) a -= (BASE << 1); \ -- if (a >= BASE) a -= BASE; \ -- } while (0) --# define MOD4(a) \ -- do { \ -- if (a >= (BASE << 4)) a -= (BASE << 4); \ -- if (a >= (BASE << 3)) a -= (BASE << 3); \ -- if (a >= (BASE << 2)) a -= (BASE << 2); \ -- if (a >= (BASE << 1)) a -= (BASE << 1); \ -- if (a >= BASE) a -= BASE; \ -- } while (0) --#else --# define MOD(a) a %= BASE --# define MOD4(a) a %= BASE --#endif -- --/* ========================================================================= */ --uLong ZEXPORT adler32(adler, buf, len) -- uLong adler; -- const Bytef *buf; -- uInt len; --{ -- unsigned long sum2; -- unsigned n; -- -- /* split Adler-32 into component sums */ -- sum2 = (adler >> 16) & 0xffff; -- adler &= 0xffff; -- -- /* in case user likes doing a byte at a time, keep it fast */ -- if (len == 1) { -- adler += buf[0]; -- if (adler >= BASE) -- adler -= BASE; -- sum2 += adler; -- if (sum2 >= BASE) -- sum2 -= BASE; -- return adler | (sum2 << 16); -- } -- -- /* initial Adler-32 value (deferred check for len == 1 speed) */ -- if (buf == Z_NULL) -- return 1L; -- -- /* in case short lengths are provided, keep it somewhat fast */ -- if (len < 16) { -- while (len--) { -- adler += *buf++; -- sum2 += adler; -- } -- if (adler >= BASE) -- adler -= BASE; -- MOD4(sum2); /* only added so many BASE's */ -- return adler | (sum2 << 16); -- } -- -- /* do length NMAX blocks -- requires just one modulo operation */ -- while (len >= NMAX) { -- len -= NMAX; -- n = NMAX / 16; /* NMAX is divisible by 16 */ -- do { -- DO16(buf); /* 16 sums unrolled */ -- buf += 16; -- } while (--n); -- MOD(adler); -- MOD(sum2); -- } -- -- /* do remaining bytes (less than NMAX, still just one modulo) */ -- if (len) { /* avoid modulos if none remaining */ -- while (len >= 16) { -- len -= 16; -- DO16(buf); -- buf += 16; -- } -- while (len--) { -- adler += *buf++; -- sum2 += adler; -- } -- MOD(adler); -- MOD(sum2); -- } -- -- /* return recombined sums */ -- return adler | (sum2 << 16); --} -- --/* ========================================================================= */ --local uLong adler32_combine_(adler1, adler2, len2) -- uLong adler1; -- uLong adler2; -- z_off64_t len2; --{ -- unsigned long sum1; -- unsigned long sum2; -- unsigned rem; -- -- /* the derivation of this formula is left as an exercise for the reader */ -- rem = (unsigned)(len2 % BASE); -- sum1 = adler1 & 0xffff; -- sum2 = rem * sum1; -- MOD(sum2); -- sum1 += (adler2 & 0xffff) + BASE - 1; -- sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem; -- if (sum1 >= BASE) sum1 -= BASE; -- if (sum1 >= BASE) sum1 -= BASE; -- if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1); -- if (sum2 >= BASE) sum2 -= BASE; -- return sum1 | (sum2 << 16); --} -- --/* ========================================================================= */ --uLong ZEXPORT adler32_combine(adler1, adler2, len2) -- uLong adler1; -- uLong adler2; -- z_off_t len2; --{ -- return adler32_combine_(adler1, adler2, len2); --} -- --uLong ZEXPORT adler32_combine64(adler1, adler2, len2) -- uLong adler1; -- uLong adler2; -- z_off64_t len2; --{ -- return adler32_combine_(adler1, adler2, len2); --} -diff --git a/thirdparty/zlib/compress.c b/thirdparty/zlib/compress.c -deleted file mode 100644 -index ea4dfbe..0000000 ---- a/thirdparty/zlib/compress.c -+++ /dev/null -@@ -1,80 +0,0 @@ --/* compress.c -- compress a memory buffer -- * Copyright (C) 1995-2005 Jean-loup Gailly. -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* @(#) $Id$ */ -- --#define ZLIB_INTERNAL --#include "zlib.h" -- --/* =========================================================================== -- Compresses the source buffer into the destination buffer. The level -- parameter has the same meaning as in deflateInit. sourceLen is the byte -- length of the source buffer. Upon entry, destLen is the total size of the -- destination buffer, which must be at least 0.1% larger than sourceLen plus -- 12 bytes. Upon exit, destLen is the actual size of the compressed buffer. -- -- compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough -- memory, Z_BUF_ERROR if there was not enough room in the output buffer, -- Z_STREAM_ERROR if the level parameter is invalid. --*/ --int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) -- Bytef *dest; -- uLongf *destLen; -- const Bytef *source; -- uLong sourceLen; -- int level; --{ -- z_stream stream; -- int err; -- -- stream.next_in = (Bytef*)source; -- stream.avail_in = (uInt)sourceLen; --#ifdef MAXSEG_64K -- /* Check for source > 64K on 16-bit machine: */ -- if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; --#endif -- stream.next_out = dest; -- stream.avail_out = (uInt)*destLen; -- if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; -- -- stream.zalloc = (alloc_func)0; -- stream.zfree = (free_func)0; -- stream.opaque = (voidpf)0; -- -- err = deflateInit(&stream, level); -- if (err != Z_OK) return err; -- -- err = deflate(&stream, Z_FINISH); -- if (err != Z_STREAM_END) { -- deflateEnd(&stream); -- return err == Z_OK ? Z_BUF_ERROR : err; -- } -- *destLen = stream.total_out; -- -- err = deflateEnd(&stream); -- return err; --} -- --/* =========================================================================== -- */ --int ZEXPORT compress (dest, destLen, source, sourceLen) -- Bytef *dest; -- uLongf *destLen; -- const Bytef *source; -- uLong sourceLen; --{ -- return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION); --} -- --/* =========================================================================== -- If the default memLevel or windowBits for deflateInit() is changed, then -- this function needs to be updated. -- */ --uLong ZEXPORT compressBound (sourceLen) -- uLong sourceLen; --{ -- return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + -- (sourceLen >> 25) + 13; --} -diff --git a/thirdparty/zlib/crc32.c b/thirdparty/zlib/crc32.c -deleted file mode 100644 -index 91be372..0000000 ---- a/thirdparty/zlib/crc32.c -+++ /dev/null -@@ -1,442 +0,0 @@ --/* crc32.c -- compute the CRC-32 of a data stream -- * Copyright (C) 1995-2006, 2010 Mark Adler -- * For conditions of distribution and use, see copyright notice in zlib.h -- * -- * Thanks to Rodney Brown for his contribution of faster -- * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing -- * tables for updating the shift register in one step with three exclusive-ors -- * instead of four steps with four exclusive-ors. This results in about a -- * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3. -- */ -- --/* @(#) $Id$ */ -- --/* -- Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore -- protection on the static variables used to control the first-use generation -- of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should -- first call get_crc_table() to initialize the tables before allowing more than -- one thread to use crc32(). -- */ -- --#ifdef MAKECRCH --# include --# ifndef DYNAMIC_CRC_TABLE --# define DYNAMIC_CRC_TABLE --# endif /* !DYNAMIC_CRC_TABLE */ --#endif /* MAKECRCH */ -- --#include "zutil.h" /* for STDC and FAR definitions */ -- --#define local static -- --/* Find a four-byte integer type for crc32_little() and crc32_big(). */ --#ifndef NOBYFOUR --# ifdef STDC /* need ANSI C limits.h to determine sizes */ --# include --# define BYFOUR --# if (UINT_MAX == 0xffffffffUL) -- typedef unsigned int u4; --# else --# if (ULONG_MAX == 0xffffffffUL) -- typedef unsigned long u4; --# else --# if (USHRT_MAX == 0xffffffffUL) -- typedef unsigned short u4; --# else --# undef BYFOUR /* can't find a four-byte integer type! */ --# endif --# endif --# endif --# endif /* STDC */ --#endif /* !NOBYFOUR */ -- --/* Definitions for doing the crc four data bytes at a time. */ --#ifdef BYFOUR --# define REV(w) ((((w)>>24)&0xff)+(((w)>>8)&0xff00)+ \ -- (((w)&0xff00)<<8)+(((w)&0xff)<<24)) -- local unsigned long crc32_little OF((unsigned long, -- const unsigned char FAR *, unsigned)); -- local unsigned long crc32_big OF((unsigned long, -- const unsigned char FAR *, unsigned)); --# define TBLS 8 --#else --# define TBLS 1 --#endif /* BYFOUR */ -- --/* Local functions for crc concatenation */ --local unsigned long gf2_matrix_times OF((unsigned long *mat, -- unsigned long vec)); --local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat)); --local uLong crc32_combine_(uLong crc1, uLong crc2, z_off64_t len2); -- -- --#ifdef DYNAMIC_CRC_TABLE -- --local volatile int crc_table_empty = 1; --local unsigned long FAR crc_table[TBLS][256]; --local void make_crc_table OF((void)); --#ifdef MAKECRCH -- local void write_table OF((FILE *, const unsigned long FAR *)); --#endif /* MAKECRCH */ --/* -- Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: -- x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1. -- -- Polynomials over GF(2) are represented in binary, one bit per coefficient, -- with the lowest powers in the most significant bit. Then adding polynomials -- is just exclusive-or, and multiplying a polynomial by x is a right shift by -- one. If we call the above polynomial p, and represent a byte as the -- polynomial q, also with the lowest power in the most significant bit (so the -- byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, -- where a mod b means the remainder after dividing a by b. -- -- This calculation is done using the shift-register method of multiplying and -- taking the remainder. The register is initialized to zero, and for each -- incoming bit, x^32 is added mod p to the register if the bit is a one (where -- x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by -- x (which is shifting right by one and adding x^32 mod p if the bit shifted -- out is a one). We start with the highest power (least significant bit) of -- q and repeat for all eight bits of q. -- -- The first table is simply the CRC of all possible eight bit values. This is -- all the information needed to generate CRCs on data a byte at a time for all -- combinations of CRC register values and incoming bytes. The remaining tables -- allow for word-at-a-time CRC calculation for both big-endian and little- -- endian machines, where a word is four bytes. --*/ --local void make_crc_table() --{ -- unsigned long c; -- int n, k; -- unsigned long poly; /* polynomial exclusive-or pattern */ -- /* terms of polynomial defining this crc (except x^32): */ -- static volatile int first = 1; /* flag to limit concurrent making */ -- static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; -- -- /* See if another task is already doing this (not thread-safe, but better -- than nothing -- significantly reduces duration of vulnerability in -- case the advice about DYNAMIC_CRC_TABLE is ignored) */ -- if (first) { -- first = 0; -- -- /* make exclusive-or pattern from polynomial (0xedb88320UL) */ -- poly = 0UL; -- for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++) -- poly |= 1UL << (31 - p[n]); -- -- /* generate a crc for every 8-bit value */ -- for (n = 0; n < 256; n++) { -- c = (unsigned long)n; -- for (k = 0; k < 8; k++) -- c = c & 1 ? poly ^ (c >> 1) : c >> 1; -- crc_table[0][n] = c; -- } -- --#ifdef BYFOUR -- /* generate crc for each value followed by one, two, and three zeros, -- and then the byte reversal of those as well as the first table */ -- for (n = 0; n < 256; n++) { -- c = crc_table[0][n]; -- crc_table[4][n] = REV(c); -- for (k = 1; k < 4; k++) { -- c = crc_table[0][c & 0xff] ^ (c >> 8); -- crc_table[k][n] = c; -- crc_table[k + 4][n] = REV(c); -- } -- } --#endif /* BYFOUR */ -- -- crc_table_empty = 0; -- } -- else { /* not first */ -- /* wait for the other guy to finish (not efficient, but rare) */ -- while (crc_table_empty) -- ; -- } -- --#ifdef MAKECRCH -- /* write out CRC tables to crc32.h */ -- { -- FILE *out; -- -- out = fopen("crc32.h", "w"); -- if (out == NULL) return; -- fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n"); -- fprintf(out, " * Generated automatically by crc32.c\n */\n\n"); -- fprintf(out, "local const unsigned long FAR "); -- fprintf(out, "crc_table[TBLS][256] =\n{\n {\n"); -- write_table(out, crc_table[0]); --# ifdef BYFOUR -- fprintf(out, "#ifdef BYFOUR\n"); -- for (k = 1; k < 8; k++) { -- fprintf(out, " },\n {\n"); -- write_table(out, crc_table[k]); -- } -- fprintf(out, "#endif\n"); --# endif /* BYFOUR */ -- fprintf(out, " }\n};\n"); -- fclose(out); -- } --#endif /* MAKECRCH */ --} -- --#ifdef MAKECRCH --local void write_table(out, table) -- FILE *out; -- const unsigned long FAR *table; --{ -- int n; -- -- for (n = 0; n < 256; n++) -- fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", table[n], -- n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); --} --#endif /* MAKECRCH */ -- --#else /* !DYNAMIC_CRC_TABLE */ --/* ======================================================================== -- * Tables of CRC-32s of all single-byte values, made by make_crc_table(). -- */ --#include "crc32.h" --#endif /* DYNAMIC_CRC_TABLE */ -- --/* ========================================================================= -- * This function can be used by asm versions of crc32() -- */ --const unsigned long FAR * ZEXPORT get_crc_table() --{ --#ifdef DYNAMIC_CRC_TABLE -- if (crc_table_empty) -- make_crc_table(); --#endif /* DYNAMIC_CRC_TABLE */ -- return (const unsigned long FAR *)crc_table; --} -- --/* ========================================================================= */ --#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8) --#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 -- --/* ========================================================================= */ --unsigned long ZEXPORT crc32(crc, buf, len) -- unsigned long crc; -- const unsigned char FAR *buf; -- uInt len; --{ -- if (buf == Z_NULL) return 0UL; -- --#ifdef DYNAMIC_CRC_TABLE -- if (crc_table_empty) -- make_crc_table(); --#endif /* DYNAMIC_CRC_TABLE */ -- --#ifdef BYFOUR -- if (sizeof(void *) == sizeof(ptrdiff_t)) { -- u4 endian; -- -- endian = 1; -- if (*((unsigned char *)(&endian))) -- return crc32_little(crc, buf, len); -- else -- return crc32_big(crc, buf, len); -- } --#endif /* BYFOUR */ -- crc = crc ^ 0xffffffffUL; -- while (len >= 8) { -- DO8; -- len -= 8; -- } -- if (len) do { -- DO1; -- } while (--len); -- return crc ^ 0xffffffffUL; --} -- --#ifdef BYFOUR -- --/* ========================================================================= */ --#define DOLIT4 c ^= *buf4++; \ -- c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \ -- crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24] --#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4 -- --/* ========================================================================= */ --local unsigned long crc32_little(crc, buf, len) -- unsigned long crc; -- const unsigned char FAR *buf; -- unsigned len; --{ -- register u4 c; -- register const u4 FAR *buf4; -- -- c = (u4)crc; -- c = ~c; -- while (len && ((ptrdiff_t)buf & 3)) { -- c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); -- len--; -- } -- -- buf4 = (const u4 FAR *)(const void FAR *)buf; -- while (len >= 32) { -- DOLIT32; -- len -= 32; -- } -- while (len >= 4) { -- DOLIT4; -- len -= 4; -- } -- buf = (const unsigned char FAR *)buf4; -- -- if (len) do { -- c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); -- } while (--len); -- c = ~c; -- return (unsigned long)c; --} -- --/* ========================================================================= */ --#define DOBIG4 c ^= *++buf4; \ -- c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \ -- crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24] --#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4 -- --/* ========================================================================= */ --local unsigned long crc32_big(crc, buf, len) -- unsigned long crc; -- const unsigned char FAR *buf; -- unsigned len; --{ -- register u4 c; -- register const u4 FAR *buf4; -- -- c = REV((u4)crc); -- c = ~c; -- while (len && ((ptrdiff_t)buf & 3)) { -- c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); -- len--; -- } -- -- buf4 = (const u4 FAR *)(const void FAR *)buf; -- buf4--; -- while (len >= 32) { -- DOBIG32; -- len -= 32; -- } -- while (len >= 4) { -- DOBIG4; -- len -= 4; -- } -- buf4++; -- buf = (const unsigned char FAR *)buf4; -- -- if (len) do { -- c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); -- } while (--len); -- c = ~c; -- return (unsigned long)(REV(c)); --} -- --#endif /* BYFOUR */ -- --#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */ -- --/* ========================================================================= */ --local unsigned long gf2_matrix_times(mat, vec) -- unsigned long *mat; -- unsigned long vec; --{ -- unsigned long sum; -- -- sum = 0; -- while (vec) { -- if (vec & 1) -- sum ^= *mat; -- vec >>= 1; -- mat++; -- } -- return sum; --} -- --/* ========================================================================= */ --local void gf2_matrix_square(square, mat) -- unsigned long *square; -- unsigned long *mat; --{ -- int n; -- -- for (n = 0; n < GF2_DIM; n++) -- square[n] = gf2_matrix_times(mat, mat[n]); --} -- --/* ========================================================================= */ --local uLong crc32_combine_(crc1, crc2, len2) -- uLong crc1; -- uLong crc2; -- z_off64_t len2; --{ -- int n; -- unsigned long row; -- unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */ -- unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */ -- -- /* degenerate case (also disallow negative lengths) */ -- if (len2 <= 0) -- return crc1; -- -- /* put operator for one zero bit in odd */ -- odd[0] = 0xedb88320UL; /* CRC-32 polynomial */ -- row = 1; -- for (n = 1; n < GF2_DIM; n++) { -- odd[n] = row; -- row <<= 1; -- } -- -- /* put operator for two zero bits in even */ -- gf2_matrix_square(even, odd); -- -- /* put operator for four zero bits in odd */ -- gf2_matrix_square(odd, even); -- -- /* apply len2 zeros to crc1 (first square will put the operator for one -- zero byte, eight zero bits, in even) */ -- do { -- /* apply zeros operator for this bit of len2 */ -- gf2_matrix_square(even, odd); -- if (len2 & 1) -- crc1 = gf2_matrix_times(even, crc1); -- len2 >>= 1; -- -- /* if no more bits set, then done */ -- if (len2 == 0) -- break; -- -- /* another iteration of the loop with odd and even swapped */ -- gf2_matrix_square(odd, even); -- if (len2 & 1) -- crc1 = gf2_matrix_times(odd, crc1); -- len2 >>= 1; -- -- /* if no more bits set, then done */ -- } while (len2 != 0); -- -- /* return combined crc */ -- crc1 ^= crc2; -- return crc1; --} -- --/* ========================================================================= */ --uLong ZEXPORT crc32_combine(crc1, crc2, len2) -- uLong crc1; -- uLong crc2; -- z_off_t len2; --{ -- return crc32_combine_(crc1, crc2, len2); --} -- --uLong ZEXPORT crc32_combine64(crc1, crc2, len2) -- uLong crc1; -- uLong crc2; -- z_off64_t len2; --{ -- return crc32_combine_(crc1, crc2, len2); --} -diff --git a/thirdparty/zlib/crc32.h b/thirdparty/zlib/crc32.h -deleted file mode 100644 -index 8053b61..0000000 ---- a/thirdparty/zlib/crc32.h -+++ /dev/null -@@ -1,441 +0,0 @@ --/* crc32.h -- tables for rapid CRC calculation -- * Generated automatically by crc32.c -- */ -- --local const unsigned long FAR crc_table[TBLS][256] = --{ -- { -- 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL, -- 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL, -- 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL, -- 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL, -- 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL, -- 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL, -- 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL, -- 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL, -- 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL, -- 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL, -- 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL, -- 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL, -- 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL, -- 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL, -- 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL, -- 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL, -- 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL, -- 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL, -- 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL, -- 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL, -- 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL, -- 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL, -- 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL, -- 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL, -- 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL, -- 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL, -- 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL, -- 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL, -- 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL, -- 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL, -- 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL, -- 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL, -- 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL, -- 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL, -- 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL, -- 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL, -- 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL, -- 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL, -- 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL, -- 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL, -- 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL, -- 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL, -- 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL, -- 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL, -- 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL, -- 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL, -- 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL, -- 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL, -- 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL, -- 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL, -- 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL, -- 0x2d02ef8dUL --#ifdef BYFOUR -- }, -- { -- 0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL, -- 0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL, -- 0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL, -- 0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL, -- 0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL, -- 0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL, -- 0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL, -- 0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL, -- 0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL, -- 0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL, -- 0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL, -- 0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL, -- 0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL, -- 0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL, -- 0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL, -- 0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL, -- 0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL, -- 0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL, -- 0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL, -- 0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL, -- 0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL, -- 0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL, -- 0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL, -- 0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL, -- 0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL, -- 0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL, -- 0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL, -- 0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL, -- 0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL, -- 0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL, -- 0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL, -- 0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL, -- 0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL, -- 0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL, -- 0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL, -- 0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL, -- 0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL, -- 0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL, -- 0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL, -- 0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL, -- 0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL, -- 0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL, -- 0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL, -- 0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL, -- 0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL, -- 0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL, -- 0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL, -- 0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL, -- 0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL, -- 0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL, -- 0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL, -- 0x9324fd72UL -- }, -- { -- 0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL, -- 0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL, -- 0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL, -- 0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL, -- 0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL, -- 0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL, -- 0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL, -- 0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL, -- 0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL, -- 0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL, -- 0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL, -- 0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL, -- 0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL, -- 0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL, -- 0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL, -- 0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL, -- 0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL, -- 0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL, -- 0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL, -- 0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL, -- 0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL, -- 0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL, -- 0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL, -- 0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL, -- 0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL, -- 0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL, -- 0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL, -- 0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL, -- 0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL, -- 0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL, -- 0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL, -- 0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL, -- 0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL, -- 0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL, -- 0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL, -- 0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL, -- 0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL, -- 0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL, -- 0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL, -- 0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL, -- 0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL, -- 0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL, -- 0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL, -- 0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL, -- 0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL, -- 0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL, -- 0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL, -- 0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL, -- 0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL, -- 0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL, -- 0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL, -- 0xbe9834edUL -- }, -- { -- 0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL, -- 0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL, -- 0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL, -- 0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL, -- 0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL, -- 0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL, -- 0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL, -- 0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL, -- 0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL, -- 0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL, -- 0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL, -- 0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL, -- 0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL, -- 0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL, -- 0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL, -- 0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL, -- 0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL, -- 0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL, -- 0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL, -- 0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL, -- 0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL, -- 0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL, -- 0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL, -- 0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL, -- 0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL, -- 0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL, -- 0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL, -- 0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL, -- 0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL, -- 0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL, -- 0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL, -- 0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL, -- 0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL, -- 0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL, -- 0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL, -- 0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL, -- 0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL, -- 0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL, -- 0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL, -- 0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL, -- 0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL, -- 0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL, -- 0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL, -- 0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL, -- 0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL, -- 0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL, -- 0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL, -- 0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL, -- 0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL, -- 0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL, -- 0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL, -- 0xde0506f1UL -- }, -- { -- 0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL, -- 0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL, -- 0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL, -- 0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL, -- 0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL, -- 0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL, -- 0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL, -- 0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL, -- 0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL, -- 0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL, -- 0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL, -- 0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL, -- 0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL, -- 0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL, -- 0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL, -- 0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL, -- 0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL, -- 0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL, -- 0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL, -- 0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL, -- 0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL, -- 0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL, -- 0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL, -- 0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL, -- 0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL, -- 0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL, -- 0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL, -- 0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL, -- 0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL, -- 0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL, -- 0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL, -- 0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL, -- 0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL, -- 0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL, -- 0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL, -- 0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL, -- 0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL, -- 0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL, -- 0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL, -- 0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL, -- 0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL, -- 0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL, -- 0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL, -- 0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL, -- 0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL, -- 0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL, -- 0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL, -- 0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL, -- 0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL, -- 0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL, -- 0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL, -- 0x8def022dUL -- }, -- { -- 0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL, -- 0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL, -- 0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL, -- 0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL, -- 0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL, -- 0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL, -- 0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL, -- 0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL, -- 0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL, -- 0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL, -- 0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL, -- 0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL, -- 0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL, -- 0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL, -- 0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL, -- 0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL, -- 0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL, -- 0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL, -- 0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL, -- 0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL, -- 0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL, -- 0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL, -- 0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL, -- 0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL, -- 0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL, -- 0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL, -- 0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL, -- 0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL, -- 0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL, -- 0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL, -- 0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL, -- 0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL, -- 0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL, -- 0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL, -- 0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL, -- 0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL, -- 0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL, -- 0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL, -- 0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL, -- 0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL, -- 0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL, -- 0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL, -- 0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL, -- 0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL, -- 0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL, -- 0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL, -- 0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL, -- 0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL, -- 0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL, -- 0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL, -- 0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL, -- 0x72fd2493UL -- }, -- { -- 0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL, -- 0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL, -- 0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL, -- 0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL, -- 0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL, -- 0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL, -- 0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL, -- 0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL, -- 0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL, -- 0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL, -- 0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL, -- 0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL, -- 0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL, -- 0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL, -- 0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL, -- 0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL, -- 0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL, -- 0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL, -- 0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL, -- 0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL, -- 0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL, -- 0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL, -- 0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL, -- 0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL, -- 0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL, -- 0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL, -- 0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL, -- 0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL, -- 0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL, -- 0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL, -- 0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL, -- 0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL, -- 0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL, -- 0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL, -- 0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL, -- 0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL, -- 0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL, -- 0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL, -- 0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL, -- 0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL, -- 0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL, -- 0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL, -- 0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL, -- 0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL, -- 0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL, -- 0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL, -- 0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL, -- 0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL, -- 0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL, -- 0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL, -- 0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL, -- 0xed3498beUL -- }, -- { -- 0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL, -- 0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL, -- 0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL, -- 0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL, -- 0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL, -- 0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL, -- 0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL, -- 0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL, -- 0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL, -- 0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL, -- 0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL, -- 0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL, -- 0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL, -- 0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL, -- 0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL, -- 0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL, -- 0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL, -- 0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL, -- 0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL, -- 0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL, -- 0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL, -- 0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL, -- 0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL, -- 0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL, -- 0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL, -- 0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL, -- 0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL, -- 0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL, -- 0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL, -- 0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL, -- 0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL, -- 0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL, -- 0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL, -- 0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL, -- 0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL, -- 0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL, -- 0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL, -- 0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL, -- 0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL, -- 0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL, -- 0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL, -- 0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL, -- 0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL, -- 0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL, -- 0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL, -- 0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL, -- 0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL, -- 0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL, -- 0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL, -- 0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL, -- 0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL, -- 0xf10605deUL --#endif -- } --}; -diff --git a/thirdparty/zlib/deflate.c b/thirdparty/zlib/deflate.c -deleted file mode 100644 -index 5c4022f..0000000 ---- a/thirdparty/zlib/deflate.c -+++ /dev/null -@@ -1,1834 +0,0 @@ --/* deflate.c -- compress data using the deflation algorithm -- * Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* -- * ALGORITHM -- * -- * The "deflation" process depends on being able to identify portions -- * of the input text which are identical to earlier input (within a -- * sliding window trailing behind the input currently being processed). -- * -- * The most straightforward technique turns out to be the fastest for -- * most input files: try all possible matches and select the longest. -- * The key feature of this algorithm is that insertions into the string -- * dictionary are very simple and thus fast, and deletions are avoided -- * completely. Insertions are performed at each input character, whereas -- * string matches are performed only when the previous match ends. So it -- * is preferable to spend more time in matches to allow very fast string -- * insertions and avoid deletions. The matching algorithm for small -- * strings is inspired from that of Rabin & Karp. A brute force approach -- * is used to find longer strings when a small match has been found. -- * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze -- * (by Leonid Broukhis). -- * A previous version of this file used a more sophisticated algorithm -- * (by Fiala and Greene) which is guaranteed to run in linear amortized -- * time, but has a larger average cost, uses more memory and is patented. -- * However the F&G algorithm may be faster for some highly redundant -- * files if the parameter max_chain_length (described below) is too large. -- * -- * ACKNOWLEDGEMENTS -- * -- * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and -- * I found it in 'freeze' written by Leonid Broukhis. -- * Thanks to many people for bug reports and testing. -- * -- * REFERENCES -- * -- * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification". -- * Available in http://www.ietf.org/rfc/rfc1951.txt -- * -- * A description of the Rabin and Karp algorithm is given in the book -- * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. -- * -- * Fiala,E.R., and Greene,D.H. -- * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 -- * -- */ -- --/* @(#) $Id$ */ -- --#include "deflate.h" -- --const char deflate_copyright[] = -- " deflate 1.2.5 Copyright 1995-2010 Jean-loup Gailly and Mark Adler "; --/* -- If you use the zlib library in a product, an acknowledgment is welcome -- in the documentation of your product. If for some reason you cannot -- include such an acknowledgment, I would appreciate that you keep this -- copyright string in the executable of your product. -- */ -- --/* =========================================================================== -- * Function prototypes. -- */ --typedef enum { -- need_more, /* block not completed, need more input or more output */ -- block_done, /* block flush performed */ -- finish_started, /* finish started, need only more output at next deflate */ -- finish_done /* finish done, accept no more input or output */ --} block_state; -- --typedef block_state (*compress_func) OF((deflate_state *s, int flush)); --/* Compression function. Returns the block state after the call. */ -- --local void fill_window OF((deflate_state *s)); --local block_state deflate_stored OF((deflate_state *s, int flush)); --local block_state deflate_fast OF((deflate_state *s, int flush)); --#ifndef FASTEST --local block_state deflate_slow OF((deflate_state *s, int flush)); --#endif --local block_state deflate_rle OF((deflate_state *s, int flush)); --local block_state deflate_huff OF((deflate_state *s, int flush)); --local void lm_init OF((deflate_state *s)); --local void putShortMSB OF((deflate_state *s, uInt b)); --local void flush_pending OF((z_streamp strm)); --local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); --#ifdef ASMV -- void match_init OF((void)); /* asm code initialization */ -- uInt longest_match OF((deflate_state *s, IPos cur_match)); --#else --local uInt longest_match OF((deflate_state *s, IPos cur_match)); --#endif -- --#ifdef DEBUG --local void check_match OF((deflate_state *s, IPos start, IPos match, -- int length)); --#endif -- --/* =========================================================================== -- * Local data -- */ -- --#define NIL 0 --/* Tail of hash chains */ -- --#ifndef TOO_FAR --# define TOO_FAR 4096 --#endif --/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ -- --/* Values for max_lazy_match, good_match and max_chain_length, depending on -- * the desired pack level (0..9). The values given below have been tuned to -- * exclude worst case performance for pathological files. Better values may be -- * found for specific files. -- */ --typedef struct config_s { -- ush good_length; /* reduce lazy search above this match length */ -- ush max_lazy; /* do not perform lazy search above this match length */ -- ush nice_length; /* quit search above this match length */ -- ush max_chain; -- compress_func func; --} config; -- --#ifdef FASTEST --local const config configuration_table[2] = { --/* good lazy nice chain */ --/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ --/* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */ --#else --local const config configuration_table[10] = { --/* good lazy nice chain */ --/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ --/* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */ --/* 2 */ {4, 5, 16, 8, deflate_fast}, --/* 3 */ {4, 6, 32, 32, deflate_fast}, -- --/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */ --/* 5 */ {8, 16, 32, 32, deflate_slow}, --/* 6 */ {8, 16, 128, 128, deflate_slow}, --/* 7 */ {8, 32, 128, 256, deflate_slow}, --/* 8 */ {32, 128, 258, 1024, deflate_slow}, --/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */ --#endif -- --/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 -- * For deflate_fast() (levels <= 3) good is ignored and lazy has a different -- * meaning. -- */ -- --#define EQUAL 0 --/* result of memcmp for equal strings */ -- --#ifndef NO_DUMMY_DECL --struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ --#endif -- --/* =========================================================================== -- * Update a hash value with the given input byte -- * IN assertion: all calls to to UPDATE_HASH are made with consecutive -- * input characters, so that a running hash key can be computed from the -- * previous key instead of complete recalculation each time. -- */ --#define UPDATE_HASH(s,h,c) (h = (((h)<hash_shift) ^ (c)) & s->hash_mask) -- -- --/* =========================================================================== -- * Insert string str in the dictionary and set match_head to the previous head -- * of the hash chain (the most recent string with same hash key). Return -- * the previous length of the hash chain. -- * If this file is compiled with -DFASTEST, the compression level is forced -- * to 1, and no hash chains are maintained. -- * IN assertion: all calls to to INSERT_STRING are made with consecutive -- * input characters and the first MIN_MATCH bytes of str are valid -- * (except for the last MIN_MATCH-1 bytes of the input file). -- */ --#ifdef FASTEST --#define INSERT_STRING(s, str, match_head) \ -- (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ -- match_head = s->head[s->ins_h], \ -- s->head[s->ins_h] = (Pos)(str)) --#else --#define INSERT_STRING(s, str, match_head) \ -- (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ -- match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \ -- s->head[s->ins_h] = (Pos)(str)) --#endif -- --/* =========================================================================== -- * Initialize the hash table (avoiding 64K overflow for 16 bit systems). -- * prev[] will be initialized on the fly. -- */ --#define CLEAR_HASH(s) \ -- s->head[s->hash_size-1] = NIL; \ -- zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); -- --/* ========================================================================= */ --int ZEXPORT deflateInit_(strm, level, version, stream_size) -- z_streamp strm; -- int level; -- const char *version; -- int stream_size; --{ -- return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, -- Z_DEFAULT_STRATEGY, version, stream_size); -- /* To do: ignore strm->next_in if we use it as window */ --} -- --/* ========================================================================= */ --int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, -- version, stream_size) -- z_streamp strm; -- int level; -- int method; -- int windowBits; -- int memLevel; -- int strategy; -- const char *version; -- int stream_size; --{ -- deflate_state *s; -- int wrap = 1; -- static const char my_version[] = ZLIB_VERSION; -- -- ushf *overlay; -- /* We overlay pending_buf and d_buf+l_buf. This works since the average -- * output size for (length,distance) codes is <= 24 bits. -- */ -- -- if (version == Z_NULL || version[0] != my_version[0] || -- stream_size != sizeof(z_stream)) { -- return Z_VERSION_ERROR; -- } -- if (strm == Z_NULL) return Z_STREAM_ERROR; -- -- strm->msg = Z_NULL; -- if (strm->zalloc == (alloc_func)0) { -- strm->zalloc = zcalloc; -- strm->opaque = (voidpf)0; -- } -- if (strm->zfree == (free_func)0) strm->zfree = zcfree; -- --#ifdef FASTEST -- if (level != 0) level = 1; --#else -- if (level == Z_DEFAULT_COMPRESSION) level = 6; --#endif -- -- if (windowBits < 0) { /* suppress zlib wrapper */ -- wrap = 0; -- windowBits = -windowBits; -- } --#ifdef GZIP -- else if (windowBits > 15) { -- wrap = 2; /* write gzip wrapper instead */ -- windowBits -= 16; -- } --#endif -- if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || -- windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || -- strategy < 0 || strategy > Z_FIXED) { -- return Z_STREAM_ERROR; -- } -- if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */ -- s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state)); -- if (s == Z_NULL) return Z_MEM_ERROR; -- strm->state = (struct internal_state FAR *)s; -- s->strm = strm; -- -- s->wrap = wrap; -- s->gzhead = Z_NULL; -- s->w_bits = windowBits; -- s->w_size = 1 << s->w_bits; -- s->w_mask = s->w_size - 1; -- -- s->hash_bits = memLevel + 7; -- s->hash_size = 1 << s->hash_bits; -- s->hash_mask = s->hash_size - 1; -- s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); -- -- s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); -- s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); -- s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); -- -- s->high_water = 0; /* nothing written to s->window yet */ -- -- s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ -- -- overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); -- s->pending_buf = (uchf *) overlay; -- s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L); -- -- if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || -- s->pending_buf == Z_NULL) { -- s->status = FINISH_STATE; -- strm->msg = (char*)ERR_MSG(Z_MEM_ERROR); -- deflateEnd (strm); -- return Z_MEM_ERROR; -- } -- s->d_buf = overlay + s->lit_bufsize/sizeof(ush); -- s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; -- -- s->level = level; -- s->strategy = strategy; -- s->method = (Byte)method; -- -- return deflateReset(strm); --} -- --/* ========================================================================= */ --int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) -- z_streamp strm; -- const Bytef *dictionary; -- uInt dictLength; --{ -- deflate_state *s; -- uInt length = dictLength; -- uInt n; -- IPos hash_head = 0; -- -- if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL || -- strm->state->wrap == 2 || -- (strm->state->wrap == 1 && strm->state->status != INIT_STATE)) -- return Z_STREAM_ERROR; -- -- s = strm->state; -- if (s->wrap) -- strm->adler = adler32(strm->adler, dictionary, dictLength); -- -- if (length < MIN_MATCH) return Z_OK; -- if (length > s->w_size) { -- length = s->w_size; -- dictionary += dictLength - length; /* use the tail of the dictionary */ -- } -- zmemcpy(s->window, dictionary, length); -- s->strstart = length; -- s->block_start = (long)length; -- -- /* Insert all strings in the hash table (except for the last two bytes). -- * s->lookahead stays null, so s->ins_h will be recomputed at the next -- * call of fill_window. -- */ -- s->ins_h = s->window[0]; -- UPDATE_HASH(s, s->ins_h, s->window[1]); -- for (n = 0; n <= length - MIN_MATCH; n++) { -- INSERT_STRING(s, n, hash_head); -- } -- if (hash_head) hash_head = 0; /* to make compiler happy */ -- return Z_OK; --} -- --/* ========================================================================= */ --int ZEXPORT deflateReset (strm) -- z_streamp strm; --{ -- deflate_state *s; -- -- if (strm == Z_NULL || strm->state == Z_NULL || -- strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) { -- return Z_STREAM_ERROR; -- } -- -- strm->total_in = strm->total_out = 0; -- strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */ -- strm->data_type = Z_UNKNOWN; -- -- s = (deflate_state *)strm->state; -- s->pending = 0; -- s->pending_out = s->pending_buf; -- -- if (s->wrap < 0) { -- s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */ -- } -- s->status = s->wrap ? INIT_STATE : BUSY_STATE; -- strm->adler = --#ifdef GZIP -- s->wrap == 2 ? crc32(0L, Z_NULL, 0) : --#endif -- adler32(0L, Z_NULL, 0); -- s->last_flush = Z_NO_FLUSH; -- -- _tr_init(s); -- lm_init(s); -- -- return Z_OK; --} -- --/* ========================================================================= */ --int ZEXPORT deflateSetHeader (strm, head) -- z_streamp strm; -- gz_headerp head; --{ -- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; -- if (strm->state->wrap != 2) return Z_STREAM_ERROR; -- strm->state->gzhead = head; -- return Z_OK; --} -- --/* ========================================================================= */ --int ZEXPORT deflatePrime (strm, bits, value) -- z_streamp strm; -- int bits; -- int value; --{ -- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; -- strm->state->bi_valid = bits; -- strm->state->bi_buf = (ush)(value & ((1 << bits) - 1)); -- return Z_OK; --} -- --/* ========================================================================= */ --int ZEXPORT deflateParams(strm, level, strategy) -- z_streamp strm; -- int level; -- int strategy; --{ -- deflate_state *s; -- compress_func func; -- int err = Z_OK; -- -- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; -- s = strm->state; -- --#ifdef FASTEST -- if (level != 0) level = 1; --#else -- if (level == Z_DEFAULT_COMPRESSION) level = 6; --#endif -- if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { -- return Z_STREAM_ERROR; -- } -- func = configuration_table[s->level].func; -- -- if ((strategy != s->strategy || func != configuration_table[level].func) && -- strm->total_in != 0) { -- /* Flush the last buffer: */ -- err = deflate(strm, Z_BLOCK); -- } -- if (s->level != level) { -- s->level = level; -- s->max_lazy_match = configuration_table[level].max_lazy; -- s->good_match = configuration_table[level].good_length; -- s->nice_match = configuration_table[level].nice_length; -- s->max_chain_length = configuration_table[level].max_chain; -- } -- s->strategy = strategy; -- return err; --} -- --/* ========================================================================= */ --int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain) -- z_streamp strm; -- int good_length; -- int max_lazy; -- int nice_length; -- int max_chain; --{ -- deflate_state *s; -- -- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; -- s = strm->state; -- s->good_match = good_length; -- s->max_lazy_match = max_lazy; -- s->nice_match = nice_length; -- s->max_chain_length = max_chain; -- return Z_OK; --} -- --/* ========================================================================= -- * For the default windowBits of 15 and memLevel of 8, this function returns -- * a close to exact, as well as small, upper bound on the compressed size. -- * They are coded as constants here for a reason--if the #define's are -- * changed, then this function needs to be changed as well. The return -- * value for 15 and 8 only works for those exact settings. -- * -- * For any setting other than those defaults for windowBits and memLevel, -- * the value returned is a conservative worst case for the maximum expansion -- * resulting from using fixed blocks instead of stored blocks, which deflate -- * can emit on compressed data for some combinations of the parameters. -- * -- * This function could be more sophisticated to provide closer upper bounds for -- * every combination of windowBits and memLevel. But even the conservative -- * upper bound of about 14% expansion does not seem onerous for output buffer -- * allocation. -- */ --uLong ZEXPORT deflateBound(strm, sourceLen) -- z_streamp strm; -- uLong sourceLen; --{ -- deflate_state *s; -- uLong complen, wraplen; -- Bytef *str; -- -- /* conservative upper bound for compressed data */ -- complen = sourceLen + -- ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5; -- -- /* if can't get parameters, return conservative bound plus zlib wrapper */ -- if (strm == Z_NULL || strm->state == Z_NULL) -- return complen + 6; -- -- /* compute wrapper length */ -- s = strm->state; -- switch (s->wrap) { -- case 0: /* raw deflate */ -- wraplen = 0; -- break; -- case 1: /* zlib wrapper */ -- wraplen = 6 + (s->strstart ? 4 : 0); -- break; -- case 2: /* gzip wrapper */ -- wraplen = 18; -- if (s->gzhead != Z_NULL) { /* user-supplied gzip header */ -- if (s->gzhead->extra != Z_NULL) -- wraplen += 2 + s->gzhead->extra_len; -- str = s->gzhead->name; -- if (str != Z_NULL) -- do { -- wraplen++; -- } while (*str++); -- str = s->gzhead->comment; -- if (str != Z_NULL) -- do { -- wraplen++; -- } while (*str++); -- if (s->gzhead->hcrc) -- wraplen += 2; -- } -- break; -- default: /* for compiler happiness */ -- wraplen = 6; -- } -- -- /* if not default parameters, return conservative bound */ -- if (s->w_bits != 15 || s->hash_bits != 8 + 7) -- return complen + wraplen; -- -- /* default settings: return tight bound for that case */ -- return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + -- (sourceLen >> 25) + 13 - 6 + wraplen; --} -- --/* ========================================================================= -- * Put a short in the pending buffer. The 16-bit value is put in MSB order. -- * IN assertion: the stream state is correct and there is enough room in -- * pending_buf. -- */ --local void putShortMSB (s, b) -- deflate_state *s; -- uInt b; --{ -- put_byte(s, (Byte)(b >> 8)); -- put_byte(s, (Byte)(b & 0xff)); --} -- --/* ========================================================================= -- * Flush as much pending output as possible. All deflate() output goes -- * through this function so some applications may wish to modify it -- * to avoid allocating a large strm->next_out buffer and copying into it. -- * (See also read_buf()). -- */ --local void flush_pending(strm) -- z_streamp strm; --{ -- unsigned len = strm->state->pending; -- -- if (len > strm->avail_out) len = strm->avail_out; -- if (len == 0) return; -- -- zmemcpy(strm->next_out, strm->state->pending_out, len); -- strm->next_out += len; -- strm->state->pending_out += len; -- strm->total_out += len; -- strm->avail_out -= len; -- strm->state->pending -= len; -- if (strm->state->pending == 0) { -- strm->state->pending_out = strm->state->pending_buf; -- } --} -- --/* ========================================================================= */ --int ZEXPORT deflate (strm, flush) -- z_streamp strm; -- int flush; --{ -- int old_flush; /* value of flush param for previous deflate call */ -- deflate_state *s; -- -- if (strm == Z_NULL || strm->state == Z_NULL || -- flush > Z_BLOCK || flush < 0) { -- return Z_STREAM_ERROR; -- } -- s = strm->state; -- -- if (strm->next_out == Z_NULL || -- (strm->next_in == Z_NULL && strm->avail_in != 0) || -- (s->status == FINISH_STATE && flush != Z_FINISH)) { -- ERR_RETURN(strm, Z_STREAM_ERROR); -- } -- if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); -- -- s->strm = strm; /* just in case */ -- old_flush = s->last_flush; -- s->last_flush = flush; -- -- /* Write the header */ -- if (s->status == INIT_STATE) { --#ifdef GZIP -- if (s->wrap == 2) { -- strm->adler = crc32(0L, Z_NULL, 0); -- put_byte(s, 31); -- put_byte(s, 139); -- put_byte(s, 8); -- if (s->gzhead == Z_NULL) { -- put_byte(s, 0); -- put_byte(s, 0); -- put_byte(s, 0); -- put_byte(s, 0); -- put_byte(s, 0); -- put_byte(s, s->level == 9 ? 2 : -- (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? -- 4 : 0)); -- put_byte(s, OS_CODE); -- s->status = BUSY_STATE; -- } -- else { -- put_byte(s, (s->gzhead->text ? 1 : 0) + -- (s->gzhead->hcrc ? 2 : 0) + -- (s->gzhead->extra == Z_NULL ? 0 : 4) + -- (s->gzhead->name == Z_NULL ? 0 : 8) + -- (s->gzhead->comment == Z_NULL ? 0 : 16) -- ); -- put_byte(s, (Byte)(s->gzhead->time & 0xff)); -- put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff)); -- put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff)); -- put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff)); -- put_byte(s, s->level == 9 ? 2 : -- (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? -- 4 : 0)); -- put_byte(s, s->gzhead->os & 0xff); -- if (s->gzhead->extra != Z_NULL) { -- put_byte(s, s->gzhead->extra_len & 0xff); -- put_byte(s, (s->gzhead->extra_len >> 8) & 0xff); -- } -- if (s->gzhead->hcrc) -- strm->adler = crc32(strm->adler, s->pending_buf, -- s->pending); -- s->gzindex = 0; -- s->status = EXTRA_STATE; -- } -- } -- else --#endif -- { -- uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; -- uInt level_flags; -- -- if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) -- level_flags = 0; -- else if (s->level < 6) -- level_flags = 1; -- else if (s->level == 6) -- level_flags = 2; -- else -- level_flags = 3; -- header |= (level_flags << 6); -- if (s->strstart != 0) header |= PRESET_DICT; -- header += 31 - (header % 31); -- -- s->status = BUSY_STATE; -- putShortMSB(s, header); -- -- /* Save the adler32 of the preset dictionary: */ -- if (s->strstart != 0) { -- putShortMSB(s, (uInt)(strm->adler >> 16)); -- putShortMSB(s, (uInt)(strm->adler & 0xffff)); -- } -- strm->adler = adler32(0L, Z_NULL, 0); -- } -- } --#ifdef GZIP -- if (s->status == EXTRA_STATE) { -- if (s->gzhead->extra != Z_NULL) { -- uInt beg = s->pending; /* start of bytes to update crc */ -- -- while (s->gzindex < (s->gzhead->extra_len & 0xffff)) { -- if (s->pending == s->pending_buf_size) { -- if (s->gzhead->hcrc && s->pending > beg) -- strm->adler = crc32(strm->adler, s->pending_buf + beg, -- s->pending - beg); -- flush_pending(strm); -- beg = s->pending; -- if (s->pending == s->pending_buf_size) -- break; -- } -- put_byte(s, s->gzhead->extra[s->gzindex]); -- s->gzindex++; -- } -- if (s->gzhead->hcrc && s->pending > beg) -- strm->adler = crc32(strm->adler, s->pending_buf + beg, -- s->pending - beg); -- if (s->gzindex == s->gzhead->extra_len) { -- s->gzindex = 0; -- s->status = NAME_STATE; -- } -- } -- else -- s->status = NAME_STATE; -- } -- if (s->status == NAME_STATE) { -- if (s->gzhead->name != Z_NULL) { -- uInt beg = s->pending; /* start of bytes to update crc */ -- int val; -- -- do { -- if (s->pending == s->pending_buf_size) { -- if (s->gzhead->hcrc && s->pending > beg) -- strm->adler = crc32(strm->adler, s->pending_buf + beg, -- s->pending - beg); -- flush_pending(strm); -- beg = s->pending; -- if (s->pending == s->pending_buf_size) { -- val = 1; -- break; -- } -- } -- val = s->gzhead->name[s->gzindex++]; -- put_byte(s, val); -- } while (val != 0); -- if (s->gzhead->hcrc && s->pending > beg) -- strm->adler = crc32(strm->adler, s->pending_buf + beg, -- s->pending - beg); -- if (val == 0) { -- s->gzindex = 0; -- s->status = COMMENT_STATE; -- } -- } -- else -- s->status = COMMENT_STATE; -- } -- if (s->status == COMMENT_STATE) { -- if (s->gzhead->comment != Z_NULL) { -- uInt beg = s->pending; /* start of bytes to update crc */ -- int val; -- -- do { -- if (s->pending == s->pending_buf_size) { -- if (s->gzhead->hcrc && s->pending > beg) -- strm->adler = crc32(strm->adler, s->pending_buf + beg, -- s->pending - beg); -- flush_pending(strm); -- beg = s->pending; -- if (s->pending == s->pending_buf_size) { -- val = 1; -- break; -- } -- } -- val = s->gzhead->comment[s->gzindex++]; -- put_byte(s, val); -- } while (val != 0); -- if (s->gzhead->hcrc && s->pending > beg) -- strm->adler = crc32(strm->adler, s->pending_buf + beg, -- s->pending - beg); -- if (val == 0) -- s->status = HCRC_STATE; -- } -- else -- s->status = HCRC_STATE; -- } -- if (s->status == HCRC_STATE) { -- if (s->gzhead->hcrc) { -- if (s->pending + 2 > s->pending_buf_size) -- flush_pending(strm); -- if (s->pending + 2 <= s->pending_buf_size) { -- put_byte(s, (Byte)(strm->adler & 0xff)); -- put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); -- strm->adler = crc32(0L, Z_NULL, 0); -- s->status = BUSY_STATE; -- } -- } -- else -- s->status = BUSY_STATE; -- } --#endif -- -- /* Flush as much pending output as possible */ -- if (s->pending != 0) { -- flush_pending(strm); -- if (strm->avail_out == 0) { -- /* Since avail_out is 0, deflate will be called again with -- * more output space, but possibly with both pending and -- * avail_in equal to zero. There won't be anything to do, -- * but this is not an error situation so make sure we -- * return OK instead of BUF_ERROR at next call of deflate: -- */ -- s->last_flush = -1; -- return Z_OK; -- } -- -- /* Make sure there is something to do and avoid duplicate consecutive -- * flushes. For repeated and useless calls with Z_FINISH, we keep -- * returning Z_STREAM_END instead of Z_BUF_ERROR. -- */ -- } else if (strm->avail_in == 0 && flush <= old_flush && -- flush != Z_FINISH) { -- ERR_RETURN(strm, Z_BUF_ERROR); -- } -- -- /* User must not provide more input after the first FINISH: */ -- if (s->status == FINISH_STATE && strm->avail_in != 0) { -- ERR_RETURN(strm, Z_BUF_ERROR); -- } -- -- /* Start a new block or continue the current one. -- */ -- if (strm->avail_in != 0 || s->lookahead != 0 || -- (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { -- block_state bstate; -- -- bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : -- (s->strategy == Z_RLE ? deflate_rle(s, flush) : -- (*(configuration_table[s->level].func))(s, flush)); -- -- if (bstate == finish_started || bstate == finish_done) { -- s->status = FINISH_STATE; -- } -- if (bstate == need_more || bstate == finish_started) { -- if (strm->avail_out == 0) { -- s->last_flush = -1; /* avoid BUF_ERROR next call, see above */ -- } -- return Z_OK; -- /* If flush != Z_NO_FLUSH && avail_out == 0, the next call -- * of deflate should use the same flush parameter to make sure -- * that the flush is complete. So we don't have to output an -- * empty block here, this will be done at next call. This also -- * ensures that for a very small output buffer, we emit at most -- * one empty block. -- */ -- } -- if (bstate == block_done) { -- if (flush == Z_PARTIAL_FLUSH) { -- _tr_align(s); -- } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */ -- _tr_stored_block(s, (char*)0, 0L, 0); -- /* For a full flush, this empty block will be recognized -- * as a special marker by inflate_sync(). -- */ -- if (flush == Z_FULL_FLUSH) { -- CLEAR_HASH(s); /* forget history */ -- if (s->lookahead == 0) { -- s->strstart = 0; -- s->block_start = 0L; -- } -- } -- } -- flush_pending(strm); -- if (strm->avail_out == 0) { -- s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ -- return Z_OK; -- } -- } -- } -- Assert(strm->avail_out > 0, "bug2"); -- -- if (flush != Z_FINISH) return Z_OK; -- if (s->wrap <= 0) return Z_STREAM_END; -- -- /* Write the trailer */ --#ifdef GZIP -- if (s->wrap == 2) { -- put_byte(s, (Byte)(strm->adler & 0xff)); -- put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); -- put_byte(s, (Byte)((strm->adler >> 16) & 0xff)); -- put_byte(s, (Byte)((strm->adler >> 24) & 0xff)); -- put_byte(s, (Byte)(strm->total_in & 0xff)); -- put_byte(s, (Byte)((strm->total_in >> 8) & 0xff)); -- put_byte(s, (Byte)((strm->total_in >> 16) & 0xff)); -- put_byte(s, (Byte)((strm->total_in >> 24) & 0xff)); -- } -- else --#endif -- { -- putShortMSB(s, (uInt)(strm->adler >> 16)); -- putShortMSB(s, (uInt)(strm->adler & 0xffff)); -- } -- flush_pending(strm); -- /* If avail_out is zero, the application will call deflate again -- * to flush the rest. -- */ -- if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */ -- return s->pending != 0 ? Z_OK : Z_STREAM_END; --} -- --/* ========================================================================= */ --int ZEXPORT deflateEnd (strm) -- z_streamp strm; --{ -- int status; -- -- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; -- -- status = strm->state->status; -- if (status != INIT_STATE && -- status != EXTRA_STATE && -- status != NAME_STATE && -- status != COMMENT_STATE && -- status != HCRC_STATE && -- status != BUSY_STATE && -- status != FINISH_STATE) { -- return Z_STREAM_ERROR; -- } -- -- /* Deallocate in reverse order of allocations: */ -- TRY_FREE(strm, strm->state->pending_buf); -- TRY_FREE(strm, strm->state->head); -- TRY_FREE(strm, strm->state->prev); -- TRY_FREE(strm, strm->state->window); -- -- ZFREE(strm, strm->state); -- strm->state = Z_NULL; -- -- return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; --} -- --/* ========================================================================= -- * Copy the source state to the destination state. -- * To simplify the source, this is not supported for 16-bit MSDOS (which -- * doesn't have enough memory anyway to duplicate compression states). -- */ --int ZEXPORT deflateCopy (dest, source) -- z_streamp dest; -- z_streamp source; --{ --#ifdef MAXSEG_64K -- return Z_STREAM_ERROR; --#else -- deflate_state *ds; -- deflate_state *ss; -- ushf *overlay; -- -- -- if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { -- return Z_STREAM_ERROR; -- } -- -- ss = source->state; -- -- zmemcpy(dest, source, sizeof(z_stream)); -- -- ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state)); -- if (ds == Z_NULL) return Z_MEM_ERROR; -- dest->state = (struct internal_state FAR *) ds; -- zmemcpy(ds, ss, sizeof(deflate_state)); -- ds->strm = dest; -- -- ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); -- ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); -- ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); -- overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2); -- ds->pending_buf = (uchf *) overlay; -- -- if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || -- ds->pending_buf == Z_NULL) { -- deflateEnd (dest); -- return Z_MEM_ERROR; -- } -- /* following zmemcpy do not work for 16-bit MSDOS */ -- zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); -- zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos)); -- zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos)); -- zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); -- -- ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); -- ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush); -- ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize; -- -- ds->l_desc.dyn_tree = ds->dyn_ltree; -- ds->d_desc.dyn_tree = ds->dyn_dtree; -- ds->bl_desc.dyn_tree = ds->bl_tree; -- -- return Z_OK; --#endif /* MAXSEG_64K */ --} -- --/* =========================================================================== -- * Read a new buffer from the current input stream, update the adler32 -- * and total number of bytes read. All deflate() input goes through -- * this function so some applications may wish to modify it to avoid -- * allocating a large strm->next_in buffer and copying from it. -- * (See also flush_pending()). -- */ --local int read_buf(strm, buf, size) -- z_streamp strm; -- Bytef *buf; -- unsigned size; --{ -- unsigned len = strm->avail_in; -- -- if (len > size) len = size; -- if (len == 0) return 0; -- -- strm->avail_in -= len; -- -- if (strm->state->wrap == 1) { -- strm->adler = adler32(strm->adler, strm->next_in, len); -- } --#ifdef GZIP -- else if (strm->state->wrap == 2) { -- strm->adler = crc32(strm->adler, strm->next_in, len); -- } --#endif -- zmemcpy(buf, strm->next_in, len); -- strm->next_in += len; -- strm->total_in += len; -- -- return (int)len; --} -- --/* =========================================================================== -- * Initialize the "longest match" routines for a new zlib stream -- */ --local void lm_init (s) -- deflate_state *s; --{ -- s->window_size = (ulg)2L*s->w_size; -- -- CLEAR_HASH(s); -- -- /* Set the default configuration parameters: -- */ -- s->max_lazy_match = configuration_table[s->level].max_lazy; -- s->good_match = configuration_table[s->level].good_length; -- s->nice_match = configuration_table[s->level].nice_length; -- s->max_chain_length = configuration_table[s->level].max_chain; -- -- s->strstart = 0; -- s->block_start = 0L; -- s->lookahead = 0; -- s->match_length = s->prev_length = MIN_MATCH-1; -- s->match_available = 0; -- s->ins_h = 0; --#ifndef FASTEST --#ifdef ASMV -- match_init(); /* initialize the asm code */ --#endif --#endif --} -- --#ifndef FASTEST --/* =========================================================================== -- * Set match_start to the longest match starting at the given string and -- * return its length. Matches shorter or equal to prev_length are discarded, -- * in which case the result is equal to prev_length and match_start is -- * garbage. -- * IN assertions: cur_match is the head of the hash chain for the current -- * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 -- * OUT assertion: the match length is not greater than s->lookahead. -- */ --#ifndef ASMV --/* For 80x86 and 680x0, an optimized version will be provided in match.asm or -- * match.S. The code will be functionally equivalent. -- */ --local uInt longest_match(s, cur_match) -- deflate_state *s; -- IPos cur_match; /* current match */ --{ -- unsigned chain_length = s->max_chain_length;/* max hash chain length */ -- register Bytef *scan = s->window + s->strstart; /* current string */ -- register Bytef *match; /* matched string */ -- register int len; /* length of current match */ -- int best_len = s->prev_length; /* best match length so far */ -- int nice_match = s->nice_match; /* stop if match long enough */ -- IPos limit = s->strstart > (IPos)MAX_DIST(s) ? -- s->strstart - (IPos)MAX_DIST(s) : NIL; -- /* Stop when cur_match becomes <= limit. To simplify the code, -- * we prevent matches with the string of window index 0. -- */ -- Posf *prev = s->prev; -- uInt wmask = s->w_mask; -- --#ifdef UNALIGNED_OK -- /* Compare two bytes at a time. Note: this is not always beneficial. -- * Try with and without -DUNALIGNED_OK to check. -- */ -- register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; -- register ush scan_start = *(ushf*)scan; -- register ush scan_end = *(ushf*)(scan+best_len-1); --#else -- register Bytef *strend = s->window + s->strstart + MAX_MATCH; -- register Byte scan_end1 = scan[best_len-1]; -- register Byte scan_end = scan[best_len]; --#endif -- -- /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. -- * It is easy to get rid of this optimization if necessary. -- */ -- Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); -- -- /* Do not waste too much time if we already have a good match: */ -- if (s->prev_length >= s->good_match) { -- chain_length >>= 2; -- } -- /* Do not look for matches beyond the end of the input. This is necessary -- * to make deflate deterministic. -- */ -- if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; -- -- Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); -- -- do { -- Assert(cur_match < s->strstart, "no future"); -- match = s->window + cur_match; -- -- /* Skip to next match if the match length cannot increase -- * or if the match length is less than 2. Note that the checks below -- * for insufficient lookahead only occur occasionally for performance -- * reasons. Therefore uninitialized memory will be accessed, and -- * conditional jumps will be made that depend on those values. -- * However the length of the match is limited to the lookahead, so -- * the output of deflate is not affected by the uninitialized values. -- */ --#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) -- /* This code assumes sizeof(unsigned short) == 2. Do not use -- * UNALIGNED_OK if your compiler uses a different size. -- */ -- if (*(ushf*)(match+best_len-1) != scan_end || -- *(ushf*)match != scan_start) continue; -- -- /* It is not necessary to compare scan[2] and match[2] since they are -- * always equal when the other bytes match, given that the hash keys -- * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at -- * strstart+3, +5, ... up to strstart+257. We check for insufficient -- * lookahead only every 4th comparison; the 128th check will be made -- * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is -- * necessary to put more guard bytes at the end of the window, or -- * to check more often for insufficient lookahead. -- */ -- Assert(scan[2] == match[2], "scan[2]?"); -- scan++, match++; -- do { -- } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && -- *(ushf*)(scan+=2) == *(ushf*)(match+=2) && -- *(ushf*)(scan+=2) == *(ushf*)(match+=2) && -- *(ushf*)(scan+=2) == *(ushf*)(match+=2) && -- scan < strend); -- /* The funny "do {}" generates better code on most compilers */ -- -- /* Here, scan <= window+strstart+257 */ -- Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); -- if (*scan == *match) scan++; -- -- len = (MAX_MATCH - 1) - (int)(strend-scan); -- scan = strend - (MAX_MATCH-1); -- --#else /* UNALIGNED_OK */ -- -- if (match[best_len] != scan_end || -- match[best_len-1] != scan_end1 || -- *match != *scan || -- *++match != scan[1]) continue; -- -- /* The check at best_len-1 can be removed because it will be made -- * again later. (This heuristic is not always a win.) -- * It is not necessary to compare scan[2] and match[2] since they -- * are always equal when the other bytes match, given that -- * the hash keys are equal and that HASH_BITS >= 8. -- */ -- scan += 2, match++; -- Assert(*scan == *match, "match[2]?"); -- -- /* We check for insufficient lookahead only every 8th comparison; -- * the 256th check will be made at strstart+258. -- */ -- do { -- } while (*++scan == *++match && *++scan == *++match && -- *++scan == *++match && *++scan == *++match && -- *++scan == *++match && *++scan == *++match && -- *++scan == *++match && *++scan == *++match && -- scan < strend); -- -- Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); -- -- len = MAX_MATCH - (int)(strend - scan); -- scan = strend - MAX_MATCH; -- --#endif /* UNALIGNED_OK */ -- -- if (len > best_len) { -- s->match_start = cur_match; -- best_len = len; -- if (len >= nice_match) break; --#ifdef UNALIGNED_OK -- scan_end = *(ushf*)(scan+best_len-1); --#else -- scan_end1 = scan[best_len-1]; -- scan_end = scan[best_len]; --#endif -- } -- } while ((cur_match = prev[cur_match & wmask]) > limit -- && --chain_length != 0); -- -- if ((uInt)best_len <= s->lookahead) return (uInt)best_len; -- return s->lookahead; --} --#endif /* ASMV */ -- --#else /* FASTEST */ -- --/* --------------------------------------------------------------------------- -- * Optimized version for FASTEST only -- */ --local uInt longest_match(s, cur_match) -- deflate_state *s; -- IPos cur_match; /* current match */ --{ -- register Bytef *scan = s->window + s->strstart; /* current string */ -- register Bytef *match; /* matched string */ -- register int len; /* length of current match */ -- register Bytef *strend = s->window + s->strstart + MAX_MATCH; -- -- /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. -- * It is easy to get rid of this optimization if necessary. -- */ -- Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); -- -- Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); -- -- Assert(cur_match < s->strstart, "no future"); -- -- match = s->window + cur_match; -- -- /* Return failure if the match length is less than 2: -- */ -- if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; -- -- /* The check at best_len-1 can be removed because it will be made -- * again later. (This heuristic is not always a win.) -- * It is not necessary to compare scan[2] and match[2] since they -- * are always equal when the other bytes match, given that -- * the hash keys are equal and that HASH_BITS >= 8. -- */ -- scan += 2, match += 2; -- Assert(*scan == *match, "match[2]?"); -- -- /* We check for insufficient lookahead only every 8th comparison; -- * the 256th check will be made at strstart+258. -- */ -- do { -- } while (*++scan == *++match && *++scan == *++match && -- *++scan == *++match && *++scan == *++match && -- *++scan == *++match && *++scan == *++match && -- *++scan == *++match && *++scan == *++match && -- scan < strend); -- -- Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); -- -- len = MAX_MATCH - (int)(strend - scan); -- -- if (len < MIN_MATCH) return MIN_MATCH - 1; -- -- s->match_start = cur_match; -- return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead; --} -- --#endif /* FASTEST */ -- --#ifdef DEBUG --/* =========================================================================== -- * Check that the match at match_start is indeed a match. -- */ --local void check_match(s, start, match, length) -- deflate_state *s; -- IPos start, match; -- int length; --{ -- /* check that the match is indeed a match */ -- if (zmemcmp(s->window + match, -- s->window + start, length) != EQUAL) { -- fprintf(stderr, " start %u, match %u, length %d\n", -- start, match, length); -- do { -- fprintf(stderr, "%c%c", s->window[match++], s->window[start++]); -- } while (--length != 0); -- z_error("invalid match"); -- } -- if (z_verbose > 1) { -- fprintf(stderr,"\\[%d,%d]", start-match, length); -- do { putc(s->window[start++], stderr); } while (--length != 0); -- } --} --#else --# define check_match(s, start, match, length) --#endif /* DEBUG */ -- --/* =========================================================================== -- * Fill the window when the lookahead becomes insufficient. -- * Updates strstart and lookahead. -- * -- * IN assertion: lookahead < MIN_LOOKAHEAD -- * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD -- * At least one byte has been read, or avail_in == 0; reads are -- * performed for at least two bytes (required for the zip translate_eol -- * option -- not supported here). -- */ --local void fill_window(s) -- deflate_state *s; --{ -- register unsigned n, m; -- register Posf *p; -- unsigned more; /* Amount of free space at the end of the window. */ -- uInt wsize = s->w_size; -- -- do { -- more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); -- -- /* Deal with !@#$% 64K limit: */ -- if (sizeof(int) <= 2) { -- if (more == 0 && s->strstart == 0 && s->lookahead == 0) { -- more = wsize; -- -- } else if (more == (unsigned)(-1)) { -- /* Very unlikely, but possible on 16 bit machine if -- * strstart == 0 && lookahead == 1 (input done a byte at time) -- */ -- more--; -- } -- } -- -- /* If the window is almost full and there is insufficient lookahead, -- * move the upper half to the lower one to make room in the upper half. -- */ -- if (s->strstart >= wsize+MAX_DIST(s)) { -- -- zmemcpy(s->window, s->window+wsize, (unsigned)wsize); -- s->match_start -= wsize; -- s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ -- s->block_start -= (long) wsize; -- -- /* Slide the hash table (could be avoided with 32 bit values -- at the expense of memory usage). We slide even when level == 0 -- to keep the hash table consistent if we switch back to level > 0 -- later. (Using level 0 permanently is not an optimal usage of -- zlib, so we don't care about this pathological case.) -- */ -- n = s->hash_size; -- p = &s->head[n]; -- do { -- m = *--p; -- *p = (Pos)(m >= wsize ? m-wsize : NIL); -- } while (--n); -- -- n = wsize; --#ifndef FASTEST -- p = &s->prev[n]; -- do { -- m = *--p; -- *p = (Pos)(m >= wsize ? m-wsize : NIL); -- /* If n is not on any hash chain, prev[n] is garbage but -- * its value will never be used. -- */ -- } while (--n); --#endif -- more += wsize; -- } -- if (s->strm->avail_in == 0) return; -- -- /* If there was no sliding: -- * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && -- * more == window_size - lookahead - strstart -- * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) -- * => more >= window_size - 2*WSIZE + 2 -- * In the BIG_MEM or MMAP case (not yet supported), -- * window_size == input_size + MIN_LOOKAHEAD && -- * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. -- * Otherwise, window_size == 2*WSIZE so more >= 2. -- * If there was sliding, more >= WSIZE. So in all cases, more >= 2. -- */ -- Assert(more >= 2, "more < 2"); -- -- n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); -- s->lookahead += n; -- -- /* Initialize the hash value now that we have some input: */ -- if (s->lookahead >= MIN_MATCH) { -- s->ins_h = s->window[s->strstart]; -- UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); --#if MIN_MATCH != 3 -- Call UPDATE_HASH() MIN_MATCH-3 more times --#endif -- } -- /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, -- * but this is not important since only literal bytes will be emitted. -- */ -- -- } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); -- -- /* If the WIN_INIT bytes after the end of the current data have never been -- * written, then zero those bytes in order to avoid memory check reports of -- * the use of uninitialized (or uninitialised as Julian writes) bytes by -- * the longest match routines. Update the high water mark for the next -- * time through here. WIN_INIT is set to MAX_MATCH since the longest match -- * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. -- */ -- if (s->high_water < s->window_size) { -- ulg curr = s->strstart + (ulg)(s->lookahead); -- ulg init; -- -- if (s->high_water < curr) { -- /* Previous high water mark below current data -- zero WIN_INIT -- * bytes or up to end of window, whichever is less. -- */ -- init = s->window_size - curr; -- if (init > WIN_INIT) -- init = WIN_INIT; -- zmemzero(s->window + curr, (unsigned)init); -- s->high_water = curr + init; -- } -- else if (s->high_water < (ulg)curr + WIN_INIT) { -- /* High water mark at or above current data, but below current data -- * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up -- * to end of window, whichever is less. -- */ -- init = (ulg)curr + WIN_INIT - s->high_water; -- if (init > s->window_size - s->high_water) -- init = s->window_size - s->high_water; -- zmemzero(s->window + s->high_water, (unsigned)init); -- s->high_water += init; -- } -- } --} -- --/* =========================================================================== -- * Flush the current block, with given end-of-file flag. -- * IN assertion: strstart is set to the end of the current match. -- */ --#define FLUSH_BLOCK_ONLY(s, last) { \ -- _tr_flush_block(s, (s->block_start >= 0L ? \ -- (charf *)&s->window[(unsigned)s->block_start] : \ -- (charf *)Z_NULL), \ -- (ulg)((long)s->strstart - s->block_start), \ -- (last)); \ -- s->block_start = s->strstart; \ -- flush_pending(s->strm); \ -- Tracev((stderr,"[FLUSH]")); \ --} -- --/* Same but force premature exit if necessary. */ --#define FLUSH_BLOCK(s, last) { \ -- FLUSH_BLOCK_ONLY(s, last); \ -- if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \ --} -- --/* =========================================================================== -- * Copy without compression as much as possible from the input stream, return -- * the current block state. -- * This function does not insert new strings in the dictionary since -- * uncompressible data is probably not useful. This function is used -- * only for the level=0 compression option. -- * NOTE: this function should be optimized to avoid extra copying from -- * window to pending_buf. -- */ --local block_state deflate_stored(s, flush) -- deflate_state *s; -- int flush; --{ -- /* Stored blocks are limited to 0xffff bytes, pending_buf is limited -- * to pending_buf_size, and each stored block has a 5 byte header: -- */ -- ulg max_block_size = 0xffff; -- ulg max_start; -- -- if (max_block_size > s->pending_buf_size - 5) { -- max_block_size = s->pending_buf_size - 5; -- } -- -- /* Copy as much as possible from input to output: */ -- for (;;) { -- /* Fill the window as much as possible: */ -- if (s->lookahead <= 1) { -- -- Assert(s->strstart < s->w_size+MAX_DIST(s) || -- s->block_start >= (long)s->w_size, "slide too late"); -- -- fill_window(s); -- if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more; -- -- if (s->lookahead == 0) break; /* flush the current block */ -- } -- Assert(s->block_start >= 0L, "block gone"); -- -- s->strstart += s->lookahead; -- s->lookahead = 0; -- -- /* Emit a stored block if pending_buf will be full: */ -- max_start = s->block_start + max_block_size; -- if (s->strstart == 0 || (ulg)s->strstart >= max_start) { -- /* strstart == 0 is possible when wraparound on 16-bit machine */ -- s->lookahead = (uInt)(s->strstart - max_start); -- s->strstart = (uInt)max_start; -- FLUSH_BLOCK(s, 0); -- } -- /* Flush if we may have to slide, otherwise block_start may become -- * negative and the data will be gone: -- */ -- if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) { -- FLUSH_BLOCK(s, 0); -- } -- } -- FLUSH_BLOCK(s, flush == Z_FINISH); -- return flush == Z_FINISH ? finish_done : block_done; --} -- --/* =========================================================================== -- * Compress as much as possible from the input stream, return the current -- * block state. -- * This function does not perform lazy evaluation of matches and inserts -- * new strings in the dictionary only for unmatched strings or for short -- * matches. It is used only for the fast compression options. -- */ --local block_state deflate_fast(s, flush) -- deflate_state *s; -- int flush; --{ -- IPos hash_head; /* head of the hash chain */ -- int bflush; /* set if current block must be flushed */ -- -- for (;;) { -- /* Make sure that we always have enough lookahead, except -- * at the end of the input file. We need MAX_MATCH bytes -- * for the next match, plus MIN_MATCH bytes to insert the -- * string following the next match. -- */ -- if (s->lookahead < MIN_LOOKAHEAD) { -- fill_window(s); -- if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { -- return need_more; -- } -- if (s->lookahead == 0) break; /* flush the current block */ -- } -- -- /* Insert the string window[strstart .. strstart+2] in the -- * dictionary, and set hash_head to the head of the hash chain: -- */ -- hash_head = NIL; -- if (s->lookahead >= MIN_MATCH) { -- INSERT_STRING(s, s->strstart, hash_head); -- } -- -- /* Find the longest match, discarding those <= prev_length. -- * At this point we have always match_length < MIN_MATCH -- */ -- if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { -- /* To simplify the code, we prevent matches with the string -- * of window index 0 (in particular we have to avoid a match -- * of the string with itself at the start of the input file). -- */ -- s->match_length = longest_match (s, hash_head); -- /* longest_match() sets match_start */ -- } -- if (s->match_length >= MIN_MATCH) { -- check_match(s, s->strstart, s->match_start, s->match_length); -- -- _tr_tally_dist(s, s->strstart - s->match_start, -- s->match_length - MIN_MATCH, bflush); -- -- s->lookahead -= s->match_length; -- -- /* Insert new strings in the hash table only if the match length -- * is not too large. This saves time but degrades compression. -- */ --#ifndef FASTEST -- if (s->match_length <= s->max_insert_length && -- s->lookahead >= MIN_MATCH) { -- s->match_length--; /* string at strstart already in table */ -- do { -- s->strstart++; -- INSERT_STRING(s, s->strstart, hash_head); -- /* strstart never exceeds WSIZE-MAX_MATCH, so there are -- * always MIN_MATCH bytes ahead. -- */ -- } while (--s->match_length != 0); -- s->strstart++; -- } else --#endif -- { -- s->strstart += s->match_length; -- s->match_length = 0; -- s->ins_h = s->window[s->strstart]; -- UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); --#if MIN_MATCH != 3 -- Call UPDATE_HASH() MIN_MATCH-3 more times --#endif -- /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not -- * matter since it will be recomputed at next deflate call. -- */ -- } -- } else { -- /* No match, output a literal byte */ -- Tracevv((stderr,"%c", s->window[s->strstart])); -- _tr_tally_lit (s, s->window[s->strstart], bflush); -- s->lookahead--; -- s->strstart++; -- } -- if (bflush) FLUSH_BLOCK(s, 0); -- } -- FLUSH_BLOCK(s, flush == Z_FINISH); -- return flush == Z_FINISH ? finish_done : block_done; --} -- --#ifndef FASTEST --/* =========================================================================== -- * Same as above, but achieves better compression. We use a lazy -- * evaluation for matches: a match is finally adopted only if there is -- * no better match at the next window position. -- */ --local block_state deflate_slow(s, flush) -- deflate_state *s; -- int flush; --{ -- IPos hash_head; /* head of hash chain */ -- int bflush; /* set if current block must be flushed */ -- -- /* Process the input block. */ -- for (;;) { -- /* Make sure that we always have enough lookahead, except -- * at the end of the input file. We need MAX_MATCH bytes -- * for the next match, plus MIN_MATCH bytes to insert the -- * string following the next match. -- */ -- if (s->lookahead < MIN_LOOKAHEAD) { -- fill_window(s); -- if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { -- return need_more; -- } -- if (s->lookahead == 0) break; /* flush the current block */ -- } -- -- /* Insert the string window[strstart .. strstart+2] in the -- * dictionary, and set hash_head to the head of the hash chain: -- */ -- hash_head = NIL; -- if (s->lookahead >= MIN_MATCH) { -- INSERT_STRING(s, s->strstart, hash_head); -- } -- -- /* Find the longest match, discarding those <= prev_length. -- */ -- s->prev_length = s->match_length, s->prev_match = s->match_start; -- s->match_length = MIN_MATCH-1; -- -- if (hash_head != NIL && s->prev_length < s->max_lazy_match && -- s->strstart - hash_head <= MAX_DIST(s)) { -- /* To simplify the code, we prevent matches with the string -- * of window index 0 (in particular we have to avoid a match -- * of the string with itself at the start of the input file). -- */ -- s->match_length = longest_match (s, hash_head); -- /* longest_match() sets match_start */ -- -- if (s->match_length <= 5 && (s->strategy == Z_FILTERED --#if TOO_FAR <= 32767 -- || (s->match_length == MIN_MATCH && -- s->strstart - s->match_start > TOO_FAR) --#endif -- )) { -- -- /* If prev_match is also MIN_MATCH, match_start is garbage -- * but we will ignore the current match anyway. -- */ -- s->match_length = MIN_MATCH-1; -- } -- } -- /* If there was a match at the previous step and the current -- * match is not better, output the previous match: -- */ -- if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { -- uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; -- /* Do not insert strings in hash table beyond this. */ -- -- check_match(s, s->strstart-1, s->prev_match, s->prev_length); -- -- _tr_tally_dist(s, s->strstart -1 - s->prev_match, -- s->prev_length - MIN_MATCH, bflush); -- -- /* Insert in hash table all strings up to the end of the match. -- * strstart-1 and strstart are already inserted. If there is not -- * enough lookahead, the last two strings are not inserted in -- * the hash table. -- */ -- s->lookahead -= s->prev_length-1; -- s->prev_length -= 2; -- do { -- if (++s->strstart <= max_insert) { -- INSERT_STRING(s, s->strstart, hash_head); -- } -- } while (--s->prev_length != 0); -- s->match_available = 0; -- s->match_length = MIN_MATCH-1; -- s->strstart++; -- -- if (bflush) FLUSH_BLOCK(s, 0); -- -- } else if (s->match_available) { -- /* If there was no match at the previous position, output a -- * single literal. If there was a match but the current match -- * is longer, truncate the previous match to a single literal. -- */ -- Tracevv((stderr,"%c", s->window[s->strstart-1])); -- _tr_tally_lit(s, s->window[s->strstart-1], bflush); -- if (bflush) { -- FLUSH_BLOCK_ONLY(s, 0); -- } -- s->strstart++; -- s->lookahead--; -- if (s->strm->avail_out == 0) return need_more; -- } else { -- /* There is no previous match to compare with, wait for -- * the next step to decide. -- */ -- s->match_available = 1; -- s->strstart++; -- s->lookahead--; -- } -- } -- Assert (flush != Z_NO_FLUSH, "no flush?"); -- if (s->match_available) { -- Tracevv((stderr,"%c", s->window[s->strstart-1])); -- _tr_tally_lit(s, s->window[s->strstart-1], bflush); -- s->match_available = 0; -- } -- FLUSH_BLOCK(s, flush == Z_FINISH); -- return flush == Z_FINISH ? finish_done : block_done; --} --#endif /* FASTEST */ -- --/* =========================================================================== -- * For Z_RLE, simply look for runs of bytes, generate matches only of distance -- * one. Do not maintain a hash table. (It will be regenerated if this run of -- * deflate switches away from Z_RLE.) -- */ --local block_state deflate_rle(s, flush) -- deflate_state *s; -- int flush; --{ -- int bflush; /* set if current block must be flushed */ -- uInt prev; /* byte at distance one to match */ -- Bytef *scan, *strend; /* scan goes up to strend for length of run */ -- -- for (;;) { -- /* Make sure that we always have enough lookahead, except -- * at the end of the input file. We need MAX_MATCH bytes -- * for the longest encodable run. -- */ -- if (s->lookahead < MAX_MATCH) { -- fill_window(s); -- if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) { -- return need_more; -- } -- if (s->lookahead == 0) break; /* flush the current block */ -- } -- -- /* See how many times the previous byte repeats */ -- s->match_length = 0; -- if (s->lookahead >= MIN_MATCH && s->strstart > 0) { -- scan = s->window + s->strstart - 1; -- prev = *scan; -- if (prev == *++scan && prev == *++scan && prev == *++scan) { -- strend = s->window + s->strstart + MAX_MATCH; -- do { -- } while (prev == *++scan && prev == *++scan && -- prev == *++scan && prev == *++scan && -- prev == *++scan && prev == *++scan && -- prev == *++scan && prev == *++scan && -- scan < strend); -- s->match_length = MAX_MATCH - (int)(strend - scan); -- if (s->match_length > s->lookahead) -- s->match_length = s->lookahead; -- } -- } -- -- /* Emit match if have run of MIN_MATCH or longer, else emit literal */ -- if (s->match_length >= MIN_MATCH) { -- check_match(s, s->strstart, s->strstart - 1, s->match_length); -- -- _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush); -- -- s->lookahead -= s->match_length; -- s->strstart += s->match_length; -- s->match_length = 0; -- } else { -- /* No match, output a literal byte */ -- Tracevv((stderr,"%c", s->window[s->strstart])); -- _tr_tally_lit (s, s->window[s->strstart], bflush); -- s->lookahead--; -- s->strstart++; -- } -- if (bflush) FLUSH_BLOCK(s, 0); -- } -- FLUSH_BLOCK(s, flush == Z_FINISH); -- return flush == Z_FINISH ? finish_done : block_done; --} -- --/* =========================================================================== -- * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. -- * (It will be regenerated if this run of deflate switches away from Huffman.) -- */ --local block_state deflate_huff(s, flush) -- deflate_state *s; -- int flush; --{ -- int bflush; /* set if current block must be flushed */ -- -- for (;;) { -- /* Make sure that we have a literal to write. */ -- if (s->lookahead == 0) { -- fill_window(s); -- if (s->lookahead == 0) { -- if (flush == Z_NO_FLUSH) -- return need_more; -- break; /* flush the current block */ -- } -- } -- -- /* Output a literal byte */ -- s->match_length = 0; -- Tracevv((stderr,"%c", s->window[s->strstart])); -- _tr_tally_lit (s, s->window[s->strstart], bflush); -- s->lookahead--; -- s->strstart++; -- if (bflush) FLUSH_BLOCK(s, 0); -- } -- FLUSH_BLOCK(s, flush == Z_FINISH); -- return flush == Z_FINISH ? finish_done : block_done; --} -diff --git a/thirdparty/zlib/deflate.h b/thirdparty/zlib/deflate.h -deleted file mode 100644 -index cbf0d1e..0000000 ---- a/thirdparty/zlib/deflate.h -+++ /dev/null -@@ -1,342 +0,0 @@ --/* deflate.h -- internal compression state -- * Copyright (C) 1995-2010 Jean-loup Gailly -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* WARNING: this file should *not* be used by applications. It is -- part of the implementation of the compression library and is -- subject to change. Applications should only use zlib.h. -- */ -- --/* @(#) $Id$ */ -- --#ifndef DEFLATE_H --#define DEFLATE_H -- --#include "zutil.h" -- --/* define NO_GZIP when compiling if you want to disable gzip header and -- trailer creation by deflate(). NO_GZIP would be used to avoid linking in -- the crc code when it is not needed. For shared libraries, gzip encoding -- should be left enabled. */ --#ifndef NO_GZIP --# define GZIP --#endif -- --/* =========================================================================== -- * Internal compression state. -- */ -- --#define LENGTH_CODES 29 --/* number of length codes, not counting the special END_BLOCK code */ -- --#define LITERALS 256 --/* number of literal bytes 0..255 */ -- --#define L_CODES (LITERALS+1+LENGTH_CODES) --/* number of Literal or Length codes, including the END_BLOCK code */ -- --#define D_CODES 30 --/* number of distance codes */ -- --#define BL_CODES 19 --/* number of codes used to transfer the bit lengths */ -- --#define HEAP_SIZE (2*L_CODES+1) --/* maximum heap size */ -- --#define MAX_BITS 15 --/* All codes must not exceed MAX_BITS bits */ -- --#define INIT_STATE 42 --#define EXTRA_STATE 69 --#define NAME_STATE 73 --#define COMMENT_STATE 91 --#define HCRC_STATE 103 --#define BUSY_STATE 113 --#define FINISH_STATE 666 --/* Stream status */ -- -- --/* Data structure describing a single value and its code string. */ --typedef struct ct_data_s { -- union { -- ush freq; /* frequency count */ -- ush code; /* bit string */ -- } fc; -- union { -- ush dad; /* father node in Huffman tree */ -- ush len; /* length of bit string */ -- } dl; --} FAR ct_data; -- --#define Freq fc.freq --#define Code fc.code --#define Dad dl.dad --#define Len dl.len -- --typedef struct static_tree_desc_s static_tree_desc; -- --typedef struct tree_desc_s { -- ct_data *dyn_tree; /* the dynamic tree */ -- int max_code; /* largest code with non zero frequency */ -- static_tree_desc *stat_desc; /* the corresponding static tree */ --} FAR tree_desc; -- --typedef ush Pos; --typedef Pos FAR Posf; --typedef unsigned IPos; -- --/* A Pos is an index in the character window. We use short instead of int to -- * save space in the various tables. IPos is used only for parameter passing. -- */ -- --typedef struct internal_state { -- z_streamp strm; /* pointer back to this zlib stream */ -- int status; /* as the name implies */ -- Bytef *pending_buf; /* output still pending */ -- ulg pending_buf_size; /* size of pending_buf */ -- Bytef *pending_out; /* next pending byte to output to the stream */ -- uInt pending; /* nb of bytes in the pending buffer */ -- int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ -- gz_headerp gzhead; /* gzip header information to write */ -- uInt gzindex; /* where in extra, name, or comment */ -- Byte method; /* STORED (for zip only) or DEFLATED */ -- int last_flush; /* value of flush param for previous deflate call */ -- -- /* used by deflate.c: */ -- -- uInt w_size; /* LZ77 window size (32K by default) */ -- uInt w_bits; /* log2(w_size) (8..16) */ -- uInt w_mask; /* w_size - 1 */ -- -- Bytef *window; -- /* Sliding window. Input bytes are read into the second half of the window, -- * and move to the first half later to keep a dictionary of at least wSize -- * bytes. With this organization, matches are limited to a distance of -- * wSize-MAX_MATCH bytes, but this ensures that IO is always -- * performed with a length multiple of the block size. Also, it limits -- * the window size to 64K, which is quite useful on MSDOS. -- * To do: use the user input buffer as sliding window. -- */ -- -- ulg window_size; -- /* Actual size of window: 2*wSize, except when the user input buffer -- * is directly used as sliding window. -- */ -- -- Posf *prev; -- /* Link to older string with same hash index. To limit the size of this -- * array to 64K, this link is maintained only for the last 32K strings. -- * An index in this array is thus a window index modulo 32K. -- */ -- -- Posf *head; /* Heads of the hash chains or NIL. */ -- -- uInt ins_h; /* hash index of string to be inserted */ -- uInt hash_size; /* number of elements in hash table */ -- uInt hash_bits; /* log2(hash_size) */ -- uInt hash_mask; /* hash_size-1 */ -- -- uInt hash_shift; -- /* Number of bits by which ins_h must be shifted at each input -- * step. It must be such that after MIN_MATCH steps, the oldest -- * byte no longer takes part in the hash key, that is: -- * hash_shift * MIN_MATCH >= hash_bits -- */ -- -- long block_start; -- /* Window position at the beginning of the current output block. Gets -- * negative when the window is moved backwards. -- */ -- -- uInt match_length; /* length of best match */ -- IPos prev_match; /* previous match */ -- int match_available; /* set if previous match exists */ -- uInt strstart; /* start of string to insert */ -- uInt match_start; /* start of matching string */ -- uInt lookahead; /* number of valid bytes ahead in window */ -- -- uInt prev_length; -- /* Length of the best match at previous step. Matches not greater than this -- * are discarded. This is used in the lazy match evaluation. -- */ -- -- uInt max_chain_length; -- /* To speed up deflation, hash chains are never searched beyond this -- * length. A higher limit improves compression ratio but degrades the -- * speed. -- */ -- -- uInt max_lazy_match; -- /* Attempt to find a better match only when the current match is strictly -- * smaller than this value. This mechanism is used only for compression -- * levels >= 4. -- */ --# define max_insert_length max_lazy_match -- /* Insert new strings in the hash table only if the match length is not -- * greater than this length. This saves time but degrades compression. -- * max_insert_length is used only for compression levels <= 3. -- */ -- -- int level; /* compression level (1..9) */ -- int strategy; /* favor or force Huffman coding*/ -- -- uInt good_match; -- /* Use a faster search when the previous match is longer than this */ -- -- int nice_match; /* Stop searching when current match exceeds this */ -- -- /* used by trees.c: */ -- /* Didn't use ct_data typedef below to supress compiler warning */ -- struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ -- struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ -- struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ -- -- struct tree_desc_s l_desc; /* desc. for literal tree */ -- struct tree_desc_s d_desc; /* desc. for distance tree */ -- struct tree_desc_s bl_desc; /* desc. for bit length tree */ -- -- ush bl_count[MAX_BITS+1]; -- /* number of codes at each bit length for an optimal tree */ -- -- int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ -- int heap_len; /* number of elements in the heap */ -- int heap_max; /* element of largest frequency */ -- /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. -- * The same heap array is used to build all trees. -- */ -- -- uch depth[2*L_CODES+1]; -- /* Depth of each subtree used as tie breaker for trees of equal frequency -- */ -- -- uchf *l_buf; /* buffer for literals or lengths */ -- -- uInt lit_bufsize; -- /* Size of match buffer for literals/lengths. There are 4 reasons for -- * limiting lit_bufsize to 64K: -- * - frequencies can be kept in 16 bit counters -- * - if compression is not successful for the first block, all input -- * data is still in the window so we can still emit a stored block even -- * when input comes from standard input. (This can also be done for -- * all blocks if lit_bufsize is not greater than 32K.) -- * - if compression is not successful for a file smaller than 64K, we can -- * even emit a stored file instead of a stored block (saving 5 bytes). -- * This is applicable only for zip (not gzip or zlib). -- * - creating new Huffman trees less frequently may not provide fast -- * adaptation to changes in the input data statistics. (Take for -- * example a binary file with poorly compressible code followed by -- * a highly compressible string table.) Smaller buffer sizes give -- * fast adaptation but have of course the overhead of transmitting -- * trees more frequently. -- * - I can't count above 4 -- */ -- -- uInt last_lit; /* running index in l_buf */ -- -- ushf *d_buf; -- /* Buffer for distances. To simplify the code, d_buf and l_buf have -- * the same number of elements. To use different lengths, an extra flag -- * array would be necessary. -- */ -- -- ulg opt_len; /* bit length of current block with optimal trees */ -- ulg static_len; /* bit length of current block with static trees */ -- uInt matches; /* number of string matches in current block */ -- int last_eob_len; /* bit length of EOB code for last block */ -- --#ifdef DEBUG -- ulg compressed_len; /* total bit length of compressed file mod 2^32 */ -- ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ --#endif -- -- ush bi_buf; -- /* Output buffer. bits are inserted starting at the bottom (least -- * significant bits). -- */ -- int bi_valid; -- /* Number of valid bits in bi_buf. All bits above the last valid bit -- * are always zero. -- */ -- -- ulg high_water; -- /* High water mark offset in window for initialized bytes -- bytes above -- * this are set to zero in order to avoid memory check warnings when -- * longest match routines access bytes past the input. This is then -- * updated to the new high water mark. -- */ -- --} FAR deflate_state; -- --/* Output a byte on the stream. -- * IN assertion: there is enough room in pending_buf. -- */ --#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} -- -- --#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) --/* Minimum amount of lookahead, except at the end of the input file. -- * See deflate.c for comments about the MIN_MATCH+1. -- */ -- --#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) --/* In order to simplify the code, particularly on 16 bit machines, match -- * distances are limited to MAX_DIST instead of WSIZE. -- */ -- --#define WIN_INIT MAX_MATCH --/* Number of bytes after end of data in window to initialize in order to avoid -- memory checker errors from longest match routines */ -- -- /* in trees.c */ --void ZLIB_INTERNAL _tr_init OF((deflate_state *s)); --int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); --void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf, -- ulg stored_len, int last)); --void ZLIB_INTERNAL _tr_align OF((deflate_state *s)); --void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, -- ulg stored_len, int last)); -- --#define d_code(dist) \ -- ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) --/* Mapping from a distance to a distance code. dist is the distance - 1 and -- * must not have side effects. _dist_code[256] and _dist_code[257] are never -- * used. -- */ -- --#ifndef DEBUG --/* Inline versions of _tr_tally for speed: */ -- --#if defined(GEN_TREES_H) || !defined(STDC) -- extern uch ZLIB_INTERNAL _length_code[]; -- extern uch ZLIB_INTERNAL _dist_code[]; --#else -- extern const uch ZLIB_INTERNAL _length_code[]; -- extern const uch ZLIB_INTERNAL _dist_code[]; --#endif -- --# define _tr_tally_lit(s, c, flush) \ -- { uch cc = (c); \ -- s->d_buf[s->last_lit] = 0; \ -- s->l_buf[s->last_lit++] = cc; \ -- s->dyn_ltree[cc].Freq++; \ -- flush = (s->last_lit == s->lit_bufsize-1); \ -- } --# define _tr_tally_dist(s, distance, length, flush) \ -- { uch len = (length); \ -- ush dist = (distance); \ -- s->d_buf[s->last_lit] = dist; \ -- s->l_buf[s->last_lit++] = len; \ -- dist--; \ -- s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ -- s->dyn_dtree[d_code(dist)].Freq++; \ -- flush = (s->last_lit == s->lit_bufsize-1); \ -- } --#else --# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) --# define _tr_tally_dist(s, distance, length, flush) \ -- flush = _tr_tally(s, distance, length) --#endif -- --#endif /* DEFLATE_H */ -diff --git a/thirdparty/zlib/gzclose.c b/thirdparty/zlib/gzclose.c -deleted file mode 100644 -index caeb99a..0000000 ---- a/thirdparty/zlib/gzclose.c -+++ /dev/null -@@ -1,25 +0,0 @@ --/* gzclose.c -- zlib gzclose() function -- * Copyright (C) 2004, 2010 Mark Adler -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --#include "gzguts.h" -- --/* gzclose() is in a separate file so that it is linked in only if it is used. -- That way the other gzclose functions can be used instead to avoid linking in -- unneeded compression or decompression routines. */ --int ZEXPORT gzclose(file) -- gzFile file; --{ --#ifndef NO_GZCOMPRESS -- gz_statep state; -- -- if (file == NULL) -- return Z_STREAM_ERROR; -- state = (gz_statep)file; -- -- return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file); --#else -- return gzclose_r(file); --#endif --} -diff --git a/thirdparty/zlib/gzguts.h b/thirdparty/zlib/gzguts.h -deleted file mode 100644 -index 0f8fb79..0000000 ---- a/thirdparty/zlib/gzguts.h -+++ /dev/null -@@ -1,132 +0,0 @@ --/* gzguts.h -- zlib internal header definitions for gz* operations -- * Copyright (C) 2004, 2005, 2010 Mark Adler -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --#ifdef _LARGEFILE64_SOURCE --# ifndef _LARGEFILE_SOURCE --# define _LARGEFILE_SOURCE 1 --# endif --# ifdef _FILE_OFFSET_BITS --# undef _FILE_OFFSET_BITS --# endif --#endif -- --#if ((__GNUC__-0) * 10 + __GNUC_MINOR__-0 >= 33) && !defined(NO_VIZ) --# define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) --#else --# define ZLIB_INTERNAL --#endif -- --#include --#include "zlib.h" --#ifdef STDC --# include --# include --# include --#endif --#include -- --#ifdef NO_DEFLATE /* for compatibility with old definition */ --# define NO_GZCOMPRESS --#endif -- --#ifdef _MSC_VER --# include --# define vsnprintf _vsnprintf --#endif -- --#ifndef local --# define local static --#endif --/* compile with -Dlocal if your debugger can't find static symbols */ -- --/* gz* functions always use library allocation functions */ --#ifndef STDC -- extern voidp malloc OF((uInt size)); -- extern void free OF((voidpf ptr)); --#endif -- --/* get errno and strerror definition */ --#if defined UNDER_CE --# include --# define zstrerror() gz_strwinerror((DWORD)GetLastError()) --#else --# ifdef STDC --# include --# define zstrerror() strerror(errno) --# else --# define zstrerror() "stdio error (consult errno)" --# endif --#endif -- --/* provide prototypes for these when building zlib without LFS */ --#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 -- ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); -- ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); -- ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); -- ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); --#endif -- --/* default i/o buffer size -- double this for output when reading */ --#define GZBUFSIZE 8192 -- --/* gzip modes, also provide a little integrity check on the passed structure */ --#define GZ_NONE 0 --#define GZ_READ 7247 --#define GZ_WRITE 31153 --#define GZ_APPEND 1 /* mode set to GZ_WRITE after the file is opened */ -- --/* values for gz_state how */ --#define LOOK 0 /* look for a gzip header */ --#define COPY 1 /* copy input directly */ --#define GZIP 2 /* decompress a gzip stream */ -- --/* internal gzip file state data structure */ --typedef struct { -- /* used for both reading and writing */ -- int mode; /* see gzip modes above */ -- int fd; /* file descriptor */ -- char *path; /* path or fd for error messages */ -- z_off64_t pos; /* current position in uncompressed data */ -- unsigned size; /* buffer size, zero if not allocated yet */ -- unsigned want; /* requested buffer size, default is GZBUFSIZE */ -- unsigned char *in; /* input buffer */ -- unsigned char *out; /* output buffer (double-sized when reading) */ -- unsigned char *next; /* next output data to deliver or write */ -- /* just for reading */ -- unsigned have; /* amount of output data unused at next */ -- int eof; /* true if end of input file reached */ -- z_off64_t start; /* where the gzip data started, for rewinding */ -- z_off64_t raw; /* where the raw data started, for seeking */ -- int how; /* 0: get header, 1: copy, 2: decompress */ -- int direct; /* true if last read direct, false if gzip */ -- /* just for writing */ -- int level; /* compression level */ -- int strategy; /* compression strategy */ -- /* seek request */ -- z_off64_t skip; /* amount to skip (already rewound if backwards) */ -- int seek; /* true if seek request pending */ -- /* error information */ -- int err; /* error code */ -- char *msg; /* error message */ -- /* zlib inflate or deflate stream */ -- z_stream strm; /* stream structure in-place (not a pointer) */ --} gz_state; --typedef gz_state FAR *gz_statep; -- --/* shared functions */ --void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *)); --#if defined UNDER_CE --char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error)); --#endif -- --/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t -- value -- needed when comparing unsigned to z_off64_t, which is signed -- (possible z_off64_t types off_t, off64_t, and long are all signed) */ --#ifdef INT_MAX --# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX) --#else --unsigned ZLIB_INTERNAL gz_intmax OF((void)); --# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax()) --#endif -diff --git a/thirdparty/zlib/gzlib.c b/thirdparty/zlib/gzlib.c -deleted file mode 100644 -index 603e60e..0000000 ---- a/thirdparty/zlib/gzlib.c -+++ /dev/null -@@ -1,537 +0,0 @@ --/* gzlib.c -- zlib functions common to reading and writing gzip files -- * Copyright (C) 2004, 2010 Mark Adler -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --#include "gzguts.h" -- --#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 --# define LSEEK lseek64 --#else --# define LSEEK lseek --#endif -- --/* Local functions */ --local void gz_reset OF((gz_statep)); --local gzFile gz_open OF((const char *, int, const char *)); -- --#if defined UNDER_CE -- --/* Map the Windows error number in ERROR to a locale-dependent error message -- string and return a pointer to it. Typically, the values for ERROR come -- from GetLastError. -- -- The string pointed to shall not be modified by the application, but may be -- overwritten by a subsequent call to gz_strwinerror -- -- The gz_strwinerror function does not change the current setting of -- GetLastError. */ --char ZLIB_INTERNAL *gz_strwinerror (error) -- DWORD error; --{ -- static char buf[1024]; -- -- wchar_t *msgbuf; -- DWORD lasterr = GetLastError(); -- DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM -- | FORMAT_MESSAGE_ALLOCATE_BUFFER, -- NULL, -- error, -- 0, /* Default language */ -- (LPVOID)&msgbuf, -- 0, -- NULL); -- if (chars != 0) { -- /* If there is an \r\n appended, zap it. */ -- if (chars >= 2 -- && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') { -- chars -= 2; -- msgbuf[chars] = 0; -- } -- -- if (chars > sizeof (buf) - 1) { -- chars = sizeof (buf) - 1; -- msgbuf[chars] = 0; -- } -- -- wcstombs(buf, msgbuf, chars + 1); -- LocalFree(msgbuf); -- } -- else { -- sprintf(buf, "unknown win32 error (%ld)", error); -- } -- -- SetLastError(lasterr); -- return buf; --} -- --#endif /* UNDER_CE */ -- --/* Reset gzip file state */ --local void gz_reset(state) -- gz_statep state; --{ -- if (state->mode == GZ_READ) { /* for reading ... */ -- state->have = 0; /* no output data available */ -- state->eof = 0; /* not at end of file */ -- state->how = LOOK; /* look for gzip header */ -- state->direct = 1; /* default for empty file */ -- } -- state->seek = 0; /* no seek request pending */ -- gz_error(state, Z_OK, NULL); /* clear error */ -- state->pos = 0; /* no uncompressed data yet */ -- state->strm.avail_in = 0; /* no input data yet */ --} -- --/* Open a gzip file either by name or file descriptor. */ --local gzFile gz_open(path, fd, mode) -- const char *path; -- int fd; -- const char *mode; --{ -- gz_statep state; -- -- /* allocate gzFile structure to return */ -- state = malloc(sizeof(gz_state)); -- if (state == NULL) -- return NULL; -- state->size = 0; /* no buffers allocated yet */ -- state->want = GZBUFSIZE; /* requested buffer size */ -- state->msg = NULL; /* no error message yet */ -- -- /* interpret mode */ -- state->mode = GZ_NONE; -- state->level = Z_DEFAULT_COMPRESSION; -- state->strategy = Z_DEFAULT_STRATEGY; -- while (*mode) { -- if (*mode >= '0' && *mode <= '9') -- state->level = *mode - '0'; -- else -- switch (*mode) { -- case 'r': -- state->mode = GZ_READ; -- break; --#ifndef NO_GZCOMPRESS -- case 'w': -- state->mode = GZ_WRITE; -- break; -- case 'a': -- state->mode = GZ_APPEND; -- break; --#endif -- case '+': /* can't read and write at the same time */ -- free(state); -- return NULL; -- case 'b': /* ignore -- will request binary anyway */ -- break; -- case 'f': -- state->strategy = Z_FILTERED; -- break; -- case 'h': -- state->strategy = Z_HUFFMAN_ONLY; -- break; -- case 'R': -- state->strategy = Z_RLE; -- break; -- case 'F': -- state->strategy = Z_FIXED; -- default: /* could consider as an error, but just ignore */ -- ; -- } -- mode++; -- } -- -- /* must provide an "r", "w", or "a" */ -- if (state->mode == GZ_NONE) { -- free(state); -- return NULL; -- } -- -- /* save the path name for error messages */ -- state->path = malloc(strlen(path) + 1); -- if (state->path == NULL) { -- free(state); -- return NULL; -- } -- strcpy(state->path, path); -- -- /* open the file with the appropriate mode (or just use fd) */ -- state->fd = fd != -1 ? fd : -- open(path, --#ifdef O_LARGEFILE -- O_LARGEFILE | --#endif --#ifdef O_BINARY -- O_BINARY | --#endif -- (state->mode == GZ_READ ? -- O_RDONLY : -- (O_WRONLY | O_CREAT | ( -- state->mode == GZ_WRITE ? -- O_TRUNC : -- O_APPEND))), -- 0666); -- if (state->fd == -1) { -- free(state->path); -- free(state); -- return NULL; -- } -- if (state->mode == GZ_APPEND) -- state->mode = GZ_WRITE; /* simplify later checks */ -- -- /* save the current position for rewinding (only if reading) */ -- if (state->mode == GZ_READ) { -- state->start = LSEEK(state->fd, 0, SEEK_CUR); -- if (state->start == -1) state->start = 0; -- } -- -- /* initialize stream */ -- gz_reset(state); -- -- /* return stream */ -- return (gzFile)state; --} -- --/* -- see zlib.h -- */ --gzFile ZEXPORT gzopen(path, mode) -- const char *path; -- const char *mode; --{ -- return gz_open(path, -1, mode); --} -- --/* -- see zlib.h -- */ --gzFile ZEXPORT gzopen64(path, mode) -- const char *path; -- const char *mode; --{ -- return gz_open(path, -1, mode); --} -- --/* -- see zlib.h -- */ --gzFile ZEXPORT gzdopen(fd, mode) -- int fd; -- const char *mode; --{ -- char *path; /* identifier for error messages */ -- gzFile gz; -- -- if (fd == -1 || (path = malloc(7 + 3 * sizeof(int))) == NULL) -- return NULL; -- sprintf(path, "", fd); /* for debugging */ -- gz = gz_open(path, fd, mode); -- free(path); -- return gz; --} -- --/* -- see zlib.h -- */ --int ZEXPORT gzbuffer(file, size) -- gzFile file; -- unsigned size; --{ -- gz_statep state; -- -- /* get internal structure and check integrity */ -- if (file == NULL) -- return -1; -- state = (gz_statep)file; -- if (state->mode != GZ_READ && state->mode != GZ_WRITE) -- return -1; -- -- /* make sure we haven't already allocated memory */ -- if (state->size != 0) -- return -1; -- -- /* check and set requested size */ -- if (size == 0) -- return -1; -- state->want = size; -- return 0; --} -- --/* -- see zlib.h -- */ --int ZEXPORT gzrewind(file) -- gzFile file; --{ -- gz_statep state; -- -- /* get internal structure */ -- if (file == NULL) -- return -1; -- state = (gz_statep)file; -- -- /* check that we're reading and that there's no error */ -- if (state->mode != GZ_READ || state->err != Z_OK) -- return -1; -- -- /* back up and start over */ -- if (LSEEK(state->fd, state->start, SEEK_SET) == -1) -- return -1; -- gz_reset(state); -- return 0; --} -- --/* -- see zlib.h -- */ --z_off64_t ZEXPORT gzseek64(file, offset, whence) -- gzFile file; -- z_off64_t offset; -- int whence; --{ -- unsigned n; -- z_off64_t ret; -- gz_statep state; -- -- /* get internal structure and check integrity */ -- if (file == NULL) -- return -1; -- state = (gz_statep)file; -- if (state->mode != GZ_READ && state->mode != GZ_WRITE) -- return -1; -- -- /* check that there's no error */ -- if (state->err != Z_OK) -- return -1; -- -- /* can only seek from start or relative to current position */ -- if (whence != SEEK_SET && whence != SEEK_CUR) -- return -1; -- -- /* normalize offset to a SEEK_CUR specification */ -- if (whence == SEEK_SET) -- offset -= state->pos; -- else if (state->seek) -- offset += state->skip; -- state->seek = 0; -- -- /* if within raw area while reading, just go there */ -- if (state->mode == GZ_READ && state->how == COPY && -- state->pos + offset >= state->raw) { -- ret = LSEEK(state->fd, offset - state->have, SEEK_CUR); -- if (ret == -1) -- return -1; -- state->have = 0; -- state->eof = 0; -- state->seek = 0; -- gz_error(state, Z_OK, NULL); -- state->strm.avail_in = 0; -- state->pos += offset; -- return state->pos; -- } -- -- /* calculate skip amount, rewinding if needed for back seek when reading */ -- if (offset < 0) { -- if (state->mode != GZ_READ) /* writing -- can't go backwards */ -- return -1; -- offset += state->pos; -- if (offset < 0) /* before start of file! */ -- return -1; -- if (gzrewind(file) == -1) /* rewind, then skip to offset */ -- return -1; -- } -- -- /* if reading, skip what's in output buffer (one less gzgetc() check) */ -- if (state->mode == GZ_READ) { -- n = GT_OFF(state->have) || (z_off64_t)state->have > offset ? -- (unsigned)offset : state->have; -- state->have -= n; -- state->next += n; -- state->pos += n; -- offset -= n; -- } -- -- /* request skip (if not zero) */ -- if (offset) { -- state->seek = 1; -- state->skip = offset; -- } -- return state->pos + offset; --} -- --/* -- see zlib.h -- */ --z_off_t ZEXPORT gzseek(file, offset, whence) -- gzFile file; -- z_off_t offset; -- int whence; --{ -- z_off64_t ret; -- -- ret = gzseek64(file, (z_off64_t)offset, whence); -- return ret == (z_off_t)ret ? (z_off_t)ret : -1; --} -- --/* -- see zlib.h -- */ --z_off64_t ZEXPORT gztell64(file) -- gzFile file; --{ -- gz_statep state; -- -- /* get internal structure and check integrity */ -- if (file == NULL) -- return -1; -- state = (gz_statep)file; -- if (state->mode != GZ_READ && state->mode != GZ_WRITE) -- return -1; -- -- /* return position */ -- return state->pos + (state->seek ? state->skip : 0); --} -- --/* -- see zlib.h -- */ --z_off_t ZEXPORT gztell(file) -- gzFile file; --{ -- z_off64_t ret; -- -- ret = gztell64(file); -- return ret == (z_off_t)ret ? (z_off_t)ret : -1; --} -- --/* -- see zlib.h -- */ --z_off64_t ZEXPORT gzoffset64(file) -- gzFile file; --{ -- z_off64_t offset; -- gz_statep state; -- -- /* get internal structure and check integrity */ -- if (file == NULL) -- return -1; -- state = (gz_statep)file; -- if (state->mode != GZ_READ && state->mode != GZ_WRITE) -- return -1; -- -- /* compute and return effective offset in file */ -- offset = LSEEK(state->fd, 0, SEEK_CUR); -- if (offset == -1) -- return -1; -- if (state->mode == GZ_READ) /* reading */ -- offset -= state->strm.avail_in; /* don't count buffered input */ -- return offset; --} -- --/* -- see zlib.h -- */ --z_off_t ZEXPORT gzoffset(file) -- gzFile file; --{ -- z_off64_t ret; -- -- ret = gzoffset64(file); -- return ret == (z_off_t)ret ? (z_off_t)ret : -1; --} -- --/* -- see zlib.h -- */ --int ZEXPORT gzeof(file) -- gzFile file; --{ -- gz_statep state; -- -- /* get internal structure and check integrity */ -- if (file == NULL) -- return 0; -- state = (gz_statep)file; -- if (state->mode != GZ_READ && state->mode != GZ_WRITE) -- return 0; -- -- /* return end-of-file state */ -- return state->mode == GZ_READ ? -- (state->eof && state->strm.avail_in == 0 && state->have == 0) : 0; --} -- --/* -- see zlib.h -- */ --const char * ZEXPORT gzerror(file, errnum) -- gzFile file; -- int *errnum; --{ -- gz_statep state; -- -- /* get internal structure and check integrity */ -- if (file == NULL) -- return NULL; -- state = (gz_statep)file; -- if (state->mode != GZ_READ && state->mode != GZ_WRITE) -- return NULL; -- -- /* return error information */ -- if (errnum != NULL) -- *errnum = state->err; -- return state->msg == NULL ? "" : state->msg; --} -- --/* -- see zlib.h -- */ --void ZEXPORT gzclearerr(file) -- gzFile file; --{ -- gz_statep state; -- -- /* get internal structure and check integrity */ -- if (file == NULL) -- return; -- state = (gz_statep)file; -- if (state->mode != GZ_READ && state->mode != GZ_WRITE) -- return; -- -- /* clear error and end-of-file */ -- if (state->mode == GZ_READ) -- state->eof = 0; -- gz_error(state, Z_OK, NULL); --} -- --/* Create an error message in allocated memory and set state->err and -- state->msg accordingly. Free any previous error message already there. Do -- not try to free or allocate space if the error is Z_MEM_ERROR (out of -- memory). Simply save the error message as a static string. If there is an -- allocation failure constructing the error message, then convert the error to -- out of memory. */ --void ZLIB_INTERNAL gz_error(state, err, msg) -- gz_statep state; -- int err; -- const char *msg; --{ -- /* free previously allocated message and clear */ -- if (state->msg != NULL) { -- if (state->err != Z_MEM_ERROR) -- free(state->msg); -- state->msg = NULL; -- } -- -- /* set error code, and if no message, then done */ -- state->err = err; -- if (msg == NULL) -- return; -- -- /* for an out of memory error, save as static string */ -- if (err == Z_MEM_ERROR) { -- state->msg = (char *)msg; -- return; -- } -- -- /* construct error message with path */ -- if ((state->msg = malloc(strlen(state->path) + strlen(msg) + 3)) == NULL) { -- state->err = Z_MEM_ERROR; -- state->msg = (char *)"out of memory"; -- return; -- } -- strcpy(state->msg, state->path); -- strcat(state->msg, ": "); -- strcat(state->msg, msg); -- return; --} -- --#ifndef INT_MAX --/* portably return maximum value for an int (when limits.h presumed not -- available) -- we need to do this to cover cases where 2's complement not -- used, since C standard permits 1's complement and sign-bit representations, -- otherwise we could just use ((unsigned)-1) >> 1 */ --unsigned ZLIB_INTERNAL gz_intmax() --{ -- unsigned p, q; -- -- p = 1; -- do { -- q = p; -- p <<= 1; -- p++; -- } while (p > q); -- return q >> 1; --} --#endif -diff --git a/thirdparty/zlib/gzread.c b/thirdparty/zlib/gzread.c -deleted file mode 100644 -index 548201a..0000000 ---- a/thirdparty/zlib/gzread.c -+++ /dev/null -@@ -1,653 +0,0 @@ --/* gzread.c -- zlib functions for reading gzip files -- * Copyright (C) 2004, 2005, 2010 Mark Adler -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --#include "gzguts.h" -- --/* Local functions */ --local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *)); --local int gz_avail OF((gz_statep)); --local int gz_next4 OF((gz_statep, unsigned long *)); --local int gz_head OF((gz_statep)); --local int gz_decomp OF((gz_statep)); --local int gz_make OF((gz_statep)); --local int gz_skip OF((gz_statep, z_off64_t)); -- --/* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from -- state->fd, and update state->eof, state->err, and state->msg as appropriate. -- This function needs to loop on read(), since read() is not guaranteed to -- read the number of bytes requested, depending on the type of descriptor. */ --local int gz_load(state, buf, len, have) -- gz_statep state; -- unsigned char *buf; -- unsigned len; -- unsigned *have; --{ -- int ret; -- -- *have = 0; -- do { -- ret = read(state->fd, buf + *have, len - *have); -- if (ret <= 0) -- break; -- *have += ret; -- } while (*have < len); -- if (ret < 0) { -- gz_error(state, Z_ERRNO, zstrerror()); -- return -1; -- } -- if (ret == 0) -- state->eof = 1; -- return 0; --} -- --/* Load up input buffer and set eof flag if last data loaded -- return -1 on -- error, 0 otherwise. Note that the eof flag is set when the end of the input -- file is reached, even though there may be unused data in the buffer. Once -- that data has been used, no more attempts will be made to read the file. -- gz_avail() assumes that strm->avail_in == 0. */ --local int gz_avail(state) -- gz_statep state; --{ -- z_streamp strm = &(state->strm); -- -- if (state->err != Z_OK) -- return -1; -- if (state->eof == 0) { -- if (gz_load(state, state->in, state->size, -- (unsigned *)&(strm->avail_in)) == -1) -- return -1; -- strm->next_in = state->in; -- } -- return 0; --} -- --/* Get next byte from input, or -1 if end or error. */ --#define NEXT() ((strm->avail_in == 0 && gz_avail(state) == -1) ? -1 : \ -- (strm->avail_in == 0 ? -1 : \ -- (strm->avail_in--, *(strm->next_in)++))) -- --/* Get a four-byte little-endian integer and return 0 on success and the value -- in *ret. Otherwise -1 is returned and *ret is not modified. */ --local int gz_next4(state, ret) -- gz_statep state; -- unsigned long *ret; --{ -- int ch; -- unsigned long val; -- z_streamp strm = &(state->strm); -- -- val = NEXT(); -- val += (unsigned)NEXT() << 8; -- val += (unsigned long)NEXT() << 16; -- ch = NEXT(); -- if (ch == -1) -- return -1; -- val += (unsigned long)ch << 24; -- *ret = val; -- return 0; --} -- --/* Look for gzip header, set up for inflate or copy. state->have must be zero. -- If this is the first time in, allocate required memory. state->how will be -- left unchanged if there is no more input data available, will be set to COPY -- if there is no gzip header and direct copying will be performed, or it will -- be set to GZIP for decompression, and the gzip header will be skipped so -- that the next available input data is the raw deflate stream. If direct -- copying, then leftover input data from the input buffer will be copied to -- the output buffer. In that case, all further file reads will be directly to -- either the output buffer or a user buffer. If decompressing, the inflate -- state and the check value will be initialized. gz_head() will return 0 on -- success or -1 on failure. Failures may include read errors or gzip header -- errors. */ --local int gz_head(state) -- gz_statep state; --{ -- z_streamp strm = &(state->strm); -- int flags; -- unsigned len; -- -- /* allocate read buffers and inflate memory */ -- if (state->size == 0) { -- /* allocate buffers */ -- state->in = malloc(state->want); -- state->out = malloc(state->want << 1); -- if (state->in == NULL || state->out == NULL) { -- if (state->out != NULL) -- free(state->out); -- if (state->in != NULL) -- free(state->in); -- gz_error(state, Z_MEM_ERROR, "out of memory"); -- return -1; -- } -- state->size = state->want; -- -- /* allocate inflate memory */ -- state->strm.zalloc = Z_NULL; -- state->strm.zfree = Z_NULL; -- state->strm.opaque = Z_NULL; -- state->strm.avail_in = 0; -- state->strm.next_in = Z_NULL; -- if (inflateInit2(&(state->strm), -15) != Z_OK) { /* raw inflate */ -- free(state->out); -- free(state->in); -- state->size = 0; -- gz_error(state, Z_MEM_ERROR, "out of memory"); -- return -1; -- } -- } -- -- /* get some data in the input buffer */ -- if (strm->avail_in == 0) { -- if (gz_avail(state) == -1) -- return -1; -- if (strm->avail_in == 0) -- return 0; -- } -- -- /* look for the gzip magic header bytes 31 and 139 */ -- if (strm->next_in[0] == 31) { -- strm->avail_in--; -- strm->next_in++; -- if (strm->avail_in == 0 && gz_avail(state) == -1) -- return -1; -- if (strm->avail_in && strm->next_in[0] == 139) { -- /* we have a gzip header, woo hoo! */ -- strm->avail_in--; -- strm->next_in++; -- -- /* skip rest of header */ -- if (NEXT() != 8) { /* compression method */ -- gz_error(state, Z_DATA_ERROR, "unknown compression method"); -- return -1; -- } -- flags = NEXT(); -- if (flags & 0xe0) { /* reserved flag bits */ -- gz_error(state, Z_DATA_ERROR, "unknown header flags set"); -- return -1; -- } -- NEXT(); /* modification time */ -- NEXT(); -- NEXT(); -- NEXT(); -- NEXT(); /* extra flags */ -- NEXT(); /* operating system */ -- if (flags & 4) { /* extra field */ -- len = (unsigned)NEXT(); -- len += (unsigned)NEXT() << 8; -- while (len--) -- if (NEXT() < 0) -- break; -- } -- if (flags & 8) /* file name */ -- while (NEXT() > 0) -- ; -- if (flags & 16) /* comment */ -- while (NEXT() > 0) -- ; -- if (flags & 2) { /* header crc */ -- NEXT(); -- NEXT(); -- } -- /* an unexpected end of file is not checked for here -- it will be -- noticed on the first request for uncompressed data */ -- -- /* set up for decompression */ -- inflateReset(strm); -- strm->adler = crc32(0L, Z_NULL, 0); -- state->how = GZIP; -- state->direct = 0; -- return 0; -- } -- else { -- /* not a gzip file -- save first byte (31) and fall to raw i/o */ -- state->out[0] = 31; -- state->have = 1; -- } -- } -- -- /* doing raw i/o, save start of raw data for seeking, copy any leftover -- input to output -- this assumes that the output buffer is larger than -- the input buffer, which also assures space for gzungetc() */ -- state->raw = state->pos; -- state->next = state->out; -- if (strm->avail_in) { -- memcpy(state->next + state->have, strm->next_in, strm->avail_in); -- state->have += strm->avail_in; -- strm->avail_in = 0; -- } -- state->how = COPY; -- state->direct = 1; -- return 0; --} -- --/* Decompress from input to the provided next_out and avail_out in the state. -- If the end of the compressed data is reached, then verify the gzip trailer -- check value and length (modulo 2^32). state->have and state->next are set -- to point to the just decompressed data, and the crc is updated. If the -- trailer is verified, state->how is reset to LOOK to look for the next gzip -- stream or raw data, once state->have is depleted. Returns 0 on success, -1 -- on failure. Failures may include invalid compressed data or a failed gzip -- trailer verification. */ --local int gz_decomp(state) -- gz_statep state; --{ -- int ret; -- unsigned had; -- unsigned long crc, len; -- z_streamp strm = &(state->strm); -- -- /* fill output buffer up to end of deflate stream */ -- had = strm->avail_out; -- do { -- /* get more input for inflate() */ -- if (strm->avail_in == 0 && gz_avail(state) == -1) -- return -1; -- if (strm->avail_in == 0) { -- gz_error(state, Z_DATA_ERROR, "unexpected end of file"); -- return -1; -- } -- -- /* decompress and handle errors */ -- ret = inflate(strm, Z_NO_FLUSH); -- if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) { -- gz_error(state, Z_STREAM_ERROR, -- "internal error: inflate stream corrupt"); -- return -1; -- } -- if (ret == Z_MEM_ERROR) { -- gz_error(state, Z_MEM_ERROR, "out of memory"); -- return -1; -- } -- if (ret == Z_DATA_ERROR) { /* deflate stream invalid */ -- gz_error(state, Z_DATA_ERROR, -- strm->msg == NULL ? "compressed data error" : strm->msg); -- return -1; -- } -- } while (strm->avail_out && ret != Z_STREAM_END); -- -- /* update available output and crc check value */ -- state->have = had - strm->avail_out; -- state->next = strm->next_out - state->have; -- strm->adler = crc32(strm->adler, state->next, state->have); -- -- /* check gzip trailer if at end of deflate stream */ -- if (ret == Z_STREAM_END) { -- if (gz_next4(state, &crc) == -1 || gz_next4(state, &len) == -1) { -- gz_error(state, Z_DATA_ERROR, "unexpected end of file"); -- return -1; -- } -- if (crc != strm->adler) { -- gz_error(state, Z_DATA_ERROR, "incorrect data check"); -- return -1; -- } -- if (len != (strm->total_out & 0xffffffffL)) { -- gz_error(state, Z_DATA_ERROR, "incorrect length check"); -- return -1; -- } -- state->how = LOOK; /* ready for next stream, once have is 0 (leave -- state->direct unchanged to remember how) */ -- } -- -- /* good decompression */ -- return 0; --} -- --/* Make data and put in the output buffer. Assumes that state->have == 0. -- Data is either copied from the input file or decompressed from the input -- file depending on state->how. If state->how is LOOK, then a gzip header is -- looked for (and skipped if found) to determine wither to copy or decompress. -- Returns -1 on error, otherwise 0. gz_make() will leave state->have as COPY -- or GZIP unless the end of the input file has been reached and all data has -- been processed. */ --local int gz_make(state) -- gz_statep state; --{ -- z_streamp strm = &(state->strm); -- -- if (state->how == LOOK) { /* look for gzip header */ -- if (gz_head(state) == -1) -- return -1; -- if (state->have) /* got some data from gz_head() */ -- return 0; -- } -- if (state->how == COPY) { /* straight copy */ -- if (gz_load(state, state->out, state->size << 1, &(state->have)) == -1) -- return -1; -- state->next = state->out; -- } -- else if (state->how == GZIP) { /* decompress */ -- strm->avail_out = state->size << 1; -- strm->next_out = state->out; -- if (gz_decomp(state) == -1) -- return -1; -- } -- return 0; --} -- --/* Skip len uncompressed bytes of output. Return -1 on error, 0 on success. */ --local int gz_skip(state, len) -- gz_statep state; -- z_off64_t len; --{ -- unsigned n; -- -- /* skip over len bytes or reach end-of-file, whichever comes first */ -- while (len) -- /* skip over whatever is in output buffer */ -- if (state->have) { -- n = GT_OFF(state->have) || (z_off64_t)state->have > len ? -- (unsigned)len : state->have; -- state->have -= n; -- state->next += n; -- state->pos += n; -- len -= n; -- } -- -- /* output buffer empty -- return if we're at the end of the input */ -- else if (state->eof && state->strm.avail_in == 0) -- break; -- -- /* need more data to skip -- load up output buffer */ -- else { -- /* get more output, looking for header if required */ -- if (gz_make(state) == -1) -- return -1; -- } -- return 0; --} -- --/* -- see zlib.h -- */ --int ZEXPORT gzread(file, buf, len) -- gzFile file; -- voidp buf; -- unsigned len; --{ -- unsigned got, n; -- gz_statep state; -- z_streamp strm; -- -- /* get internal structure */ -- if (file == NULL) -- return -1; -- state = (gz_statep)file; -- strm = &(state->strm); -- -- /* check that we're reading and that there's no error */ -- if (state->mode != GZ_READ || state->err != Z_OK) -- return -1; -- -- /* since an int is returned, make sure len fits in one, otherwise return -- with an error (this avoids the flaw in the interface) */ -- if ((int)len < 0) { -- gz_error(state, Z_BUF_ERROR, "requested length does not fit in int"); -- return -1; -- } -- -- /* if len is zero, avoid unnecessary operations */ -- if (len == 0) -- return 0; -- -- /* process a skip request */ -- if (state->seek) { -- state->seek = 0; -- if (gz_skip(state, state->skip) == -1) -- return -1; -- } -- -- /* get len bytes to buf, or less than len if at the end */ -- got = 0; -- do { -- /* first just try copying data from the output buffer */ -- if (state->have) { -- n = state->have > len ? len : state->have; -- memcpy(buf, state->next, n); -- state->next += n; -- state->have -= n; -- } -- -- /* output buffer empty -- return if we're at the end of the input */ -- else if (state->eof && strm->avail_in == 0) -- break; -- -- /* need output data -- for small len or new stream load up our output -- buffer */ -- else if (state->how == LOOK || len < (state->size << 1)) { -- /* get more output, looking for header if required */ -- if (gz_make(state) == -1) -- return -1; -- continue; /* no progress yet -- go back to memcpy() above */ -- /* the copy above assures that we will leave with space in the -- output buffer, allowing at least one gzungetc() to succeed */ -- } -- -- /* large len -- read directly into user buffer */ -- else if (state->how == COPY) { /* read directly */ -- if (gz_load(state, buf, len, &n) == -1) -- return -1; -- } -- -- /* large len -- decompress directly into user buffer */ -- else { /* state->how == GZIP */ -- strm->avail_out = len; -- strm->next_out = buf; -- if (gz_decomp(state) == -1) -- return -1; -- n = state->have; -- state->have = 0; -- } -- -- /* update progress */ -- len -= n; -- buf = (char *)buf + n; -- got += n; -- state->pos += n; -- } while (len); -- -- /* return number of bytes read into user buffer (will fit in int) */ -- return (int)got; --} -- --/* -- see zlib.h -- */ --int ZEXPORT gzgetc(file) -- gzFile file; --{ -- int ret; -- unsigned char buf[1]; -- gz_statep state; -- -- /* get internal structure */ -- if (file == NULL) -- return -1; -- state = (gz_statep)file; -- -- /* check that we're reading and that there's no error */ -- if (state->mode != GZ_READ || state->err != Z_OK) -- return -1; -- -- /* try output buffer (no need to check for skip request) */ -- if (state->have) { -- state->have--; -- state->pos++; -- return *(state->next)++; -- } -- -- /* nothing there -- try gzread() */ -- ret = gzread(file, buf, 1); -- return ret < 1 ? -1 : buf[0]; --} -- --/* -- see zlib.h -- */ --int ZEXPORT gzungetc(c, file) -- int c; -- gzFile file; --{ -- gz_statep state; -- -- /* get internal structure */ -- if (file == NULL) -- return -1; -- state = (gz_statep)file; -- -- /* check that we're reading and that there's no error */ -- if (state->mode != GZ_READ || state->err != Z_OK) -- return -1; -- -- /* process a skip request */ -- if (state->seek) { -- state->seek = 0; -- if (gz_skip(state, state->skip) == -1) -- return -1; -- } -- -- /* can't push EOF */ -- if (c < 0) -- return -1; -- -- /* if output buffer empty, put byte at end (allows more pushing) */ -- if (state->have == 0) { -- state->have = 1; -- state->next = state->out + (state->size << 1) - 1; -- state->next[0] = c; -- state->pos--; -- return c; -- } -- -- /* if no room, give up (must have already done a gzungetc()) */ -- if (state->have == (state->size << 1)) { -- gz_error(state, Z_BUF_ERROR, "out of room to push characters"); -- return -1; -- } -- -- /* slide output data if needed and insert byte before existing data */ -- if (state->next == state->out) { -- unsigned char *src = state->out + state->have; -- unsigned char *dest = state->out + (state->size << 1); -- while (src > state->out) -- *--dest = *--src; -- state->next = dest; -- } -- state->have++; -- state->next--; -- state->next[0] = c; -- state->pos--; -- return c; --} -- --/* -- see zlib.h -- */ --char * ZEXPORT gzgets(file, buf, len) -- gzFile file; -- char *buf; -- int len; --{ -- unsigned left, n; -- char *str; -- unsigned char *eol; -- gz_statep state; -- -- /* check parameters and get internal structure */ -- if (file == NULL || buf == NULL || len < 1) -- return NULL; -- state = (gz_statep)file; -- -- /* check that we're reading and that there's no error */ -- if (state->mode != GZ_READ || state->err != Z_OK) -- return NULL; -- -- /* process a skip request */ -- if (state->seek) { -- state->seek = 0; -- if (gz_skip(state, state->skip) == -1) -- return NULL; -- } -- -- /* copy output bytes up to new line or len - 1, whichever comes first -- -- append a terminating zero to the string (we don't check for a zero in -- the contents, let the user worry about that) */ -- str = buf; -- left = (unsigned)len - 1; -- if (left) do { -- /* assure that something is in the output buffer */ -- if (state->have == 0) { -- if (gz_make(state) == -1) -- return NULL; /* error */ -- if (state->have == 0) { /* end of file */ -- if (buf == str) /* got bupkus */ -- return NULL; -- break; /* got something -- return it */ -- } -- } -- -- /* look for end-of-line in current output buffer */ -- n = state->have > left ? left : state->have; -- eol = memchr(state->next, '\n', n); -- if (eol != NULL) -- n = (unsigned)(eol - state->next) + 1; -- -- /* copy through end-of-line, or remainder if not found */ -- memcpy(buf, state->next, n); -- state->have -= n; -- state->next += n; -- state->pos += n; -- left -= n; -- buf += n; -- } while (left && eol == NULL); -- -- /* found end-of-line or out of space -- terminate string and return it */ -- buf[0] = 0; -- return str; --} -- --/* -- see zlib.h -- */ --int ZEXPORT gzdirect(file) -- gzFile file; --{ -- gz_statep state; -- -- /* get internal structure */ -- if (file == NULL) -- return 0; -- state = (gz_statep)file; -- -- /* check that we're reading */ -- if (state->mode != GZ_READ) -- return 0; -- -- /* if the state is not known, but we can find out, then do so (this is -- mainly for right after a gzopen() or gzdopen()) */ -- if (state->how == LOOK && state->have == 0) -- (void)gz_head(state); -- -- /* return 1 if reading direct, 0 if decompressing a gzip stream */ -- return state->direct; --} -- --/* -- see zlib.h -- */ --int ZEXPORT gzclose_r(file) -- gzFile file; --{ -- int ret; -- gz_statep state; -- -- /* get internal structure */ -- if (file == NULL) -- return Z_STREAM_ERROR; -- state = (gz_statep)file; -- -- /* check that we're reading */ -- if (state->mode != GZ_READ) -- return Z_STREAM_ERROR; -- -- /* free memory and close file */ -- if (state->size) { -- inflateEnd(&(state->strm)); -- free(state->out); -- free(state->in); -- } -- gz_error(state, Z_OK, NULL); -- free(state->path); -- ret = close(state->fd); -- free(state); -- return ret ? Z_ERRNO : Z_OK; --} -diff --git a/thirdparty/zlib/gzwrite.c b/thirdparty/zlib/gzwrite.c -deleted file mode 100644 -index e8defc6..0000000 ---- a/thirdparty/zlib/gzwrite.c -+++ /dev/null -@@ -1,531 +0,0 @@ --/* gzwrite.c -- zlib functions for writing gzip files -- * Copyright (C) 2004, 2005, 2010 Mark Adler -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --#include "gzguts.h" -- --/* Local functions */ --local int gz_init OF((gz_statep)); --local int gz_comp OF((gz_statep, int)); --local int gz_zero OF((gz_statep, z_off64_t)); -- --/* Initialize state for writing a gzip file. Mark initialization by setting -- state->size to non-zero. Return -1 on failure or 0 on success. */ --local int gz_init(state) -- gz_statep state; --{ -- int ret; -- z_streamp strm = &(state->strm); -- -- /* allocate input and output buffers */ -- state->in = malloc(state->want); -- state->out = malloc(state->want); -- if (state->in == NULL || state->out == NULL) { -- if (state->out != NULL) -- free(state->out); -- if (state->in != NULL) -- free(state->in); -- gz_error(state, Z_MEM_ERROR, "out of memory"); -- return -1; -- } -- -- /* allocate deflate memory, set up for gzip compression */ -- strm->zalloc = Z_NULL; -- strm->zfree = Z_NULL; -- strm->opaque = Z_NULL; -- ret = deflateInit2(strm, state->level, Z_DEFLATED, -- 15 + 16, 8, state->strategy); -- if (ret != Z_OK) { -- free(state->in); -- gz_error(state, Z_MEM_ERROR, "out of memory"); -- return -1; -- } -- -- /* mark state as initialized */ -- state->size = state->want; -- -- /* initialize write buffer */ -- strm->avail_out = state->size; -- strm->next_out = state->out; -- state->next = strm->next_out; -- return 0; --} -- --/* Compress whatever is at avail_in and next_in and write to the output file. -- Return -1 if there is an error writing to the output file, otherwise 0. -- flush is assumed to be a valid deflate() flush value. If flush is Z_FINISH, -- then the deflate() state is reset to start a new gzip stream. */ --local int gz_comp(state, flush) -- gz_statep state; -- int flush; --{ -- int ret, got; -- unsigned have; -- z_streamp strm = &(state->strm); -- -- /* allocate memory if this is the first time through */ -- if (state->size == 0 && gz_init(state) == -1) -- return -1; -- -- /* run deflate() on provided input until it produces no more output */ -- ret = Z_OK; -- do { -- /* write out current buffer contents if full, or if flushing, but if -- doing Z_FINISH then don't write until we get to Z_STREAM_END */ -- if (strm->avail_out == 0 || (flush != Z_NO_FLUSH && -- (flush != Z_FINISH || ret == Z_STREAM_END))) { -- have = (unsigned)(strm->next_out - state->next); -- if (have && ((got = write(state->fd, state->next, have)) < 0 || -- (unsigned)got != have)) { -- gz_error(state, Z_ERRNO, zstrerror()); -- return -1; -- } -- if (strm->avail_out == 0) { -- strm->avail_out = state->size; -- strm->next_out = state->out; -- } -- state->next = strm->next_out; -- } -- -- /* compress */ -- have = strm->avail_out; -- ret = deflate(strm, flush); -- if (ret == Z_STREAM_ERROR) { -- gz_error(state, Z_STREAM_ERROR, -- "internal error: deflate stream corrupt"); -- return -1; -- } -- have -= strm->avail_out; -- } while (have); -- -- /* if that completed a deflate stream, allow another to start */ -- if (flush == Z_FINISH) -- deflateReset(strm); -- -- /* all done, no errors */ -- return 0; --} -- --/* Compress len zeros to output. Return -1 on error, 0 on success. */ --local int gz_zero(state, len) -- gz_statep state; -- z_off64_t len; --{ -- int first; -- unsigned n; -- z_streamp strm = &(state->strm); -- -- /* consume whatever's left in the input buffer */ -- if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) -- return -1; -- -- /* compress len zeros (len guaranteed > 0) */ -- first = 1; -- while (len) { -- n = GT_OFF(state->size) || (z_off64_t)state->size > len ? -- (unsigned)len : state->size; -- if (first) { -- memset(state->in, 0, n); -- first = 0; -- } -- strm->avail_in = n; -- strm->next_in = state->in; -- state->pos += n; -- if (gz_comp(state, Z_NO_FLUSH) == -1) -- return -1; -- len -= n; -- } -- return 0; --} -- --/* -- see zlib.h -- */ --int ZEXPORT gzwrite(file, buf, len) -- gzFile file; -- voidpc buf; -- unsigned len; --{ -- unsigned put = len; -- unsigned n; -- gz_statep state; -- z_streamp strm; -- -- /* get internal structure */ -- if (file == NULL) -- return 0; -- state = (gz_statep)file; -- strm = &(state->strm); -- -- /* check that we're writing and that there's no error */ -- if (state->mode != GZ_WRITE || state->err != Z_OK) -- return 0; -- -- /* since an int is returned, make sure len fits in one, otherwise return -- with an error (this avoids the flaw in the interface) */ -- if ((int)len < 0) { -- gz_error(state, Z_BUF_ERROR, "requested length does not fit in int"); -- return 0; -- } -- -- /* if len is zero, avoid unnecessary operations */ -- if (len == 0) -- return 0; -- -- /* allocate memory if this is the first time through */ -- if (state->size == 0 && gz_init(state) == -1) -- return 0; -- -- /* check for seek request */ -- if (state->seek) { -- state->seek = 0; -- if (gz_zero(state, state->skip) == -1) -- return 0; -- } -- -- /* for small len, copy to input buffer, otherwise compress directly */ -- if (len < state->size) { -- /* copy to input buffer, compress when full */ -- do { -- if (strm->avail_in == 0) -- strm->next_in = state->in; -- n = state->size - strm->avail_in; -- if (n > len) -- n = len; -- memcpy(strm->next_in + strm->avail_in, buf, n); -- strm->avail_in += n; -- state->pos += n; -- buf = (char *)buf + n; -- len -= n; -- if (len && gz_comp(state, Z_NO_FLUSH) == -1) -- return 0; -- } while (len); -- } -- else { -- /* consume whatever's left in the input buffer */ -- if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) -- return 0; -- -- /* directly compress user buffer to file */ -- strm->avail_in = len; -- strm->next_in = (voidp)buf; -- state->pos += len; -- if (gz_comp(state, Z_NO_FLUSH) == -1) -- return 0; -- } -- -- /* input was all buffered or compressed (put will fit in int) */ -- return (int)put; --} -- --/* -- see zlib.h -- */ --int ZEXPORT gzputc(file, c) -- gzFile file; -- int c; --{ -- unsigned char buf[1]; -- gz_statep state; -- z_streamp strm; -- -- /* get internal structure */ -- if (file == NULL) -- return -1; -- state = (gz_statep)file; -- strm = &(state->strm); -- -- /* check that we're writing and that there's no error */ -- if (state->mode != GZ_WRITE || state->err != Z_OK) -- return -1; -- -- /* check for seek request */ -- if (state->seek) { -- state->seek = 0; -- if (gz_zero(state, state->skip) == -1) -- return -1; -- } -- -- /* try writing to input buffer for speed (state->size == 0 if buffer not -- initialized) */ -- if (strm->avail_in < state->size) { -- if (strm->avail_in == 0) -- strm->next_in = state->in; -- strm->next_in[strm->avail_in++] = c; -- state->pos++; -- return c; -- } -- -- /* no room in buffer or not initialized, use gz_write() */ -- buf[0] = c; -- if (gzwrite(file, buf, 1) != 1) -- return -1; -- return c; --} -- --/* -- see zlib.h -- */ --int ZEXPORT gzputs(file, str) -- gzFile file; -- const char *str; --{ -- int ret; -- unsigned len; -- -- /* write string */ -- len = (unsigned)strlen(str); -- ret = gzwrite(file, str, len); -- return ret == 0 && len != 0 ? -1 : ret; --} -- --#ifdef STDC --#include -- --/* -- see zlib.h -- */ --int ZEXPORTVA gzprintf (gzFile file, const char *format, ...) --{ -- int size, len; -- gz_statep state; -- z_streamp strm; -- va_list va; -- -- /* get internal structure */ -- if (file == NULL) -- return -1; -- state = (gz_statep)file; -- strm = &(state->strm); -- -- /* check that we're writing and that there's no error */ -- if (state->mode != GZ_WRITE || state->err != Z_OK) -- return 0; -- -- /* make sure we have some buffer space */ -- if (state->size == 0 && gz_init(state) == -1) -- return 0; -- -- /* check for seek request */ -- if (state->seek) { -- state->seek = 0; -- if (gz_zero(state, state->skip) == -1) -- return 0; -- } -- -- /* consume whatever's left in the input buffer */ -- if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) -- return 0; -- -- /* do the printf() into the input buffer, put length in len */ -- size = (int)(state->size); -- state->in[size - 1] = 0; -- va_start(va, format); --#ifdef NO_vsnprintf --# ifdef HAS_vsprintf_void -- (void)vsprintf(state->in, format, va); -- va_end(va); -- for (len = 0; len < size; len++) -- if (state->in[len] == 0) break; --# else -- len = vsprintf(state->in, format, va); -- va_end(va); --# endif --#else --# ifdef HAS_vsnprintf_void -- (void)vsnprintf(state->in, size, format, va); -- va_end(va); -- len = strlen(state->in); --# else -- len = vsnprintf((char *)(state->in), size, format, va); -- va_end(va); --# endif --#endif -- -- /* check that printf() results fit in buffer */ -- if (len <= 0 || len >= (int)size || state->in[size - 1] != 0) -- return 0; -- -- /* update buffer and position, defer compression until needed */ -- strm->avail_in = (unsigned)len; -- strm->next_in = state->in; -- state->pos += len; -- return len; --} -- --#else /* !STDC */ -- --/* -- see zlib.h -- */ --int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, -- a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) -- gzFile file; -- const char *format; -- int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, -- a11, a12, a13, a14, a15, a16, a17, a18, a19, a20; --{ -- int size, len; -- gz_statep state; -- z_streamp strm; -- -- /* get internal structure */ -- if (file == NULL) -- return -1; -- state = (gz_statep)file; -- strm = &(state->strm); -- -- /* check that we're writing and that there's no error */ -- if (state->mode != GZ_WRITE || state->err != Z_OK) -- return 0; -- -- /* make sure we have some buffer space */ -- if (state->size == 0 && gz_init(state) == -1) -- return 0; -- -- /* check for seek request */ -- if (state->seek) { -- state->seek = 0; -- if (gz_zero(state, state->skip) == -1) -- return 0; -- } -- -- /* consume whatever's left in the input buffer */ -- if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) -- return 0; -- -- /* do the printf() into the input buffer, put length in len */ -- size = (int)(state->size); -- state->in[size - 1] = 0; --#ifdef NO_snprintf --# ifdef HAS_sprintf_void -- sprintf(state->in, format, a1, a2, a3, a4, a5, a6, a7, a8, -- a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); -- for (len = 0; len < size; len++) -- if (state->in[len] == 0) break; --# else -- len = sprintf(state->in, format, a1, a2, a3, a4, a5, a6, a7, a8, -- a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); --# endif --#else --# ifdef HAS_snprintf_void -- snprintf(state->in, size, format, a1, a2, a3, a4, a5, a6, a7, a8, -- a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); -- len = strlen(state->in); --# else -- len = snprintf(state->in, size, format, a1, a2, a3, a4, a5, a6, a7, a8, -- a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); --# endif --#endif -- -- /* check that printf() results fit in buffer */ -- if (len <= 0 || len >= (int)size || state->in[size - 1] != 0) -- return 0; -- -- /* update buffer and position, defer compression until needed */ -- strm->avail_in = (unsigned)len; -- strm->next_in = state->in; -- state->pos += len; -- return len; --} -- --#endif -- --/* -- see zlib.h -- */ --int ZEXPORT gzflush(file, flush) -- gzFile file; -- int flush; --{ -- gz_statep state; -- -- /* get internal structure */ -- if (file == NULL) -- return -1; -- state = (gz_statep)file; -- -- /* check that we're writing and that there's no error */ -- if (state->mode != GZ_WRITE || state->err != Z_OK) -- return Z_STREAM_ERROR; -- -- /* check flush parameter */ -- if (flush < 0 || flush > Z_FINISH) -- return Z_STREAM_ERROR; -- -- /* check for seek request */ -- if (state->seek) { -- state->seek = 0; -- if (gz_zero(state, state->skip) == -1) -- return -1; -- } -- -- /* compress remaining data with requested flush */ -- gz_comp(state, flush); -- return state->err; --} -- --/* -- see zlib.h -- */ --int ZEXPORT gzsetparams(file, level, strategy) -- gzFile file; -- int level; -- int strategy; --{ -- gz_statep state; -- z_streamp strm; -- -- /* get internal structure */ -- if (file == NULL) -- return Z_STREAM_ERROR; -- state = (gz_statep)file; -- strm = &(state->strm); -- -- /* check that we're writing and that there's no error */ -- if (state->mode != GZ_WRITE || state->err != Z_OK) -- return Z_STREAM_ERROR; -- -- /* if no change is requested, then do nothing */ -- if (level == state->level && strategy == state->strategy) -- return Z_OK; -- -- /* check for seek request */ -- if (state->seek) { -- state->seek = 0; -- if (gz_zero(state, state->skip) == -1) -- return -1; -- } -- -- /* change compression parameters for subsequent input */ -- if (state->size) { -- /* flush previous input with previous parameters before changing */ -- if (strm->avail_in && gz_comp(state, Z_PARTIAL_FLUSH) == -1) -- return state->err; -- deflateParams(strm, level, strategy); -- } -- state->level = level; -- state->strategy = strategy; -- return Z_OK; --} -- --/* -- see zlib.h -- */ --int ZEXPORT gzclose_w(file) -- gzFile file; --{ -- int ret = 0; -- gz_statep state; -- -- /* get internal structure */ -- if (file == NULL) -- return Z_STREAM_ERROR; -- state = (gz_statep)file; -- -- /* check that we're writing */ -- if (state->mode != GZ_WRITE) -- return Z_STREAM_ERROR; -- -- /* check for seek request */ -- if (state->seek) { -- state->seek = 0; -- ret += gz_zero(state, state->skip); -- } -- -- /* flush, free memory, and close file */ -- ret += gz_comp(state, Z_FINISH); -- (void)deflateEnd(&(state->strm)); -- free(state->out); -- free(state->in); -- gz_error(state, Z_OK, NULL); -- free(state->path); -- ret += close(state->fd); -- free(state); -- return ret ? Z_ERRNO : Z_OK; --} -diff --git a/thirdparty/zlib/infback.c b/thirdparty/zlib/infback.c -deleted file mode 100644 -index af3a8c9..0000000 ---- a/thirdparty/zlib/infback.c -+++ /dev/null -@@ -1,632 +0,0 @@ --/* infback.c -- inflate using a call-back interface -- * Copyright (C) 1995-2009 Mark Adler -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* -- This code is largely copied from inflate.c. Normally either infback.o or -- inflate.o would be linked into an application--not both. The interface -- with inffast.c is retained so that optimized assembler-coded versions of -- inflate_fast() can be used with either inflate.c or infback.c. -- */ -- --#include "zutil.h" --#include "inftrees.h" --#include "inflate.h" --#include "inffast.h" -- --/* function prototypes */ --local void fixedtables OF((struct inflate_state FAR *state)); -- --/* -- strm provides memory allocation functions in zalloc and zfree, or -- Z_NULL to use the library memory allocation functions. -- -- windowBits is in the range 8..15, and window is a user-supplied -- window and output buffer that is 2**windowBits bytes. -- */ --int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size) --z_streamp strm; --int windowBits; --unsigned char FAR *window; --const char *version; --int stream_size; --{ -- struct inflate_state FAR *state; -- -- if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || -- stream_size != (int)(sizeof(z_stream))) -- return Z_VERSION_ERROR; -- if (strm == Z_NULL || window == Z_NULL || -- windowBits < 8 || windowBits > 15) -- return Z_STREAM_ERROR; -- strm->msg = Z_NULL; /* in case we return an error */ -- if (strm->zalloc == (alloc_func)0) { -- strm->zalloc = zcalloc; -- strm->opaque = (voidpf)0; -- } -- if (strm->zfree == (free_func)0) strm->zfree = zcfree; -- state = (struct inflate_state FAR *)ZALLOC(strm, 1, -- sizeof(struct inflate_state)); -- if (state == Z_NULL) return Z_MEM_ERROR; -- Tracev((stderr, "inflate: allocated\n")); -- strm->state = (struct internal_state FAR *)state; -- state->dmax = 32768U; -- state->wbits = windowBits; -- state->wsize = 1U << windowBits; -- state->window = window; -- state->wnext = 0; -- state->whave = 0; -- return Z_OK; --} -- --/* -- Return state with length and distance decoding tables and index sizes set to -- fixed code decoding. Normally this returns fixed tables from inffixed.h. -- If BUILDFIXED is defined, then instead this routine builds the tables the -- first time it's called, and returns those tables the first time and -- thereafter. This reduces the size of the code by about 2K bytes, in -- exchange for a little execution time. However, BUILDFIXED should not be -- used for threaded applications, since the rewriting of the tables and virgin -- may not be thread-safe. -- */ --local void fixedtables(state) --struct inflate_state FAR *state; --{ --#ifdef BUILDFIXED -- static int virgin = 1; -- static code *lenfix, *distfix; -- static code fixed[544]; -- -- /* build fixed huffman tables if first call (may not be thread safe) */ -- if (virgin) { -- unsigned sym, bits; -- static code *next; -- -- /* literal/length table */ -- sym = 0; -- while (sym < 144) state->lens[sym++] = 8; -- while (sym < 256) state->lens[sym++] = 9; -- while (sym < 280) state->lens[sym++] = 7; -- while (sym < 288) state->lens[sym++] = 8; -- next = fixed; -- lenfix = next; -- bits = 9; -- inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); -- -- /* distance table */ -- sym = 0; -- while (sym < 32) state->lens[sym++] = 5; -- distfix = next; -- bits = 5; -- inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); -- -- /* do this just once */ -- virgin = 0; -- } --#else /* !BUILDFIXED */ --# include "inffixed.h" --#endif /* BUILDFIXED */ -- state->lencode = lenfix; -- state->lenbits = 9; -- state->distcode = distfix; -- state->distbits = 5; --} -- --/* Macros for inflateBack(): */ -- --/* Load returned state from inflate_fast() */ --#define LOAD() \ -- do { \ -- put = strm->next_out; \ -- left = strm->avail_out; \ -- next = strm->next_in; \ -- have = strm->avail_in; \ -- hold = state->hold; \ -- bits = state->bits; \ -- } while (0) -- --/* Set state from registers for inflate_fast() */ --#define RESTORE() \ -- do { \ -- strm->next_out = put; \ -- strm->avail_out = left; \ -- strm->next_in = next; \ -- strm->avail_in = have; \ -- state->hold = hold; \ -- state->bits = bits; \ -- } while (0) -- --/* Clear the input bit accumulator */ --#define INITBITS() \ -- do { \ -- hold = 0; \ -- bits = 0; \ -- } while (0) -- --/* Assure that some input is available. If input is requested, but denied, -- then return a Z_BUF_ERROR from inflateBack(). */ --#define PULL() \ -- do { \ -- if (have == 0) { \ -- have = in(in_desc, &next); \ -- if (have == 0) { \ -- next = Z_NULL; \ -- ret = Z_BUF_ERROR; \ -- goto inf_leave; \ -- } \ -- } \ -- } while (0) -- --/* Get a byte of input into the bit accumulator, or return from inflateBack() -- with an error if there is no input available. */ --#define PULLBYTE() \ -- do { \ -- PULL(); \ -- have--; \ -- hold += (unsigned long)(*next++) << bits; \ -- bits += 8; \ -- } while (0) -- --/* Assure that there are at least n bits in the bit accumulator. If there is -- not enough available input to do that, then return from inflateBack() with -- an error. */ --#define NEEDBITS(n) \ -- do { \ -- while (bits < (unsigned)(n)) \ -- PULLBYTE(); \ -- } while (0) -- --/* Return the low n bits of the bit accumulator (n < 16) */ --#define BITS(n) \ -- ((unsigned)hold & ((1U << (n)) - 1)) -- --/* Remove n bits from the bit accumulator */ --#define DROPBITS(n) \ -- do { \ -- hold >>= (n); \ -- bits -= (unsigned)(n); \ -- } while (0) -- --/* Remove zero to seven bits as needed to go to a byte boundary */ --#define BYTEBITS() \ -- do { \ -- hold >>= bits & 7; \ -- bits -= bits & 7; \ -- } while (0) -- --/* Assure that some output space is available, by writing out the window -- if it's full. If the write fails, return from inflateBack() with a -- Z_BUF_ERROR. */ --#define ROOM() \ -- do { \ -- if (left == 0) { \ -- put = state->window; \ -- left = state->wsize; \ -- state->whave = left; \ -- if (out(out_desc, put, left)) { \ -- ret = Z_BUF_ERROR; \ -- goto inf_leave; \ -- } \ -- } \ -- } while (0) -- --/* -- strm provides the memory allocation functions and window buffer on input, -- and provides information on the unused input on return. For Z_DATA_ERROR -- returns, strm will also provide an error message. -- -- in() and out() are the call-back input and output functions. When -- inflateBack() needs more input, it calls in(). When inflateBack() has -- filled the window with output, or when it completes with data in the -- window, it calls out() to write out the data. The application must not -- change the provided input until in() is called again or inflateBack() -- returns. The application must not change the window/output buffer until -- inflateBack() returns. -- -- in() and out() are called with a descriptor parameter provided in the -- inflateBack() call. This parameter can be a structure that provides the -- information required to do the read or write, as well as accumulated -- information on the input and output such as totals and check values. -- -- in() should return zero on failure. out() should return non-zero on -- failure. If either in() or out() fails, than inflateBack() returns a -- Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it -- was in() or out() that caused in the error. Otherwise, inflateBack() -- returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format -- error, or Z_MEM_ERROR if it could not allocate memory for the state. -- inflateBack() can also return Z_STREAM_ERROR if the input parameters -- are not correct, i.e. strm is Z_NULL or the state was not initialized. -- */ --int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc) --z_streamp strm; --in_func in; --void FAR *in_desc; --out_func out; --void FAR *out_desc; --{ -- struct inflate_state FAR *state; -- unsigned char FAR *next; /* next input */ -- unsigned char FAR *put; /* next output */ -- unsigned have, left; /* available input and output */ -- unsigned long hold; /* bit buffer */ -- unsigned bits; /* bits in bit buffer */ -- unsigned copy; /* number of stored or match bytes to copy */ -- unsigned char FAR *from; /* where to copy match bytes from */ -- code here; /* current decoding table entry */ -- code last; /* parent table entry */ -- unsigned len; /* length to copy for repeats, bits to drop */ -- int ret; /* return code */ -- static const unsigned short order[19] = /* permutation of code lengths */ -- {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; -- -- /* Check that the strm exists and that the state was initialized */ -- if (strm == Z_NULL || strm->state == Z_NULL) -- return Z_STREAM_ERROR; -- state = (struct inflate_state FAR *)strm->state; -- -- /* Reset the state */ -- strm->msg = Z_NULL; -- state->mode = TYPE; -- state->last = 0; -- state->whave = 0; -- next = strm->next_in; -- have = next != Z_NULL ? strm->avail_in : 0; -- hold = 0; -- bits = 0; -- put = state->window; -- left = state->wsize; -- -- /* Inflate until end of block marked as last */ -- for (;;) -- switch (state->mode) { -- case TYPE: -- /* determine and dispatch block type */ -- if (state->last) { -- BYTEBITS(); -- state->mode = DONE; -- break; -- } -- NEEDBITS(3); -- state->last = BITS(1); -- DROPBITS(1); -- switch (BITS(2)) { -- case 0: /* stored block */ -- Tracev((stderr, "inflate: stored block%s\n", -- state->last ? " (last)" : "")); -- state->mode = STORED; -- break; -- case 1: /* fixed block */ -- fixedtables(state); -- Tracev((stderr, "inflate: fixed codes block%s\n", -- state->last ? " (last)" : "")); -- state->mode = LEN; /* decode codes */ -- break; -- case 2: /* dynamic block */ -- Tracev((stderr, "inflate: dynamic codes block%s\n", -- state->last ? " (last)" : "")); -- state->mode = TABLE; -- break; -- case 3: -- strm->msg = (char *)"invalid block type"; -- state->mode = BAD; -- } -- DROPBITS(2); -- break; -- -- case STORED: -- /* get and verify stored block length */ -- BYTEBITS(); /* go to byte boundary */ -- NEEDBITS(32); -- if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { -- strm->msg = (char *)"invalid stored block lengths"; -- state->mode = BAD; -- break; -- } -- state->length = (unsigned)hold & 0xffff; -- Tracev((stderr, "inflate: stored length %u\n", -- state->length)); -- INITBITS(); -- -- /* copy stored block from input to output */ -- while (state->length != 0) { -- copy = state->length; -- PULL(); -- ROOM(); -- if (copy > have) copy = have; -- if (copy > left) copy = left; -- zmemcpy(put, next, copy); -- have -= copy; -- next += copy; -- left -= copy; -- put += copy; -- state->length -= copy; -- } -- Tracev((stderr, "inflate: stored end\n")); -- state->mode = TYPE; -- break; -- -- case TABLE: -- /* get dynamic table entries descriptor */ -- NEEDBITS(14); -- state->nlen = BITS(5) + 257; -- DROPBITS(5); -- state->ndist = BITS(5) + 1; -- DROPBITS(5); -- state->ncode = BITS(4) + 4; -- DROPBITS(4); --#ifndef PKZIP_BUG_WORKAROUND -- if (state->nlen > 286 || state->ndist > 30) { -- strm->msg = (char *)"too many length or distance symbols"; -- state->mode = BAD; -- break; -- } --#endif -- Tracev((stderr, "inflate: table sizes ok\n")); -- -- /* get code length code lengths (not a typo) */ -- state->have = 0; -- while (state->have < state->ncode) { -- NEEDBITS(3); -- state->lens[order[state->have++]] = (unsigned short)BITS(3); -- DROPBITS(3); -- } -- while (state->have < 19) -- state->lens[order[state->have++]] = 0; -- state->next = state->codes; -- state->lencode = (code const FAR *)(state->next); -- state->lenbits = 7; -- ret = inflate_table(CODES, state->lens, 19, &(state->next), -- &(state->lenbits), state->work); -- if (ret) { -- strm->msg = (char *)"invalid code lengths set"; -- state->mode = BAD; -- break; -- } -- Tracev((stderr, "inflate: code lengths ok\n")); -- -- /* get length and distance code code lengths */ -- state->have = 0; -- while (state->have < state->nlen + state->ndist) { -- for (;;) { -- here = state->lencode[BITS(state->lenbits)]; -- if ((unsigned)(here.bits) <= bits) break; -- PULLBYTE(); -- } -- if (here.val < 16) { -- NEEDBITS(here.bits); -- DROPBITS(here.bits); -- state->lens[state->have++] = here.val; -- } -- else { -- if (here.val == 16) { -- NEEDBITS(here.bits + 2); -- DROPBITS(here.bits); -- if (state->have == 0) { -- strm->msg = (char *)"invalid bit length repeat"; -- state->mode = BAD; -- break; -- } -- len = (unsigned)(state->lens[state->have - 1]); -- copy = 3 + BITS(2); -- DROPBITS(2); -- } -- else if (here.val == 17) { -- NEEDBITS(here.bits + 3); -- DROPBITS(here.bits); -- len = 0; -- copy = 3 + BITS(3); -- DROPBITS(3); -- } -- else { -- NEEDBITS(here.bits + 7); -- DROPBITS(here.bits); -- len = 0; -- copy = 11 + BITS(7); -- DROPBITS(7); -- } -- if (state->have + copy > state->nlen + state->ndist) { -- strm->msg = (char *)"invalid bit length repeat"; -- state->mode = BAD; -- break; -- } -- while (copy--) -- state->lens[state->have++] = (unsigned short)len; -- } -- } -- -- /* handle error breaks in while */ -- if (state->mode == BAD) break; -- -- /* check for end-of-block code (better have one) */ -- if (state->lens[256] == 0) { -- strm->msg = (char *)"invalid code -- missing end-of-block"; -- state->mode = BAD; -- break; -- } -- -- /* build code tables -- note: do not change the lenbits or distbits -- values here (9 and 6) without reading the comments in inftrees.h -- concerning the ENOUGH constants, which depend on those values */ -- state->next = state->codes; -- state->lencode = (code const FAR *)(state->next); -- state->lenbits = 9; -- ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), -- &(state->lenbits), state->work); -- if (ret) { -- strm->msg = (char *)"invalid literal/lengths set"; -- state->mode = BAD; -- break; -- } -- state->distcode = (code const FAR *)(state->next); -- state->distbits = 6; -- ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, -- &(state->next), &(state->distbits), state->work); -- if (ret) { -- strm->msg = (char *)"invalid distances set"; -- state->mode = BAD; -- break; -- } -- Tracev((stderr, "inflate: codes ok\n")); -- state->mode = LEN; -- -- case LEN: -- /* use inflate_fast() if we have enough input and output */ -- if (have >= 6 && left >= 258) { -- RESTORE(); -- if (state->whave < state->wsize) -- state->whave = state->wsize - left; -- inflate_fast(strm, state->wsize); -- LOAD(); -- break; -- } -- -- /* get a literal, length, or end-of-block code */ -- for (;;) { -- here = state->lencode[BITS(state->lenbits)]; -- if ((unsigned)(here.bits) <= bits) break; -- PULLBYTE(); -- } -- if (here.op && (here.op & 0xf0) == 0) { -- last = here; -- for (;;) { -- here = state->lencode[last.val + -- (BITS(last.bits + last.op) >> last.bits)]; -- if ((unsigned)(last.bits + here.bits) <= bits) break; -- PULLBYTE(); -- } -- DROPBITS(last.bits); -- } -- DROPBITS(here.bits); -- state->length = (unsigned)here.val; -- -- /* process literal */ -- if (here.op == 0) { -- Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? -- "inflate: literal '%c'\n" : -- "inflate: literal 0x%02x\n", here.val)); -- ROOM(); -- *put++ = (unsigned char)(state->length); -- left--; -- state->mode = LEN; -- break; -- } -- -- /* process end of block */ -- if (here.op & 32) { -- Tracevv((stderr, "inflate: end of block\n")); -- state->mode = TYPE; -- break; -- } -- -- /* invalid code */ -- if (here.op & 64) { -- strm->msg = (char *)"invalid literal/length code"; -- state->mode = BAD; -- break; -- } -- -- /* length code -- get extra bits, if any */ -- state->extra = (unsigned)(here.op) & 15; -- if (state->extra != 0) { -- NEEDBITS(state->extra); -- state->length += BITS(state->extra); -- DROPBITS(state->extra); -- } -- Tracevv((stderr, "inflate: length %u\n", state->length)); -- -- /* get distance code */ -- for (;;) { -- here = state->distcode[BITS(state->distbits)]; -- if ((unsigned)(here.bits) <= bits) break; -- PULLBYTE(); -- } -- if ((here.op & 0xf0) == 0) { -- last = here; -- for (;;) { -- here = state->distcode[last.val + -- (BITS(last.bits + last.op) >> last.bits)]; -- if ((unsigned)(last.bits + here.bits) <= bits) break; -- PULLBYTE(); -- } -- DROPBITS(last.bits); -- } -- DROPBITS(here.bits); -- if (here.op & 64) { -- strm->msg = (char *)"invalid distance code"; -- state->mode = BAD; -- break; -- } -- state->offset = (unsigned)here.val; -- -- /* get distance extra bits, if any */ -- state->extra = (unsigned)(here.op) & 15; -- if (state->extra != 0) { -- NEEDBITS(state->extra); -- state->offset += BITS(state->extra); -- DROPBITS(state->extra); -- } -- if (state->offset > state->wsize - (state->whave < state->wsize ? -- left : 0)) { -- strm->msg = (char *)"invalid distance too far back"; -- state->mode = BAD; -- break; -- } -- Tracevv((stderr, "inflate: distance %u\n", state->offset)); -- -- /* copy match from window to output */ -- do { -- ROOM(); -- copy = state->wsize - state->offset; -- if (copy < left) { -- from = put + copy; -- copy = left - copy; -- } -- else { -- from = put - state->offset; -- copy = left; -- } -- if (copy > state->length) copy = state->length; -- state->length -= copy; -- left -= copy; -- do { -- *put++ = *from++; -- } while (--copy); -- } while (state->length != 0); -- break; -- -- case DONE: -- /* inflate stream terminated properly -- write leftover output */ -- ret = Z_STREAM_END; -- if (left < state->wsize) { -- if (out(out_desc, state->window, state->wsize - left)) -- ret = Z_BUF_ERROR; -- } -- goto inf_leave; -- -- case BAD: -- ret = Z_DATA_ERROR; -- goto inf_leave; -- -- default: /* can't happen, but makes compilers happy */ -- ret = Z_STREAM_ERROR; -- goto inf_leave; -- } -- -- /* Return unused input */ -- inf_leave: -- strm->next_in = next; -- strm->avail_in = have; -- return ret; --} -- --int ZEXPORT inflateBackEnd(strm) --z_streamp strm; --{ -- if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) -- return Z_STREAM_ERROR; -- ZFREE(strm, strm->state); -- strm->state = Z_NULL; -- Tracev((stderr, "inflate: end\n")); -- return Z_OK; --} -diff --git a/thirdparty/zlib/inffast.c b/thirdparty/zlib/inffast.c -deleted file mode 100644 -index 2f1d60b..0000000 ---- a/thirdparty/zlib/inffast.c -+++ /dev/null -@@ -1,340 +0,0 @@ --/* inffast.c -- fast decoding -- * Copyright (C) 1995-2008, 2010 Mark Adler -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --#include "zutil.h" --#include "inftrees.h" --#include "inflate.h" --#include "inffast.h" -- --#ifndef ASMINF -- --/* Allow machine dependent optimization for post-increment or pre-increment. -- Based on testing to date, -- Pre-increment preferred for: -- - PowerPC G3 (Adler) -- - MIPS R5000 (Randers-Pehrson) -- Post-increment preferred for: -- - none -- No measurable difference: -- - Pentium III (Anderson) -- - M68060 (Nikl) -- */ --#ifdef POSTINC --# define OFF 0 --# define PUP(a) *(a)++ --#else --# define OFF 1 --# define PUP(a) *++(a) --#endif -- --/* -- Decode literal, length, and distance codes and write out the resulting -- literal and match bytes until either not enough input or output is -- available, an end-of-block is encountered, or a data error is encountered. -- When large enough input and output buffers are supplied to inflate(), for -- example, a 16K input buffer and a 64K output buffer, more than 95% of the -- inflate execution time is spent in this routine. -- -- Entry assumptions: -- -- state->mode == LEN -- strm->avail_in >= 6 -- strm->avail_out >= 258 -- start >= strm->avail_out -- state->bits < 8 -- -- On return, state->mode is one of: -- -- LEN -- ran out of enough output space or enough available input -- TYPE -- reached end of block code, inflate() to interpret next block -- BAD -- error in block data -- -- Notes: -- -- - The maximum input bits used by a length/distance pair is 15 bits for the -- length code, 5 bits for the length extra, 15 bits for the distance code, -- and 13 bits for the distance extra. This totals 48 bits, or six bytes. -- Therefore if strm->avail_in >= 6, then there is enough input to avoid -- checking for available input while decoding. -- -- - The maximum bytes that a single length/distance pair can output is 258 -- bytes, which is the maximum length that can be coded. inflate_fast() -- requires strm->avail_out >= 258 for each loop to avoid checking for -- output space. -- */ --void ZLIB_INTERNAL inflate_fast(strm, start) --z_streamp strm; --unsigned start; /* inflate()'s starting value for strm->avail_out */ --{ -- struct inflate_state FAR *state; -- unsigned char FAR *in; /* local strm->next_in */ -- unsigned char FAR *last; /* while in < last, enough input available */ -- unsigned char FAR *out; /* local strm->next_out */ -- unsigned char FAR *beg; /* inflate()'s initial strm->next_out */ -- unsigned char FAR *end; /* while out < end, enough space available */ --#ifdef INFLATE_STRICT -- unsigned dmax; /* maximum distance from zlib header */ --#endif -- unsigned wsize; /* window size or zero if not using window */ -- unsigned whave; /* valid bytes in the window */ -- unsigned wnext; /* window write index */ -- unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */ -- unsigned long hold; /* local strm->hold */ -- unsigned bits; /* local strm->bits */ -- code const FAR *lcode; /* local strm->lencode */ -- code const FAR *dcode; /* local strm->distcode */ -- unsigned lmask; /* mask for first level of length codes */ -- unsigned dmask; /* mask for first level of distance codes */ -- code here; /* retrieved table entry */ -- unsigned op; /* code bits, operation, extra bits, or */ -- /* window position, window bytes to copy */ -- unsigned len; /* match length, unused bytes */ -- unsigned dist; /* match distance */ -- unsigned char FAR *from; /* where to copy match from */ -- -- /* copy state to local variables */ -- state = (struct inflate_state FAR *)strm->state; -- in = strm->next_in - OFF; -- last = in + (strm->avail_in - 5); -- out = strm->next_out - OFF; -- beg = out - (start - strm->avail_out); -- end = out + (strm->avail_out - 257); --#ifdef INFLATE_STRICT -- dmax = state->dmax; --#endif -- wsize = state->wsize; -- whave = state->whave; -- wnext = state->wnext; -- window = state->window; -- hold = state->hold; -- bits = state->bits; -- lcode = state->lencode; -- dcode = state->distcode; -- lmask = (1U << state->lenbits) - 1; -- dmask = (1U << state->distbits) - 1; -- -- /* decode literals and length/distances until end-of-block or not enough -- input data or output space */ -- do { -- if (bits < 15) { -- hold += (unsigned long)(PUP(in)) << bits; -- bits += 8; -- hold += (unsigned long)(PUP(in)) << bits; -- bits += 8; -- } -- here = lcode[hold & lmask]; -- dolen: -- op = (unsigned)(here.bits); -- hold >>= op; -- bits -= op; -- op = (unsigned)(here.op); -- if (op == 0) { /* literal */ -- Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? -- "inflate: literal '%c'\n" : -- "inflate: literal 0x%02x\n", here.val)); -- PUP(out) = (unsigned char)(here.val); -- } -- else if (op & 16) { /* length base */ -- len = (unsigned)(here.val); -- op &= 15; /* number of extra bits */ -- if (op) { -- if (bits < op) { -- hold += (unsigned long)(PUP(in)) << bits; -- bits += 8; -- } -- len += (unsigned)hold & ((1U << op) - 1); -- hold >>= op; -- bits -= op; -- } -- Tracevv((stderr, "inflate: length %u\n", len)); -- if (bits < 15) { -- hold += (unsigned long)(PUP(in)) << bits; -- bits += 8; -- hold += (unsigned long)(PUP(in)) << bits; -- bits += 8; -- } -- here = dcode[hold & dmask]; -- dodist: -- op = (unsigned)(here.bits); -- hold >>= op; -- bits -= op; -- op = (unsigned)(here.op); -- if (op & 16) { /* distance base */ -- dist = (unsigned)(here.val); -- op &= 15; /* number of extra bits */ -- if (bits < op) { -- hold += (unsigned long)(PUP(in)) << bits; -- bits += 8; -- if (bits < op) { -- hold += (unsigned long)(PUP(in)) << bits; -- bits += 8; -- } -- } -- dist += (unsigned)hold & ((1U << op) - 1); --#ifdef INFLATE_STRICT -- if (dist > dmax) { -- strm->msg = (char *)"invalid distance too far back"; -- state->mode = BAD; -- break; -- } --#endif -- hold >>= op; -- bits -= op; -- Tracevv((stderr, "inflate: distance %u\n", dist)); -- op = (unsigned)(out - beg); /* max distance in output */ -- if (dist > op) { /* see if copy from window */ -- op = dist - op; /* distance back in window */ -- if (op > whave) { -- if (state->sane) { -- strm->msg = -- (char *)"invalid distance too far back"; -- state->mode = BAD; -- break; -- } --#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR -- if (len <= op - whave) { -- do { -- PUP(out) = 0; -- } while (--len); -- continue; -- } -- len -= op - whave; -- do { -- PUP(out) = 0; -- } while (--op > whave); -- if (op == 0) { -- from = out - dist; -- do { -- PUP(out) = PUP(from); -- } while (--len); -- continue; -- } --#endif -- } -- from = window - OFF; -- if (wnext == 0) { /* very common case */ -- from += wsize - op; -- if (op < len) { /* some from window */ -- len -= op; -- do { -- PUP(out) = PUP(from); -- } while (--op); -- from = out - dist; /* rest from output */ -- } -- } -- else if (wnext < op) { /* wrap around window */ -- from += wsize + wnext - op; -- op -= wnext; -- if (op < len) { /* some from end of window */ -- len -= op; -- do { -- PUP(out) = PUP(from); -- } while (--op); -- from = window - OFF; -- if (wnext < len) { /* some from start of window */ -- op = wnext; -- len -= op; -- do { -- PUP(out) = PUP(from); -- } while (--op); -- from = out - dist; /* rest from output */ -- } -- } -- } -- else { /* contiguous in window */ -- from += wnext - op; -- if (op < len) { /* some from window */ -- len -= op; -- do { -- PUP(out) = PUP(from); -- } while (--op); -- from = out - dist; /* rest from output */ -- } -- } -- while (len > 2) { -- PUP(out) = PUP(from); -- PUP(out) = PUP(from); -- PUP(out) = PUP(from); -- len -= 3; -- } -- if (len) { -- PUP(out) = PUP(from); -- if (len > 1) -- PUP(out) = PUP(from); -- } -- } -- else { -- from = out - dist; /* copy direct from output */ -- do { /* minimum length is three */ -- PUP(out) = PUP(from); -- PUP(out) = PUP(from); -- PUP(out) = PUP(from); -- len -= 3; -- } while (len > 2); -- if (len) { -- PUP(out) = PUP(from); -- if (len > 1) -- PUP(out) = PUP(from); -- } -- } -- } -- else if ((op & 64) == 0) { /* 2nd level distance code */ -- here = dcode[here.val + (hold & ((1U << op) - 1))]; -- goto dodist; -- } -- else { -- strm->msg = (char *)"invalid distance code"; -- state->mode = BAD; -- break; -- } -- } -- else if ((op & 64) == 0) { /* 2nd level length code */ -- here = lcode[here.val + (hold & ((1U << op) - 1))]; -- goto dolen; -- } -- else if (op & 32) { /* end-of-block */ -- Tracevv((stderr, "inflate: end of block\n")); -- state->mode = TYPE; -- break; -- } -- else { -- strm->msg = (char *)"invalid literal/length code"; -- state->mode = BAD; -- break; -- } -- } while (in < last && out < end); -- -- /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ -- len = bits >> 3; -- in -= len; -- bits -= len << 3; -- hold &= (1U << bits) - 1; -- -- /* update state and return */ -- strm->next_in = in + OFF; -- strm->next_out = out + OFF; -- strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last)); -- strm->avail_out = (unsigned)(out < end ? -- 257 + (end - out) : 257 - (out - end)); -- state->hold = hold; -- state->bits = bits; -- return; --} -- --/* -- inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe): -- - Using bit fields for code structure -- - Different op definition to avoid & for extra bits (do & for table bits) -- - Three separate decoding do-loops for direct, window, and wnext == 0 -- - Special case for distance > 1 copies to do overlapped load and store copy -- - Explicit branch predictions (based on measured branch probabilities) -- - Deferring match copy and interspersed it with decoding subsequent codes -- - Swapping literal/length else -- - Swapping window/direct else -- - Larger unrolled copy loops (three is about right) -- - Moving len -= 3 statement into middle of loop -- */ -- --#endif /* !ASMINF */ -diff --git a/thirdparty/zlib/inffast.h b/thirdparty/zlib/inffast.h -deleted file mode 100644 -index e5c1aa4..0000000 ---- a/thirdparty/zlib/inffast.h -+++ /dev/null -@@ -1,11 +0,0 @@ --/* inffast.h -- header to use inffast.c -- * Copyright (C) 1995-2003, 2010 Mark Adler -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* WARNING: this file should *not* be used by applications. It is -- part of the implementation of the compression library and is -- subject to change. Applications should only use zlib.h. -- */ -- --void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start)); -diff --git a/thirdparty/zlib/inffixed.h b/thirdparty/zlib/inffixed.h -deleted file mode 100644 -index 75ed4b5..0000000 ---- a/thirdparty/zlib/inffixed.h -+++ /dev/null -@@ -1,94 +0,0 @@ -- /* inffixed.h -- table for decoding fixed codes -- * Generated automatically by makefixed(). -- */ -- -- /* WARNING: this file should *not* be used by applications. It -- is part of the implementation of the compression library and -- is subject to change. Applications should only use zlib.h. -- */ -- -- static const code lenfix[512] = { -- {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, -- {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, -- {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, -- {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, -- {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, -- {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, -- {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, -- {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, -- {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, -- {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, -- {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, -- {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, -- {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, -- {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, -- {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, -- {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, -- {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, -- {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142}, -- {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, -- {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, -- {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, -- {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, -- {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, -- {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, -- {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, -- {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, -- {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, -- {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, -- {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, -- {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, -- {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, -- {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, -- {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55}, -- {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, -- {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, -- {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190}, -- {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16}, -- {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, -- {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, -- {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, -- {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, -- {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, -- {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, -- {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, -- {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, -- {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, -- {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, -- {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, -- {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, -- {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, -- {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51}, -- {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, -- {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, -- {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110}, -- {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0}, -- {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, -- {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, -- {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, -- {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, -- {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258}, -- {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, -- {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, -- {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, -- {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, -- {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, -- {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, -- {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, -- {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, -- {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, -- {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, -- {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, -- {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, -- {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, -- {0,9,255} -- }; -- -- static const code distfix[32] = { -- {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, -- {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, -- {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385}, -- {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, -- {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, -- {22,5,193},{64,5,0} -- }; -diff --git a/thirdparty/zlib/inflate.c b/thirdparty/zlib/inflate.c -deleted file mode 100644 -index a8431ab..0000000 ---- a/thirdparty/zlib/inflate.c -+++ /dev/null -@@ -1,1480 +0,0 @@ --/* inflate.c -- zlib decompression -- * Copyright (C) 1995-2010 Mark Adler -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* -- * Change history: -- * -- * 1.2.beta0 24 Nov 2002 -- * - First version -- complete rewrite of inflate to simplify code, avoid -- * creation of window when not needed, minimize use of window when it is -- * needed, make inffast.c even faster, implement gzip decoding, and to -- * improve code readability and style over the previous zlib inflate code -- * -- * 1.2.beta1 25 Nov 2002 -- * - Use pointers for available input and output checking in inffast.c -- * - Remove input and output counters in inffast.c -- * - Change inffast.c entry and loop from avail_in >= 7 to >= 6 -- * - Remove unnecessary second byte pull from length extra in inffast.c -- * - Unroll direct copy to three copies per loop in inffast.c -- * -- * 1.2.beta2 4 Dec 2002 -- * - Change external routine names to reduce potential conflicts -- * - Correct filename to inffixed.h for fixed tables in inflate.c -- * - Make hbuf[] unsigned char to match parameter type in inflate.c -- * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset) -- * to avoid negation problem on Alphas (64 bit) in inflate.c -- * -- * 1.2.beta3 22 Dec 2002 -- * - Add comments on state->bits assertion in inffast.c -- * - Add comments on op field in inftrees.h -- * - Fix bug in reuse of allocated window after inflateReset() -- * - Remove bit fields--back to byte structure for speed -- * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths -- * - Change post-increments to pre-increments in inflate_fast(), PPC biased? -- * - Add compile time option, POSTINC, to use post-increments instead (Intel?) -- * - Make MATCH copy in inflate() much faster for when inflate_fast() not used -- * - Use local copies of stream next and avail values, as well as local bit -- * buffer and bit count in inflate()--for speed when inflate_fast() not used -- * -- * 1.2.beta4 1 Jan 2003 -- * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings -- * - Move a comment on output buffer sizes from inffast.c to inflate.c -- * - Add comments in inffast.c to introduce the inflate_fast() routine -- * - Rearrange window copies in inflate_fast() for speed and simplification -- * - Unroll last copy for window match in inflate_fast() -- * - Use local copies of window variables in inflate_fast() for speed -- * - Pull out common wnext == 0 case for speed in inflate_fast() -- * - Make op and len in inflate_fast() unsigned for consistency -- * - Add FAR to lcode and dcode declarations in inflate_fast() -- * - Simplified bad distance check in inflate_fast() -- * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new -- * source file infback.c to provide a call-back interface to inflate for -- * programs like gzip and unzip -- uses window as output buffer to avoid -- * window copying -- * -- * 1.2.beta5 1 Jan 2003 -- * - Improved inflateBack() interface to allow the caller to provide initial -- * input in strm. -- * - Fixed stored blocks bug in inflateBack() -- * -- * 1.2.beta6 4 Jan 2003 -- * - Added comments in inffast.c on effectiveness of POSTINC -- * - Typecasting all around to reduce compiler warnings -- * - Changed loops from while (1) or do {} while (1) to for (;;), again to -- * make compilers happy -- * - Changed type of window in inflateBackInit() to unsigned char * -- * -- * 1.2.beta7 27 Jan 2003 -- * - Changed many types to unsigned or unsigned short to avoid warnings -- * - Added inflateCopy() function -- * -- * 1.2.0 9 Mar 2003 -- * - Changed inflateBack() interface to provide separate opaque descriptors -- * for the in() and out() functions -- * - Changed inflateBack() argument and in_func typedef to swap the length -- * and buffer address return values for the input function -- * - Check next_in and next_out for Z_NULL on entry to inflate() -- * -- * The history for versions after 1.2.0 are in ChangeLog in zlib distribution. -- */ -- --#include "zutil.h" --#include "inftrees.h" --#include "inflate.h" --#include "inffast.h" -- --#ifdef MAKEFIXED --# ifndef BUILDFIXED --# define BUILDFIXED --# endif --#endif -- --/* function prototypes */ --local void fixedtables OF((struct inflate_state FAR *state)); --local int updatewindow OF((z_streamp strm, unsigned out)); --#ifdef BUILDFIXED -- void makefixed OF((void)); --#endif --local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf, -- unsigned len)); -- --int ZEXPORT inflateReset(strm) --z_streamp strm; --{ -- struct inflate_state FAR *state; -- -- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; -- state = (struct inflate_state FAR *)strm->state; -- strm->total_in = strm->total_out = state->total = 0; -- strm->msg = Z_NULL; -- strm->adler = 1; /* to support ill-conceived Java test suite */ -- state->mode = HEAD; -- state->last = 0; -- state->havedict = 0; -- state->dmax = 32768U; -- state->head = Z_NULL; -- state->wsize = 0; -- state->whave = 0; -- state->wnext = 0; -- state->hold = 0; -- state->bits = 0; -- state->lencode = state->distcode = state->next = state->codes; -- state->sane = 1; -- state->back = -1; -- Tracev((stderr, "inflate: reset\n")); -- return Z_OK; --} -- --int ZEXPORT inflateReset2(strm, windowBits) --z_streamp strm; --int windowBits; --{ -- int wrap; -- struct inflate_state FAR *state; -- -- /* get the state */ -- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; -- state = (struct inflate_state FAR *)strm->state; -- -- /* extract wrap request from windowBits parameter */ -- if (windowBits < 0) { -- wrap = 0; -- windowBits = -windowBits; -- } -- else { -- wrap = (windowBits >> 4) + 1; --#ifdef GUNZIP -- if (windowBits < 48) -- windowBits &= 15; --#endif -- } -- -- /* set number of window bits, free window if different */ -- if (windowBits && (windowBits < 8 || windowBits > 15)) -- return Z_STREAM_ERROR; -- if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) { -- ZFREE(strm, state->window); -- state->window = Z_NULL; -- } -- -- /* update state and reset the rest of it */ -- state->wrap = wrap; -- state->wbits = (unsigned)windowBits; -- return inflateReset(strm); --} -- --int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size) --z_streamp strm; --int windowBits; --const char *version; --int stream_size; --{ -- int ret; -- struct inflate_state FAR *state; -- -- if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || -- stream_size != (int)(sizeof(z_stream))) -- return Z_VERSION_ERROR; -- if (strm == Z_NULL) return Z_STREAM_ERROR; -- strm->msg = Z_NULL; /* in case we return an error */ -- if (strm->zalloc == (alloc_func)0) { -- strm->zalloc = zcalloc; -- strm->opaque = (voidpf)0; -- } -- if (strm->zfree == (free_func)0) strm->zfree = zcfree; -- state = (struct inflate_state FAR *) -- ZALLOC(strm, 1, sizeof(struct inflate_state)); -- if (state == Z_NULL) return Z_MEM_ERROR; -- Tracev((stderr, "inflate: allocated\n")); -- strm->state = (struct internal_state FAR *)state; -- state->window = Z_NULL; -- ret = inflateReset2(strm, windowBits); -- if (ret != Z_OK) { -- ZFREE(strm, state); -- strm->state = Z_NULL; -- } -- return ret; --} -- --int ZEXPORT inflateInit_(strm, version, stream_size) --z_streamp strm; --const char *version; --int stream_size; --{ -- return inflateInit2_(strm, DEF_WBITS, version, stream_size); --} -- --int ZEXPORT inflatePrime(strm, bits, value) --z_streamp strm; --int bits; --int value; --{ -- struct inflate_state FAR *state; -- -- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; -- state = (struct inflate_state FAR *)strm->state; -- if (bits < 0) { -- state->hold = 0; -- state->bits = 0; -- return Z_OK; -- } -- if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR; -- value &= (1L << bits) - 1; -- state->hold += value << state->bits; -- state->bits += bits; -- return Z_OK; --} -- --/* -- Return state with length and distance decoding tables and index sizes set to -- fixed code decoding. Normally this returns fixed tables from inffixed.h. -- If BUILDFIXED is defined, then instead this routine builds the tables the -- first time it's called, and returns those tables the first time and -- thereafter. This reduces the size of the code by about 2K bytes, in -- exchange for a little execution time. However, BUILDFIXED should not be -- used for threaded applications, since the rewriting of the tables and virgin -- may not be thread-safe. -- */ --local void fixedtables(state) --struct inflate_state FAR *state; --{ --#ifdef BUILDFIXED -- static int virgin = 1; -- static code *lenfix, *distfix; -- static code fixed[544]; -- -- /* build fixed huffman tables if first call (may not be thread safe) */ -- if (virgin) { -- unsigned sym, bits; -- static code *next; -- -- /* literal/length table */ -- sym = 0; -- while (sym < 144) state->lens[sym++] = 8; -- while (sym < 256) state->lens[sym++] = 9; -- while (sym < 280) state->lens[sym++] = 7; -- while (sym < 288) state->lens[sym++] = 8; -- next = fixed; -- lenfix = next; -- bits = 9; -- inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); -- -- /* distance table */ -- sym = 0; -- while (sym < 32) state->lens[sym++] = 5; -- distfix = next; -- bits = 5; -- inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); -- -- /* do this just once */ -- virgin = 0; -- } --#else /* !BUILDFIXED */ --# include "inffixed.h" --#endif /* BUILDFIXED */ -- state->lencode = lenfix; -- state->lenbits = 9; -- state->distcode = distfix; -- state->distbits = 5; --} -- --#ifdef MAKEFIXED --#include -- --/* -- Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also -- defines BUILDFIXED, so the tables are built on the fly. makefixed() writes -- those tables to stdout, which would be piped to inffixed.h. A small program -- can simply call makefixed to do this: -- -- void makefixed(void); -- -- int main(void) -- { -- makefixed(); -- return 0; -- } -- -- Then that can be linked with zlib built with MAKEFIXED defined and run: -- -- a.out > inffixed.h -- */ --void makefixed() --{ -- unsigned low, size; -- struct inflate_state state; -- -- fixedtables(&state); -- puts(" /* inffixed.h -- table for decoding fixed codes"); -- puts(" * Generated automatically by makefixed()."); -- puts(" */"); -- puts(""); -- puts(" /* WARNING: this file should *not* be used by applications."); -- puts(" It is part of the implementation of this library and is"); -- puts(" subject to change. Applications should only use zlib.h."); -- puts(" */"); -- puts(""); -- size = 1U << 9; -- printf(" static const code lenfix[%u] = {", size); -- low = 0; -- for (;;) { -- if ((low % 7) == 0) printf("\n "); -- printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits, -- state.lencode[low].val); -- if (++low == size) break; -- putchar(','); -- } -- puts("\n };"); -- size = 1U << 5; -- printf("\n static const code distfix[%u] = {", size); -- low = 0; -- for (;;) { -- if ((low % 6) == 0) printf("\n "); -- printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, -- state.distcode[low].val); -- if (++low == size) break; -- putchar(','); -- } -- puts("\n };"); --} --#endif /* MAKEFIXED */ -- --/* -- Update the window with the last wsize (normally 32K) bytes written before -- returning. If window does not exist yet, create it. This is only called -- when a window is already in use, or when output has been written during this -- inflate call, but the end of the deflate stream has not been reached yet. -- It is also called to create a window for dictionary data when a dictionary -- is loaded. -- -- Providing output buffers larger than 32K to inflate() should provide a speed -- advantage, since only the last 32K of output is copied to the sliding window -- upon return from inflate(), and since all distances after the first 32K of -- output will fall in the output data, making match copies simpler and faster. -- The advantage may be dependent on the size of the processor's data caches. -- */ --local int updatewindow(strm, out) --z_streamp strm; --unsigned out; --{ -- struct inflate_state FAR *state; -- unsigned copy, dist; -- -- state = (struct inflate_state FAR *)strm->state; -- -- /* if it hasn't been done already, allocate space for the window */ -- if (state->window == Z_NULL) { -- state->window = (unsigned char FAR *) -- ZALLOC(strm, 1U << state->wbits, -- sizeof(unsigned char)); -- if (state->window == Z_NULL) return 1; -- } -- -- /* if window not in use yet, initialize */ -- if (state->wsize == 0) { -- state->wsize = 1U << state->wbits; -- state->wnext = 0; -- state->whave = 0; -- } -- -- /* copy state->wsize or less output bytes into the circular window */ -- copy = out - strm->avail_out; -- if (copy >= state->wsize) { -- zmemcpy(state->window, strm->next_out - state->wsize, state->wsize); -- state->wnext = 0; -- state->whave = state->wsize; -- } -- else { -- dist = state->wsize - state->wnext; -- if (dist > copy) dist = copy; -- zmemcpy(state->window + state->wnext, strm->next_out - copy, dist); -- copy -= dist; -- if (copy) { -- zmemcpy(state->window, strm->next_out - copy, copy); -- state->wnext = copy; -- state->whave = state->wsize; -- } -- else { -- state->wnext += dist; -- if (state->wnext == state->wsize) state->wnext = 0; -- if (state->whave < state->wsize) state->whave += dist; -- } -- } -- return 0; --} -- --/* Macros for inflate(): */ -- --/* check function to use adler32() for zlib or crc32() for gzip */ --#ifdef GUNZIP --# define UPDATE(check, buf, len) \ -- (state->flags ? crc32(check, buf, len) : adler32(check, buf, len)) --#else --# define UPDATE(check, buf, len) adler32(check, buf, len) --#endif -- --/* check macros for header crc */ --#ifdef GUNZIP --# define CRC2(check, word) \ -- do { \ -- hbuf[0] = (unsigned char)(word); \ -- hbuf[1] = (unsigned char)((word) >> 8); \ -- check = crc32(check, hbuf, 2); \ -- } while (0) -- --# define CRC4(check, word) \ -- do { \ -- hbuf[0] = (unsigned char)(word); \ -- hbuf[1] = (unsigned char)((word) >> 8); \ -- hbuf[2] = (unsigned char)((word) >> 16); \ -- hbuf[3] = (unsigned char)((word) >> 24); \ -- check = crc32(check, hbuf, 4); \ -- } while (0) --#endif -- --/* Load registers with state in inflate() for speed */ --#define LOAD() \ -- do { \ -- put = strm->next_out; \ -- left = strm->avail_out; \ -- next = strm->next_in; \ -- have = strm->avail_in; \ -- hold = state->hold; \ -- bits = state->bits; \ -- } while (0) -- --/* Restore state from registers in inflate() */ --#define RESTORE() \ -- do { \ -- strm->next_out = put; \ -- strm->avail_out = left; \ -- strm->next_in = next; \ -- strm->avail_in = have; \ -- state->hold = hold; \ -- state->bits = bits; \ -- } while (0) -- --/* Clear the input bit accumulator */ --#define INITBITS() \ -- do { \ -- hold = 0; \ -- bits = 0; \ -- } while (0) -- --/* Get a byte of input into the bit accumulator, or return from inflate() -- if there is no input available. */ --#define PULLBYTE() \ -- do { \ -- if (have == 0) goto inf_leave; \ -- have--; \ -- hold += (unsigned long)(*next++) << bits; \ -- bits += 8; \ -- } while (0) -- --/* Assure that there are at least n bits in the bit accumulator. If there is -- not enough available input to do that, then return from inflate(). */ --#define NEEDBITS(n) \ -- do { \ -- while (bits < (unsigned)(n)) \ -- PULLBYTE(); \ -- } while (0) -- --/* Return the low n bits of the bit accumulator (n < 16) */ --#define BITS(n) \ -- ((unsigned)hold & ((1U << (n)) - 1)) -- --/* Remove n bits from the bit accumulator */ --#define DROPBITS(n) \ -- do { \ -- hold >>= (n); \ -- bits -= (unsigned)(n); \ -- } while (0) -- --/* Remove zero to seven bits as needed to go to a byte boundary */ --#define BYTEBITS() \ -- do { \ -- hold >>= bits & 7; \ -- bits -= bits & 7; \ -- } while (0) -- --/* Reverse the bytes in a 32-bit value */ --#define REVERSE(q) \ -- ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ -- (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) -- --/* -- inflate() uses a state machine to process as much input data and generate as -- much output data as possible before returning. The state machine is -- structured roughly as follows: -- -- for (;;) switch (state) { -- ... -- case STATEn: -- if (not enough input data or output space to make progress) -- return; -- ... make progress ... -- state = STATEm; -- break; -- ... -- } -- -- so when inflate() is called again, the same case is attempted again, and -- if the appropriate resources are provided, the machine proceeds to the -- next state. The NEEDBITS() macro is usually the way the state evaluates -- whether it can proceed or should return. NEEDBITS() does the return if -- the requested bits are not available. The typical use of the BITS macros -- is: -- -- NEEDBITS(n); -- ... do something with BITS(n) ... -- DROPBITS(n); -- -- where NEEDBITS(n) either returns from inflate() if there isn't enough -- input left to load n bits into the accumulator, or it continues. BITS(n) -- gives the low n bits in the accumulator. When done, DROPBITS(n) drops -- the low n bits off the accumulator. INITBITS() clears the accumulator -- and sets the number of available bits to zero. BYTEBITS() discards just -- enough bits to put the accumulator on a byte boundary. After BYTEBITS() -- and a NEEDBITS(8), then BITS(8) would return the next byte in the stream. -- -- NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return -- if there is no input available. The decoding of variable length codes uses -- PULLBYTE() directly in order to pull just enough bytes to decode the next -- code, and no more. -- -- Some states loop until they get enough input, making sure that enough -- state information is maintained to continue the loop where it left off -- if NEEDBITS() returns in the loop. For example, want, need, and keep -- would all have to actually be part of the saved state in case NEEDBITS() -- returns: -- -- case STATEw: -- while (want < need) { -- NEEDBITS(n); -- keep[want++] = BITS(n); -- DROPBITS(n); -- } -- state = STATEx; -- case STATEx: -- -- As shown above, if the next state is also the next case, then the break -- is omitted. -- -- A state may also return if there is not enough output space available to -- complete that state. Those states are copying stored data, writing a -- literal byte, and copying a matching string. -- -- When returning, a "goto inf_leave" is used to update the total counters, -- update the check value, and determine whether any progress has been made -- during that inflate() call in order to return the proper return code. -- Progress is defined as a change in either strm->avail_in or strm->avail_out. -- When there is a window, goto inf_leave will update the window with the last -- output written. If a goto inf_leave occurs in the middle of decompression -- and there is no window currently, goto inf_leave will create one and copy -- output to the window for the next call of inflate(). -- -- In this implementation, the flush parameter of inflate() only affects the -- return code (per zlib.h). inflate() always writes as much as possible to -- strm->next_out, given the space available and the provided input--the effect -- documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers -- the allocation of and copying into a sliding window until necessary, which -- provides the effect documented in zlib.h for Z_FINISH when the entire input -- stream available. So the only thing the flush parameter actually does is: -- when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it -- will return Z_BUF_ERROR if it has not reached the end of the stream. -- */ -- --int ZEXPORT inflate(strm, flush) --z_streamp strm; --int flush; --{ -- struct inflate_state FAR *state; -- unsigned char FAR *next; /* next input */ -- unsigned char FAR *put; /* next output */ -- unsigned have, left; /* available input and output */ -- unsigned long hold; /* bit buffer */ -- unsigned bits; /* bits in bit buffer */ -- unsigned in, out; /* save starting available input and output */ -- unsigned copy; /* number of stored or match bytes to copy */ -- unsigned char FAR *from; /* where to copy match bytes from */ -- code here; /* current decoding table entry */ -- code last; /* parent table entry */ -- unsigned len; /* length to copy for repeats, bits to drop */ -- int ret; /* return code */ --#ifdef GUNZIP -- unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ --#endif -- static const unsigned short order[19] = /* permutation of code lengths */ -- {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; -- -- if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL || -- (strm->next_in == Z_NULL && strm->avail_in != 0)) -- return Z_STREAM_ERROR; -- -- state = (struct inflate_state FAR *)strm->state; -- if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */ -- LOAD(); -- in = have; -- out = left; -- ret = Z_OK; -- for (;;) -- switch (state->mode) { -- case HEAD: -- if (state->wrap == 0) { -- state->mode = TYPEDO; -- break; -- } -- NEEDBITS(16); --#ifdef GUNZIP -- if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */ -- state->check = crc32(0L, Z_NULL, 0); -- CRC2(state->check, hold); -- INITBITS(); -- state->mode = FLAGS; -- break; -- } -- state->flags = 0; /* expect zlib header */ -- if (state->head != Z_NULL) -- state->head->done = -1; -- if (!(state->wrap & 1) || /* check if zlib header allowed */ --#else -- if ( --#endif -- ((BITS(8) << 8) + (hold >> 8)) % 31) { -- strm->msg = (char *)"incorrect header check"; -- state->mode = BAD; -- break; -- } -- if (BITS(4) != Z_DEFLATED) { -- strm->msg = (char *)"unknown compression method"; -- state->mode = BAD; -- break; -- } -- DROPBITS(4); -- len = BITS(4) + 8; -- if (state->wbits == 0) -- state->wbits = len; -- else if (len > state->wbits) { -- strm->msg = (char *)"invalid window size"; -- state->mode = BAD; -- break; -- } -- state->dmax = 1U << len; -- Tracev((stderr, "inflate: zlib header ok\n")); -- strm->adler = state->check = adler32(0L, Z_NULL, 0); -- state->mode = hold & 0x200 ? DICTID : TYPE; -- INITBITS(); -- break; --#ifdef GUNZIP -- case FLAGS: -- NEEDBITS(16); -- state->flags = (int)(hold); -- if ((state->flags & 0xff) != Z_DEFLATED) { -- strm->msg = (char *)"unknown compression method"; -- state->mode = BAD; -- break; -- } -- if (state->flags & 0xe000) { -- strm->msg = (char *)"unknown header flags set"; -- state->mode = BAD; -- break; -- } -- if (state->head != Z_NULL) -- state->head->text = (int)((hold >> 8) & 1); -- if (state->flags & 0x0200) CRC2(state->check, hold); -- INITBITS(); -- state->mode = TIME; -- case TIME: -- NEEDBITS(32); -- if (state->head != Z_NULL) -- state->head->time = hold; -- if (state->flags & 0x0200) CRC4(state->check, hold); -- INITBITS(); -- state->mode = OS; -- case OS: -- NEEDBITS(16); -- if (state->head != Z_NULL) { -- state->head->xflags = (int)(hold & 0xff); -- state->head->os = (int)(hold >> 8); -- } -- if (state->flags & 0x0200) CRC2(state->check, hold); -- INITBITS(); -- state->mode = EXLEN; -- case EXLEN: -- if (state->flags & 0x0400) { -- NEEDBITS(16); -- state->length = (unsigned)(hold); -- if (state->head != Z_NULL) -- state->head->extra_len = (unsigned)hold; -- if (state->flags & 0x0200) CRC2(state->check, hold); -- INITBITS(); -- } -- else if (state->head != Z_NULL) -- state->head->extra = Z_NULL; -- state->mode = EXTRA; -- case EXTRA: -- if (state->flags & 0x0400) { -- copy = state->length; -- if (copy > have) copy = have; -- if (copy) { -- if (state->head != Z_NULL && -- state->head->extra != Z_NULL) { -- len = state->head->extra_len - state->length; -- zmemcpy(state->head->extra + len, next, -- len + copy > state->head->extra_max ? -- state->head->extra_max - len : copy); -- } -- if (state->flags & 0x0200) -- state->check = crc32(state->check, next, copy); -- have -= copy; -- next += copy; -- state->length -= copy; -- } -- if (state->length) goto inf_leave; -- } -- state->length = 0; -- state->mode = NAME; -- case NAME: -- if (state->flags & 0x0800) { -- if (have == 0) goto inf_leave; -- copy = 0; -- do { -- len = (unsigned)(next[copy++]); -- if (state->head != Z_NULL && -- state->head->name != Z_NULL && -- state->length < state->head->name_max) -- state->head->name[state->length++] = len; -- } while (len && copy < have); -- if (state->flags & 0x0200) -- state->check = crc32(state->check, next, copy); -- have -= copy; -- next += copy; -- if (len) goto inf_leave; -- } -- else if (state->head != Z_NULL) -- state->head->name = Z_NULL; -- state->length = 0; -- state->mode = COMMENT; -- case COMMENT: -- if (state->flags & 0x1000) { -- if (have == 0) goto inf_leave; -- copy = 0; -- do { -- len = (unsigned)(next[copy++]); -- if (state->head != Z_NULL && -- state->head->comment != Z_NULL && -- state->length < state->head->comm_max) -- state->head->comment[state->length++] = len; -- } while (len && copy < have); -- if (state->flags & 0x0200) -- state->check = crc32(state->check, next, copy); -- have -= copy; -- next += copy; -- if (len) goto inf_leave; -- } -- else if (state->head != Z_NULL) -- state->head->comment = Z_NULL; -- state->mode = HCRC; -- case HCRC: -- if (state->flags & 0x0200) { -- NEEDBITS(16); -- if (hold != (state->check & 0xffff)) { -- strm->msg = (char *)"header crc mismatch"; -- state->mode = BAD; -- break; -- } -- INITBITS(); -- } -- if (state->head != Z_NULL) { -- state->head->hcrc = (int)((state->flags >> 9) & 1); -- state->head->done = 1; -- } -- strm->adler = state->check = crc32(0L, Z_NULL, 0); -- state->mode = TYPE; -- break; --#endif -- case DICTID: -- NEEDBITS(32); -- strm->adler = state->check = REVERSE(hold); -- INITBITS(); -- state->mode = DICT; -- case DICT: -- if (state->havedict == 0) { -- RESTORE(); -- return Z_NEED_DICT; -- } -- strm->adler = state->check = adler32(0L, Z_NULL, 0); -- state->mode = TYPE; -- case TYPE: -- if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; -- case TYPEDO: -- if (state->last) { -- BYTEBITS(); -- state->mode = CHECK; -- break; -- } -- NEEDBITS(3); -- state->last = BITS(1); -- DROPBITS(1); -- switch (BITS(2)) { -- case 0: /* stored block */ -- Tracev((stderr, "inflate: stored block%s\n", -- state->last ? " (last)" : "")); -- state->mode = STORED; -- break; -- case 1: /* fixed block */ -- fixedtables(state); -- Tracev((stderr, "inflate: fixed codes block%s\n", -- state->last ? " (last)" : "")); -- state->mode = LEN_; /* decode codes */ -- if (flush == Z_TREES) { -- DROPBITS(2); -- goto inf_leave; -- } -- break; -- case 2: /* dynamic block */ -- Tracev((stderr, "inflate: dynamic codes block%s\n", -- state->last ? " (last)" : "")); -- state->mode = TABLE; -- break; -- case 3: -- strm->msg = (char *)"invalid block type"; -- state->mode = BAD; -- } -- DROPBITS(2); -- break; -- case STORED: -- BYTEBITS(); /* go to byte boundary */ -- NEEDBITS(32); -- if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { -- strm->msg = (char *)"invalid stored block lengths"; -- state->mode = BAD; -- break; -- } -- state->length = (unsigned)hold & 0xffff; -- Tracev((stderr, "inflate: stored length %u\n", -- state->length)); -- INITBITS(); -- state->mode = COPY_; -- if (flush == Z_TREES) goto inf_leave; -- case COPY_: -- state->mode = COPY; -- case COPY: -- copy = state->length; -- if (copy) { -- if (copy > have) copy = have; -- if (copy > left) copy = left; -- if (copy == 0) goto inf_leave; -- zmemcpy(put, next, copy); -- have -= copy; -- next += copy; -- left -= copy; -- put += copy; -- state->length -= copy; -- break; -- } -- Tracev((stderr, "inflate: stored end\n")); -- state->mode = TYPE; -- break; -- case TABLE: -- NEEDBITS(14); -- state->nlen = BITS(5) + 257; -- DROPBITS(5); -- state->ndist = BITS(5) + 1; -- DROPBITS(5); -- state->ncode = BITS(4) + 4; -- DROPBITS(4); --#ifndef PKZIP_BUG_WORKAROUND -- if (state->nlen > 286 || state->ndist > 30) { -- strm->msg = (char *)"too many length or distance symbols"; -- state->mode = BAD; -- break; -- } --#endif -- Tracev((stderr, "inflate: table sizes ok\n")); -- state->have = 0; -- state->mode = LENLENS; -- case LENLENS: -- while (state->have < state->ncode) { -- NEEDBITS(3); -- state->lens[order[state->have++]] = (unsigned short)BITS(3); -- DROPBITS(3); -- } -- while (state->have < 19) -- state->lens[order[state->have++]] = 0; -- state->next = state->codes; -- state->lencode = (code const FAR *)(state->next); -- state->lenbits = 7; -- ret = inflate_table(CODES, state->lens, 19, &(state->next), -- &(state->lenbits), state->work); -- if (ret) { -- strm->msg = (char *)"invalid code lengths set"; -- state->mode = BAD; -- break; -- } -- Tracev((stderr, "inflate: code lengths ok\n")); -- state->have = 0; -- state->mode = CODELENS; -- case CODELENS: -- while (state->have < state->nlen + state->ndist) { -- for (;;) { -- here = state->lencode[BITS(state->lenbits)]; -- if ((unsigned)(here.bits) <= bits) break; -- PULLBYTE(); -- } -- if (here.val < 16) { -- NEEDBITS(here.bits); -- DROPBITS(here.bits); -- state->lens[state->have++] = here.val; -- } -- else { -- if (here.val == 16) { -- NEEDBITS(here.bits + 2); -- DROPBITS(here.bits); -- if (state->have == 0) { -- strm->msg = (char *)"invalid bit length repeat"; -- state->mode = BAD; -- break; -- } -- len = state->lens[state->have - 1]; -- copy = 3 + BITS(2); -- DROPBITS(2); -- } -- else if (here.val == 17) { -- NEEDBITS(here.bits + 3); -- DROPBITS(here.bits); -- len = 0; -- copy = 3 + BITS(3); -- DROPBITS(3); -- } -- else { -- NEEDBITS(here.bits + 7); -- DROPBITS(here.bits); -- len = 0; -- copy = 11 + BITS(7); -- DROPBITS(7); -- } -- if (state->have + copy > state->nlen + state->ndist) { -- strm->msg = (char *)"invalid bit length repeat"; -- state->mode = BAD; -- break; -- } -- while (copy--) -- state->lens[state->have++] = (unsigned short)len; -- } -- } -- -- /* handle error breaks in while */ -- if (state->mode == BAD) break; -- -- /* check for end-of-block code (better have one) */ -- if (state->lens[256] == 0) { -- strm->msg = (char *)"invalid code -- missing end-of-block"; -- state->mode = BAD; -- break; -- } -- -- /* build code tables -- note: do not change the lenbits or distbits -- values here (9 and 6) without reading the comments in inftrees.h -- concerning the ENOUGH constants, which depend on those values */ -- state->next = state->codes; -- state->lencode = (code const FAR *)(state->next); -- state->lenbits = 9; -- ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), -- &(state->lenbits), state->work); -- if (ret) { -- strm->msg = (char *)"invalid literal/lengths set"; -- state->mode = BAD; -- break; -- } -- state->distcode = (code const FAR *)(state->next); -- state->distbits = 6; -- ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, -- &(state->next), &(state->distbits), state->work); -- if (ret) { -- strm->msg = (char *)"invalid distances set"; -- state->mode = BAD; -- break; -- } -- Tracev((stderr, "inflate: codes ok\n")); -- state->mode = LEN_; -- if (flush == Z_TREES) goto inf_leave; -- case LEN_: -- state->mode = LEN; -- case LEN: -- if (have >= 6 && left >= 258) { -- RESTORE(); -- inflate_fast(strm, out); -- LOAD(); -- if (state->mode == TYPE) -- state->back = -1; -- break; -- } -- state->back = 0; -- for (;;) { -- here = state->lencode[BITS(state->lenbits)]; -- if ((unsigned)(here.bits) <= bits) break; -- PULLBYTE(); -- } -- if (here.op && (here.op & 0xf0) == 0) { -- last = here; -- for (;;) { -- here = state->lencode[last.val + -- (BITS(last.bits + last.op) >> last.bits)]; -- if ((unsigned)(last.bits + here.bits) <= bits) break; -- PULLBYTE(); -- } -- DROPBITS(last.bits); -- state->back += last.bits; -- } -- DROPBITS(here.bits); -- state->back += here.bits; -- state->length = (unsigned)here.val; -- if ((int)(here.op) == 0) { -- Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? -- "inflate: literal '%c'\n" : -- "inflate: literal 0x%02x\n", here.val)); -- state->mode = LIT; -- break; -- } -- if (here.op & 32) { -- Tracevv((stderr, "inflate: end of block\n")); -- state->back = -1; -- state->mode = TYPE; -- break; -- } -- if (here.op & 64) { -- strm->msg = (char *)"invalid literal/length code"; -- state->mode = BAD; -- break; -- } -- state->extra = (unsigned)(here.op) & 15; -- state->mode = LENEXT; -- case LENEXT: -- if (state->extra) { -- NEEDBITS(state->extra); -- state->length += BITS(state->extra); -- DROPBITS(state->extra); -- state->back += state->extra; -- } -- Tracevv((stderr, "inflate: length %u\n", state->length)); -- state->was = state->length; -- state->mode = DIST; -- case DIST: -- for (;;) { -- here = state->distcode[BITS(state->distbits)]; -- if ((unsigned)(here.bits) <= bits) break; -- PULLBYTE(); -- } -- if ((here.op & 0xf0) == 0) { -- last = here; -- for (;;) { -- here = state->distcode[last.val + -- (BITS(last.bits + last.op) >> last.bits)]; -- if ((unsigned)(last.bits + here.bits) <= bits) break; -- PULLBYTE(); -- } -- DROPBITS(last.bits); -- state->back += last.bits; -- } -- DROPBITS(here.bits); -- state->back += here.bits; -- if (here.op & 64) { -- strm->msg = (char *)"invalid distance code"; -- state->mode = BAD; -- break; -- } -- state->offset = (unsigned)here.val; -- state->extra = (unsigned)(here.op) & 15; -- state->mode = DISTEXT; -- case DISTEXT: -- if (state->extra) { -- NEEDBITS(state->extra); -- state->offset += BITS(state->extra); -- DROPBITS(state->extra); -- state->back += state->extra; -- } --#ifdef INFLATE_STRICT -- if (state->offset > state->dmax) { -- strm->msg = (char *)"invalid distance too far back"; -- state->mode = BAD; -- break; -- } --#endif -- Tracevv((stderr, "inflate: distance %u\n", state->offset)); -- state->mode = MATCH; -- case MATCH: -- if (left == 0) goto inf_leave; -- copy = out - left; -- if (state->offset > copy) { /* copy from window */ -- copy = state->offset - copy; -- if (copy > state->whave) { -- if (state->sane) { -- strm->msg = (char *)"invalid distance too far back"; -- state->mode = BAD; -- break; -- } --#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR -- Trace((stderr, "inflate.c too far\n")); -- copy -= state->whave; -- if (copy > state->length) copy = state->length; -- if (copy > left) copy = left; -- left -= copy; -- state->length -= copy; -- do { -- *put++ = 0; -- } while (--copy); -- if (state->length == 0) state->mode = LEN; -- break; --#endif -- } -- if (copy > state->wnext) { -- copy -= state->wnext; -- from = state->window + (state->wsize - copy); -- } -- else -- from = state->window + (state->wnext - copy); -- if (copy > state->length) copy = state->length; -- } -- else { /* copy from output */ -- from = put - state->offset; -- copy = state->length; -- } -- if (copy > left) copy = left; -- left -= copy; -- state->length -= copy; -- do { -- *put++ = *from++; -- } while (--copy); -- if (state->length == 0) state->mode = LEN; -- break; -- case LIT: -- if (left == 0) goto inf_leave; -- *put++ = (unsigned char)(state->length); -- left--; -- state->mode = LEN; -- break; -- case CHECK: -- if (state->wrap) { -- NEEDBITS(32); -- out -= left; -- strm->total_out += out; -- state->total += out; -- if (out) -- strm->adler = state->check = -- UPDATE(state->check, put - out, out); -- out = left; -- if (( --#ifdef GUNZIP -- state->flags ? hold : --#endif -- REVERSE(hold)) != state->check) { -- strm->msg = (char *)"incorrect data check"; -- state->mode = BAD; -- break; -- } -- INITBITS(); -- Tracev((stderr, "inflate: check matches trailer\n")); -- } --#ifdef GUNZIP -- state->mode = LENGTH; -- case LENGTH: -- if (state->wrap && state->flags) { -- NEEDBITS(32); -- if (hold != (state->total & 0xffffffffUL)) { -- strm->msg = (char *)"incorrect length check"; -- state->mode = BAD; -- break; -- } -- INITBITS(); -- Tracev((stderr, "inflate: length matches trailer\n")); -- } --#endif -- state->mode = DONE; -- case DONE: -- ret = Z_STREAM_END; -- goto inf_leave; -- case BAD: -- ret = Z_DATA_ERROR; -- goto inf_leave; -- case MEM: -- return Z_MEM_ERROR; -- case SYNC: -- default: -- return Z_STREAM_ERROR; -- } -- -- /* -- Return from inflate(), updating the total counts and the check value. -- If there was no progress during the inflate() call, return a buffer -- error. Call updatewindow() to create and/or update the window state. -- Note: a memory error from inflate() is non-recoverable. -- */ -- inf_leave: -- RESTORE(); -- if (state->wsize || (state->mode < CHECK && out != strm->avail_out)) -- if (updatewindow(strm, out)) { -- state->mode = MEM; -- return Z_MEM_ERROR; -- } -- in -= strm->avail_in; -- out -= strm->avail_out; -- strm->total_in += in; -- strm->total_out += out; -- state->total += out; -- if (state->wrap && out) -- strm->adler = state->check = -- UPDATE(state->check, strm->next_out - out, out); -- strm->data_type = state->bits + (state->last ? 64 : 0) + -- (state->mode == TYPE ? 128 : 0) + -- (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0); -- if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) -- ret = Z_BUF_ERROR; -- return ret; --} -- --int ZEXPORT inflateEnd(strm) --z_streamp strm; --{ -- struct inflate_state FAR *state; -- if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) -- return Z_STREAM_ERROR; -- state = (struct inflate_state FAR *)strm->state; -- if (state->window != Z_NULL) ZFREE(strm, state->window); -- ZFREE(strm, strm->state); -- strm->state = Z_NULL; -- Tracev((stderr, "inflate: end\n")); -- return Z_OK; --} -- --int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) --z_streamp strm; --const Bytef *dictionary; --uInt dictLength; --{ -- struct inflate_state FAR *state; -- unsigned long id; -- -- /* check state */ -- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; -- state = (struct inflate_state FAR *)strm->state; -- if (state->wrap != 0 && state->mode != DICT) -- return Z_STREAM_ERROR; -- -- /* check for correct dictionary id */ -- if (state->mode == DICT) { -- id = adler32(0L, Z_NULL, 0); -- id = adler32(id, dictionary, dictLength); -- if (id != state->check) -- return Z_DATA_ERROR; -- } -- -- /* copy dictionary to window */ -- if (updatewindow(strm, strm->avail_out)) { -- state->mode = MEM; -- return Z_MEM_ERROR; -- } -- if (dictLength > state->wsize) { -- zmemcpy(state->window, dictionary + dictLength - state->wsize, -- state->wsize); -- state->whave = state->wsize; -- } -- else { -- zmemcpy(state->window + state->wsize - dictLength, dictionary, -- dictLength); -- state->whave = dictLength; -- } -- state->havedict = 1; -- Tracev((stderr, "inflate: dictionary set\n")); -- return Z_OK; --} -- --int ZEXPORT inflateGetHeader(strm, head) --z_streamp strm; --gz_headerp head; --{ -- struct inflate_state FAR *state; -- -- /* check state */ -- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; -- state = (struct inflate_state FAR *)strm->state; -- if ((state->wrap & 2) == 0) return Z_STREAM_ERROR; -- -- /* save header structure */ -- state->head = head; -- head->done = 0; -- return Z_OK; --} -- --/* -- Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found -- or when out of input. When called, *have is the number of pattern bytes -- found in order so far, in 0..3. On return *have is updated to the new -- state. If on return *have equals four, then the pattern was found and the -- return value is how many bytes were read including the last byte of the -- pattern. If *have is less than four, then the pattern has not been found -- yet and the return value is len. In the latter case, syncsearch() can be -- called again with more data and the *have state. *have is initialized to -- zero for the first call. -- */ --local unsigned syncsearch(have, buf, len) --unsigned FAR *have; --unsigned char FAR *buf; --unsigned len; --{ -- unsigned got; -- unsigned next; -- -- got = *have; -- next = 0; -- while (next < len && got < 4) { -- if ((int)(buf[next]) == (got < 2 ? 0 : 0xff)) -- got++; -- else if (buf[next]) -- got = 0; -- else -- got = 4 - got; -- next++; -- } -- *have = got; -- return next; --} -- --int ZEXPORT inflateSync(strm) --z_streamp strm; --{ -- unsigned len; /* number of bytes to look at or looked at */ -- unsigned long in, out; /* temporary to save total_in and total_out */ -- unsigned char buf[4]; /* to restore bit buffer to byte string */ -- struct inflate_state FAR *state; -- -- /* check parameters */ -- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; -- state = (struct inflate_state FAR *)strm->state; -- if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR; -- -- /* if first time, start search in bit buffer */ -- if (state->mode != SYNC) { -- state->mode = SYNC; -- state->hold <<= state->bits & 7; -- state->bits -= state->bits & 7; -- len = 0; -- while (state->bits >= 8) { -- buf[len++] = (unsigned char)(state->hold); -- state->hold >>= 8; -- state->bits -= 8; -- } -- state->have = 0; -- syncsearch(&(state->have), buf, len); -- } -- -- /* search available input */ -- len = syncsearch(&(state->have), strm->next_in, strm->avail_in); -- strm->avail_in -= len; -- strm->next_in += len; -- strm->total_in += len; -- -- /* return no joy or set up to restart inflate() on a new block */ -- if (state->have != 4) return Z_DATA_ERROR; -- in = strm->total_in; out = strm->total_out; -- inflateReset(strm); -- strm->total_in = in; strm->total_out = out; -- state->mode = TYPE; -- return Z_OK; --} -- --/* -- Returns true if inflate is currently at the end of a block generated by -- Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP -- implementation to provide an additional safety check. PPP uses -- Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored -- block. When decompressing, PPP checks that at the end of input packet, -- inflate is waiting for these length bytes. -- */ --int ZEXPORT inflateSyncPoint(strm) --z_streamp strm; --{ -- struct inflate_state FAR *state; -- -- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; -- state = (struct inflate_state FAR *)strm->state; -- return state->mode == STORED && state->bits == 0; --} -- --int ZEXPORT inflateCopy(dest, source) --z_streamp dest; --z_streamp source; --{ -- struct inflate_state FAR *state; -- struct inflate_state FAR *copy; -- unsigned char FAR *window; -- unsigned wsize; -- -- /* check input */ -- if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL || -- source->zalloc == (alloc_func)0 || source->zfree == (free_func)0) -- return Z_STREAM_ERROR; -- state = (struct inflate_state FAR *)source->state; -- -- /* allocate space */ -- copy = (struct inflate_state FAR *) -- ZALLOC(source, 1, sizeof(struct inflate_state)); -- if (copy == Z_NULL) return Z_MEM_ERROR; -- window = Z_NULL; -- if (state->window != Z_NULL) { -- window = (unsigned char FAR *) -- ZALLOC(source, 1U << state->wbits, sizeof(unsigned char)); -- if (window == Z_NULL) { -- ZFREE(source, copy); -- return Z_MEM_ERROR; -- } -- } -- -- /* copy state */ -- zmemcpy(dest, source, sizeof(z_stream)); -- zmemcpy(copy, state, sizeof(struct inflate_state)); -- if (state->lencode >= state->codes && -- state->lencode <= state->codes + ENOUGH - 1) { -- copy->lencode = copy->codes + (state->lencode - state->codes); -- copy->distcode = copy->codes + (state->distcode - state->codes); -- } -- copy->next = copy->codes + (state->next - state->codes); -- if (window != Z_NULL) { -- wsize = 1U << state->wbits; -- zmemcpy(window, state->window, wsize); -- } -- copy->window = window; -- dest->state = (struct internal_state FAR *)copy; -- return Z_OK; --} -- --int ZEXPORT inflateUndermine(strm, subvert) --z_streamp strm; --int subvert; --{ -- struct inflate_state FAR *state; -- -- if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; -- state = (struct inflate_state FAR *)strm->state; -- state->sane = !subvert; --#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR -- return Z_OK; --#else -- state->sane = 1; -- return Z_DATA_ERROR; --#endif --} -- --long ZEXPORT inflateMark(strm) --z_streamp strm; --{ -- struct inflate_state FAR *state; -- -- if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16; -- state = (struct inflate_state FAR *)strm->state; -- return ((long)(state->back) << 16) + -- (state->mode == COPY ? state->length : -- (state->mode == MATCH ? state->was - state->length : 0)); --} -diff --git a/thirdparty/zlib/inflate.h b/thirdparty/zlib/inflate.h -deleted file mode 100644 -index 95f4986..0000000 ---- a/thirdparty/zlib/inflate.h -+++ /dev/null -@@ -1,122 +0,0 @@ --/* inflate.h -- internal inflate state definition -- * Copyright (C) 1995-2009 Mark Adler -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* WARNING: this file should *not* be used by applications. It is -- part of the implementation of the compression library and is -- subject to change. Applications should only use zlib.h. -- */ -- --/* define NO_GZIP when compiling if you want to disable gzip header and -- trailer decoding by inflate(). NO_GZIP would be used to avoid linking in -- the crc code when it is not needed. For shared libraries, gzip decoding -- should be left enabled. */ --#ifndef NO_GZIP --# define GUNZIP --#endif -- --/* Possible inflate modes between inflate() calls */ --typedef enum { -- HEAD, /* i: waiting for magic header */ -- FLAGS, /* i: waiting for method and flags (gzip) */ -- TIME, /* i: waiting for modification time (gzip) */ -- OS, /* i: waiting for extra flags and operating system (gzip) */ -- EXLEN, /* i: waiting for extra length (gzip) */ -- EXTRA, /* i: waiting for extra bytes (gzip) */ -- NAME, /* i: waiting for end of file name (gzip) */ -- COMMENT, /* i: waiting for end of comment (gzip) */ -- HCRC, /* i: waiting for header crc (gzip) */ -- DICTID, /* i: waiting for dictionary check value */ -- DICT, /* waiting for inflateSetDictionary() call */ -- TYPE, /* i: waiting for type bits, including last-flag bit */ -- TYPEDO, /* i: same, but skip check to exit inflate on new block */ -- STORED, /* i: waiting for stored size (length and complement) */ -- COPY_, /* i/o: same as COPY below, but only first time in */ -- COPY, /* i/o: waiting for input or output to copy stored block */ -- TABLE, /* i: waiting for dynamic block table lengths */ -- LENLENS, /* i: waiting for code length code lengths */ -- CODELENS, /* i: waiting for length/lit and distance code lengths */ -- LEN_, /* i: same as LEN below, but only first time in */ -- LEN, /* i: waiting for length/lit/eob code */ -- LENEXT, /* i: waiting for length extra bits */ -- DIST, /* i: waiting for distance code */ -- DISTEXT, /* i: waiting for distance extra bits */ -- MATCH, /* o: waiting for output space to copy string */ -- LIT, /* o: waiting for output space to write literal */ -- CHECK, /* i: waiting for 32-bit check value */ -- LENGTH, /* i: waiting for 32-bit length (gzip) */ -- DONE, /* finished check, done -- remain here until reset */ -- BAD, /* got a data error -- remain here until reset */ -- MEM, /* got an inflate() memory error -- remain here until reset */ -- SYNC /* looking for synchronization bytes to restart inflate() */ --} inflate_mode; -- --/* -- State transitions between above modes - -- -- (most modes can go to BAD or MEM on error -- not shown for clarity) -- -- Process header: -- HEAD -> (gzip) or (zlib) or (raw) -- (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT -> -- HCRC -> TYPE -- (zlib) -> DICTID or TYPE -- DICTID -> DICT -> TYPE -- (raw) -> TYPEDO -- Read deflate blocks: -- TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK -- STORED -> COPY_ -> COPY -> TYPE -- TABLE -> LENLENS -> CODELENS -> LEN_ -- LEN_ -> LEN -- Read deflate codes in fixed or dynamic block: -- LEN -> LENEXT or LIT or TYPE -- LENEXT -> DIST -> DISTEXT -> MATCH -> LEN -- LIT -> LEN -- Process trailer: -- CHECK -> LENGTH -> DONE -- */ -- --/* state maintained between inflate() calls. Approximately 10K bytes. */ --struct inflate_state { -- inflate_mode mode; /* current inflate mode */ -- int last; /* true if processing last block */ -- int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ -- int havedict; /* true if dictionary provided */ -- int flags; /* gzip header method and flags (0 if zlib) */ -- unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */ -- unsigned long check; /* protected copy of check value */ -- unsigned long total; /* protected copy of output count */ -- gz_headerp head; /* where to save gzip header information */ -- /* sliding window */ -- unsigned wbits; /* log base 2 of requested window size */ -- unsigned wsize; /* window size or zero if not using window */ -- unsigned whave; /* valid bytes in the window */ -- unsigned wnext; /* window write index */ -- unsigned char FAR *window; /* allocated sliding window, if needed */ -- /* bit accumulator */ -- unsigned long hold; /* input bit accumulator */ -- unsigned bits; /* number of bits in "in" */ -- /* for string and stored block copying */ -- unsigned length; /* literal or length of data to copy */ -- unsigned offset; /* distance back to copy string from */ -- /* for table and code decoding */ -- unsigned extra; /* extra bits needed */ -- /* fixed and dynamic code tables */ -- code const FAR *lencode; /* starting table for length/literal codes */ -- code const FAR *distcode; /* starting table for distance codes */ -- unsigned lenbits; /* index bits for lencode */ -- unsigned distbits; /* index bits for distcode */ -- /* dynamic table building */ -- unsigned ncode; /* number of code length code lengths */ -- unsigned nlen; /* number of length code lengths */ -- unsigned ndist; /* number of distance code lengths */ -- unsigned have; /* number of code lengths in lens[] */ -- code FAR *next; /* next available space in codes[] */ -- unsigned short lens[320]; /* temporary storage for code lengths */ -- unsigned short work[288]; /* work area for code table building */ -- code codes[ENOUGH]; /* space for code tables */ -- int sane; /* if false, allow invalid distance too far */ -- int back; /* bits back of last unprocessed length/lit */ -- unsigned was; /* initial length of match */ --}; -diff --git a/thirdparty/zlib/inftrees.c b/thirdparty/zlib/inftrees.c -deleted file mode 100644 -index 11e9c52..0000000 ---- a/thirdparty/zlib/inftrees.c -+++ /dev/null -@@ -1,330 +0,0 @@ --/* inftrees.c -- generate Huffman trees for efficient decoding -- * Copyright (C) 1995-2010 Mark Adler -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --#include "zutil.h" --#include "inftrees.h" -- --#define MAXBITS 15 -- --const char inflate_copyright[] = -- " inflate 1.2.5 Copyright 1995-2010 Mark Adler "; --/* -- If you use the zlib library in a product, an acknowledgment is welcome -- in the documentation of your product. If for some reason you cannot -- include such an acknowledgment, I would appreciate that you keep this -- copyright string in the executable of your product. -- */ -- --/* -- Build a set of tables to decode the provided canonical Huffman code. -- The code lengths are lens[0..codes-1]. The result starts at *table, -- whose indices are 0..2^bits-1. work is a writable array of at least -- lens shorts, which is used as a work area. type is the type of code -- to be generated, CODES, LENS, or DISTS. On return, zero is success, -- -1 is an invalid code, and +1 means that ENOUGH isn't enough. table -- on return points to the next available entry's address. bits is the -- requested root table index bits, and on return it is the actual root -- table index bits. It will differ if the request is greater than the -- longest code or if it is less than the shortest code. -- */ --int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work) --codetype type; --unsigned short FAR *lens; --unsigned codes; --code FAR * FAR *table; --unsigned FAR *bits; --unsigned short FAR *work; --{ -- unsigned len; /* a code's length in bits */ -- unsigned sym; /* index of code symbols */ -- unsigned min, max; /* minimum and maximum code lengths */ -- unsigned root; /* number of index bits for root table */ -- unsigned curr; /* number of index bits for current table */ -- unsigned drop; /* code bits to drop for sub-table */ -- int left; /* number of prefix codes available */ -- unsigned used; /* code entries in table used */ -- unsigned huff; /* Huffman code */ -- unsigned incr; /* for incrementing code, index */ -- unsigned fill; /* index for replicating entries */ -- unsigned low; /* low bits for current root entry */ -- unsigned mask; /* mask for low root bits */ -- code here; /* table entry for duplication */ -- code FAR *next; /* next available space in table */ -- const unsigned short FAR *base; /* base value table to use */ -- const unsigned short FAR *extra; /* extra bits table to use */ -- int end; /* use base and extra for symbol > end */ -- unsigned short count[MAXBITS+1]; /* number of codes of each length */ -- unsigned short offs[MAXBITS+1]; /* offsets in table for each length */ -- static const unsigned short lbase[31] = { /* Length codes 257..285 base */ -- 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, -- 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; -- static const unsigned short lext[31] = { /* Length codes 257..285 extra */ -- 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, -- 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 73, 195}; -- static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ -- 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, -- 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, -- 8193, 12289, 16385, 24577, 0, 0}; -- static const unsigned short dext[32] = { /* Distance codes 0..29 extra */ -- 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, -- 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, -- 28, 28, 29, 29, 64, 64}; -- -- /* -- Process a set of code lengths to create a canonical Huffman code. The -- code lengths are lens[0..codes-1]. Each length corresponds to the -- symbols 0..codes-1. The Huffman code is generated by first sorting the -- symbols by length from short to long, and retaining the symbol order -- for codes with equal lengths. Then the code starts with all zero bits -- for the first code of the shortest length, and the codes are integer -- increments for the same length, and zeros are appended as the length -- increases. For the deflate format, these bits are stored backwards -- from their more natural integer increment ordering, and so when the -- decoding tables are built in the large loop below, the integer codes -- are incremented backwards. -- -- This routine assumes, but does not check, that all of the entries in -- lens[] are in the range 0..MAXBITS. The caller must assure this. -- 1..MAXBITS is interpreted as that code length. zero means that that -- symbol does not occur in this code. -- -- The codes are sorted by computing a count of codes for each length, -- creating from that a table of starting indices for each length in the -- sorted table, and then entering the symbols in order in the sorted -- table. The sorted table is work[], with that space being provided by -- the caller. -- -- The length counts are used for other purposes as well, i.e. finding -- the minimum and maximum length codes, determining if there are any -- codes at all, checking for a valid set of lengths, and looking ahead -- at length counts to determine sub-table sizes when building the -- decoding tables. -- */ -- -- /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ -- for (len = 0; len <= MAXBITS; len++) -- count[len] = 0; -- for (sym = 0; sym < codes; sym++) -- count[lens[sym]]++; -- -- /* bound code lengths, force root to be within code lengths */ -- root = *bits; -- for (max = MAXBITS; max >= 1; max--) -- if (count[max] != 0) break; -- if (root > max) root = max; -- if (max == 0) { /* no symbols to code at all */ -- here.op = (unsigned char)64; /* invalid code marker */ -- here.bits = (unsigned char)1; -- here.val = (unsigned short)0; -- *(*table)++ = here; /* make a table to force an error */ -- *(*table)++ = here; -- *bits = 1; -- return 0; /* no symbols, but wait for decoding to report error */ -- } -- for (min = 1; min < max; min++) -- if (count[min] != 0) break; -- if (root < min) root = min; -- -- /* check for an over-subscribed or incomplete set of lengths */ -- left = 1; -- for (len = 1; len <= MAXBITS; len++) { -- left <<= 1; -- left -= count[len]; -- if (left < 0) return -1; /* over-subscribed */ -- } -- if (left > 0 && (type == CODES || max != 1)) -- return -1; /* incomplete set */ -- -- /* generate offsets into symbol table for each length for sorting */ -- offs[1] = 0; -- for (len = 1; len < MAXBITS; len++) -- offs[len + 1] = offs[len] + count[len]; -- -- /* sort symbols by length, by symbol order within each length */ -- for (sym = 0; sym < codes; sym++) -- if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym; -- -- /* -- Create and fill in decoding tables. In this loop, the table being -- filled is at next and has curr index bits. The code being used is huff -- with length len. That code is converted to an index by dropping drop -- bits off of the bottom. For codes where len is less than drop + curr, -- those top drop + curr - len bits are incremented through all values to -- fill the table with replicated entries. -- -- root is the number of index bits for the root table. When len exceeds -- root, sub-tables are created pointed to by the root entry with an index -- of the low root bits of huff. This is saved in low to check for when a -- new sub-table should be started. drop is zero when the root table is -- being filled, and drop is root when sub-tables are being filled. -- -- When a new sub-table is needed, it is necessary to look ahead in the -- code lengths to determine what size sub-table is needed. The length -- counts are used for this, and so count[] is decremented as codes are -- entered in the tables. -- -- used keeps track of how many table entries have been allocated from the -- provided *table space. It is checked for LENS and DIST tables against -- the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in -- the initial root table size constants. See the comments in inftrees.h -- for more information. -- -- sym increments through all symbols, and the loop terminates when -- all codes of length max, i.e. all codes, have been processed. This -- routine permits incomplete codes, so another loop after this one fills -- in the rest of the decoding tables with invalid code markers. -- */ -- -- /* set up for code type */ -- switch (type) { -- case CODES: -- base = extra = work; /* dummy value--not used */ -- end = 19; -- break; -- case LENS: -- base = lbase; -- base -= 257; -- extra = lext; -- extra -= 257; -- end = 256; -- break; -- default: /* DISTS */ -- base = dbase; -- extra = dext; -- end = -1; -- } -- -- /* initialize state for loop */ -- huff = 0; /* starting code */ -- sym = 0; /* starting code symbol */ -- len = min; /* starting code length */ -- next = *table; /* current table to fill in */ -- curr = root; /* current table index bits */ -- drop = 0; /* current bits to drop from code for index */ -- low = (unsigned)(-1); /* trigger new sub-table when len > root */ -- used = 1U << root; /* use root table entries */ -- mask = used - 1; /* mask for comparing low */ -- -- /* check available table space */ -- if ((type == LENS && used >= ENOUGH_LENS) || -- (type == DISTS && used >= ENOUGH_DISTS)) -- return 1; -- -- /* process all codes and make table entries */ -- for (;;) { -- /* create table entry */ -- here.bits = (unsigned char)(len - drop); -- if ((int)(work[sym]) < end) { -- here.op = (unsigned char)0; -- here.val = work[sym]; -- } -- else if ((int)(work[sym]) > end) { -- here.op = (unsigned char)(extra[work[sym]]); -- here.val = base[work[sym]]; -- } -- else { -- here.op = (unsigned char)(32 + 64); /* end of block */ -- here.val = 0; -- } -- -- /* replicate for those indices with low len bits equal to huff */ -- incr = 1U << (len - drop); -- fill = 1U << curr; -- min = fill; /* save offset to next table */ -- do { -- fill -= incr; -- next[(huff >> drop) + fill] = here; -- } while (fill != 0); -- -- /* backwards increment the len-bit code huff */ -- incr = 1U << (len - 1); -- while (huff & incr) -- incr >>= 1; -- if (incr != 0) { -- huff &= incr - 1; -- huff += incr; -- } -- else -- huff = 0; -- -- /* go to next symbol, update count, len */ -- sym++; -- if (--(count[len]) == 0) { -- if (len == max) break; -- len = lens[work[sym]]; -- } -- -- /* create new sub-table if needed */ -- if (len > root && (huff & mask) != low) { -- /* if first time, transition to sub-tables */ -- if (drop == 0) -- drop = root; -- -- /* increment past last table */ -- next += min; /* here min is 1 << curr */ -- -- /* determine length of next table */ -- curr = len - drop; -- left = (int)(1 << curr); -- while (curr + drop < max) { -- left -= count[curr + drop]; -- if (left <= 0) break; -- curr++; -- left <<= 1; -- } -- -- /* check for enough space */ -- used += 1U << curr; -- if ((type == LENS && used >= ENOUGH_LENS) || -- (type == DISTS && used >= ENOUGH_DISTS)) -- return 1; -- -- /* point entry in root table to sub-table */ -- low = huff & mask; -- (*table)[low].op = (unsigned char)curr; -- (*table)[low].bits = (unsigned char)root; -- (*table)[low].val = (unsigned short)(next - *table); -- } -- } -- -- /* -- Fill in rest of table for incomplete codes. This loop is similar to the -- loop above in incrementing huff for table indices. It is assumed that -- len is equal to curr + drop, so there is no loop needed to increment -- through high index bits. When the current sub-table is filled, the loop -- drops back to the root table to fill in any remaining entries there. -- */ -- here.op = (unsigned char)64; /* invalid code marker */ -- here.bits = (unsigned char)(len - drop); -- here.val = (unsigned short)0; -- while (huff != 0) { -- /* when done with sub-table, drop back to root table */ -- if (drop != 0 && (huff & mask) != low) { -- drop = 0; -- len = root; -- next = *table; -- here.bits = (unsigned char)len; -- } -- -- /* put invalid code marker in table */ -- next[huff >> drop] = here; -- -- /* backwards increment the len-bit code huff */ -- incr = 1U << (len - 1); -- while (huff & incr) -- incr >>= 1; -- if (incr != 0) { -- huff &= incr - 1; -- huff += incr; -- } -- else -- huff = 0; -- } -- -- /* set return parameters */ -- *table += used; -- *bits = root; -- return 0; --} -diff --git a/thirdparty/zlib/inftrees.h b/thirdparty/zlib/inftrees.h -deleted file mode 100644 -index baa53a0..0000000 ---- a/thirdparty/zlib/inftrees.h -+++ /dev/null -@@ -1,62 +0,0 @@ --/* inftrees.h -- header to use inftrees.c -- * Copyright (C) 1995-2005, 2010 Mark Adler -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* WARNING: this file should *not* be used by applications. It is -- part of the implementation of the compression library and is -- subject to change. Applications should only use zlib.h. -- */ -- --/* Structure for decoding tables. Each entry provides either the -- information needed to do the operation requested by the code that -- indexed that table entry, or it provides a pointer to another -- table that indexes more bits of the code. op indicates whether -- the entry is a pointer to another table, a literal, a length or -- distance, an end-of-block, or an invalid code. For a table -- pointer, the low four bits of op is the number of index bits of -- that table. For a length or distance, the low four bits of op -- is the number of extra bits to get after the code. bits is -- the number of bits in this code or part of the code to drop off -- of the bit buffer. val is the actual byte to output in the case -- of a literal, the base length or distance, or the offset from -- the current table to the next table. Each entry is four bytes. */ --typedef struct { -- unsigned char op; /* operation, extra bits, table bits */ -- unsigned char bits; /* bits in this part of the code */ -- unsigned short val; /* offset in table or code value */ --} code; -- --/* op values as set by inflate_table(): -- 00000000 - literal -- 0000tttt - table link, tttt != 0 is the number of table index bits -- 0001eeee - length or distance, eeee is the number of extra bits -- 01100000 - end of block -- 01000000 - invalid code -- */ -- --/* Maximum size of the dynamic table. The maximum number of code structures is -- 1444, which is the sum of 852 for literal/length codes and 592 for distance -- codes. These values were found by exhaustive searches using the program -- examples/enough.c found in the zlib distribtution. The arguments to that -- program are the number of symbols, the initial root table size, and the -- maximum bit length of a code. "enough 286 9 15" for literal/length codes -- returns returns 852, and "enough 30 6 15" for distance codes returns 592. -- The initial root table size (9 or 6) is found in the fifth argument of the -- inflate_table() calls in inflate.c and infback.c. If the root table size is -- changed, then these maximum sizes would be need to be recalculated and -- updated. */ --#define ENOUGH_LENS 852 --#define ENOUGH_DISTS 592 --#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS) -- --/* Type of code to build for inflate_table() */ --typedef enum { -- CODES, -- LENS, -- DISTS --} codetype; -- --int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens, -- unsigned codes, code FAR * FAR *table, -- unsigned FAR *bits, unsigned short FAR *work)); -diff --git a/thirdparty/zlib/minigzip.c b/thirdparty/zlib/minigzip.c -deleted file mode 100644 -index 9825ccc..0000000 ---- a/thirdparty/zlib/minigzip.c -+++ /dev/null -@@ -1,440 +0,0 @@ --/* minigzip.c -- simulate gzip using the zlib compression library -- * Copyright (C) 1995-2006, 2010 Jean-loup Gailly. -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* -- * minigzip is a minimal implementation of the gzip utility. This is -- * only an example of using zlib and isn't meant to replace the -- * full-featured gzip. No attempt is made to deal with file systems -- * limiting names to 14 or 8+3 characters, etc... Error checking is -- * very limited. So use minigzip only for testing; use gzip for the -- * real thing. On MSDOS, use only on file names without extension -- * or in pipe mode. -- */ -- --/* @(#) $Id$ */ -- --#include "zlib.h" --#include -- --#ifdef STDC --# include --# include --#endif -- --#ifdef USE_MMAP --# include --# include --# include --#endif -- --#if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__) --# include --# include --# ifdef UNDER_CE --# include --# endif --# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY) --#else --# define SET_BINARY_MODE(file) --#endif -- --#ifdef VMS --# define unlink delete --# define GZ_SUFFIX "-gz" --#endif --#ifdef RISCOS --# define unlink remove --# define GZ_SUFFIX "-gz" --# define fileno(file) file->__file --#endif --#if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os --# include /* for fileno */ --#endif -- --#if !defined(Z_HAVE_UNISTD_H) && !defined(_LARGEFILE64_SOURCE) --#ifndef WIN32 /* unlink already in stdio.h for WIN32 */ -- extern int unlink OF((const char *)); --#endif --#endif -- --#if defined(UNDER_CE) --# include --# define perror(s) pwinerror(s) -- --/* Map the Windows error number in ERROR to a locale-dependent error -- message string and return a pointer to it. Typically, the values -- for ERROR come from GetLastError. -- -- The string pointed to shall not be modified by the application, -- but may be overwritten by a subsequent call to strwinerror -- -- The strwinerror function does not change the current setting -- of GetLastError. */ -- --static char *strwinerror (error) -- DWORD error; --{ -- static char buf[1024]; -- -- wchar_t *msgbuf; -- DWORD lasterr = GetLastError(); -- DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM -- | FORMAT_MESSAGE_ALLOCATE_BUFFER, -- NULL, -- error, -- 0, /* Default language */ -- (LPVOID)&msgbuf, -- 0, -- NULL); -- if (chars != 0) { -- /* If there is an \r\n appended, zap it. */ -- if (chars >= 2 -- && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') { -- chars -= 2; -- msgbuf[chars] = 0; -- } -- -- if (chars > sizeof (buf) - 1) { -- chars = sizeof (buf) - 1; -- msgbuf[chars] = 0; -- } -- -- wcstombs(buf, msgbuf, chars + 1); -- LocalFree(msgbuf); -- } -- else { -- sprintf(buf, "unknown win32 error (%ld)", error); -- } -- -- SetLastError(lasterr); -- return buf; --} -- --static void pwinerror (s) -- const char *s; --{ -- if (s && *s) -- fprintf(stderr, "%s: %s\n", s, strwinerror(GetLastError ())); -- else -- fprintf(stderr, "%s\n", strwinerror(GetLastError ())); --} -- --#endif /* UNDER_CE */ -- --#ifndef GZ_SUFFIX --# define GZ_SUFFIX ".gz" --#endif --#define SUFFIX_LEN (sizeof(GZ_SUFFIX)-1) -- --#define BUFLEN 16384 --#define MAX_NAME_LEN 1024 -- --#ifdef MAXSEG_64K --# define local static -- /* Needed for systems with limitation on stack size. */ --#else --# define local --#endif -- --char *prog; -- --void error OF((const char *msg)); --void gz_compress OF((FILE *in, gzFile out)); --#ifdef USE_MMAP --int gz_compress_mmap OF((FILE *in, gzFile out)); --#endif --void gz_uncompress OF((gzFile in, FILE *out)); --void file_compress OF((char *file, char *mode)); --void file_uncompress OF((char *file)); --int main OF((int argc, char *argv[])); -- --/* =========================================================================== -- * Display error message and exit -- */ --void error(msg) -- const char *msg; --{ -- fprintf(stderr, "%s: %s\n", prog, msg); -- exit(1); --} -- --/* =========================================================================== -- * Compress input to output then close both files. -- */ -- --void gz_compress(in, out) -- FILE *in; -- gzFile out; --{ -- local char buf[BUFLEN]; -- int len; -- int err; -- --#ifdef USE_MMAP -- /* Try first compressing with mmap. If mmap fails (minigzip used in a -- * pipe), use the normal fread loop. -- */ -- if (gz_compress_mmap(in, out) == Z_OK) return; --#endif -- for (;;) { -- len = (int)fread(buf, 1, sizeof(buf), in); -- if (ferror(in)) { -- perror("fread"); -- exit(1); -- } -- if (len == 0) break; -- -- if (gzwrite(out, buf, (unsigned)len) != len) error(gzerror(out, &err)); -- } -- fclose(in); -- if (gzclose(out) != Z_OK) error("failed gzclose"); --} -- --#ifdef USE_MMAP /* MMAP version, Miguel Albrecht */ -- --/* Try compressing the input file at once using mmap. Return Z_OK if -- * if success, Z_ERRNO otherwise. -- */ --int gz_compress_mmap(in, out) -- FILE *in; -- gzFile out; --{ -- int len; -- int err; -- int ifd = fileno(in); -- caddr_t buf; /* mmap'ed buffer for the entire input file */ -- off_t buf_len; /* length of the input file */ -- struct stat sb; -- -- /* Determine the size of the file, needed for mmap: */ -- if (fstat(ifd, &sb) < 0) return Z_ERRNO; -- buf_len = sb.st_size; -- if (buf_len <= 0) return Z_ERRNO; -- -- /* Now do the actual mmap: */ -- buf = mmap((caddr_t) 0, buf_len, PROT_READ, MAP_SHARED, ifd, (off_t)0); -- if (buf == (caddr_t)(-1)) return Z_ERRNO; -- -- /* Compress the whole file at once: */ -- len = gzwrite(out, (char *)buf, (unsigned)buf_len); -- -- if (len != (int)buf_len) error(gzerror(out, &err)); -- -- munmap(buf, buf_len); -- fclose(in); -- if (gzclose(out) != Z_OK) error("failed gzclose"); -- return Z_OK; --} --#endif /* USE_MMAP */ -- --/* =========================================================================== -- * Uncompress input to output then close both files. -- */ --void gz_uncompress(in, out) -- gzFile in; -- FILE *out; --{ -- local char buf[BUFLEN]; -- int len; -- int err; -- -- for (;;) { -- len = gzread(in, buf, sizeof(buf)); -- if (len < 0) error (gzerror(in, &err)); -- if (len == 0) break; -- -- if ((int)fwrite(buf, 1, (unsigned)len, out) != len) { -- error("failed fwrite"); -- } -- } -- if (fclose(out)) error("failed fclose"); -- -- if (gzclose(in) != Z_OK) error("failed gzclose"); --} -- -- --/* =========================================================================== -- * Compress the given file: create a corresponding .gz file and remove the -- * original. -- */ --void file_compress(file, mode) -- char *file; -- char *mode; --{ -- local char outfile[MAX_NAME_LEN]; -- FILE *in; -- gzFile out; -- -- if (strlen(file) + strlen(GZ_SUFFIX) >= sizeof(outfile)) { -- fprintf(stderr, "%s: filename too long\n", prog); -- exit(1); -- } -- -- strcpy(outfile, file); -- strcat(outfile, GZ_SUFFIX); -- -- in = fopen(file, "rb"); -- if (in == NULL) { -- perror(file); -- exit(1); -- } -- out = gzopen(outfile, mode); -- if (out == NULL) { -- fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile); -- exit(1); -- } -- gz_compress(in, out); -- -- unlink(file); --} -- -- --/* =========================================================================== -- * Uncompress the given file and remove the original. -- */ --void file_uncompress(file) -- char *file; --{ -- local char buf[MAX_NAME_LEN]; -- char *infile, *outfile; -- FILE *out; -- gzFile in; -- size_t len = strlen(file); -- -- if (len + strlen(GZ_SUFFIX) >= sizeof(buf)) { -- fprintf(stderr, "%s: filename too long\n", prog); -- exit(1); -- } -- -- strcpy(buf, file); -- -- if (len > SUFFIX_LEN && strcmp(file+len-SUFFIX_LEN, GZ_SUFFIX) == 0) { -- infile = file; -- outfile = buf; -- outfile[len-3] = '\0'; -- } else { -- outfile = file; -- infile = buf; -- strcat(infile, GZ_SUFFIX); -- } -- in = gzopen(infile, "rb"); -- if (in == NULL) { -- fprintf(stderr, "%s: can't gzopen %s\n", prog, infile); -- exit(1); -- } -- out = fopen(outfile, "wb"); -- if (out == NULL) { -- perror(file); -- exit(1); -- } -- -- gz_uncompress(in, out); -- -- unlink(infile); --} -- -- --/* =========================================================================== -- * Usage: minigzip [-c] [-d] [-f] [-h] [-r] [-1 to -9] [files...] -- * -c : write to standard output -- * -d : decompress -- * -f : compress with Z_FILTERED -- * -h : compress with Z_HUFFMAN_ONLY -- * -r : compress with Z_RLE -- * -1 to -9 : compression level -- */ -- --int main(argc, argv) -- int argc; -- char *argv[]; --{ -- int copyout = 0; -- int uncompr = 0; -- gzFile file; -- char *bname, outmode[20]; -- -- strcpy(outmode, "wb6 "); -- -- prog = argv[0]; -- bname = strrchr(argv[0], '/'); -- if (bname) -- bname++; -- else -- bname = argv[0]; -- argc--, argv++; -- -- if (!strcmp(bname, "gunzip")) -- uncompr = 1; -- else if (!strcmp(bname, "zcat")) -- copyout = uncompr = 1; -- -- while (argc > 0) { -- if (strcmp(*argv, "-c") == 0) -- copyout = 1; -- else if (strcmp(*argv, "-d") == 0) -- uncompr = 1; -- else if (strcmp(*argv, "-f") == 0) -- outmode[3] = 'f'; -- else if (strcmp(*argv, "-h") == 0) -- outmode[3] = 'h'; -- else if (strcmp(*argv, "-r") == 0) -- outmode[3] = 'R'; -- else if ((*argv)[0] == '-' && (*argv)[1] >= '1' && (*argv)[1] <= '9' && -- (*argv)[2] == 0) -- outmode[2] = (*argv)[1]; -- else -- break; -- argc--, argv++; -- } -- if (outmode[3] == ' ') -- outmode[3] = 0; -- if (argc == 0) { -- SET_BINARY_MODE(stdin); -- SET_BINARY_MODE(stdout); -- if (uncompr) { -- file = gzdopen(fileno(stdin), "rb"); -- if (file == NULL) error("can't gzdopen stdin"); -- gz_uncompress(file, stdout); -- } else { -- file = gzdopen(fileno(stdout), outmode); -- if (file == NULL) error("can't gzdopen stdout"); -- gz_compress(stdin, file); -- } -- } else { -- if (copyout) { -- SET_BINARY_MODE(stdout); -- } -- do { -- if (uncompr) { -- if (copyout) { -- file = gzopen(*argv, "rb"); -- if (file == NULL) -- fprintf(stderr, "%s: can't gzopen %s\n", prog, *argv); -- else -- gz_uncompress(file, stdout); -- } else { -- file_uncompress(*argv); -- } -- } else { -- if (copyout) { -- FILE * in = fopen(*argv, "rb"); -- -- if (in == NULL) { -- perror(*argv); -- } else { -- file = gzdopen(fileno(stdout), outmode); -- if (file == NULL) error("can't gzdopen stdout"); -- -- gz_compress(in, file); -- } -- -- } else { -- file_compress(*argv, outmode); -- } -- } -- } while (argv++, --argc); -- } -- return 0; --} -diff --git a/thirdparty/zlib/trees.c b/thirdparty/zlib/trees.c -deleted file mode 100644 -index 56e9bb1..0000000 ---- a/thirdparty/zlib/trees.c -+++ /dev/null -@@ -1,1244 +0,0 @@ --/* trees.c -- output deflated data using Huffman coding -- * Copyright (C) 1995-2010 Jean-loup Gailly -- * detect_data_type() function provided freely by Cosmin Truta, 2006 -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* -- * ALGORITHM -- * -- * The "deflation" process uses several Huffman trees. The more -- * common source values are represented by shorter bit sequences. -- * -- * Each code tree is stored in a compressed form which is itself -- * a Huffman encoding of the lengths of all the code strings (in -- * ascending order by source values). The actual code strings are -- * reconstructed from the lengths in the inflate process, as described -- * in the deflate specification. -- * -- * REFERENCES -- * -- * Deutsch, L.P.,"'Deflate' Compressed Data Format Specification". -- * Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc -- * -- * Storer, James A. -- * Data Compression: Methods and Theory, pp. 49-50. -- * Computer Science Press, 1988. ISBN 0-7167-8156-5. -- * -- * Sedgewick, R. -- * Algorithms, p290. -- * Addison-Wesley, 1983. ISBN 0-201-06672-6. -- */ -- --/* @(#) $Id$ */ -- --/* #define GEN_TREES_H */ -- --#include "deflate.h" -- --#ifdef DEBUG --# include --#endif -- --/* =========================================================================== -- * Constants -- */ -- --#define MAX_BL_BITS 7 --/* Bit length codes must not exceed MAX_BL_BITS bits */ -- --#define END_BLOCK 256 --/* end of block literal code */ -- --#define REP_3_6 16 --/* repeat previous bit length 3-6 times (2 bits of repeat count) */ -- --#define REPZ_3_10 17 --/* repeat a zero length 3-10 times (3 bits of repeat count) */ -- --#define REPZ_11_138 18 --/* repeat a zero length 11-138 times (7 bits of repeat count) */ -- --local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */ -- = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0}; -- --local const int extra_dbits[D_CODES] /* extra bits for each distance code */ -- = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; -- --local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */ -- = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7}; -- --local const uch bl_order[BL_CODES] -- = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15}; --/* The lengths of the bit length codes are sent in order of decreasing -- * probability, to avoid transmitting the lengths for unused bit length codes. -- */ -- --#define Buf_size (8 * 2*sizeof(char)) --/* Number of bits used within bi_buf. (bi_buf might be implemented on -- * more than 16 bits on some systems.) -- */ -- --/* =========================================================================== -- * Local data. These are initialized only once. -- */ -- --#define DIST_CODE_LEN 512 /* see definition of array dist_code below */ -- --#if defined(GEN_TREES_H) || !defined(STDC) --/* non ANSI compilers may not accept trees.h */ -- --local ct_data static_ltree[L_CODES+2]; --/* The static literal tree. Since the bit lengths are imposed, there is no -- * need for the L_CODES extra codes used during heap construction. However -- * The codes 286 and 287 are needed to build a canonical tree (see _tr_init -- * below). -- */ -- --local ct_data static_dtree[D_CODES]; --/* The static distance tree. (Actually a trivial tree since all codes use -- * 5 bits.) -- */ -- --uch _dist_code[DIST_CODE_LEN]; --/* Distance codes. The first 256 values correspond to the distances -- * 3 .. 258, the last 256 values correspond to the top 8 bits of -- * the 15 bit distances. -- */ -- --uch _length_code[MAX_MATCH-MIN_MATCH+1]; --/* length code for each normalized match length (0 == MIN_MATCH) */ -- --local int base_length[LENGTH_CODES]; --/* First normalized length for each code (0 = MIN_MATCH) */ -- --local int base_dist[D_CODES]; --/* First normalized distance for each code (0 = distance of 1) */ -- --#else --# include "trees.h" --#endif /* GEN_TREES_H */ -- --struct static_tree_desc_s { -- const ct_data *static_tree; /* static tree or NULL */ -- const intf *extra_bits; /* extra bits for each code or NULL */ -- int extra_base; /* base index for extra_bits */ -- int elems; /* max number of elements in the tree */ -- int max_length; /* max bit length for the codes */ --}; -- --local static_tree_desc static_l_desc = --{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS}; -- --local static_tree_desc static_d_desc = --{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS}; -- --local static_tree_desc static_bl_desc = --{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS}; -- --/* =========================================================================== -- * Local (static) routines in this file. -- */ -- --local void tr_static_init OF((void)); --local void init_block OF((deflate_state *s)); --local void pqdownheap OF((deflate_state *s, ct_data *tree, int k)); --local void gen_bitlen OF((deflate_state *s, tree_desc *desc)); --local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count)); --local void build_tree OF((deflate_state *s, tree_desc *desc)); --local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code)); --local void send_tree OF((deflate_state *s, ct_data *tree, int max_code)); --local int build_bl_tree OF((deflate_state *s)); --local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, -- int blcodes)); --local void compress_block OF((deflate_state *s, ct_data *ltree, -- ct_data *dtree)); --local int detect_data_type OF((deflate_state *s)); --local unsigned bi_reverse OF((unsigned value, int length)); --local void bi_windup OF((deflate_state *s)); --local void bi_flush OF((deflate_state *s)); --local void copy_block OF((deflate_state *s, charf *buf, unsigned len, -- int header)); -- --#ifdef GEN_TREES_H --local void gen_trees_header OF((void)); --#endif -- --#ifndef DEBUG --# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len) -- /* Send a code of the given tree. c and tree must not have side effects */ -- --#else /* DEBUG */ --# define send_code(s, c, tree) \ -- { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \ -- send_bits(s, tree[c].Code, tree[c].Len); } --#endif -- --/* =========================================================================== -- * Output a short LSB first on the stream. -- * IN assertion: there is enough room in pendingBuf. -- */ --#define put_short(s, w) { \ -- put_byte(s, (uch)((w) & 0xff)); \ -- put_byte(s, (uch)((ush)(w) >> 8)); \ --} -- --/* =========================================================================== -- * Send a value on a given number of bits. -- * IN assertion: length <= 16 and value fits in length bits. -- */ --#ifdef DEBUG --local void send_bits OF((deflate_state *s, int value, int length)); -- --local void send_bits(s, value, length) -- deflate_state *s; -- int value; /* value to send */ -- int length; /* number of bits */ --{ -- Tracevv((stderr," l %2d v %4x ", length, value)); -- Assert(length > 0 && length <= 15, "invalid length"); -- s->bits_sent += (ulg)length; -- -- /* If not enough room in bi_buf, use (valid) bits from bi_buf and -- * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) -- * unused bits in value. -- */ -- if (s->bi_valid > (int)Buf_size - length) { -- s->bi_buf |= (ush)value << s->bi_valid; -- put_short(s, s->bi_buf); -- s->bi_buf = (ush)value >> (Buf_size - s->bi_valid); -- s->bi_valid += length - Buf_size; -- } else { -- s->bi_buf |= (ush)value << s->bi_valid; -- s->bi_valid += length; -- } --} --#else /* !DEBUG */ -- --#define send_bits(s, value, length) \ --{ int len = length;\ -- if (s->bi_valid > (int)Buf_size - len) {\ -- int val = value;\ -- s->bi_buf |= (ush)val << s->bi_valid;\ -- put_short(s, s->bi_buf);\ -- s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\ -- s->bi_valid += len - Buf_size;\ -- } else {\ -- s->bi_buf |= (ush)(value) << s->bi_valid;\ -- s->bi_valid += len;\ -- }\ --} --#endif /* DEBUG */ -- -- --/* the arguments must not have side effects */ -- --/* =========================================================================== -- * Initialize the various 'constant' tables. -- */ --local void tr_static_init() --{ --#if defined(GEN_TREES_H) || !defined(STDC) -- static int static_init_done = 0; -- int n; /* iterates over tree elements */ -- int bits; /* bit counter */ -- int length; /* length value */ -- int code; /* code value */ -- int dist; /* distance index */ -- ush bl_count[MAX_BITS+1]; -- /* number of codes at each bit length for an optimal tree */ -- -- if (static_init_done) return; -- -- /* For some embedded targets, global variables are not initialized: */ --#ifdef NO_INIT_GLOBAL_POINTERS -- static_l_desc.static_tree = static_ltree; -- static_l_desc.extra_bits = extra_lbits; -- static_d_desc.static_tree = static_dtree; -- static_d_desc.extra_bits = extra_dbits; -- static_bl_desc.extra_bits = extra_blbits; --#endif -- -- /* Initialize the mapping length (0..255) -> length code (0..28) */ -- length = 0; -- for (code = 0; code < LENGTH_CODES-1; code++) { -- base_length[code] = length; -- for (n = 0; n < (1< dist code (0..29) */ -- dist = 0; -- for (code = 0 ; code < 16; code++) { -- base_dist[code] = dist; -- for (n = 0; n < (1<>= 7; /* from now on, all distances are divided by 128 */ -- for ( ; code < D_CODES; code++) { -- base_dist[code] = dist << 7; -- for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) { -- _dist_code[256 + dist++] = (uch)code; -- } -- } -- Assert (dist == 256, "tr_static_init: 256+dist != 512"); -- -- /* Construct the codes of the static literal tree */ -- for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0; -- n = 0; -- while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++; -- while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++; -- while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++; -- while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++; -- /* Codes 286 and 287 do not exist, but we must include them in the -- * tree construction to get a canonical Huffman tree (longest code -- * all ones) -- */ -- gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count); -- -- /* The static distance tree is trivial: */ -- for (n = 0; n < D_CODES; n++) { -- static_dtree[n].Len = 5; -- static_dtree[n].Code = bi_reverse((unsigned)n, 5); -- } -- static_init_done = 1; -- --# ifdef GEN_TREES_H -- gen_trees_header(); --# endif --#endif /* defined(GEN_TREES_H) || !defined(STDC) */ --} -- --/* =========================================================================== -- * Genererate the file trees.h describing the static trees. -- */ --#ifdef GEN_TREES_H --# ifndef DEBUG --# include --# endif -- --# define SEPARATOR(i, last, width) \ -- ((i) == (last)? "\n};\n\n" : \ -- ((i) % (width) == (width)-1 ? ",\n" : ", ")) -- --void gen_trees_header() --{ -- FILE *header = fopen("trees.h", "w"); -- int i; -- -- Assert (header != NULL, "Can't open trees.h"); -- fprintf(header, -- "/* header created automatically with -DGEN_TREES_H */\n\n"); -- -- fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n"); -- for (i = 0; i < L_CODES+2; i++) { -- fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code, -- static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5)); -- } -- -- fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n"); -- for (i = 0; i < D_CODES; i++) { -- fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code, -- static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5)); -- } -- -- fprintf(header, "const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n"); -- for (i = 0; i < DIST_CODE_LEN; i++) { -- fprintf(header, "%2u%s", _dist_code[i], -- SEPARATOR(i, DIST_CODE_LEN-1, 20)); -- } -- -- fprintf(header, -- "const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n"); -- for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) { -- fprintf(header, "%2u%s", _length_code[i], -- SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20)); -- } -- -- fprintf(header, "local const int base_length[LENGTH_CODES] = {\n"); -- for (i = 0; i < LENGTH_CODES; i++) { -- fprintf(header, "%1u%s", base_length[i], -- SEPARATOR(i, LENGTH_CODES-1, 20)); -- } -- -- fprintf(header, "local const int base_dist[D_CODES] = {\n"); -- for (i = 0; i < D_CODES; i++) { -- fprintf(header, "%5u%s", base_dist[i], -- SEPARATOR(i, D_CODES-1, 10)); -- } -- -- fclose(header); --} --#endif /* GEN_TREES_H */ -- --/* =========================================================================== -- * Initialize the tree data structures for a new zlib stream. -- */ --void ZLIB_INTERNAL _tr_init(s) -- deflate_state *s; --{ -- tr_static_init(); -- -- s->l_desc.dyn_tree = s->dyn_ltree; -- s->l_desc.stat_desc = &static_l_desc; -- -- s->d_desc.dyn_tree = s->dyn_dtree; -- s->d_desc.stat_desc = &static_d_desc; -- -- s->bl_desc.dyn_tree = s->bl_tree; -- s->bl_desc.stat_desc = &static_bl_desc; -- -- s->bi_buf = 0; -- s->bi_valid = 0; -- s->last_eob_len = 8; /* enough lookahead for inflate */ --#ifdef DEBUG -- s->compressed_len = 0L; -- s->bits_sent = 0L; --#endif -- -- /* Initialize the first block of the first file: */ -- init_block(s); --} -- --/* =========================================================================== -- * Initialize a new block. -- */ --local void init_block(s) -- deflate_state *s; --{ -- int n; /* iterates over tree elements */ -- -- /* Initialize the trees. */ -- for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0; -- for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0; -- for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0; -- -- s->dyn_ltree[END_BLOCK].Freq = 1; -- s->opt_len = s->static_len = 0L; -- s->last_lit = s->matches = 0; --} -- --#define SMALLEST 1 --/* Index within the heap array of least frequent node in the Huffman tree */ -- -- --/* =========================================================================== -- * Remove the smallest element from the heap and recreate the heap with -- * one less element. Updates heap and heap_len. -- */ --#define pqremove(s, tree, top) \ --{\ -- top = s->heap[SMALLEST]; \ -- s->heap[SMALLEST] = s->heap[s->heap_len--]; \ -- pqdownheap(s, tree, SMALLEST); \ --} -- --/* =========================================================================== -- * Compares to subtrees, using the tree depth as tie breaker when -- * the subtrees have equal frequency. This minimizes the worst case length. -- */ --#define smaller(tree, n, m, depth) \ -- (tree[n].Freq < tree[m].Freq || \ -- (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m])) -- --/* =========================================================================== -- * Restore the heap property by moving down the tree starting at node k, -- * exchanging a node with the smallest of its two sons if necessary, stopping -- * when the heap property is re-established (each father smaller than its -- * two sons). -- */ --local void pqdownheap(s, tree, k) -- deflate_state *s; -- ct_data *tree; /* the tree to restore */ -- int k; /* node to move down */ --{ -- int v = s->heap[k]; -- int j = k << 1; /* left son of k */ -- while (j <= s->heap_len) { -- /* Set j to the smallest of the two sons: */ -- if (j < s->heap_len && -- smaller(tree, s->heap[j+1], s->heap[j], s->depth)) { -- j++; -- } -- /* Exit if v is smaller than both sons */ -- if (smaller(tree, v, s->heap[j], s->depth)) break; -- -- /* Exchange v with the smallest son */ -- s->heap[k] = s->heap[j]; k = j; -- -- /* And continue down the tree, setting j to the left son of k */ -- j <<= 1; -- } -- s->heap[k] = v; --} -- --/* =========================================================================== -- * Compute the optimal bit lengths for a tree and update the total bit length -- * for the current block. -- * IN assertion: the fields freq and dad are set, heap[heap_max] and -- * above are the tree nodes sorted by increasing frequency. -- * OUT assertions: the field len is set to the optimal bit length, the -- * array bl_count contains the frequencies for each bit length. -- * The length opt_len is updated; static_len is also updated if stree is -- * not null. -- */ --local void gen_bitlen(s, desc) -- deflate_state *s; -- tree_desc *desc; /* the tree descriptor */ --{ -- ct_data *tree = desc->dyn_tree; -- int max_code = desc->max_code; -- const ct_data *stree = desc->stat_desc->static_tree; -- const intf *extra = desc->stat_desc->extra_bits; -- int base = desc->stat_desc->extra_base; -- int max_length = desc->stat_desc->max_length; -- int h; /* heap index */ -- int n, m; /* iterate over the tree elements */ -- int bits; /* bit length */ -- int xbits; /* extra bits */ -- ush f; /* frequency */ -- int overflow = 0; /* number of elements with bit length too large */ -- -- for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0; -- -- /* In a first pass, compute the optimal bit lengths (which may -- * overflow in the case of the bit length tree). -- */ -- tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */ -- -- for (h = s->heap_max+1; h < HEAP_SIZE; h++) { -- n = s->heap[h]; -- bits = tree[tree[n].Dad].Len + 1; -- if (bits > max_length) bits = max_length, overflow++; -- tree[n].Len = (ush)bits; -- /* We overwrite tree[n].Dad which is no longer needed */ -- -- if (n > max_code) continue; /* not a leaf node */ -- -- s->bl_count[bits]++; -- xbits = 0; -- if (n >= base) xbits = extra[n-base]; -- f = tree[n].Freq; -- s->opt_len += (ulg)f * (bits + xbits); -- if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits); -- } -- if (overflow == 0) return; -- -- Trace((stderr,"\nbit length overflow\n")); -- /* This happens for example on obj2 and pic of the Calgary corpus */ -- -- /* Find the first bit length which could increase: */ -- do { -- bits = max_length-1; -- while (s->bl_count[bits] == 0) bits--; -- s->bl_count[bits]--; /* move one leaf down the tree */ -- s->bl_count[bits+1] += 2; /* move one overflow item as its brother */ -- s->bl_count[max_length]--; -- /* The brother of the overflow item also moves one step up, -- * but this does not affect bl_count[max_length] -- */ -- overflow -= 2; -- } while (overflow > 0); -- -- /* Now recompute all bit lengths, scanning in increasing frequency. -- * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all -- * lengths instead of fixing only the wrong ones. This idea is taken -- * from 'ar' written by Haruhiko Okumura.) -- */ -- for (bits = max_length; bits != 0; bits--) { -- n = s->bl_count[bits]; -- while (n != 0) { -- m = s->heap[--h]; -- if (m > max_code) continue; -- if ((unsigned) tree[m].Len != (unsigned) bits) { -- Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); -- s->opt_len += ((long)bits - (long)tree[m].Len) -- *(long)tree[m].Freq; -- tree[m].Len = (ush)bits; -- } -- n--; -- } -- } --} -- --/* =========================================================================== -- * Generate the codes for a given tree and bit counts (which need not be -- * optimal). -- * IN assertion: the array bl_count contains the bit length statistics for -- * the given tree and the field len is set for all tree elements. -- * OUT assertion: the field code is set for all tree elements of non -- * zero code length. -- */ --local void gen_codes (tree, max_code, bl_count) -- ct_data *tree; /* the tree to decorate */ -- int max_code; /* largest code with non zero frequency */ -- ushf *bl_count; /* number of codes at each bit length */ --{ -- ush next_code[MAX_BITS+1]; /* next code value for each bit length */ -- ush code = 0; /* running code value */ -- int bits; /* bit index */ -- int n; /* code index */ -- -- /* The distribution counts are first used to generate the code values -- * without bit reversal. -- */ -- for (bits = 1; bits <= MAX_BITS; bits++) { -- next_code[bits] = code = (code + bl_count[bits-1]) << 1; -- } -- /* Check that the bit counts in bl_count are consistent. The last code -- * must be all ones. -- */ -- Assert (code + bl_count[MAX_BITS]-1 == (1<dyn_tree; -- const ct_data *stree = desc->stat_desc->static_tree; -- int elems = desc->stat_desc->elems; -- int n, m; /* iterate over heap elements */ -- int max_code = -1; /* largest code with non zero frequency */ -- int node; /* new node being created */ -- -- /* Construct the initial heap, with least frequent element in -- * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. -- * heap[0] is not used. -- */ -- s->heap_len = 0, s->heap_max = HEAP_SIZE; -- -- for (n = 0; n < elems; n++) { -- if (tree[n].Freq != 0) { -- s->heap[++(s->heap_len)] = max_code = n; -- s->depth[n] = 0; -- } else { -- tree[n].Len = 0; -- } -- } -- -- /* The pkzip format requires that at least one distance code exists, -- * and that at least one bit should be sent even if there is only one -- * possible code. So to avoid special checks later on we force at least -- * two codes of non zero frequency. -- */ -- while (s->heap_len < 2) { -- node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0); -- tree[node].Freq = 1; -- s->depth[node] = 0; -- s->opt_len--; if (stree) s->static_len -= stree[node].Len; -- /* node is 0 or 1 so it does not have extra bits */ -- } -- desc->max_code = max_code; -- -- /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, -- * establish sub-heaps of increasing lengths: -- */ -- for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n); -- -- /* Construct the Huffman tree by repeatedly combining the least two -- * frequent nodes. -- */ -- node = elems; /* next internal node of the tree */ -- do { -- pqremove(s, tree, n); /* n = node of least frequency */ -- m = s->heap[SMALLEST]; /* m = node of next least frequency */ -- -- s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */ -- s->heap[--(s->heap_max)] = m; -- -- /* Create a new node father of n and m */ -- tree[node].Freq = tree[n].Freq + tree[m].Freq; -- s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ? -- s->depth[n] : s->depth[m]) + 1); -- tree[n].Dad = tree[m].Dad = (ush)node; --#ifdef DUMP_BL_TREE -- if (tree == s->bl_tree) { -- fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)", -- node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq); -- } --#endif -- /* and insert the new node in the heap */ -- s->heap[SMALLEST] = node++; -- pqdownheap(s, tree, SMALLEST); -- -- } while (s->heap_len >= 2); -- -- s->heap[--(s->heap_max)] = s->heap[SMALLEST]; -- -- /* At this point, the fields freq and dad are set. We can now -- * generate the bit lengths. -- */ -- gen_bitlen(s, (tree_desc *)desc); -- -- /* The field len is now set, we can generate the bit codes */ -- gen_codes ((ct_data *)tree, max_code, s->bl_count); --} -- --/* =========================================================================== -- * Scan a literal or distance tree to determine the frequencies of the codes -- * in the bit length tree. -- */ --local void scan_tree (s, tree, max_code) -- deflate_state *s; -- ct_data *tree; /* the tree to be scanned */ -- int max_code; /* and its largest code of non zero frequency */ --{ -- int n; /* iterates over all tree elements */ -- int prevlen = -1; /* last emitted length */ -- int curlen; /* length of current code */ -- int nextlen = tree[0].Len; /* length of next code */ -- int count = 0; /* repeat count of the current code */ -- int max_count = 7; /* max repeat count */ -- int min_count = 4; /* min repeat count */ -- -- if (nextlen == 0) max_count = 138, min_count = 3; -- tree[max_code+1].Len = (ush)0xffff; /* guard */ -- -- for (n = 0; n <= max_code; n++) { -- curlen = nextlen; nextlen = tree[n+1].Len; -- if (++count < max_count && curlen == nextlen) { -- continue; -- } else if (count < min_count) { -- s->bl_tree[curlen].Freq += count; -- } else if (curlen != 0) { -- if (curlen != prevlen) s->bl_tree[curlen].Freq++; -- s->bl_tree[REP_3_6].Freq++; -- } else if (count <= 10) { -- s->bl_tree[REPZ_3_10].Freq++; -- } else { -- s->bl_tree[REPZ_11_138].Freq++; -- } -- count = 0; prevlen = curlen; -- if (nextlen == 0) { -- max_count = 138, min_count = 3; -- } else if (curlen == nextlen) { -- max_count = 6, min_count = 3; -- } else { -- max_count = 7, min_count = 4; -- } -- } --} -- --/* =========================================================================== -- * Send a literal or distance tree in compressed form, using the codes in -- * bl_tree. -- */ --local void send_tree (s, tree, max_code) -- deflate_state *s; -- ct_data *tree; /* the tree to be scanned */ -- int max_code; /* and its largest code of non zero frequency */ --{ -- int n; /* iterates over all tree elements */ -- int prevlen = -1; /* last emitted length */ -- int curlen; /* length of current code */ -- int nextlen = tree[0].Len; /* length of next code */ -- int count = 0; /* repeat count of the current code */ -- int max_count = 7; /* max repeat count */ -- int min_count = 4; /* min repeat count */ -- -- /* tree[max_code+1].Len = -1; */ /* guard already set */ -- if (nextlen == 0) max_count = 138, min_count = 3; -- -- for (n = 0; n <= max_code; n++) { -- curlen = nextlen; nextlen = tree[n+1].Len; -- if (++count < max_count && curlen == nextlen) { -- continue; -- } else if (count < min_count) { -- do { send_code(s, curlen, s->bl_tree); } while (--count != 0); -- -- } else if (curlen != 0) { -- if (curlen != prevlen) { -- send_code(s, curlen, s->bl_tree); count--; -- } -- Assert(count >= 3 && count <= 6, " 3_6?"); -- send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2); -- -- } else if (count <= 10) { -- send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3); -- -- } else { -- send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7); -- } -- count = 0; prevlen = curlen; -- if (nextlen == 0) { -- max_count = 138, min_count = 3; -- } else if (curlen == nextlen) { -- max_count = 6, min_count = 3; -- } else { -- max_count = 7, min_count = 4; -- } -- } --} -- --/* =========================================================================== -- * Construct the Huffman tree for the bit lengths and return the index in -- * bl_order of the last bit length code to send. -- */ --local int build_bl_tree(s) -- deflate_state *s; --{ -- int max_blindex; /* index of last bit length code of non zero freq */ -- -- /* Determine the bit length frequencies for literal and distance trees */ -- scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code); -- scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code); -- -- /* Build the bit length tree: */ -- build_tree(s, (tree_desc *)(&(s->bl_desc))); -- /* opt_len now includes the length of the tree representations, except -- * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. -- */ -- -- /* Determine the number of bit length codes to send. The pkzip format -- * requires that at least 4 bit length codes be sent. (appnote.txt says -- * 3 but the actual value used is 4.) -- */ -- for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) { -- if (s->bl_tree[bl_order[max_blindex]].Len != 0) break; -- } -- /* Update opt_len to include the bit length tree and counts */ -- s->opt_len += 3*(max_blindex+1) + 5+5+4; -- Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", -- s->opt_len, s->static_len)); -- -- return max_blindex; --} -- --/* =========================================================================== -- * Send the header for a block using dynamic Huffman trees: the counts, the -- * lengths of the bit length codes, the literal tree and the distance tree. -- * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. -- */ --local void send_all_trees(s, lcodes, dcodes, blcodes) -- deflate_state *s; -- int lcodes, dcodes, blcodes; /* number of codes for each tree */ --{ -- int rank; /* index in bl_order */ -- -- Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); -- Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, -- "too many codes"); -- Tracev((stderr, "\nbl counts: ")); -- send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */ -- send_bits(s, dcodes-1, 5); -- send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */ -- for (rank = 0; rank < blcodes; rank++) { -- Tracev((stderr, "\nbl code %2d ", bl_order[rank])); -- send_bits(s, s->bl_tree[bl_order[rank]].Len, 3); -- } -- Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); -- -- send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */ -- Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); -- -- send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */ -- Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); --} -- --/* =========================================================================== -- * Send a stored block -- */ --void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last) -- deflate_state *s; -- charf *buf; /* input block */ -- ulg stored_len; /* length of input block */ -- int last; /* one if this is the last block for a file */ --{ -- send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */ --#ifdef DEBUG -- s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; -- s->compressed_len += (stored_len + 4) << 3; --#endif -- copy_block(s, buf, (unsigned)stored_len, 1); /* with header */ --} -- --/* =========================================================================== -- * Send one empty static block to give enough lookahead for inflate. -- * This takes 10 bits, of which 7 may remain in the bit buffer. -- * The current inflate code requires 9 bits of lookahead. If the -- * last two codes for the previous block (real code plus EOB) were coded -- * on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode -- * the last real code. In this case we send two empty static blocks instead -- * of one. (There are no problems if the previous block is stored or fixed.) -- * To simplify the code, we assume the worst case of last real code encoded -- * on one bit only. -- */ --void ZLIB_INTERNAL _tr_align(s) -- deflate_state *s; --{ -- send_bits(s, STATIC_TREES<<1, 3); -- send_code(s, END_BLOCK, static_ltree); --#ifdef DEBUG -- s->compressed_len += 10L; /* 3 for block type, 7 for EOB */ --#endif -- bi_flush(s); -- /* Of the 10 bits for the empty block, we have already sent -- * (10 - bi_valid) bits. The lookahead for the last real code (before -- * the EOB of the previous block) was thus at least one plus the length -- * of the EOB plus what we have just sent of the empty static block. -- */ -- if (1 + s->last_eob_len + 10 - s->bi_valid < 9) { -- send_bits(s, STATIC_TREES<<1, 3); -- send_code(s, END_BLOCK, static_ltree); --#ifdef DEBUG -- s->compressed_len += 10L; --#endif -- bi_flush(s); -- } -- s->last_eob_len = 7; --} -- --/* =========================================================================== -- * Determine the best encoding for the current block: dynamic trees, static -- * trees or store, and output the encoded block to the zip file. -- */ --void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) -- deflate_state *s; -- charf *buf; /* input block, or NULL if too old */ -- ulg stored_len; /* length of input block */ -- int last; /* one if this is the last block for a file */ --{ -- ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ -- int max_blindex = 0; /* index of last bit length code of non zero freq */ -- -- /* Build the Huffman trees unless a stored block is forced */ -- if (s->level > 0) { -- -- /* Check if the file is binary or text */ -- if (s->strm->data_type == Z_UNKNOWN) -- s->strm->data_type = detect_data_type(s); -- -- /* Construct the literal and distance trees */ -- build_tree(s, (tree_desc *)(&(s->l_desc))); -- Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, -- s->static_len)); -- -- build_tree(s, (tree_desc *)(&(s->d_desc))); -- Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, -- s->static_len)); -- /* At this point, opt_len and static_len are the total bit lengths of -- * the compressed block data, excluding the tree representations. -- */ -- -- /* Build the bit length tree for the above two trees, and get the index -- * in bl_order of the last bit length code to send. -- */ -- max_blindex = build_bl_tree(s); -- -- /* Determine the best encoding. Compute the block lengths in bytes. */ -- opt_lenb = (s->opt_len+3+7)>>3; -- static_lenb = (s->static_len+3+7)>>3; -- -- Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", -- opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, -- s->last_lit)); -- -- if (static_lenb <= opt_lenb) opt_lenb = static_lenb; -- -- } else { -- Assert(buf != (char*)0, "lost buf"); -- opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ -- } -- --#ifdef FORCE_STORED -- if (buf != (char*)0) { /* force stored block */ --#else -- if (stored_len+4 <= opt_lenb && buf != (char*)0) { -- /* 4: two words for the lengths */ --#endif -- /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. -- * Otherwise we can't have processed more than WSIZE input bytes since -- * the last block flush, because compression would have been -- * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to -- * transform a block into a stored block. -- */ -- _tr_stored_block(s, buf, stored_len, last); -- --#ifdef FORCE_STATIC -- } else if (static_lenb >= 0) { /* force static trees */ --#else -- } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) { --#endif -- send_bits(s, (STATIC_TREES<<1)+last, 3); -- compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree); --#ifdef DEBUG -- s->compressed_len += 3 + s->static_len; --#endif -- } else { -- send_bits(s, (DYN_TREES<<1)+last, 3); -- send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, -- max_blindex+1); -- compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree); --#ifdef DEBUG -- s->compressed_len += 3 + s->opt_len; --#endif -- } -- Assert (s->compressed_len == s->bits_sent, "bad compressed size"); -- /* The above check is made mod 2^32, for files larger than 512 MB -- * and uLong implemented on 32 bits. -- */ -- init_block(s); -- -- if (last) { -- bi_windup(s); --#ifdef DEBUG -- s->compressed_len += 7; /* align on byte boundary */ --#endif -- } -- Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, -- s->compressed_len-7*last)); --} -- --/* =========================================================================== -- * Save the match info and tally the frequency counts. Return true if -- * the current block must be flushed. -- */ --int ZLIB_INTERNAL _tr_tally (s, dist, lc) -- deflate_state *s; -- unsigned dist; /* distance of matched string */ -- unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ --{ -- s->d_buf[s->last_lit] = (ush)dist; -- s->l_buf[s->last_lit++] = (uch)lc; -- if (dist == 0) { -- /* lc is the unmatched char */ -- s->dyn_ltree[lc].Freq++; -- } else { -- s->matches++; -- /* Here, lc is the match length - MIN_MATCH */ -- dist--; /* dist = match distance - 1 */ -- Assert((ush)dist < (ush)MAX_DIST(s) && -- (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && -- (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); -- -- s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++; -- s->dyn_dtree[d_code(dist)].Freq++; -- } -- --#ifdef TRUNCATE_BLOCK -- /* Try to guess if it is profitable to stop the current block here */ -- if ((s->last_lit & 0x1fff) == 0 && s->level > 2) { -- /* Compute an upper bound for the compressed length */ -- ulg out_length = (ulg)s->last_lit*8L; -- ulg in_length = (ulg)((long)s->strstart - s->block_start); -- int dcode; -- for (dcode = 0; dcode < D_CODES; dcode++) { -- out_length += (ulg)s->dyn_dtree[dcode].Freq * -- (5L+extra_dbits[dcode]); -- } -- out_length >>= 3; -- Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", -- s->last_lit, in_length, out_length, -- 100L - out_length*100L/in_length)); -- if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1; -- } --#endif -- return (s->last_lit == s->lit_bufsize-1); -- /* We avoid equality with lit_bufsize because of wraparound at 64K -- * on 16 bit machines and because stored blocks are restricted to -- * 64K-1 bytes. -- */ --} -- --/* =========================================================================== -- * Send the block data compressed using the given Huffman trees -- */ --local void compress_block(s, ltree, dtree) -- deflate_state *s; -- ct_data *ltree; /* literal tree */ -- ct_data *dtree; /* distance tree */ --{ -- unsigned dist; /* distance of matched string */ -- int lc; /* match length or unmatched char (if dist == 0) */ -- unsigned lx = 0; /* running index in l_buf */ -- unsigned code; /* the code to send */ -- int extra; /* number of extra bits to send */ -- -- if (s->last_lit != 0) do { -- dist = s->d_buf[lx]; -- lc = s->l_buf[lx++]; -- if (dist == 0) { -- send_code(s, lc, ltree); /* send a literal byte */ -- Tracecv(isgraph(lc), (stderr," '%c' ", lc)); -- } else { -- /* Here, lc is the match length - MIN_MATCH */ -- code = _length_code[lc]; -- send_code(s, code+LITERALS+1, ltree); /* send the length code */ -- extra = extra_lbits[code]; -- if (extra != 0) { -- lc -= base_length[code]; -- send_bits(s, lc, extra); /* send the extra length bits */ -- } -- dist--; /* dist is now the match distance - 1 */ -- code = d_code(dist); -- Assert (code < D_CODES, "bad d_code"); -- -- send_code(s, code, dtree); /* send the distance code */ -- extra = extra_dbits[code]; -- if (extra != 0) { -- dist -= base_dist[code]; -- send_bits(s, dist, extra); /* send the extra distance bits */ -- } -- } /* literal or match pair ? */ -- -- /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ -- Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx, -- "pendingBuf overflow"); -- -- } while (lx < s->last_lit); -- -- send_code(s, END_BLOCK, ltree); -- s->last_eob_len = ltree[END_BLOCK].Len; --} -- --/* =========================================================================== -- * Check if the data type is TEXT or BINARY, using the following algorithm: -- * - TEXT if the two conditions below are satisfied: -- * a) There are no non-portable control characters belonging to the -- * "black list" (0..6, 14..25, 28..31). -- * b) There is at least one printable character belonging to the -- * "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255). -- * - BINARY otherwise. -- * - The following partially-portable control characters form a -- * "gray list" that is ignored in this detection algorithm: -- * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). -- * IN assertion: the fields Freq of dyn_ltree are set. -- */ --local int detect_data_type(s) -- deflate_state *s; --{ -- /* black_mask is the bit mask of black-listed bytes -- * set bits 0..6, 14..25, and 28..31 -- * 0xf3ffc07f = binary 11110011111111111100000001111111 -- */ -- unsigned long black_mask = 0xf3ffc07fUL; -- int n; -- -- /* Check for non-textual ("black-listed") bytes. */ -- for (n = 0; n <= 31; n++, black_mask >>= 1) -- if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0)) -- return Z_BINARY; -- -- /* Check for textual ("white-listed") bytes. */ -- if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0 -- || s->dyn_ltree[13].Freq != 0) -- return Z_TEXT; -- for (n = 32; n < LITERALS; n++) -- if (s->dyn_ltree[n].Freq != 0) -- return Z_TEXT; -- -- /* There are no "black-listed" or "white-listed" bytes: -- * this stream either is empty or has tolerated ("gray-listed") bytes only. -- */ -- return Z_BINARY; --} -- --/* =========================================================================== -- * Reverse the first len bits of a code, using straightforward code (a faster -- * method would use a table) -- * IN assertion: 1 <= len <= 15 -- */ --local unsigned bi_reverse(code, len) -- unsigned code; /* the value to invert */ -- int len; /* its bit length */ --{ -- register unsigned res = 0; -- do { -- res |= code & 1; -- code >>= 1, res <<= 1; -- } while (--len > 0); -- return res >> 1; --} -- --/* =========================================================================== -- * Flush the bit buffer, keeping at most 7 bits in it. -- */ --local void bi_flush(s) -- deflate_state *s; --{ -- if (s->bi_valid == 16) { -- put_short(s, s->bi_buf); -- s->bi_buf = 0; -- s->bi_valid = 0; -- } else if (s->bi_valid >= 8) { -- put_byte(s, (Byte)s->bi_buf); -- s->bi_buf >>= 8; -- s->bi_valid -= 8; -- } --} -- --/* =========================================================================== -- * Flush the bit buffer and align the output on a byte boundary -- */ --local void bi_windup(s) -- deflate_state *s; --{ -- if (s->bi_valid > 8) { -- put_short(s, s->bi_buf); -- } else if (s->bi_valid > 0) { -- put_byte(s, (Byte)s->bi_buf); -- } -- s->bi_buf = 0; -- s->bi_valid = 0; --#ifdef DEBUG -- s->bits_sent = (s->bits_sent+7) & ~7; --#endif --} -- --/* =========================================================================== -- * Copy a stored block, storing first the length and its -- * one's complement if requested. -- */ --local void copy_block(s, buf, len, header) -- deflate_state *s; -- charf *buf; /* the input data */ -- unsigned len; /* its length */ -- int header; /* true if block header must be written */ --{ -- bi_windup(s); /* align on byte boundary */ -- s->last_eob_len = 8; /* enough lookahead for inflate */ -- -- if (header) { -- put_short(s, (ush)len); -- put_short(s, (ush)~len); --#ifdef DEBUG -- s->bits_sent += 2*16; --#endif -- } --#ifdef DEBUG -- s->bits_sent += (ulg)len<<3; --#endif -- while (len--) { -- put_byte(s, *buf++); -- } --} -diff --git a/thirdparty/zlib/trees.h b/thirdparty/zlib/trees.h -deleted file mode 100644 -index d35639d..0000000 ---- a/thirdparty/zlib/trees.h -+++ /dev/null -@@ -1,128 +0,0 @@ --/* header created automatically with -DGEN_TREES_H */ -- --local const ct_data static_ltree[L_CODES+2] = { --{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}}, --{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}}, --{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}}, --{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}}, --{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}}, --{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}}, --{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}}, --{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}}, --{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}}, --{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}}, --{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}}, --{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}}, --{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}}, --{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}}, --{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}}, --{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}}, --{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}}, --{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}}, --{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}}, --{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}}, --{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}}, --{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}}, --{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}}, --{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}}, --{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}}, --{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}}, --{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}}, --{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}}, --{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}}, --{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}}, --{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}}, --{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}}, --{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}}, --{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}}, --{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}}, --{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}}, --{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}}, --{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}}, --{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}}, --{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}}, --{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}}, --{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}}, --{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}}, --{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}}, --{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}}, --{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}}, --{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}}, --{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}}, --{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}}, --{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}}, --{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}}, --{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}}, --{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}}, --{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}}, --{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}}, --{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}}, --{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}}, --{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}} --}; -- --local const ct_data static_dtree[D_CODES] = { --{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}}, --{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}}, --{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}}, --{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}}, --{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}}, --{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}} --}; -- --const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = { -- 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, -- 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, --10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, --11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, --12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, --13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, --13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, --14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, --14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, --14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, --15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, --15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, --15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, --18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, --23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, --24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, --26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, --26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, --27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, --27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, --28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, --28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, --28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, --29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, --29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, --29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 --}; -- --const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= { -- 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, --13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, --17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, --19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, --21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, --22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, --23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, --24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, --25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, --25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, --26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, --26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, --27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 --}; -- --local const int base_length[LENGTH_CODES] = { --0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, --64, 80, 96, 112, 128, 160, 192, 224, 0 --}; -- --local const int base_dist[D_CODES] = { -- 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, -- 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, -- 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 --}; -- -diff --git a/thirdparty/zlib/uncompr.c b/thirdparty/zlib/uncompr.c -deleted file mode 100644 -index ad98be3..0000000 ---- a/thirdparty/zlib/uncompr.c -+++ /dev/null -@@ -1,59 +0,0 @@ --/* uncompr.c -- decompress a memory buffer -- * Copyright (C) 1995-2003, 2010 Jean-loup Gailly. -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* @(#) $Id$ */ -- --#define ZLIB_INTERNAL --#include "zlib.h" -- --/* =========================================================================== -- Decompresses the source buffer into the destination buffer. sourceLen is -- the byte length of the source buffer. Upon entry, destLen is the total -- size of the destination buffer, which must be large enough to hold the -- entire uncompressed data. (The size of the uncompressed data must have -- been saved previously by the compressor and transmitted to the decompressor -- by some mechanism outside the scope of this compression library.) -- Upon exit, destLen is the actual size of the compressed buffer. -- -- uncompress returns Z_OK if success, Z_MEM_ERROR if there was not -- enough memory, Z_BUF_ERROR if there was not enough room in the output -- buffer, or Z_DATA_ERROR if the input data was corrupted. --*/ --int ZEXPORT uncompress (dest, destLen, source, sourceLen) -- Bytef *dest; -- uLongf *destLen; -- const Bytef *source; -- uLong sourceLen; --{ -- z_stream stream; -- int err; -- -- stream.next_in = (Bytef*)source; -- stream.avail_in = (uInt)sourceLen; -- /* Check for source > 64K on 16-bit machine: */ -- if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; -- -- stream.next_out = dest; -- stream.avail_out = (uInt)*destLen; -- if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; -- -- stream.zalloc = (alloc_func)0; -- stream.zfree = (free_func)0; -- -- err = inflateInit(&stream); -- if (err != Z_OK) return err; -- -- err = inflate(&stream, Z_FINISH); -- if (err != Z_STREAM_END) { -- inflateEnd(&stream); -- if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0)) -- return Z_DATA_ERROR; -- return err; -- } -- *destLen = stream.total_out; -- -- err = inflateEnd(&stream); -- return err; --} -diff --git a/thirdparty/zlib/zconf.h b/thirdparty/zlib/zconf.h -deleted file mode 100644 -index 02ce56c..0000000 ---- a/thirdparty/zlib/zconf.h -+++ /dev/null -@@ -1,428 +0,0 @@ --/* zconf.h -- configuration of the zlib compression library -- * Copyright (C) 1995-2010 Jean-loup Gailly. -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* @(#) $Id$ */ -- --#ifndef ZCONF_H --#define ZCONF_H -- --/* -- * If you *really* need a unique prefix for all types and library functions, -- * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. -- * Even better than compiling with -DZ_PREFIX would be to use configure to set -- * this permanently in zconf.h using "./configure --zprefix". -- */ --#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ -- --/* all linked symbols */ --# define _dist_code z__dist_code --# define _length_code z__length_code --# define _tr_align z__tr_align --# define _tr_flush_block z__tr_flush_block --# define _tr_init z__tr_init --# define _tr_stored_block z__tr_stored_block --# define _tr_tally z__tr_tally --# define adler32 z_adler32 --# define adler32_combine z_adler32_combine --# define adler32_combine64 z_adler32_combine64 --# define compress z_compress --# define compress2 z_compress2 --# define compressBound z_compressBound --# define crc32 z_crc32 --# define crc32_combine z_crc32_combine --# define crc32_combine64 z_crc32_combine64 --# define deflate z_deflate --# define deflateBound z_deflateBound --# define deflateCopy z_deflateCopy --# define deflateEnd z_deflateEnd --# define deflateInit2_ z_deflateInit2_ --# define deflateInit_ z_deflateInit_ --# define deflateParams z_deflateParams --# define deflatePrime z_deflatePrime --# define deflateReset z_deflateReset --# define deflateSetDictionary z_deflateSetDictionary --# define deflateSetHeader z_deflateSetHeader --# define deflateTune z_deflateTune --# define deflate_copyright z_deflate_copyright --# define get_crc_table z_get_crc_table --# define gz_error z_gz_error --# define gz_intmax z_gz_intmax --# define gz_strwinerror z_gz_strwinerror --# define gzbuffer z_gzbuffer --# define gzclearerr z_gzclearerr --# define gzclose z_gzclose --# define gzclose_r z_gzclose_r --# define gzclose_w z_gzclose_w --# define gzdirect z_gzdirect --# define gzdopen z_gzdopen --# define gzeof z_gzeof --# define gzerror z_gzerror --# define gzflush z_gzflush --# define gzgetc z_gzgetc --# define gzgets z_gzgets --# define gzoffset z_gzoffset --# define gzoffset64 z_gzoffset64 --# define gzopen z_gzopen --# define gzopen64 z_gzopen64 --# define gzprintf z_gzprintf --# define gzputc z_gzputc --# define gzputs z_gzputs --# define gzread z_gzread --# define gzrewind z_gzrewind --# define gzseek z_gzseek --# define gzseek64 z_gzseek64 --# define gzsetparams z_gzsetparams --# define gztell z_gztell --# define gztell64 z_gztell64 --# define gzungetc z_gzungetc --# define gzwrite z_gzwrite --# define inflate z_inflate --# define inflateBack z_inflateBack --# define inflateBackEnd z_inflateBackEnd --# define inflateBackInit_ z_inflateBackInit_ --# define inflateCopy z_inflateCopy --# define inflateEnd z_inflateEnd --# define inflateGetHeader z_inflateGetHeader --# define inflateInit2_ z_inflateInit2_ --# define inflateInit_ z_inflateInit_ --# define inflateMark z_inflateMark --# define inflatePrime z_inflatePrime --# define inflateReset z_inflateReset --# define inflateReset2 z_inflateReset2 --# define inflateSetDictionary z_inflateSetDictionary --# define inflateSync z_inflateSync --# define inflateSyncPoint z_inflateSyncPoint --# define inflateUndermine z_inflateUndermine --# define inflate_copyright z_inflate_copyright --# define inflate_fast z_inflate_fast --# define inflate_table z_inflate_table --# define uncompress z_uncompress --# define zError z_zError --# define zcalloc z_zcalloc --# define zcfree z_zcfree --# define zlibCompileFlags z_zlibCompileFlags --# define zlibVersion z_zlibVersion -- --/* all zlib typedefs in zlib.h and zconf.h */ --# define Byte z_Byte --# define Bytef z_Bytef --# define alloc_func z_alloc_func --# define charf z_charf --# define free_func z_free_func --# define gzFile z_gzFile --# define gz_header z_gz_header --# define gz_headerp z_gz_headerp --# define in_func z_in_func --# define intf z_intf --# define out_func z_out_func --# define uInt z_uInt --# define uIntf z_uIntf --# define uLong z_uLong --# define uLongf z_uLongf --# define voidp z_voidp --# define voidpc z_voidpc --# define voidpf z_voidpf -- --/* all zlib structs in zlib.h and zconf.h */ --# define gz_header_s z_gz_header_s --# define internal_state z_internal_state -- --#endif -- --#if defined(__MSDOS__) && !defined(MSDOS) --# define MSDOS --#endif --#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) --# define OS2 --#endif --#if defined(_WINDOWS) && !defined(WINDOWS) --# define WINDOWS --#endif --#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) --# ifndef WIN32 --# define WIN32 --# endif --#endif --#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) --# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) --# ifndef SYS16BIT --# define SYS16BIT --# endif --# endif --#endif -- --/* -- * Compile with -DMAXSEG_64K if the alloc function cannot allocate more -- * than 64k bytes at a time (needed on systems with 16-bit int). -- */ --#ifdef SYS16BIT --# define MAXSEG_64K --#endif --#ifdef MSDOS --# define UNALIGNED_OK --#endif -- --#ifdef __STDC_VERSION__ --# ifndef STDC --# define STDC --# endif --# if __STDC_VERSION__ >= 199901L --# ifndef STDC99 --# define STDC99 --# endif --# endif --#endif --#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) --# define STDC --#endif --#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) --# define STDC --#endif --#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) --# define STDC --#endif --#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) --# define STDC --#endif -- --#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ --# define STDC --#endif -- --#ifndef STDC --# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ --# define const /* note: need a more gentle solution here */ --# endif --#endif -- --/* Some Mac compilers merge all .h files incorrectly: */ --#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) --# define NO_DUMMY_DECL --#endif -- --/* Maximum value for memLevel in deflateInit2 */ --#ifndef MAX_MEM_LEVEL --# ifdef MAXSEG_64K --# define MAX_MEM_LEVEL 8 --# else --# define MAX_MEM_LEVEL 9 --# endif --#endif -- --/* Maximum value for windowBits in deflateInit2 and inflateInit2. -- * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files -- * created by gzip. (Files created by minigzip can still be extracted by -- * gzip.) -- */ --#ifndef MAX_WBITS --# define MAX_WBITS 15 /* 32K LZ77 window */ --#endif -- --/* The memory requirements for deflate are (in bytes): -- (1 << (windowBits+2)) + (1 << (memLevel+9)) -- that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) -- plus a few kilobytes for small objects. For example, if you want to reduce -- the default memory requirements from 256K to 128K, compile with -- make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" -- Of course this will generally degrade compression (there's no free lunch). -- -- The memory requirements for inflate are (in bytes) 1 << windowBits -- that is, 32K for windowBits=15 (default value) plus a few kilobytes -- for small objects. --*/ -- -- /* Type declarations */ -- --#ifndef OF /* function prototypes */ --# ifdef STDC --# define OF(args) args --# else --# define OF(args) () --# endif --#endif -- --/* The following definitions for FAR are needed only for MSDOS mixed -- * model programming (small or medium model with some far allocations). -- * This was tested only with MSC; for other MSDOS compilers you may have -- * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, -- * just define FAR to be empty. -- */ --#ifdef SYS16BIT --# if defined(M_I86SM) || defined(M_I86MM) -- /* MSC small or medium model */ --# define SMALL_MEDIUM --# ifdef _MSC_VER --# define FAR _far --# else --# define FAR far --# endif --# endif --# if (defined(__SMALL__) || defined(__MEDIUM__)) -- /* Turbo C small or medium model */ --# define SMALL_MEDIUM --# ifdef __BORLANDC__ --# define FAR _far --# else --# define FAR far --# endif --# endif --#endif -- --#if defined(WINDOWS) || defined(WIN32) -- /* If building or using zlib as a DLL, define ZLIB_DLL. -- * This is not mandatory, but it offers a little performance increase. -- */ --# ifdef ZLIB_DLL --# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) --# ifdef ZLIB_INTERNAL --# define ZEXTERN extern __declspec(dllexport) --# else --# define ZEXTERN extern __declspec(dllimport) --# endif --# endif --# endif /* ZLIB_DLL */ -- /* If building or using zlib with the WINAPI/WINAPIV calling convention, -- * define ZLIB_WINAPI. -- * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. -- */ --# ifdef ZLIB_WINAPI --# ifdef FAR --# undef FAR --# endif --# include -- /* No need for _export, use ZLIB.DEF instead. */ -- /* For complete Windows compatibility, use WINAPI, not __stdcall. */ --# define ZEXPORT WINAPI --# ifdef WIN32 --# define ZEXPORTVA WINAPIV --# else --# define ZEXPORTVA FAR CDECL --# endif --# endif --#endif -- --#if defined (__BEOS__) --# ifdef ZLIB_DLL --# ifdef ZLIB_INTERNAL --# define ZEXPORT __declspec(dllexport) --# define ZEXPORTVA __declspec(dllexport) --# else --# define ZEXPORT __declspec(dllimport) --# define ZEXPORTVA __declspec(dllimport) --# endif --# endif --#endif -- --#ifndef ZEXTERN --# define ZEXTERN extern --#endif --#ifndef ZEXPORT --# define ZEXPORT --#endif --#ifndef ZEXPORTVA --# define ZEXPORTVA --#endif -- --#ifndef FAR --# define FAR --#endif -- --#if !defined(__MACTYPES__) --typedef unsigned char Byte; /* 8 bits */ --#endif --typedef unsigned int uInt; /* 16 bits or more */ --typedef unsigned long uLong; /* 32 bits or more */ -- --#ifdef SMALL_MEDIUM -- /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ --# define Bytef Byte FAR --#else -- typedef Byte FAR Bytef; --#endif --typedef char FAR charf; --typedef int FAR intf; --typedef uInt FAR uIntf; --typedef uLong FAR uLongf; -- --#ifdef STDC -- typedef void const *voidpc; -- typedef void FAR *voidpf; -- typedef void *voidp; --#else -- typedef Byte const *voidpc; -- typedef Byte FAR *voidpf; -- typedef Byte *voidp; --#endif -- --#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ --# define Z_HAVE_UNISTD_H --#endif -- --#ifdef STDC --# include /* for off_t */ --#endif -- --/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and -- * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even -- * though the former does not conform to the LFS document), but considering -- * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as -- * equivalently requesting no 64-bit operations -- */ --#if -_LARGEFILE64_SOURCE - -1 == 1 --# undef _LARGEFILE64_SOURCE --#endif -- --#if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) --# include /* for SEEK_* and off_t */ --# ifdef VMS --# include /* for off_t */ --# endif --# ifndef z_off_t --# define z_off_t off_t --# endif --#endif -- --#ifndef SEEK_SET --# define SEEK_SET 0 /* Seek from beginning of file. */ --# define SEEK_CUR 1 /* Seek from current position. */ --# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ --#endif -- --#ifndef z_off_t --# define z_off_t long --#endif -- --#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 --# define z_off64_t off64_t --#else --# define z_off64_t z_off_t --#endif -- --#if defined(__OS400__) --# define NO_vsnprintf --#endif -- --#if defined(__MVS__) --# define NO_vsnprintf --#endif -- --/* MVS linker does not support external names larger than 8 bytes */ --#if defined(__MVS__) -- #pragma map(deflateInit_,"DEIN") -- #pragma map(deflateInit2_,"DEIN2") -- #pragma map(deflateEnd,"DEEND") -- #pragma map(deflateBound,"DEBND") -- #pragma map(inflateInit_,"ININ") -- #pragma map(inflateInit2_,"ININ2") -- #pragma map(inflateEnd,"INEND") -- #pragma map(inflateSync,"INSY") -- #pragma map(inflateSetDictionary,"INSEDI") -- #pragma map(compressBound,"CMBND") -- #pragma map(inflate_table,"INTABL") -- #pragma map(inflate_fast,"INFA") -- #pragma map(inflate_copyright,"INCOPY") --#endif -- --#endif /* ZCONF_H */ -diff --git a/thirdparty/zlib/zconf.in.h b/thirdparty/zlib/zconf.in.h -deleted file mode 100644 -index 03a9431..0000000 ---- a/thirdparty/zlib/zconf.in.h -+++ /dev/null -@@ -1,332 +0,0 @@ --/* zconf.h -- configuration of the zlib compression library -- * Copyright (C) 1995-2005 Jean-loup Gailly. -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* @(#) $Id$ */ -- --#ifndef ZCONF_H --#define ZCONF_H -- --/* -- * If you *really* need a unique prefix for all types and library functions, -- * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. -- */ --#ifdef Z_PREFIX --# define deflateInit_ z_deflateInit_ --# define deflate z_deflate --# define deflateEnd z_deflateEnd --# define inflateInit_ z_inflateInit_ --# define inflate z_inflate --# define inflateEnd z_inflateEnd --# define deflateInit2_ z_deflateInit2_ --# define deflateSetDictionary z_deflateSetDictionary --# define deflateCopy z_deflateCopy --# define deflateReset z_deflateReset --# define deflateParams z_deflateParams --# define deflateBound z_deflateBound --# define deflatePrime z_deflatePrime --# define inflateInit2_ z_inflateInit2_ --# define inflateSetDictionary z_inflateSetDictionary --# define inflateSync z_inflateSync --# define inflateSyncPoint z_inflateSyncPoint --# define inflateCopy z_inflateCopy --# define inflateReset z_inflateReset --# define inflateBack z_inflateBack --# define inflateBackEnd z_inflateBackEnd --# define compress z_compress --# define compress2 z_compress2 --# define compressBound z_compressBound --# define uncompress z_uncompress --# define adler32 z_adler32 --# define crc32 z_crc32 --# define get_crc_table z_get_crc_table --# define zError z_zError -- --# define alloc_func z_alloc_func --# define free_func z_free_func --# define in_func z_in_func --# define out_func z_out_func --# define Byte z_Byte --# define uInt z_uInt --# define uLong z_uLong --# define Bytef z_Bytef --# define charf z_charf --# define intf z_intf --# define uIntf z_uIntf --# define uLongf z_uLongf --# define voidpf z_voidpf --# define voidp z_voidp --#endif -- --#if defined(__MSDOS__) && !defined(MSDOS) --# define MSDOS --#endif --#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) --# define OS2 --#endif --#if defined(_WINDOWS) && !defined(WINDOWS) --# define WINDOWS --#endif --#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) --# ifndef WIN32 --# define WIN32 --# endif --#endif --#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) --# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) --# ifndef SYS16BIT --# define SYS16BIT --# endif --# endif --#endif -- --/* -- * Compile with -DMAXSEG_64K if the alloc function cannot allocate more -- * than 64k bytes at a time (needed on systems with 16-bit int). -- */ --#ifdef SYS16BIT --# define MAXSEG_64K --#endif --#ifdef MSDOS --# define UNALIGNED_OK --#endif -- --#ifdef __STDC_VERSION__ --# ifndef STDC --# define STDC --# endif --# if __STDC_VERSION__ >= 199901L --# ifndef STDC99 --# define STDC99 --# endif --# endif --#endif --#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) --# define STDC --#endif --#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) --# define STDC --#endif --#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) --# define STDC --#endif --#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) --# define STDC --#endif -- --#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ --# define STDC --#endif -- --#ifndef STDC --# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ --# define const /* note: need a more gentle solution here */ --# endif --#endif -- --/* Some Mac compilers merge all .h files incorrectly: */ --#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) --# define NO_DUMMY_DECL --#endif -- --/* Maximum value for memLevel in deflateInit2 */ --#ifndef MAX_MEM_LEVEL --# ifdef MAXSEG_64K --# define MAX_MEM_LEVEL 8 --# else --# define MAX_MEM_LEVEL 9 --# endif --#endif -- --/* Maximum value for windowBits in deflateInit2 and inflateInit2. -- * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files -- * created by gzip. (Files created by minigzip can still be extracted by -- * gzip.) -- */ --#ifndef MAX_WBITS --# define MAX_WBITS 15 /* 32K LZ77 window */ --#endif -- --/* The memory requirements for deflate are (in bytes): -- (1 << (windowBits+2)) + (1 << (memLevel+9)) -- that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) -- plus a few kilobytes for small objects. For example, if you want to reduce -- the default memory requirements from 256K to 128K, compile with -- make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" -- Of course this will generally degrade compression (there's no free lunch). -- -- The memory requirements for inflate are (in bytes) 1 << windowBits -- that is, 32K for windowBits=15 (default value) plus a few kilobytes -- for small objects. --*/ -- -- /* Type declarations */ -- --#ifndef OF /* function prototypes */ --# ifdef STDC --# define OF(args) args --# else --# define OF(args) () --# endif --#endif -- --/* The following definitions for FAR are needed only for MSDOS mixed -- * model programming (small or medium model with some far allocations). -- * This was tested only with MSC; for other MSDOS compilers you may have -- * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, -- * just define FAR to be empty. -- */ --#ifdef SYS16BIT --# if defined(M_I86SM) || defined(M_I86MM) -- /* MSC small or medium model */ --# define SMALL_MEDIUM --# ifdef _MSC_VER --# define FAR _far --# else --# define FAR far --# endif --# endif --# if (defined(__SMALL__) || defined(__MEDIUM__)) -- /* Turbo C small or medium model */ --# define SMALL_MEDIUM --# ifdef __BORLANDC__ --# define FAR _far --# else --# define FAR far --# endif --# endif --#endif -- --#if defined(WINDOWS) || defined(WIN32) -- /* If building or using zlib as a DLL, define ZLIB_DLL. -- * This is not mandatory, but it offers a little performance increase. -- */ --# ifdef ZLIB_DLL --# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) --# ifdef ZLIB_INTERNAL --# define ZEXTERN extern __declspec(dllexport) --# else --# define ZEXTERN extern __declspec(dllimport) --# endif --# endif --# endif /* ZLIB_DLL */ -- /* If building or using zlib with the WINAPI/WINAPIV calling convention, -- * define ZLIB_WINAPI. -- * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. -- */ --# ifdef ZLIB_WINAPI --# ifdef FAR --# undef FAR --# endif --# include -- /* No need for _export, use ZLIB.DEF instead. */ -- /* For complete Windows compatibility, use WINAPI, not __stdcall. */ --# define ZEXPORT WINAPI --# ifdef WIN32 --# define ZEXPORTVA WINAPIV --# else --# define ZEXPORTVA FAR CDECL --# endif --# endif --#endif -- --#if defined (__BEOS__) --# ifdef ZLIB_DLL --# ifdef ZLIB_INTERNAL --# define ZEXPORT __declspec(dllexport) --# define ZEXPORTVA __declspec(dllexport) --# else --# define ZEXPORT __declspec(dllimport) --# define ZEXPORTVA __declspec(dllimport) --# endif --# endif --#endif -- --#ifndef ZEXTERN --# define ZEXTERN extern --#endif --#ifndef ZEXPORT --# define ZEXPORT --#endif --#ifndef ZEXPORTVA --# define ZEXPORTVA --#endif -- --#ifndef FAR --# define FAR --#endif -- --#if !defined(__MACTYPES__) --typedef unsigned char Byte; /* 8 bits */ --#endif --typedef unsigned int uInt; /* 16 bits or more */ --typedef unsigned long uLong; /* 32 bits or more */ -- --#ifdef SMALL_MEDIUM -- /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ --# define Bytef Byte FAR --#else -- typedef Byte FAR Bytef; --#endif --typedef char FAR charf; --typedef int FAR intf; --typedef uInt FAR uIntf; --typedef uLong FAR uLongf; -- --#ifdef STDC -- typedef void const *voidpc; -- typedef void FAR *voidpf; -- typedef void *voidp; --#else -- typedef Byte const *voidpc; -- typedef Byte FAR *voidpf; -- typedef Byte *voidp; --#endif -- --#if 0 /* HAVE_UNISTD_H -- this line is updated by ./configure */ --# include /* for off_t */ --# include /* for SEEK_* and off_t */ --# ifdef VMS --# include /* for off_t */ --# endif --# define z_off_t off_t --#endif --#ifndef SEEK_SET --# define SEEK_SET 0 /* Seek from beginning of file. */ --# define SEEK_CUR 1 /* Seek from current position. */ --# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ --#endif --#ifndef z_off_t --# define z_off_t long --#endif -- --#if defined(__OS400__) --# define NO_vsnprintf --#endif -- --#if defined(__MVS__) --# define NO_vsnprintf --# ifdef FAR --# undef FAR --# endif --#endif -- --/* MVS linker does not support external names larger than 8 bytes */ --#if defined(__MVS__) --# pragma map(deflateInit_,"DEIN") --# pragma map(deflateInit2_,"DEIN2") --# pragma map(deflateEnd,"DEEND") --# pragma map(deflateBound,"DEBND") --# pragma map(inflateInit_,"ININ") --# pragma map(inflateInit2_,"ININ2") --# pragma map(inflateEnd,"INEND") --# pragma map(inflateSync,"INSY") --# pragma map(inflateSetDictionary,"INSEDI") --# pragma map(compressBound,"CMBND") --# pragma map(inflate_table,"INTABL") --# pragma map(inflate_fast,"INFA") --# pragma map(inflate_copyright,"INCOPY") --#endif -- --#endif /* ZCONF_H */ -diff --git a/thirdparty/zlib/zlib.h b/thirdparty/zlib/zlib.h -deleted file mode 100644 -index bfbba83..0000000 ---- a/thirdparty/zlib/zlib.h -+++ /dev/null -@@ -1,1613 +0,0 @@ --/* zlib.h -- interface of the 'zlib' general purpose compression library -- version 1.2.5, April 19th, 2010 -- -- Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler -- -- This software is provided 'as-is', without any express or implied -- warranty. In no event will the authors be held liable for any damages -- arising from the use of this software. -- -- Permission is granted to anyone to use this software for any purpose, -- including commercial applications, and to alter it and redistribute it -- freely, subject to the following restrictions: -- -- 1. The origin of this software must not be misrepresented; you must not -- claim that you wrote the original software. If you use this software -- in a product, an acknowledgment in the product documentation would be -- appreciated but is not required. -- 2. Altered source versions must be plainly marked as such, and must not be -- misrepresented as being the original software. -- 3. This notice may not be removed or altered from any source distribution. -- -- Jean-loup Gailly Mark Adler -- jloup@gzip.org madler@alumni.caltech.edu -- -- -- The data format used by the zlib library is described by RFCs (Request for -- Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt -- (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). --*/ -- --#ifndef ZLIB_H --#define ZLIB_H -- --#include "zconf.h" -- --#ifdef __cplusplus --extern "C" { --#endif -- --#define ZLIB_VERSION "1.2.5" --#define ZLIB_VERNUM 0x1250 --#define ZLIB_VER_MAJOR 1 --#define ZLIB_VER_MINOR 2 --#define ZLIB_VER_REVISION 5 --#define ZLIB_VER_SUBREVISION 0 -- --/* -- The 'zlib' compression library provides in-memory compression and -- decompression functions, including integrity checks of the uncompressed data. -- This version of the library supports only one compression method (deflation) -- but other algorithms will be added later and will have the same stream -- interface. -- -- Compression can be done in a single step if the buffers are large enough, -- or can be done by repeated calls of the compression function. In the latter -- case, the application must provide more input and/or consume the output -- (providing more output space) before each call. -- -- The compressed data format used by default by the in-memory functions is -- the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped -- around a deflate stream, which is itself documented in RFC 1951. -- -- The library also supports reading and writing files in gzip (.gz) format -- with an interface similar to that of stdio using the functions that start -- with "gz". The gzip format is different from the zlib format. gzip is a -- gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. -- -- This library can optionally read and write gzip streams in memory as well. -- -- The zlib format was designed to be compact and fast for use in memory -- and on communications channels. The gzip format was designed for single- -- file compression on file systems, has a larger header than zlib to maintain -- directory information, and uses a different, slower check method than zlib. -- -- The library does not install any signal handler. The decoder checks -- the consistency of the compressed data, so the library should never crash -- even in case of corrupted input. --*/ -- --typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); --typedef void (*free_func) OF((voidpf opaque, voidpf address)); -- --struct internal_state; -- --typedef struct z_stream_s { -- Bytef *next_in; /* next input byte */ -- uInt avail_in; /* number of bytes available at next_in */ -- uLong total_in; /* total nb of input bytes read so far */ -- -- Bytef *next_out; /* next output byte should be put there */ -- uInt avail_out; /* remaining free space at next_out */ -- uLong total_out; /* total nb of bytes output so far */ -- -- char *msg; /* last error message, NULL if no error */ -- struct internal_state FAR *state; /* not visible by applications */ -- -- alloc_func zalloc; /* used to allocate the internal state */ -- free_func zfree; /* used to free the internal state */ -- voidpf opaque; /* private data object passed to zalloc and zfree */ -- -- int data_type; /* best guess about the data type: binary or text */ -- uLong adler; /* adler32 value of the uncompressed data */ -- uLong reserved; /* reserved for future use */ --} z_stream; -- --typedef z_stream FAR *z_streamp; -- --/* -- gzip header information passed to and from zlib routines. See RFC 1952 -- for more details on the meanings of these fields. --*/ --typedef struct gz_header_s { -- int text; /* true if compressed data believed to be text */ -- uLong time; /* modification time */ -- int xflags; /* extra flags (not used when writing a gzip file) */ -- int os; /* operating system */ -- Bytef *extra; /* pointer to extra field or Z_NULL if none */ -- uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ -- uInt extra_max; /* space at extra (only when reading header) */ -- Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ -- uInt name_max; /* space at name (only when reading header) */ -- Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ -- uInt comm_max; /* space at comment (only when reading header) */ -- int hcrc; /* true if there was or will be a header crc */ -- int done; /* true when done reading gzip header (not used -- when writing a gzip file) */ --} gz_header; -- --typedef gz_header FAR *gz_headerp; -- --/* -- The application must update next_in and avail_in when avail_in has dropped -- to zero. It must update next_out and avail_out when avail_out has dropped -- to zero. The application must initialize zalloc, zfree and opaque before -- calling the init function. All other fields are set by the compression -- library and must not be updated by the application. -- -- The opaque value provided by the application will be passed as the first -- parameter for calls of zalloc and zfree. This can be useful for custom -- memory management. The compression library attaches no meaning to the -- opaque value. -- -- zalloc must return Z_NULL if there is not enough memory for the object. -- If zlib is used in a multi-threaded application, zalloc and zfree must be -- thread safe. -- -- On 16-bit systems, the functions zalloc and zfree must be able to allocate -- exactly 65536 bytes, but will not be required to allocate more than this if -- the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, pointers -- returned by zalloc for objects of exactly 65536 bytes *must* have their -- offset normalized to zero. The default allocation function provided by this -- library ensures this (see zutil.c). To reduce memory requirements and avoid -- any allocation of 64K objects, at the expense of compression ratio, compile -- the library with -DMAX_WBITS=14 (see zconf.h). -- -- The fields total_in and total_out can be used for statistics or progress -- reports. After compression, total_in holds the total size of the -- uncompressed data and may be saved for use in the decompressor (particularly -- if the decompressor wants to decompress everything in a single step). --*/ -- -- /* constants */ -- --#define Z_NO_FLUSH 0 --#define Z_PARTIAL_FLUSH 1 --#define Z_SYNC_FLUSH 2 --#define Z_FULL_FLUSH 3 --#define Z_FINISH 4 --#define Z_BLOCK 5 --#define Z_TREES 6 --/* Allowed flush values; see deflate() and inflate() below for details */ -- --#define Z_OK 0 --#define Z_STREAM_END 1 --#define Z_NEED_DICT 2 --#define Z_ERRNO (-1) --#define Z_STREAM_ERROR (-2) --#define Z_DATA_ERROR (-3) --#define Z_MEM_ERROR (-4) --#define Z_BUF_ERROR (-5) --#define Z_VERSION_ERROR (-6) --/* Return codes for the compression/decompression functions. Negative values -- * are errors, positive values are used for special but normal events. -- */ -- --#define Z_NO_COMPRESSION 0 --#define Z_BEST_SPEED 1 --#define Z_BEST_COMPRESSION 9 --#define Z_DEFAULT_COMPRESSION (-1) --/* compression levels */ -- --#define Z_FILTERED 1 --#define Z_HUFFMAN_ONLY 2 --#define Z_RLE 3 --#define Z_FIXED 4 --#define Z_DEFAULT_STRATEGY 0 --/* compression strategy; see deflateInit2() below for details */ -- --#define Z_BINARY 0 --#define Z_TEXT 1 --#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ --#define Z_UNKNOWN 2 --/* Possible values of the data_type field (though see inflate()) */ -- --#define Z_DEFLATED 8 --/* The deflate compression method (the only one supported in this version) */ -- --#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ -- --#define zlib_version zlibVersion() --/* for compatibility with versions < 1.0.2 */ -- -- -- /* basic functions */ -- --ZEXTERN const char * ZEXPORT zlibVersion OF((void)); --/* The application can compare zlibVersion and ZLIB_VERSION for consistency. -- If the first character differs, the library code actually used is not -- compatible with the zlib.h header file used by the application. This check -- is automatically made by deflateInit and inflateInit. -- */ -- --/* --ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); -- -- Initializes the internal stream state for compression. The fields -- zalloc, zfree and opaque must be initialized before by the caller. If -- zalloc and zfree are set to Z_NULL, deflateInit updates them to use default -- allocation functions. -- -- The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: -- 1 gives best speed, 9 gives best compression, 0 gives no compression at all -- (the input data is simply copied a block at a time). Z_DEFAULT_COMPRESSION -- requests a default compromise between speed and compression (currently -- equivalent to level 6). -- -- deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough -- memory, Z_STREAM_ERROR if level is not a valid compression level, or -- Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible -- with the version assumed by the caller (ZLIB_VERSION). msg is set to null -- if there is no error message. deflateInit does not perform any compression: -- this will be done by deflate(). --*/ -- -- --ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); --/* -- deflate compresses as much data as possible, and stops when the input -- buffer becomes empty or the output buffer becomes full. It may introduce -- some output latency (reading input without producing any output) except when -- forced to flush. -- -- The detailed semantics are as follows. deflate performs one or both of the -- following actions: -- -- - Compress more input starting at next_in and update next_in and avail_in -- accordingly. If not all input can be processed (because there is not -- enough room in the output buffer), next_in and avail_in are updated and -- processing will resume at this point for the next call of deflate(). -- -- - Provide more output starting at next_out and update next_out and avail_out -- accordingly. This action is forced if the parameter flush is non zero. -- Forcing flush frequently degrades the compression ratio, so this parameter -- should be set only when necessary (in interactive applications). Some -- output may be provided even if flush is not set. -- -- Before the call of deflate(), the application should ensure that at least -- one of the actions is possible, by providing more input and/or consuming more -- output, and updating avail_in or avail_out accordingly; avail_out should -- never be zero before the call. The application can consume the compressed -- output when it wants, for example when the output buffer is full (avail_out -- == 0), or after each call of deflate(). If deflate returns Z_OK and with -- zero avail_out, it must be called again after making room in the output -- buffer because there might be more output pending. -- -- Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to -- decide how much data to accumulate before producing output, in order to -- maximize compression. -- -- If the parameter flush is set to Z_SYNC_FLUSH, all pending output is -- flushed to the output buffer and the output is aligned on a byte boundary, so -- that the decompressor can get all input data available so far. (In -- particular avail_in is zero after the call if enough output space has been -- provided before the call.) Flushing may degrade compression for some -- compression algorithms and so it should be used only when necessary. This -- completes the current deflate block and follows it with an empty stored block -- that is three bits plus filler bits to the next byte, followed by four bytes -- (00 00 ff ff). -- -- If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the -- output buffer, but the output is not aligned to a byte boundary. All of the -- input data so far will be available to the decompressor, as for Z_SYNC_FLUSH. -- This completes the current deflate block and follows it with an empty fixed -- codes block that is 10 bits long. This assures that enough bytes are output -- in order for the decompressor to finish the block before the empty fixed code -- block. -- -- If flush is set to Z_BLOCK, a deflate block is completed and emitted, as -- for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to -- seven bits of the current block are held to be written as the next byte after -- the next deflate block is completed. In this case, the decompressor may not -- be provided enough bits at this point in order to complete decompression of -- the data provided so far to the compressor. It may need to wait for the next -- block to be emitted. This is for advanced applications that need to control -- the emission of deflate blocks. -- -- If flush is set to Z_FULL_FLUSH, all output is flushed as with -- Z_SYNC_FLUSH, and the compression state is reset so that decompression can -- restart from this point if previous compressed data has been damaged or if -- random access is desired. Using Z_FULL_FLUSH too often can seriously degrade -- compression. -- -- If deflate returns with avail_out == 0, this function must be called again -- with the same value of the flush parameter and more output space (updated -- avail_out), until the flush is complete (deflate returns with non-zero -- avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that -- avail_out is greater than six to avoid repeated flush markers due to -- avail_out == 0 on return. -- -- If the parameter flush is set to Z_FINISH, pending input is processed, -- pending output is flushed and deflate returns with Z_STREAM_END if there was -- enough output space; if deflate returns with Z_OK, this function must be -- called again with Z_FINISH and more output space (updated avail_out) but no -- more input data, until it returns with Z_STREAM_END or an error. After -- deflate has returned Z_STREAM_END, the only possible operations on the stream -- are deflateReset or deflateEnd. -- -- Z_FINISH can be used immediately after deflateInit if all the compression -- is to be done in a single step. In this case, avail_out must be at least the -- value returned by deflateBound (see below). If deflate does not return -- Z_STREAM_END, then it must be called again as described above. -- -- deflate() sets strm->adler to the adler32 checksum of all input read -- so far (that is, total_in bytes). -- -- deflate() may update strm->data_type if it can make a good guess about -- the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered -- binary. This field is only for information purposes and does not affect the -- compression algorithm in any manner. -- -- deflate() returns Z_OK if some progress has been made (more input -- processed or more output produced), Z_STREAM_END if all input has been -- consumed and all output has been produced (only when flush is set to -- Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example -- if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible -- (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not -- fatal, and deflate() can be called again with more input and more output -- space to continue compressing. --*/ -- -- --ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); --/* -- All dynamically allocated data structures for this stream are freed. -- This function discards any unprocessed input and does not flush any pending -- output. -- -- deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the -- stream state was inconsistent, Z_DATA_ERROR if the stream was freed -- prematurely (some input or output was discarded). In the error case, msg -- may be set but then points to a static string (which must not be -- deallocated). --*/ -- -- --/* --ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); -- -- Initializes the internal stream state for decompression. The fields -- next_in, avail_in, zalloc, zfree and opaque must be initialized before by -- the caller. If next_in is not Z_NULL and avail_in is large enough (the -- exact value depends on the compression method), inflateInit determines the -- compression method from the zlib header and allocates all data structures -- accordingly; otherwise the allocation will be deferred to the first call of -- inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to -- use default allocation functions. -- -- inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough -- memory, Z_VERSION_ERROR if the zlib library version is incompatible with the -- version assumed by the caller, or Z_STREAM_ERROR if the parameters are -- invalid, such as a null pointer to the structure. msg is set to null if -- there is no error message. inflateInit does not perform any decompression -- apart from possibly reading the zlib header if present: actual decompression -- will be done by inflate(). (So next_in and avail_in may be modified, but -- next_out and avail_out are unused and unchanged.) The current implementation -- of inflateInit() does not process any header information -- that is deferred -- until inflate() is called. --*/ -- -- --ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); --/* -- inflate decompresses as much data as possible, and stops when the input -- buffer becomes empty or the output buffer becomes full. It may introduce -- some output latency (reading input without producing any output) except when -- forced to flush. -- -- The detailed semantics are as follows. inflate performs one or both of the -- following actions: -- -- - Decompress more input starting at next_in and update next_in and avail_in -- accordingly. If not all input can be processed (because there is not -- enough room in the output buffer), next_in is updated and processing will -- resume at this point for the next call of inflate(). -- -- - Provide more output starting at next_out and update next_out and avail_out -- accordingly. inflate() provides as much output as possible, until there is -- no more input data or no more space in the output buffer (see below about -- the flush parameter). -- -- Before the call of inflate(), the application should ensure that at least -- one of the actions is possible, by providing more input and/or consuming more -- output, and updating the next_* and avail_* values accordingly. The -- application can consume the uncompressed output when it wants, for example -- when the output buffer is full (avail_out == 0), or after each call of -- inflate(). If inflate returns Z_OK and with zero avail_out, it must be -- called again after making room in the output buffer because there might be -- more output pending. -- -- The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH, -- Z_BLOCK, or Z_TREES. Z_SYNC_FLUSH requests that inflate() flush as much -- output as possible to the output buffer. Z_BLOCK requests that inflate() -- stop if and when it gets to the next deflate block boundary. When decoding -- the zlib or gzip format, this will cause inflate() to return immediately -- after the header and before the first block. When doing a raw inflate, -- inflate() will go ahead and process the first block, and will return when it -- gets to the end of that block, or when it runs out of data. -- -- The Z_BLOCK option assists in appending to or combining deflate streams. -- Also to assist in this, on return inflate() will set strm->data_type to the -- number of unused bits in the last byte taken from strm->next_in, plus 64 if -- inflate() is currently decoding the last block in the deflate stream, plus -- 128 if inflate() returned immediately after decoding an end-of-block code or -- decoding the complete header up to just before the first byte of the deflate -- stream. The end-of-block will not be indicated until all of the uncompressed -- data from that block has been written to strm->next_out. The number of -- unused bits may in general be greater than seven, except when bit 7 of -- data_type is set, in which case the number of unused bits will be less than -- eight. data_type is set as noted here every time inflate() returns for all -- flush options, and so can be used to determine the amount of currently -- consumed input in bits. -- -- The Z_TREES option behaves as Z_BLOCK does, but it also returns when the -- end of each deflate block header is reached, before any actual data in that -- block is decoded. This allows the caller to determine the length of the -- deflate block header for later use in random access within a deflate block. -- 256 is added to the value of strm->data_type when inflate() returns -- immediately after reaching the end of the deflate block header. -- -- inflate() should normally be called until it returns Z_STREAM_END or an -- error. However if all decompression is to be performed in a single step (a -- single call of inflate), the parameter flush should be set to Z_FINISH. In -- this case all pending input is processed and all pending output is flushed; -- avail_out must be large enough to hold all the uncompressed data. (The size -- of the uncompressed data may have been saved by the compressor for this -- purpose.) The next operation on this stream must be inflateEnd to deallocate -- the decompression state. The use of Z_FINISH is never required, but can be -- used to inform inflate that a faster approach may be used for the single -- inflate() call. -- -- In this implementation, inflate() always flushes as much output as -- possible to the output buffer, and always uses the faster approach on the -- first call. So the only effect of the flush parameter in this implementation -- is on the return value of inflate(), as noted below, or when it returns early -- because Z_BLOCK or Z_TREES is used. -- -- If a preset dictionary is needed after this call (see inflateSetDictionary -- below), inflate sets strm->adler to the adler32 checksum of the dictionary -- chosen by the compressor and returns Z_NEED_DICT; otherwise it sets -- strm->adler to the adler32 checksum of all output produced so far (that is, -- total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described -- below. At the end of the stream, inflate() checks that its computed adler32 -- checksum is equal to that saved by the compressor and returns Z_STREAM_END -- only if the checksum is correct. -- -- inflate() can decompress and check either zlib-wrapped or gzip-wrapped -- deflate data. The header type is detected automatically, if requested when -- initializing with inflateInit2(). Any information contained in the gzip -- header is not retained, so applications that need that information should -- instead use raw inflate, see inflateInit2() below, or inflateBack() and -- perform their own processing of the gzip header and trailer. -- -- inflate() returns Z_OK if some progress has been made (more input processed -- or more output produced), Z_STREAM_END if the end of the compressed data has -- been reached and all uncompressed output has been produced, Z_NEED_DICT if a -- preset dictionary is needed at this point, Z_DATA_ERROR if the input data was -- corrupted (input stream not conforming to the zlib format or incorrect check -- value), Z_STREAM_ERROR if the stream structure was inconsistent (for example -- next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory, -- Z_BUF_ERROR if no progress is possible or if there was not enough room in the -- output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and -- inflate() can be called again with more input and more output space to -- continue decompressing. If Z_DATA_ERROR is returned, the application may -- then call inflateSync() to look for a good compression block if a partial -- recovery of the data is desired. --*/ -- -- --ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); --/* -- All dynamically allocated data structures for this stream are freed. -- This function discards any unprocessed input and does not flush any pending -- output. -- -- inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state -- was inconsistent. In the error case, msg may be set but then points to a -- static string (which must not be deallocated). --*/ -- -- -- /* Advanced functions */ -- --/* -- The following functions are needed only in some special applications. --*/ -- --/* --ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, -- int level, -- int method, -- int windowBits, -- int memLevel, -- int strategy)); -- -- This is another version of deflateInit with more compression options. The -- fields next_in, zalloc, zfree and opaque must be initialized before by the -- caller. -- -- The method parameter is the compression method. It must be Z_DEFLATED in -- this version of the library. -- -- The windowBits parameter is the base two logarithm of the window size -- (the size of the history buffer). It should be in the range 8..15 for this -- version of the library. Larger values of this parameter result in better -- compression at the expense of memory usage. The default value is 15 if -- deflateInit is used instead. -- -- windowBits can also be -8..-15 for raw deflate. In this case, -windowBits -- determines the window size. deflate() will then generate raw deflate data -- with no zlib header or trailer, and will not compute an adler32 check value. -- -- windowBits can also be greater than 15 for optional gzip encoding. Add -- 16 to windowBits to write a simple gzip header and trailer around the -- compressed data instead of a zlib wrapper. The gzip header will have no -- file name, no extra data, no comment, no modification time (set to zero), no -- header crc, and the operating system will be set to 255 (unknown). If a -- gzip stream is being written, strm->adler is a crc32 instead of an adler32. -- -- The memLevel parameter specifies how much memory should be allocated -- for the internal compression state. memLevel=1 uses minimum memory but is -- slow and reduces compression ratio; memLevel=9 uses maximum memory for -- optimal speed. The default value is 8. See zconf.h for total memory usage -- as a function of windowBits and memLevel. -- -- The strategy parameter is used to tune the compression algorithm. Use the -- value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a -- filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no -- string match), or Z_RLE to limit match distances to one (run-length -- encoding). Filtered data consists mostly of small values with a somewhat -- random distribution. In this case, the compression algorithm is tuned to -- compress them better. The effect of Z_FILTERED is to force more Huffman -- coding and less string matching; it is somewhat intermediate between -- Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as -- fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data. The -- strategy parameter only affects the compression ratio but not the -- correctness of the compressed output even if it is not set appropriately. -- Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler -- decoder for special applications. -- -- deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough -- memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid -- method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is -- incompatible with the version assumed by the caller (ZLIB_VERSION). msg is -- set to null if there is no error message. deflateInit2 does not perform any -- compression: this will be done by deflate(). --*/ -- --ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, -- const Bytef *dictionary, -- uInt dictLength)); --/* -- Initializes the compression dictionary from the given byte sequence -- without producing any compressed output. This function must be called -- immediately after deflateInit, deflateInit2 or deflateReset, before any call -- of deflate. The compressor and decompressor must use exactly the same -- dictionary (see inflateSetDictionary). -- -- The dictionary should consist of strings (byte sequences) that are likely -- to be encountered later in the data to be compressed, with the most commonly -- used strings preferably put towards the end of the dictionary. Using a -- dictionary is most useful when the data to be compressed is short and can be -- predicted with good accuracy; the data can then be compressed better than -- with the default empty dictionary. -- -- Depending on the size of the compression data structures selected by -- deflateInit or deflateInit2, a part of the dictionary may in effect be -- discarded, for example if the dictionary is larger than the window size -- provided in deflateInit or deflateInit2. Thus the strings most likely to be -- useful should be put at the end of the dictionary, not at the front. In -- addition, the current implementation of deflate will use at most the window -- size minus 262 bytes of the provided dictionary. -- -- Upon return of this function, strm->adler is set to the adler32 value -- of the dictionary; the decompressor may later use this value to determine -- which dictionary has been used by the compressor. (The adler32 value -- applies to the whole dictionary even if only a subset of the dictionary is -- actually used by the compressor.) If a raw deflate was requested, then the -- adler32 value is not computed and strm->adler is not set. -- -- deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a -- parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is -- inconsistent (for example if deflate has already been called for this stream -- or if the compression method is bsort). deflateSetDictionary does not -- perform any compression: this will be done by deflate(). --*/ -- --ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, -- z_streamp source)); --/* -- Sets the destination stream as a complete copy of the source stream. -- -- This function can be useful when several compression strategies will be -- tried, for example when there are several ways of pre-processing the input -- data with a filter. The streams that will be discarded should then be freed -- by calling deflateEnd. Note that deflateCopy duplicates the internal -- compression state which can be quite large, so this strategy is slow and can -- consume lots of memory. -- -- deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not -- enough memory, Z_STREAM_ERROR if the source stream state was inconsistent -- (such as zalloc being Z_NULL). msg is left unchanged in both source and -- destination. --*/ -- --ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); --/* -- This function is equivalent to deflateEnd followed by deflateInit, -- but does not free and reallocate all the internal compression state. The -- stream will keep the same compression level and any other attributes that -- may have been set by deflateInit2. -- -- deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source -- stream state was inconsistent (such as zalloc or state being Z_NULL). --*/ -- --ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, -- int level, -- int strategy)); --/* -- Dynamically update the compression level and compression strategy. The -- interpretation of level and strategy is as in deflateInit2. This can be -- used to switch between compression and straight copy of the input data, or -- to switch to a different kind of input data requiring a different strategy. -- If the compression level is changed, the input available so far is -- compressed with the old level (and may be flushed); the new level will take -- effect only at the next call of deflate(). -- -- Before the call of deflateParams, the stream state must be set as for -- a call of deflate(), since the currently available input may have to be -- compressed and flushed. In particular, strm->avail_out must be non-zero. -- -- deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source -- stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if -- strm->avail_out was zero. --*/ -- --ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, -- int good_length, -- int max_lazy, -- int nice_length, -- int max_chain)); --/* -- Fine tune deflate's internal compression parameters. This should only be -- used by someone who understands the algorithm used by zlib's deflate for -- searching for the best matching string, and even then only by the most -- fanatic optimizer trying to squeeze out the last compressed bit for their -- specific input data. Read the deflate.c source code for the meaning of the -- max_lazy, good_length, nice_length, and max_chain parameters. -- -- deflateTune() can be called after deflateInit() or deflateInit2(), and -- returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. -- */ -- --ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, -- uLong sourceLen)); --/* -- deflateBound() returns an upper bound on the compressed size after -- deflation of sourceLen bytes. It must be called after deflateInit() or -- deflateInit2(), and after deflateSetHeader(), if used. This would be used -- to allocate an output buffer for deflation in a single pass, and so would be -- called before deflate(). --*/ -- --ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, -- int bits, -- int value)); --/* -- deflatePrime() inserts bits in the deflate output stream. The intent -- is that this function is used to start off the deflate output with the bits -- leftover from a previous deflate stream when appending to it. As such, this -- function can only be used for raw deflate, and must be used before the first -- deflate() call after a deflateInit2() or deflateReset(). bits must be less -- than or equal to 16, and that many of the least significant bits of value -- will be inserted in the output. -- -- deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source -- stream state was inconsistent. --*/ -- --ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, -- gz_headerp head)); --/* -- deflateSetHeader() provides gzip header information for when a gzip -- stream is requested by deflateInit2(). deflateSetHeader() may be called -- after deflateInit2() or deflateReset() and before the first call of -- deflate(). The text, time, os, extra field, name, and comment information -- in the provided gz_header structure are written to the gzip header (xflag is -- ignored -- the extra flags are set according to the compression level). The -- caller must assure that, if not Z_NULL, name and comment are terminated with -- a zero byte, and that if extra is not Z_NULL, that extra_len bytes are -- available there. If hcrc is true, a gzip header crc is included. Note that -- the current versions of the command-line version of gzip (up through version -- 1.3.x) do not support header crc's, and will report that it is a "multi-part -- gzip file" and give up. -- -- If deflateSetHeader is not used, the default gzip header has text false, -- the time set to zero, and os set to 255, with no extra, name, or comment -- fields. The gzip header is returned to the default state by deflateReset(). -- -- deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source -- stream state was inconsistent. --*/ -- --/* --ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, -- int windowBits)); -- -- This is another version of inflateInit with an extra parameter. The -- fields next_in, avail_in, zalloc, zfree and opaque must be initialized -- before by the caller. -- -- The windowBits parameter is the base two logarithm of the maximum window -- size (the size of the history buffer). It should be in the range 8..15 for -- this version of the library. The default value is 15 if inflateInit is used -- instead. windowBits must be greater than or equal to the windowBits value -- provided to deflateInit2() while compressing, or it must be equal to 15 if -- deflateInit2() was not used. If a compressed stream with a larger window -- size is given as input, inflate() will return with the error code -- Z_DATA_ERROR instead of trying to allocate a larger window. -- -- windowBits can also be zero to request that inflate use the window size in -- the zlib header of the compressed stream. -- -- windowBits can also be -8..-15 for raw inflate. In this case, -windowBits -- determines the window size. inflate() will then process raw deflate data, -- not looking for a zlib or gzip header, not generating a check value, and not -- looking for any check values for comparison at the end of the stream. This -- is for use with other formats that use the deflate compressed data format -- such as zip. Those formats provide their own check values. If a custom -- format is developed using the raw deflate format for compressed data, it is -- recommended that a check value such as an adler32 or a crc32 be applied to -- the uncompressed data as is done in the zlib, gzip, and zip formats. For -- most applications, the zlib format should be used as is. Note that comments -- above on the use in deflateInit2() applies to the magnitude of windowBits. -- -- windowBits can also be greater than 15 for optional gzip decoding. Add -- 32 to windowBits to enable zlib and gzip decoding with automatic header -- detection, or add 16 to decode only the gzip format (the zlib format will -- return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a -- crc32 instead of an adler32. -- -- inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough -- memory, Z_VERSION_ERROR if the zlib library version is incompatible with the -- version assumed by the caller, or Z_STREAM_ERROR if the parameters are -- invalid, such as a null pointer to the structure. msg is set to null if -- there is no error message. inflateInit2 does not perform any decompression -- apart from possibly reading the zlib header if present: actual decompression -- will be done by inflate(). (So next_in and avail_in may be modified, but -- next_out and avail_out are unused and unchanged.) The current implementation -- of inflateInit2() does not process any header information -- that is -- deferred until inflate() is called. --*/ -- --ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, -- const Bytef *dictionary, -- uInt dictLength)); --/* -- Initializes the decompression dictionary from the given uncompressed byte -- sequence. This function must be called immediately after a call of inflate, -- if that call returned Z_NEED_DICT. The dictionary chosen by the compressor -- can be determined from the adler32 value returned by that call of inflate. -- The compressor and decompressor must use exactly the same dictionary (see -- deflateSetDictionary). For raw inflate, this function can be called -- immediately after inflateInit2() or inflateReset() and before any call of -- inflate() to set the dictionary. The application must insure that the -- dictionary that was used for compression is provided. -- -- inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a -- parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is -- inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the -- expected one (incorrect adler32 value). inflateSetDictionary does not -- perform any decompression: this will be done by subsequent calls of -- inflate(). --*/ -- --ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); --/* -- Skips invalid compressed data until a full flush point (see above the -- description of deflate with Z_FULL_FLUSH) can be found, or until all -- available input is skipped. No output is provided. -- -- inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR -- if no more input was provided, Z_DATA_ERROR if no flush point has been -- found, or Z_STREAM_ERROR if the stream structure was inconsistent. In the -- success case, the application may save the current current value of total_in -- which indicates where valid compressed data was found. In the error case, -- the application may repeatedly call inflateSync, providing more input each -- time, until success or end of the input data. --*/ -- --ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, -- z_streamp source)); --/* -- Sets the destination stream as a complete copy of the source stream. -- -- This function can be useful when randomly accessing a large stream. The -- first pass through the stream can periodically record the inflate state, -- allowing restarting inflate at those points when randomly accessing the -- stream. -- -- inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not -- enough memory, Z_STREAM_ERROR if the source stream state was inconsistent -- (such as zalloc being Z_NULL). msg is left unchanged in both source and -- destination. --*/ -- --ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); --/* -- This function is equivalent to inflateEnd followed by inflateInit, -- but does not free and reallocate all the internal decompression state. The -- stream will keep attributes that may have been set by inflateInit2. -- -- inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source -- stream state was inconsistent (such as zalloc or state being Z_NULL). --*/ -- --ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, -- int windowBits)); --/* -- This function is the same as inflateReset, but it also permits changing -- the wrap and window size requests. The windowBits parameter is interpreted -- the same as it is for inflateInit2. -- -- inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source -- stream state was inconsistent (such as zalloc or state being Z_NULL), or if -- the windowBits parameter is invalid. --*/ -- --ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, -- int bits, -- int value)); --/* -- This function inserts bits in the inflate input stream. The intent is -- that this function is used to start inflating at a bit position in the -- middle of a byte. The provided bits will be used before any bytes are used -- from next_in. This function should only be used with raw inflate, and -- should be used before the first inflate() call after inflateInit2() or -- inflateReset(). bits must be less than or equal to 16, and that many of the -- least significant bits of value will be inserted in the input. -- -- If bits is negative, then the input stream bit buffer is emptied. Then -- inflatePrime() can be called again to put bits in the buffer. This is used -- to clear out bits leftover after feeding inflate a block description prior -- to feeding inflate codes. -- -- inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source -- stream state was inconsistent. --*/ -- --ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); --/* -- This function returns two values, one in the lower 16 bits of the return -- value, and the other in the remaining upper bits, obtained by shifting the -- return value down 16 bits. If the upper value is -1 and the lower value is -- zero, then inflate() is currently decoding information outside of a block. -- If the upper value is -1 and the lower value is non-zero, then inflate is in -- the middle of a stored block, with the lower value equaling the number of -- bytes from the input remaining to copy. If the upper value is not -1, then -- it is the number of bits back from the current bit position in the input of -- the code (literal or length/distance pair) currently being processed. In -- that case the lower value is the number of bytes already emitted for that -- code. -- -- A code is being processed if inflate is waiting for more input to complete -- decoding of the code, or if it has completed decoding but is waiting for -- more output space to write the literal or match data. -- -- inflateMark() is used to mark locations in the input data for random -- access, which may be at bit positions, and to note those cases where the -- output of a code may span boundaries of random access blocks. The current -- location in the input stream can be determined from avail_in and data_type -- as noted in the description for the Z_BLOCK flush parameter for inflate. -- -- inflateMark returns the value noted above or -1 << 16 if the provided -- source stream state was inconsistent. --*/ -- --ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, -- gz_headerp head)); --/* -- inflateGetHeader() requests that gzip header information be stored in the -- provided gz_header structure. inflateGetHeader() may be called after -- inflateInit2() or inflateReset(), and before the first call of inflate(). -- As inflate() processes the gzip stream, head->done is zero until the header -- is completed, at which time head->done is set to one. If a zlib stream is -- being decoded, then head->done is set to -1 to indicate that there will be -- no gzip header information forthcoming. Note that Z_BLOCK or Z_TREES can be -- used to force inflate() to return immediately after header processing is -- complete and before any actual data is decompressed. -- -- The text, time, xflags, and os fields are filled in with the gzip header -- contents. hcrc is set to true if there is a header CRC. (The header CRC -- was valid if done is set to one.) If extra is not Z_NULL, then extra_max -- contains the maximum number of bytes to write to extra. Once done is true, -- extra_len contains the actual extra field length, and extra contains the -- extra field, or that field truncated if extra_max is less than extra_len. -- If name is not Z_NULL, then up to name_max characters are written there, -- terminated with a zero unless the length is greater than name_max. If -- comment is not Z_NULL, then up to comm_max characters are written there, -- terminated with a zero unless the length is greater than comm_max. When any -- of extra, name, or comment are not Z_NULL and the respective field is not -- present in the header, then that field is set to Z_NULL to signal its -- absence. This allows the use of deflateSetHeader() with the returned -- structure to duplicate the header. However if those fields are set to -- allocated memory, then the application will need to save those pointers -- elsewhere so that they can be eventually freed. -- -- If inflateGetHeader is not used, then the header information is simply -- discarded. The header is always checked for validity, including the header -- CRC if present. inflateReset() will reset the process to discard the header -- information. The application would need to call inflateGetHeader() again to -- retrieve the header from the next gzip stream. -- -- inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source -- stream state was inconsistent. --*/ -- --/* --ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, -- unsigned char FAR *window)); -- -- Initialize the internal stream state for decompression using inflateBack() -- calls. The fields zalloc, zfree and opaque in strm must be initialized -- before the call. If zalloc and zfree are Z_NULL, then the default library- -- derived memory allocation routines are used. windowBits is the base two -- logarithm of the window size, in the range 8..15. window is a caller -- supplied buffer of that size. Except for special applications where it is -- assured that deflate was used with small window sizes, windowBits must be 15 -- and a 32K byte window must be supplied to be able to decompress general -- deflate streams. -- -- See inflateBack() for the usage of these routines. -- -- inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of -- the paramaters are invalid, Z_MEM_ERROR if the internal state could not be -- allocated, or Z_VERSION_ERROR if the version of the library does not match -- the version of the header file. --*/ -- --typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); --typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); -- --ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, -- in_func in, void FAR *in_desc, -- out_func out, void FAR *out_desc)); --/* -- inflateBack() does a raw inflate with a single call using a call-back -- interface for input and output. This is more efficient than inflate() for -- file i/o applications in that it avoids copying between the output and the -- sliding window by simply making the window itself the output buffer. This -- function trusts the application to not change the output buffer passed by -- the output function, at least until inflateBack() returns. -- -- inflateBackInit() must be called first to allocate the internal state -- and to initialize the state with the user-provided window buffer. -- inflateBack() may then be used multiple times to inflate a complete, raw -- deflate stream with each call. inflateBackEnd() is then called to free the -- allocated state. -- -- A raw deflate stream is one with no zlib or gzip header or trailer. -- This routine would normally be used in a utility that reads zip or gzip -- files and writes out uncompressed files. The utility would decode the -- header and process the trailer on its own, hence this routine expects only -- the raw deflate stream to decompress. This is different from the normal -- behavior of inflate(), which expects either a zlib or gzip header and -- trailer around the deflate stream. -- -- inflateBack() uses two subroutines supplied by the caller that are then -- called by inflateBack() for input and output. inflateBack() calls those -- routines until it reads a complete deflate stream and writes out all of the -- uncompressed data, or until it encounters an error. The function's -- parameters and return types are defined above in the in_func and out_func -- typedefs. inflateBack() will call in(in_desc, &buf) which should return the -- number of bytes of provided input, and a pointer to that input in buf. If -- there is no input available, in() must return zero--buf is ignored in that -- case--and inflateBack() will return a buffer error. inflateBack() will call -- out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() -- should return zero on success, or non-zero on failure. If out() returns -- non-zero, inflateBack() will return with an error. Neither in() nor out() -- are permitted to change the contents of the window provided to -- inflateBackInit(), which is also the buffer that out() uses to write from. -- The length written by out() will be at most the window size. Any non-zero -- amount of input may be provided by in(). -- -- For convenience, inflateBack() can be provided input on the first call by -- setting strm->next_in and strm->avail_in. If that input is exhausted, then -- in() will be called. Therefore strm->next_in must be initialized before -- calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called -- immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in -- must also be initialized, and then if strm->avail_in is not zero, input will -- initially be taken from strm->next_in[0 .. strm->avail_in - 1]. -- -- The in_desc and out_desc parameters of inflateBack() is passed as the -- first parameter of in() and out() respectively when they are called. These -- descriptors can be optionally used to pass any information that the caller- -- supplied in() and out() functions need to do their job. -- -- On return, inflateBack() will set strm->next_in and strm->avail_in to -- pass back any unused input that was provided by the last in() call. The -- return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR -- if in() or out() returned an error, Z_DATA_ERROR if there was a format error -- in the deflate stream (in which case strm->msg is set to indicate the nature -- of the error), or Z_STREAM_ERROR if the stream was not properly initialized. -- In the case of Z_BUF_ERROR, an input or output error can be distinguished -- using strm->next_in which will be Z_NULL only if in() returned an error. If -- strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning -- non-zero. (in() will always be called before out(), so strm->next_in is -- assured to be defined if out() returns non-zero.) Note that inflateBack() -- cannot return Z_OK. --*/ -- --ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); --/* -- All memory allocated by inflateBackInit() is freed. -- -- inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream -- state was inconsistent. --*/ -- --ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); --/* Return flags indicating compile-time options. -- -- Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: -- 1.0: size of uInt -- 3.2: size of uLong -- 5.4: size of voidpf (pointer) -- 7.6: size of z_off_t -- -- Compiler, assembler, and debug options: -- 8: DEBUG -- 9: ASMV or ASMINF -- use ASM code -- 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention -- 11: 0 (reserved) -- -- One-time table building (smaller code, but not thread-safe if true): -- 12: BUILDFIXED -- build static block decoding tables when needed -- 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed -- 14,15: 0 (reserved) -- -- Library content (indicates missing functionality): -- 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking -- deflate code when not needed) -- 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect -- and decode gzip streams (to avoid linking crc code) -- 18-19: 0 (reserved) -- -- Operation variations (changes in library functionality): -- 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate -- 21: FASTEST -- deflate algorithm with only one, lowest compression level -- 22,23: 0 (reserved) -- -- The sprintf variant used by gzprintf (zero is best): -- 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format -- 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! -- 26: 0 = returns value, 1 = void -- 1 means inferred string length returned -- -- Remainder: -- 27-31: 0 (reserved) -- */ -- -- -- /* utility functions */ -- --/* -- The following utility functions are implemented on top of the basic -- stream-oriented functions. To simplify the interface, some default options -- are assumed (compression level and memory usage, standard memory allocation -- functions). The source code of these utility functions can be modified if -- you need special options. --*/ -- --ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, -- const Bytef *source, uLong sourceLen)); --/* -- Compresses the source buffer into the destination buffer. sourceLen is -- the byte length of the source buffer. Upon entry, destLen is the total size -- of the destination buffer, which must be at least the value returned by -- compressBound(sourceLen). Upon exit, destLen is the actual size of the -- compressed buffer. -- -- compress returns Z_OK if success, Z_MEM_ERROR if there was not -- enough memory, Z_BUF_ERROR if there was not enough room in the output -- buffer. --*/ -- --ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, -- const Bytef *source, uLong sourceLen, -- int level)); --/* -- Compresses the source buffer into the destination buffer. The level -- parameter has the same meaning as in deflateInit. sourceLen is the byte -- length of the source buffer. Upon entry, destLen is the total size of the -- destination buffer, which must be at least the value returned by -- compressBound(sourceLen). Upon exit, destLen is the actual size of the -- compressed buffer. -- -- compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough -- memory, Z_BUF_ERROR if there was not enough room in the output buffer, -- Z_STREAM_ERROR if the level parameter is invalid. --*/ -- --ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); --/* -- compressBound() returns an upper bound on the compressed size after -- compress() or compress2() on sourceLen bytes. It would be used before a -- compress() or compress2() call to allocate the destination buffer. --*/ -- --ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, -- const Bytef *source, uLong sourceLen)); --/* -- Decompresses the source buffer into the destination buffer. sourceLen is -- the byte length of the source buffer. Upon entry, destLen is the total size -- of the destination buffer, which must be large enough to hold the entire -- uncompressed data. (The size of the uncompressed data must have been saved -- previously by the compressor and transmitted to the decompressor by some -- mechanism outside the scope of this compression library.) Upon exit, destLen -- is the actual size of the uncompressed buffer. -- -- uncompress returns Z_OK if success, Z_MEM_ERROR if there was not -- enough memory, Z_BUF_ERROR if there was not enough room in the output -- buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. --*/ -- -- -- /* gzip file access functions */ -- --/* -- This library supports reading and writing files in gzip (.gz) format with -- an interface similar to that of stdio, using the functions that start with -- "gz". The gzip format is different from the zlib format. gzip is a gzip -- wrapper, documented in RFC 1952, wrapped around a deflate stream. --*/ -- --typedef voidp gzFile; /* opaque gzip file descriptor */ -- --/* --ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); -- -- Opens a gzip (.gz) file for reading or writing. The mode parameter is as -- in fopen ("rb" or "wb") but can also include a compression level ("wb9") or -- a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only -- compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F' -- for fixed code compression as in "wb9F". (See the description of -- deflateInit2 for more information about the strategy parameter.) Also "a" -- can be used instead of "w" to request that the gzip stream that will be -- written be appended to the file. "+" will result in an error, since reading -- and writing to the same gzip file is not supported. -- -- gzopen can be used to read a file which is not in gzip format; in this -- case gzread will directly read from the file without decompression. -- -- gzopen returns NULL if the file could not be opened, if there was -- insufficient memory to allocate the gzFile state, or if an invalid mode was -- specified (an 'r', 'w', or 'a' was not provided, or '+' was provided). -- errno can be checked to determine if the reason gzopen failed was that the -- file could not be opened. --*/ -- --ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); --/* -- gzdopen associates a gzFile with the file descriptor fd. File descriptors -- are obtained from calls like open, dup, creat, pipe or fileno (if the file -- has been previously opened with fopen). The mode parameter is as in gzopen. -- -- The next call of gzclose on the returned gzFile will also close the file -- descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor -- fd. If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd, -- mode);. The duplicated descriptor should be saved to avoid a leak, since -- gzdopen does not close fd if it fails. -- -- gzdopen returns NULL if there was insufficient memory to allocate the -- gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not -- provided, or '+' was provided), or if fd is -1. The file descriptor is not -- used until the next gz* read, write, seek, or close operation, so gzdopen -- will not detect if fd is invalid (unless fd is -1). --*/ -- --ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); --/* -- Set the internal buffer size used by this library's functions. The -- default buffer size is 8192 bytes. This function must be called after -- gzopen() or gzdopen(), and before any other calls that read or write the -- file. The buffer memory allocation is always deferred to the first read or -- write. Two buffers are allocated, either both of the specified size when -- writing, or one of the specified size and the other twice that size when -- reading. A larger buffer size of, for example, 64K or 128K bytes will -- noticeably increase the speed of decompression (reading). -- -- The new buffer size also affects the maximum length for gzprintf(). -- -- gzbuffer() returns 0 on success, or -1 on failure, such as being called -- too late. --*/ -- --ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); --/* -- Dynamically update the compression level or strategy. See the description -- of deflateInit2 for the meaning of these parameters. -- -- gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not -- opened for writing. --*/ -- --ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); --/* -- Reads the given number of uncompressed bytes from the compressed file. If -- the input file was not in gzip format, gzread copies the given number of -- bytes into the buffer. -- -- After reaching the end of a gzip stream in the input, gzread will continue -- to read, looking for another gzip stream, or failing that, reading the rest -- of the input file directly without decompression. The entire input file -- will be read if gzread is called until it returns less than the requested -- len. -- -- gzread returns the number of uncompressed bytes actually read, less than -- len for end of file, or -1 for error. --*/ -- --ZEXTERN int ZEXPORT gzwrite OF((gzFile file, -- voidpc buf, unsigned len)); --/* -- Writes the given number of uncompressed bytes into the compressed file. -- gzwrite returns the number of uncompressed bytes written or 0 in case of -- error. --*/ -- --ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); --/* -- Converts, formats, and writes the arguments to the compressed file under -- control of the format string, as in fprintf. gzprintf returns the number of -- uncompressed bytes actually written, or 0 in case of error. The number of -- uncompressed bytes written is limited to 8191, or one less than the buffer -- size given to gzbuffer(). The caller should assure that this limit is not -- exceeded. If it is exceeded, then gzprintf() will return an error (0) with -- nothing written. In this case, there may also be a buffer overflow with -- unpredictable consequences, which is possible only if zlib was compiled with -- the insecure functions sprintf() or vsprintf() because the secure snprintf() -- or vsnprintf() functions were not available. This can be determined using -- zlibCompileFlags(). --*/ -- --ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); --/* -- Writes the given null-terminated string to the compressed file, excluding -- the terminating null character. -- -- gzputs returns the number of characters written, or -1 in case of error. --*/ -- --ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); --/* -- Reads bytes from the compressed file until len-1 characters are read, or a -- newline character is read and transferred to buf, or an end-of-file -- condition is encountered. If any characters are read or if len == 1, the -- string is terminated with a null character. If no characters are read due -- to an end-of-file or len < 1, then the buffer is left untouched. -- -- gzgets returns buf which is a null-terminated string, or it returns NULL -- for end-of-file or in case of error. If there was an error, the contents at -- buf are indeterminate. --*/ -- --ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); --/* -- Writes c, converted to an unsigned char, into the compressed file. gzputc -- returns the value that was written, or -1 in case of error. --*/ -- --ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); --/* -- Reads one byte from the compressed file. gzgetc returns this byte or -1 -- in case of end of file or error. --*/ -- --ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); --/* -- Push one character back onto the stream to be read as the first character -- on the next read. At least one character of push-back is allowed. -- gzungetc() returns the character pushed, or -1 on failure. gzungetc() will -- fail if c is -1, and may fail if a character has been pushed but not read -- yet. If gzungetc is used immediately after gzopen or gzdopen, at least the -- output buffer size of pushed characters is allowed. (See gzbuffer above.) -- The pushed character will be discarded if the stream is repositioned with -- gzseek() or gzrewind(). --*/ -- --ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); --/* -- Flushes all pending output into the compressed file. The parameter flush -- is as in the deflate() function. The return value is the zlib error number -- (see function gzerror below). gzflush is only permitted when writing. -- -- If the flush parameter is Z_FINISH, the remaining data is written and the -- gzip stream is completed in the output. If gzwrite() is called again, a new -- gzip stream will be started in the output. gzread() is able to read such -- concatented gzip streams. -- -- gzflush should be called only when strictly necessary because it will -- degrade compression if called too often. --*/ -- --/* --ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, -- z_off_t offset, int whence)); -- -- Sets the starting position for the next gzread or gzwrite on the given -- compressed file. The offset represents a number of bytes in the -- uncompressed data stream. The whence parameter is defined as in lseek(2); -- the value SEEK_END is not supported. -- -- If the file is opened for reading, this function is emulated but can be -- extremely slow. If the file is opened for writing, only forward seeks are -- supported; gzseek then compresses a sequence of zeroes up to the new -- starting position. -- -- gzseek returns the resulting offset location as measured in bytes from -- the beginning of the uncompressed stream, or -1 in case of error, in -- particular if the file is opened for writing and the new starting position -- would be before the current position. --*/ -- --ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); --/* -- Rewinds the given file. This function is supported only for reading. -- -- gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) --*/ -- --/* --ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); -- -- Returns the starting position for the next gzread or gzwrite on the given -- compressed file. This position represents a number of bytes in the -- uncompressed data stream, and is zero when starting, even if appending or -- reading a gzip stream from the middle of a file using gzdopen(). -- -- gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) --*/ -- --/* --ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); -- -- Returns the current offset in the file being read or written. This offset -- includes the count of bytes that precede the gzip stream, for example when -- appending or when using gzdopen() for reading. When reading, the offset -- does not include as yet unused buffered input. This information can be used -- for a progress indicator. On error, gzoffset() returns -1. --*/ -- --ZEXTERN int ZEXPORT gzeof OF((gzFile file)); --/* -- Returns true (1) if the end-of-file indicator has been set while reading, -- false (0) otherwise. Note that the end-of-file indicator is set only if the -- read tried to go past the end of the input, but came up short. Therefore, -- just like feof(), gzeof() may return false even if there is no more data to -- read, in the event that the last read request was for the exact number of -- bytes remaining in the input file. This will happen if the input file size -- is an exact multiple of the buffer size. -- -- If gzeof() returns true, then the read functions will return no more data, -- unless the end-of-file indicator is reset by gzclearerr() and the input file -- has grown since the previous end of file was detected. --*/ -- --ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); --/* -- Returns true (1) if file is being copied directly while reading, or false -- (0) if file is a gzip stream being decompressed. This state can change from -- false to true while reading the input file if the end of a gzip stream is -- reached, but is followed by data that is not another gzip stream. -- -- If the input file is empty, gzdirect() will return true, since the input -- does not contain a gzip stream. -- -- If gzdirect() is used immediately after gzopen() or gzdopen() it will -- cause buffers to be allocated to allow reading the file to determine if it -- is a gzip file. Therefore if gzbuffer() is used, it should be called before -- gzdirect(). --*/ -- --ZEXTERN int ZEXPORT gzclose OF((gzFile file)); --/* -- Flushes all pending output if necessary, closes the compressed file and -- deallocates the (de)compression state. Note that once file is closed, you -- cannot call gzerror with file, since its structures have been deallocated. -- gzclose must not be called more than once on the same file, just as free -- must not be called more than once on the same allocation. -- -- gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a -- file operation error, or Z_OK on success. --*/ -- --ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); --ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); --/* -- Same as gzclose(), but gzclose_r() is only for use when reading, and -- gzclose_w() is only for use when writing or appending. The advantage to -- using these instead of gzclose() is that they avoid linking in zlib -- compression or decompression code that is not used when only reading or only -- writing respectively. If gzclose() is used, then both compression and -- decompression code will be included the application when linking to a static -- zlib library. --*/ -- --ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); --/* -- Returns the error message for the last error which occurred on the given -- compressed file. errnum is set to zlib error number. If an error occurred -- in the file system and not in the compression library, errnum is set to -- Z_ERRNO and the application may consult errno to get the exact error code. -- -- The application must not modify the returned string. Future calls to -- this function may invalidate the previously returned string. If file is -- closed, then the string previously returned by gzerror will no longer be -- available. -- -- gzerror() should be used to distinguish errors from end-of-file for those -- functions above that do not distinguish those cases in their return values. --*/ -- --ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); --/* -- Clears the error and end-of-file flags for file. This is analogous to the -- clearerr() function in stdio. This is useful for continuing to read a gzip -- file that is being written concurrently. --*/ -- -- -- /* checksum functions */ -- --/* -- These functions are not related to compression but are exported -- anyway because they might be useful in applications using the compression -- library. --*/ -- --ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); --/* -- Update a running Adler-32 checksum with the bytes buf[0..len-1] and -- return the updated checksum. If buf is Z_NULL, this function returns the -- required initial value for the checksum. -- -- An Adler-32 checksum is almost as reliable as a CRC32 but can be computed -- much faster. -- -- Usage example: -- -- uLong adler = adler32(0L, Z_NULL, 0); -- -- while (read_buffer(buffer, length) != EOF) { -- adler = adler32(adler, buffer, length); -- } -- if (adler != original_adler) error(); --*/ -- --/* --ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, -- z_off_t len2)); -- -- Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 -- and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for -- each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of -- seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. --*/ -- --ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); --/* -- Update a running CRC-32 with the bytes buf[0..len-1] and return the -- updated CRC-32. If buf is Z_NULL, this function returns the required -- initial value for the for the crc. Pre- and post-conditioning (one's -- complement) is performed within this function so it shouldn't be done by the -- application. -- -- Usage example: -- -- uLong crc = crc32(0L, Z_NULL, 0); -- -- while (read_buffer(buffer, length) != EOF) { -- crc = crc32(crc, buffer, length); -- } -- if (crc != original_crc) error(); --*/ -- --/* --ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); -- -- Combine two CRC-32 check values into one. For two sequences of bytes, -- seq1 and seq2 with lengths len1 and len2, CRC-32 check values were -- calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 -- check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and -- len2. --*/ -- -- -- /* various hacks, don't look :) */ -- --/* deflateInit and inflateInit are macros to allow checking the zlib version -- * and the compiler's view of z_stream: -- */ --ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, -- const char *version, int stream_size)); --ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, -- const char *version, int stream_size)); --ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, -- int windowBits, int memLevel, -- int strategy, const char *version, -- int stream_size)); --ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, -- const char *version, int stream_size)); --ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, -- unsigned char FAR *window, -- const char *version, -- int stream_size)); --#define deflateInit(strm, level) \ -- deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) --#define inflateInit(strm) \ -- inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) --#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ -- deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ -- (strategy), ZLIB_VERSION, sizeof(z_stream)) --#define inflateInit2(strm, windowBits) \ -- inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) --#define inflateBackInit(strm, windowBits, window) \ -- inflateBackInit_((strm), (windowBits), (window), \ -- ZLIB_VERSION, sizeof(z_stream)) -- --/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or -- * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if -- * both are true, the application gets the *64 functions, and the regular -- * functions are changed to 64 bits) -- in case these are set on systems -- * without large file support, _LFS64_LARGEFILE must also be true -- */ --#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 -- ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); -- ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); -- ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); -- ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); -- ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t)); -- ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); --#endif -- --#if !defined(ZLIB_INTERNAL) && _FILE_OFFSET_BITS-0 == 64 && _LFS64_LARGEFILE-0 --# define gzopen gzopen64 --# define gzseek gzseek64 --# define gztell gztell64 --# define gzoffset gzoffset64 --# define adler32_combine adler32_combine64 --# define crc32_combine crc32_combine64 --# ifdef _LARGEFILE64_SOURCE -- ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); -- ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); -- ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); -- ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); -- ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); -- ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); --# endif --#else -- ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); -- ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); -- ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); -- ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); -- ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); -- ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); --#endif -- --/* hack for buggy compilers */ --#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) -- struct internal_state {int dummy;}; --#endif -- --/* undocumented functions */ --ZEXTERN const char * ZEXPORT zError OF((int)); --ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); --ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); --ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); -- --#ifdef __cplusplus --} --#endif -- --#endif /* ZLIB_H */ -diff --git a/thirdparty/zlib/zlib_vs2010.vcxproj b/thirdparty/zlib/zlib_vs2010.vcxproj -deleted file mode 100644 -index 5717376..0000000 ---- a/thirdparty/zlib/zlib_vs2010.vcxproj -+++ /dev/null -@@ -1,246 +0,0 @@ -- -- -- -- -- Debug -- Win32 -- -- -- Debug -- x64 -- -- -- Release LIB -- Win32 -- -- -- Release LIB -- x64 -- -- -- Release -- Win32 -- -- -- Release -- x64 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- zlib -- {00929DA3-31A1-4853-ABCE-145385A4AC63} -- zlib -- Win32Proj -- -- -- -- StaticLibrary -- Unicode -- true -- -- -- StaticLibrary -- Unicode -- true -- -- -- StaticLibrary -- Unicode -- true -- -- -- StaticLibrary -- Unicode -- true -- -- -- StaticLibrary -- Unicode -- -- -- StaticLibrary -- Unicode -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- <_ProjectFileVersion>10.0.30319.1 -- $(SolutionDir)thirdparty\lib\ -- $(SolutionDir)thirdparty\lib\$(Platform)\ -- $(Configuration)\ -- $(SolutionDir)\thirdparty\lib\ -- $(SolutionDir)\thirdparty\lib\$(Platform)\ -- $(Configuration)\ -- $(SolutionDir)\thirdparty\lib\ -- $(SolutionDir)\thirdparty\lib\$(Platform)\ -- $(Configuration)\ -- $(Configuration)\ -- AllRules.ruleset -- AllRules.ruleset -- -- -- -- -- AllRules.ruleset -- AllRules.ruleset -- -- -- -- -- AllRules.ruleset -- AllRules.ruleset -- -- -- -- -- zlibd -- zlibd -- zlib -- zlib -- zlib -- zlib -- -- -- -- Disabled -- WIN32;_DEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions) -- EnableFastChecks -- MultiThreadedDebugDLL -- -- -- Level3 -- EditAndContinue -- 4996;4267;%(DisableSpecificWarnings) -- true -- -- -- -- -- -- Disabled -- _WIN64;_DEBUG;_LIB;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions) -- EnableFastChecks -- MultiThreadedDebugDLL -- -- -- Level3 -- ProgramDatabase -- 4996;4267;%(DisableSpecificWarnings) -- true -- -- -- -- -- -- WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) -- MultiThreadedDLL -- -- -- Level3 -- ProgramDatabase -- 4996;4267;%(DisableSpecificWarnings) -- MinSpace -- Size -- true -- -- -- -- -- -- WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) -- MultiThreadedDLL -- -- -- Level3 -- ProgramDatabase -- 4996;4267;%(DisableSpecificWarnings) -- MinSpace -- Size -- true -- -- -- -- -- -- WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) -- MultiThreaded -- -- -- Level3 -- ProgramDatabase -- 4996;4267;%(DisableSpecificWarnings) -- MinSpace -- Size -- true -- -- -- -- -- -- WIN64;NDEBUG;_LIB;%(PreprocessorDefinitions) -- MultiThreaded -- -- -- Level3 -- ProgramDatabase -- 4996;4267;%(DisableSpecificWarnings) -- true -- -- -- -- -- -- -- -\ No newline at end of file -diff --git a/thirdparty/zlib/zutil.c b/thirdparty/zlib/zutil.c -deleted file mode 100644 -index 898ed34..0000000 ---- a/thirdparty/zlib/zutil.c -+++ /dev/null -@@ -1,318 +0,0 @@ --/* zutil.c -- target dependent utility functions for the compression library -- * Copyright (C) 1995-2005, 2010 Jean-loup Gailly. -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* @(#) $Id$ */ -- --#include "zutil.h" -- --#ifndef NO_DUMMY_DECL --struct internal_state {int dummy;}; /* for buggy compilers */ --#endif -- --const char * const z_errmsg[10] = { --"need dictionary", /* Z_NEED_DICT 2 */ --"stream end", /* Z_STREAM_END 1 */ --"", /* Z_OK 0 */ --"file error", /* Z_ERRNO (-1) */ --"stream error", /* Z_STREAM_ERROR (-2) */ --"data error", /* Z_DATA_ERROR (-3) */ --"insufficient memory", /* Z_MEM_ERROR (-4) */ --"buffer error", /* Z_BUF_ERROR (-5) */ --"incompatible version",/* Z_VERSION_ERROR (-6) */ --""}; -- -- --const char * ZEXPORT zlibVersion() --{ -- return ZLIB_VERSION; --} -- --uLong ZEXPORT zlibCompileFlags() --{ -- uLong flags; -- -- flags = 0; -- switch ((int)(sizeof(uInt))) { -- case 2: break; -- case 4: flags += 1; break; -- case 8: flags += 2; break; -- default: flags += 3; -- } -- switch ((int)(sizeof(uLong))) { -- case 2: break; -- case 4: flags += 1 << 2; break; -- case 8: flags += 2 << 2; break; -- default: flags += 3 << 2; -- } -- switch ((int)(sizeof(voidpf))) { -- case 2: break; -- case 4: flags += 1 << 4; break; -- case 8: flags += 2 << 4; break; -- default: flags += 3 << 4; -- } -- switch ((int)(sizeof(z_off_t))) { -- case 2: break; -- case 4: flags += 1 << 6; break; -- case 8: flags += 2 << 6; break; -- default: flags += 3 << 6; -- } --#ifdef DEBUG -- flags += 1 << 8; --#endif --#if defined(ASMV) || defined(ASMINF) -- flags += 1 << 9; --#endif --#ifdef ZLIB_WINAPI -- flags += 1 << 10; --#endif --#ifdef BUILDFIXED -- flags += 1 << 12; --#endif --#ifdef DYNAMIC_CRC_TABLE -- flags += 1 << 13; --#endif --#ifdef NO_GZCOMPRESS -- flags += 1L << 16; --#endif --#ifdef NO_GZIP -- flags += 1L << 17; --#endif --#ifdef PKZIP_BUG_WORKAROUND -- flags += 1L << 20; --#endif --#ifdef FASTEST -- flags += 1L << 21; --#endif --#ifdef STDC --# ifdef NO_vsnprintf -- flags += 1L << 25; --# ifdef HAS_vsprintf_void -- flags += 1L << 26; --# endif --# else --# ifdef HAS_vsnprintf_void -- flags += 1L << 26; --# endif --# endif --#else -- flags += 1L << 24; --# ifdef NO_snprintf -- flags += 1L << 25; --# ifdef HAS_sprintf_void -- flags += 1L << 26; --# endif --# else --# ifdef HAS_snprintf_void -- flags += 1L << 26; --# endif --# endif --#endif -- return flags; --} -- --#ifdef DEBUG -- --# ifndef verbose --# define verbose 0 --# endif --int ZLIB_INTERNAL z_verbose = verbose; -- --void ZLIB_INTERNAL z_error (m) -- char *m; --{ -- fprintf(stderr, "%s\n", m); -- exit(1); --} --#endif -- --/* exported to allow conversion of error code to string for compress() and -- * uncompress() -- */ --const char * ZEXPORT zError(err) -- int err; --{ -- return ERR_MSG(err); --} -- --#if defined(_WIN32_WCE) -- /* The Microsoft C Run-Time Library for Windows CE doesn't have -- * errno. We define it as a global variable to simplify porting. -- * Its value is always 0 and should not be used. -- */ -- int errno = 0; --#endif -- --#ifndef HAVE_MEMCPY -- --void ZLIB_INTERNAL zmemcpy(dest, source, len) -- Bytef* dest; -- const Bytef* source; -- uInt len; --{ -- if (len == 0) return; -- do { -- *dest++ = *source++; /* ??? to be unrolled */ -- } while (--len != 0); --} -- --int ZLIB_INTERNAL zmemcmp(s1, s2, len) -- const Bytef* s1; -- const Bytef* s2; -- uInt len; --{ -- uInt j; -- -- for (j = 0; j < len; j++) { -- if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1; -- } -- return 0; --} -- --void ZLIB_INTERNAL zmemzero(dest, len) -- Bytef* dest; -- uInt len; --{ -- if (len == 0) return; -- do { -- *dest++ = 0; /* ??? to be unrolled */ -- } while (--len != 0); --} --#endif -- -- --#ifdef SYS16BIT -- --#ifdef __TURBOC__ --/* Turbo C in 16-bit mode */ -- --# define MY_ZCALLOC -- --/* Turbo C malloc() does not allow dynamic allocation of 64K bytes -- * and farmalloc(64K) returns a pointer with an offset of 8, so we -- * must fix the pointer. Warning: the pointer must be put back to its -- * original form in order to free it, use zcfree(). -- */ -- --#define MAX_PTR 10 --/* 10*64K = 640K */ -- --local int next_ptr = 0; -- --typedef struct ptr_table_s { -- voidpf org_ptr; -- voidpf new_ptr; --} ptr_table; -- --local ptr_table table[MAX_PTR]; --/* This table is used to remember the original form of pointers -- * to large buffers (64K). Such pointers are normalized with a zero offset. -- * Since MSDOS is not a preemptive multitasking OS, this table is not -- * protected from concurrent access. This hack doesn't work anyway on -- * a protected system like OS/2. Use Microsoft C instead. -- */ -- --voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size) --{ -- voidpf buf = opaque; /* just to make some compilers happy */ -- ulg bsize = (ulg)items*size; -- -- /* If we allocate less than 65520 bytes, we assume that farmalloc -- * will return a usable pointer which doesn't have to be normalized. -- */ -- if (bsize < 65520L) { -- buf = farmalloc(bsize); -- if (*(ush*)&buf != 0) return buf; -- } else { -- buf = farmalloc(bsize + 16L); -- } -- if (buf == NULL || next_ptr >= MAX_PTR) return NULL; -- table[next_ptr].org_ptr = buf; -- -- /* Normalize the pointer to seg:0 */ -- *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; -- *(ush*)&buf = 0; -- table[next_ptr++].new_ptr = buf; -- return buf; --} -- --void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) --{ -- int n; -- if (*(ush*)&ptr != 0) { /* object < 64K */ -- farfree(ptr); -- return; -- } -- /* Find the original pointer */ -- for (n = 0; n < next_ptr; n++) { -- if (ptr != table[n].new_ptr) continue; -- -- farfree(table[n].org_ptr); -- while (++n < next_ptr) { -- table[n-1] = table[n]; -- } -- next_ptr--; -- return; -- } -- ptr = opaque; /* just to make some compilers happy */ -- Assert(0, "zcfree: ptr not found"); --} -- --#endif /* __TURBOC__ */ -- -- --#ifdef M_I86 --/* Microsoft C in 16-bit mode */ -- --# define MY_ZCALLOC -- --#if (!defined(_MSC_VER) || (_MSC_VER <= 600)) --# define _halloc halloc --# define _hfree hfree --#endif -- --voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size) --{ -- if (opaque) opaque = 0; /* to make compiler happy */ -- return _halloc((long)items, size); --} -- --void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) --{ -- if (opaque) opaque = 0; /* to make compiler happy */ -- _hfree(ptr); --} -- --#endif /* M_I86 */ -- --#endif /* SYS16BIT */ -- -- --#ifndef MY_ZCALLOC /* Any system without a special alloc function */ -- --#ifndef STDC --extern voidp malloc OF((uInt size)); --extern voidp calloc OF((uInt items, uInt size)); --extern void free OF((voidpf ptr)); --#endif -- --voidpf ZLIB_INTERNAL zcalloc (opaque, items, size) -- voidpf opaque; -- unsigned items; -- unsigned size; --{ -- if (opaque) items += size - size; /* make compiler happy */ -- return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : -- (voidpf)calloc(items, size); --} -- --void ZLIB_INTERNAL zcfree (opaque, ptr) -- voidpf opaque; -- voidpf ptr; --{ -- free(ptr); -- if (opaque) return; /* make compiler happy */ --} -- --#endif /* MY_ZCALLOC */ -diff --git a/thirdparty/zlib/zutil.h b/thirdparty/zlib/zutil.h -deleted file mode 100644 -index 258fa88..0000000 ---- a/thirdparty/zlib/zutil.h -+++ /dev/null -@@ -1,274 +0,0 @@ --/* zutil.h -- internal interface and configuration of the compression library -- * Copyright (C) 1995-2010 Jean-loup Gailly. -- * For conditions of distribution and use, see copyright notice in zlib.h -- */ -- --/* WARNING: this file should *not* be used by applications. It is -- part of the implementation of the compression library and is -- subject to change. Applications should only use zlib.h. -- */ -- --/* @(#) $Id$ */ -- --#ifndef ZUTIL_H --#define ZUTIL_H -- --#if ((__GNUC__-0) * 10 + __GNUC_MINOR__-0 >= 33) && !defined(NO_VIZ) --# define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) --#else --# define ZLIB_INTERNAL --#endif -- --#include "zlib.h" -- --#ifdef STDC --# if !(defined(_WIN32_WCE) && defined(_MSC_VER)) --# include --# endif --# include --# include --#endif -- --#ifndef local --# define local static --#endif --/* compile with -Dlocal if your debugger can't find static symbols */ -- --typedef unsigned char uch; --typedef uch FAR uchf; --typedef unsigned short ush; --typedef ush FAR ushf; --typedef unsigned long ulg; -- --extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ --/* (size given to avoid silly warnings with Visual C++) */ -- --#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)] -- --#define ERR_RETURN(strm,err) \ -- return (strm->msg = (char*)ERR_MSG(err), (err)) --/* To be used only when the state is known to be valid */ -- -- /* common constants */ -- --#ifndef DEF_WBITS --# define DEF_WBITS MAX_WBITS --#endif --/* default windowBits for decompression. MAX_WBITS is for compression only */ -- --#if MAX_MEM_LEVEL >= 8 --# define DEF_MEM_LEVEL 8 --#else --# define DEF_MEM_LEVEL MAX_MEM_LEVEL --#endif --/* default memLevel */ -- --#define STORED_BLOCK 0 --#define STATIC_TREES 1 --#define DYN_TREES 2 --/* The three kinds of block type */ -- --#define MIN_MATCH 3 --#define MAX_MATCH 258 --/* The minimum and maximum match lengths */ -- --#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */ -- -- /* target dependencies */ -- --#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32)) --# define OS_CODE 0x00 --# if defined(__TURBOC__) || defined(__BORLANDC__) --# if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) -- /* Allow compilation with ANSI keywords only enabled */ -- void _Cdecl farfree( void *block ); -- void *_Cdecl farmalloc( unsigned long nbytes ); --# else --# include --# endif --# else /* MSC or DJGPP */ --# include --# endif --#endif -- --#ifdef AMIGA --# define OS_CODE 0x01 --#endif -- --#if defined(VAXC) || defined(VMS) --# define OS_CODE 0x02 --# define F_OPEN(name, mode) \ -- fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512") --#endif -- --#if defined(ATARI) || defined(atarist) --# define OS_CODE 0x05 --#endif -- --#ifdef OS2 --# define OS_CODE 0x06 --# ifdef M_I86 --# include --# endif --#endif -- --#if defined(MACOS) || defined(TARGET_OS_MAC) --# define OS_CODE 0x07 --# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os --# include /* for fdopen */ --# else --# ifndef fdopen --# define fdopen(fd,mode) NULL /* No fdopen() */ --# endif --# endif --#endif -- --#ifdef TOPS20 --# define OS_CODE 0x0a --#endif -- --#ifdef WIN32 --# ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */ --# define OS_CODE 0x0b --# endif --#endif -- --#ifdef __50SERIES /* Prime/PRIMOS */ --# define OS_CODE 0x0f --#endif -- --#if defined(_BEOS_) || defined(RISCOS) --# define fdopen(fd,mode) NULL /* No fdopen() */ --#endif -- --#if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX --# if defined(_WIN32_WCE) --# define fdopen(fd,mode) NULL /* No fdopen() */ --# ifndef _PTRDIFF_T_DEFINED -- typedef int ptrdiff_t; --# define _PTRDIFF_T_DEFINED --# endif --# else --# define fdopen(fd,type) _fdopen(fd,type) --# endif --#endif -- --#if defined(__BORLANDC__) -- #pragma warn -8004 -- #pragma warn -8008 -- #pragma warn -8066 --#endif -- --/* provide prototypes for these when building zlib without LFS */ --#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 -- ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); -- ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); --#endif -- -- /* common defaults */ -- --#ifndef OS_CODE --# define OS_CODE 0x03 /* assume Unix */ --#endif -- --#ifndef F_OPEN --# define F_OPEN(name, mode) fopen((name), (mode)) --#endif -- -- /* functions */ -- --#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550) --# ifndef HAVE_VSNPRINTF --# define HAVE_VSNPRINTF --# endif --#endif --#if defined(__CYGWIN__) --# ifndef HAVE_VSNPRINTF --# define HAVE_VSNPRINTF --# endif --#endif --#ifndef HAVE_VSNPRINTF --# ifdef MSDOS -- /* vsnprintf may exist on some MS-DOS compilers (DJGPP?), -- but for now we just assume it doesn't. */ --# define NO_vsnprintf --# endif --# ifdef __TURBOC__ --# define NO_vsnprintf --# endif --# ifdef WIN32 -- /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */ --# if !defined(vsnprintf) && !defined(NO_vsnprintf) --# if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 ) --# define vsnprintf _vsnprintf --# endif --# endif --# endif --# ifdef __SASC --# define NO_vsnprintf --# endif --#endif --#ifdef VMS --# define NO_vsnprintf --#endif -- --#if defined(pyr) --# define NO_MEMCPY --#endif --#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) -- /* Use our own functions for small and medium model with MSC <= 5.0. -- * You may have to use the same strategy for Borland C (untested). -- * The __SC__ check is for Symantec. -- */ --# define NO_MEMCPY --#endif --#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY) --# define HAVE_MEMCPY --#endif --#ifdef HAVE_MEMCPY --# ifdef SMALL_MEDIUM /* MSDOS small or medium model */ --# define zmemcpy _fmemcpy --# define zmemcmp _fmemcmp --# define zmemzero(dest, len) _fmemset(dest, 0, len) --# else --# define zmemcpy memcpy --# define zmemcmp memcmp --# define zmemzero(dest, len) memset(dest, 0, len) --# endif --#else -- void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); -- int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); -- void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len)); --#endif -- --/* Diagnostic functions */ --#ifdef DEBUG --# include -- extern int ZLIB_INTERNAL z_verbose; -- extern void ZLIB_INTERNAL z_error OF((char *m)); --# define Assert(cond,msg) {if(!(cond)) z_error(msg);} --# define Trace(x) {if (z_verbose>=0) fprintf x ;} --# define Tracev(x) {if (z_verbose>0) fprintf x ;} --# define Tracevv(x) {if (z_verbose>1) fprintf x ;} --# define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;} --# define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;} --#else --# define Assert(cond,msg) --# define Trace(x) --# define Tracev(x) --# define Tracevv(x) --# define Tracec(c,x) --# define Tracecv(c,x) --#endif -- -- --voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items, -- unsigned size)); --void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr)); -- --#define ZALLOC(strm, items, size) \ -- (*((strm)->zalloc))((strm)->opaque, (items), (size)) --#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) --#define TRY_FREE(s, p) {if (p) ZFREE(s, p);} -- --#endif /* ZUTIL_H */ From 50d9ba739a3b6d639ee122bb9ab5984326962862 Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Fri, 24 Apr 2020 12:27:55 -0400 Subject: [PATCH 07/20] Add vcpkg_copy_tool_dependencies so that dlls for CrashSender .exe will be copied to tools folder --- ports/crashrpt/portfile.cmake | 1 + 1 file changed, 1 insertion(+) diff --git a/ports/crashrpt/portfile.cmake b/ports/crashrpt/portfile.cmake index a71f273c3fd3a6..e237af8ae053a7 100644 --- a/ports/crashrpt/portfile.cmake +++ b/ports/crashrpt/portfile.cmake @@ -41,6 +41,7 @@ vcpkg_configure_cmake( vcpkg_install_cmake() vcpkg_copy_pdbs() +vcpkg_copy_tool_dependencies(${CURRENT_PACKAGES_DIR}/tools/${PORT}) file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include") From e058a23f048f2c944202419bf5d442c751b8635c Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Fri, 24 Apr 2020 12:45:16 -0400 Subject: [PATCH 08/20] Add install for crprober.exe tool --- ports/crashrpt/001-cmake-install.patch | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/ports/crashrpt/001-cmake-install.patch b/ports/crashrpt/001-cmake-install.patch index 4748fa94129259..c4d1710eeaed9d 100644 --- a/ports/crashrpt/001-cmake-install.patch +++ b/ports/crashrpt/001-cmake-install.patch @@ -49,6 +49,21 @@ index a6c692a..35e06bb 100644 + ARCHIVE + RUNTIME +) +diff --git a/processing/crprober/CMakeLists.txt b/processing/crprober/CMakeLists.txt +index 046ba57..255e200 100644 +--- a/processing/crprober/CMakeLists.txt ++++ b/processing/crprober/CMakeLists.txt +@@ -18,4 +18,8 @@ add_executable(crprober ${source_files} ${header_files}) + # Add input link libraries + target_link_libraries(crprober CrashRptProbe) + +-set_target_properties(crprober PROPERTIES DEBUG_POSTFIX d ) +\ No newline at end of file ++set_target_properties(crprober PROPERTIES DEBUG_POSTFIX d ) ++ ++install(TARGETS crprober ++ RUNTIME DESTINATION tools/crashrpt ++) diff --git a/reporting/crashrpt/CMakeLists.txt b/reporting/crashrpt/CMakeLists.txt index 42d40e2..a335ca9 100644 --- a/reporting/crashrpt/CMakeLists.txt From 6de10b666d84c457f11f2c97f3b6cd5b2108a9e7 Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Fri, 24 Apr 2020 15:17:46 -0400 Subject: [PATCH 09/20] Replace libogg and libtheora vendored dependencies using find_library() and find_path() --- .../crashrpt/003-find-libogg-libtheora.patch | 57 +++++++++++++++++++ ports/crashrpt/CONTROL | 2 +- ports/crashrpt/portfile.cmake | 3 +- 3 files changed, 60 insertions(+), 2 deletions(-) create mode 100644 ports/crashrpt/003-find-libogg-libtheora.patch diff --git a/ports/crashrpt/003-find-libogg-libtheora.patch b/ports/crashrpt/003-find-libogg-libtheora.patch new file mode 100644 index 00000000000000..e148ac946ebb5c --- /dev/null +++ b/ports/crashrpt/003-find-libogg-libtheora.patch @@ -0,0 +1,57 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 7a20e49..42a55fc 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -99,6 +99,17 @@ endmacro() + find_package(ZLIB REQUIRED) + find_package(MINIZIP REQUIRED) + find_package(PNG REQUIRED) ++find_package(Ogg REQUIRED) ++ ++find_library(THEORA_LIBRARY theora) ++if(NOT THEORA_LIBRARY) ++ message(FATAL_ERROR "theora library not found") ++endif() ++ ++find_path(THEORA_INCLUDE_DIR theora/theora.h) ++if(NOT THEORA_INCLUDE_DIR) ++ message(FATAL_ERROR "theora include dir not found") ++endif() + + # Other CMakeLists are located in project subdirectories + +@@ -132,8 +143,8 @@ add_subdirectory("thirdparty/jpeg") + #add_subdirectory("thirdparty/libpng") + #add_subdirectory("thirdparty/minizip") + #add_subdirectory("thirdparty/zlib") +-add_subdirectory("thirdparty/libogg") +-add_subdirectory("thirdparty/libtheora") ++#add_subdirectory("thirdparty/libogg") ++#add_subdirectory("thirdparty/libtheora") + + + +diff --git a/reporting/crashsender/CMakeLists.txt b/reporting/crashsender/CMakeLists.txt +index 25cd467..9e191c4 100644 +--- a/reporting/crashsender/CMakeLists.txt ++++ b/reporting/crashsender/CMakeLists.txt +@@ -30,8 +30,8 @@ include_directories( ${CMAKE_SOURCE_DIR}/include + ${PNG_INCLUDE_DIRS} + ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml + ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include +- ${CMAKE_SOURCE_DIR}/thirdparty/libogg/include +- ${CMAKE_SOURCE_DIR}/thirdparty/libtheora/include) ++ ${OGG_INCLUDE_DIRS} ++ ${THEORA_INCLUDE_DIR}) + + if(NOT CMAKE_CL_64) + link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib ) +@@ -43,7 +43,7 @@ endif(NOT CMAKE_CL_64) + add_executable(CrashSender WIN32 ${source_files} ${header_files}) + + # Add input link libraries +-target_link_libraries(CrashSender ZLIB::ZLIB minizip::minizip libjpeg PNG::PNG tinyxml libogg libtheora WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) ++target_link_libraries(CrashSender ZLIB::ZLIB minizip::minizip libjpeg PNG::PNG tinyxml Ogg::ogg ${THEORA_LIBRARY} WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) + + # Add compiler flags (/MP for multi-processor compilation, /Os to favor small code) + set_target_properties(CrashRpt PROPERTIES COMPILE_FLAGS "/Os") diff --git a/ports/crashrpt/CONTROL b/ports/crashrpt/CONTROL index 0d78e16c008be2..32c187ba8b4210 100644 --- a/ports/crashrpt/CONTROL +++ b/ports/crashrpt/CONTROL @@ -2,4 +2,4 @@ Source: crashrpt Version: 1.4.3 Description: A crash reporting system for Windows applications Homepage: http://crashrpt.sourceforge.net/ -Build-Depends: libpng, minizip, zlib +Build-Depends: libogg, libpng, libtheora, minizip, zlib diff --git a/ports/crashrpt/portfile.cmake b/ports/crashrpt/portfile.cmake index e237af8ae053a7..22c66005bc7392 100644 --- a/ports/crashrpt/portfile.cmake +++ b/ports/crashrpt/portfile.cmake @@ -15,10 +15,11 @@ vcpkg_from_git( PATCHES 001-cmake-install.patch 002-find-minizip-png-zlib.patch + 003-find-libogg-libtheora.patch ) # Remove vendored dependencies to ensure they are not picked up by the build -foreach(DEPENDENCY libpng minizip zlib) +foreach(DEPENDENCY libogg libpng libtheora minizip zlib) if(EXISTS ${SOURCE_PATH}/thirdparty/${DEPENDENCY}) file(REMOVE_RECURSE ${SOURCE_PATH}/thirdparty/${DEPENDENCY}) endif() From f41feb8550eab486e0a54a9e92c95568e38aa1a8 Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Fri, 24 Apr 2020 17:10:27 -0400 Subject: [PATCH 10/20] Replace vendored tinyxml library --- ports/crashrpt/004-find-tinyxml.patch | 87 +++++++++++++++++++++++++++ ports/crashrpt/CONTROL | 2 +- ports/crashrpt/portfile.cmake | 3 +- 3 files changed, 90 insertions(+), 2 deletions(-) create mode 100644 ports/crashrpt/004-find-tinyxml.patch diff --git a/ports/crashrpt/004-find-tinyxml.patch b/ports/crashrpt/004-find-tinyxml.patch new file mode 100644 index 00000000000000..3ab1aa812cc7d5 --- /dev/null +++ b/ports/crashrpt/004-find-tinyxml.patch @@ -0,0 +1,87 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 42a55fc..281f66b 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -111,6 +111,16 @@ if(NOT THEORA_INCLUDE_DIR) + message(FATAL_ERROR "theora include dir not found") + endif() + ++find_library(TINYXML_LIBRARY NAMES tinyxml) ++if(NOT TINYXML_LIBRARY) ++ message(FATAL_ERROR "tinyxml library not found") ++endif() ++ ++find_path(TINYXML_INCLUDE_DIR tinyxml.h) ++if(NOT TINYXML_INCLUDE_DIR) ++ message(FATAL_ERROR "tinyxml include dir not found") ++endif() ++ + # Other CMakeLists are located in project subdirectories + + if(CRASHRPT_BUILD_DEMOS) +@@ -138,7 +148,7 @@ else(CMAKE_CL_64) + set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/thirdparty/lib) + endif(CMAKE_CL_64) + +-add_subdirectory("thirdparty/tinyxml") ++#add_subdirectory("thirdparty/tinyxml") + add_subdirectory("thirdparty/jpeg") + #add_subdirectory("thirdparty/libpng") + #add_subdirectory("thirdparty/minizip") +diff --git a/processing/crashrptprobe/CMakeLists.txt b/processing/crashrptprobe/CMakeLists.txt +index 4a54302..2aeb395 100644 +--- a/processing/crashrptprobe/CMakeLists.txt ++++ b/processing/crashrptprobe/CMakeLists.txt +@@ -24,7 +24,7 @@ include_directories( ${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/thirdparty/wtl + ${ZLIB_INCLUDE_DIRS} + ${MINIZIP_INCLUDE_DIR} +- ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml ++ ${TINYXML_INCLUDE_DIR} + ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include) + + # Add library build target +@@ -42,7 +42,7 @@ else(CMAKE_CL_64) + target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/dbghelp.lib) + endif(CMAKE_CL_64) + +-target_link_libraries(CrashRptProbe ZLIB::ZLIB minizip::minizip tinyxml Rpcrt4.lib shell32.lib gdi32.lib version.lib psapi.lib) ++target_link_libraries(CrashRptProbe ZLIB::ZLIB minizip::minizip ${TINYXML_LIBRARY} Rpcrt4.lib shell32.lib gdi32.lib version.lib psapi.lib) + + if(CRASHRPT_BUILD_SHARED_LIBS) + +diff --git a/reporting/crashsender/CMakeLists.txt b/reporting/crashsender/CMakeLists.txt +index 9e191c4..780b756 100644 +--- a/reporting/crashsender/CMakeLists.txt ++++ b/reporting/crashsender/CMakeLists.txt +@@ -28,7 +28,7 @@ include_directories( ${CMAKE_SOURCE_DIR}/include + ${MINIZIP_INCLUDE_DIR} + ${CMAKE_SOURCE_DIR}/thirdparty/jpeg + ${PNG_INCLUDE_DIRS} +- ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml ++ ${TINYXML_INCLUDE_DIR} + ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include + ${OGG_INCLUDE_DIRS} + ${THEORA_INCLUDE_DIR}) +@@ -43,7 +43,7 @@ endif(NOT CMAKE_CL_64) + add_executable(CrashSender WIN32 ${source_files} ${header_files}) + + # Add input link libraries +-target_link_libraries(CrashSender ZLIB::ZLIB minizip::minizip libjpeg PNG::PNG tinyxml Ogg::ogg ${THEORA_LIBRARY} WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) ++target_link_libraries(CrashSender ZLIB::ZLIB minizip::minizip libjpeg PNG::PNG ${TINYXML_LIBRARY} Ogg::ogg ${THEORA_LIBRARY} WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) + + # Add compiler flags (/MP for multi-processor compilation, /Os to favor small code) + set_target_properties(CrashRpt PROPERTIES COMPILE_FLAGS "/Os") +diff --git a/reporting/crashsender/ErrorReportSender.cpp b/reporting/crashsender/ErrorReportSender.cpp +index 369fd4d..46d6d12 100644 +--- a/reporting/crashsender/ErrorReportSender.cpp ++++ b/reporting/crashsender/ErrorReportSender.cpp +@@ -1086,7 +1086,7 @@ BOOL CErrorReportSender::CreateCrashDescriptionXML(CErrorReportInfo& eri) + goto cleanup; + } + +- doc.useMicrosoftBOM = true; ++ //doc.useMicrosoftBOM = true; + bool bSave = doc.SaveFile(f); + if(!bSave) + { diff --git a/ports/crashrpt/CONTROL b/ports/crashrpt/CONTROL index 32c187ba8b4210..2db0662bd21fea 100644 --- a/ports/crashrpt/CONTROL +++ b/ports/crashrpt/CONTROL @@ -2,4 +2,4 @@ Source: crashrpt Version: 1.4.3 Description: A crash reporting system for Windows applications Homepage: http://crashrpt.sourceforge.net/ -Build-Depends: libogg, libpng, libtheora, minizip, zlib +Build-Depends: libogg, libpng, libtheora, minizip, tinyxml, zlib diff --git a/ports/crashrpt/portfile.cmake b/ports/crashrpt/portfile.cmake index 22c66005bc7392..f8d66dc9b79040 100644 --- a/ports/crashrpt/portfile.cmake +++ b/ports/crashrpt/portfile.cmake @@ -16,10 +16,11 @@ vcpkg_from_git( 001-cmake-install.patch 002-find-minizip-png-zlib.patch 003-find-libogg-libtheora.patch + 004-find-tinyxml.patch ) # Remove vendored dependencies to ensure they are not picked up by the build -foreach(DEPENDENCY libogg libpng libtheora minizip zlib) +foreach(DEPENDENCY libogg libpng libtheora minizip tinyxml zlib) if(EXISTS ${SOURCE_PATH}/thirdparty/${DEPENDENCY}) file(REMOVE_RECURSE ${SOURCE_PATH}/thirdparty/${DEPENDENCY}) endif() From 213e55c1b4013a55704349977726fb08d41c2c06 Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Fri, 24 Apr 2020 17:47:39 -0400 Subject: [PATCH 11/20] Replace vendored wtl library --- ports/crashrpt/005-find-wtl.patch | 185 ++++++++++++++++++++++++++++++ ports/crashrpt/CONTROL | 2 +- ports/crashrpt/portfile.cmake | 3 +- 3 files changed, 188 insertions(+), 2 deletions(-) create mode 100644 ports/crashrpt/005-find-wtl.patch diff --git a/ports/crashrpt/005-find-wtl.patch b/ports/crashrpt/005-find-wtl.patch new file mode 100644 index 00000000000000..c9c785bdca79a6 --- /dev/null +++ b/ports/crashrpt/005-find-wtl.patch @@ -0,0 +1,185 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 281f66b..b95a781 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -121,6 +121,11 @@ if(NOT TINYXML_INCLUDE_DIR) + message(FATAL_ERROR "tinyxml include dir not found") + endif() + ++find_path(WTL_INCLUDE_DIR wtl/atlapp.h) ++if(NOT WTL_INCLUDE_DIR) ++ message(FATAL_ERROR "WTL include dir not found") ++endif() ++ + # Other CMakeLists are located in project subdirectories + + if(CRASHRPT_BUILD_DEMOS) +diff --git a/processing/crashrptprobe/CMakeLists.txt b/processing/crashrptprobe/CMakeLists.txt +index 2aeb395..dafb007 100644 +--- a/processing/crashrptprobe/CMakeLists.txt ++++ b/processing/crashrptprobe/CMakeLists.txt +@@ -21,7 +21,7 @@ fix_default_compiler_settings_() + include_directories( ${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/reporting/crashrpt + ${CMAKE_SOURCE_DIR}/reporting/crashsender +- ${CMAKE_SOURCE_DIR}/thirdparty/wtl ++ ${WTL_INCLUDE_DIR} + ${ZLIB_INCLUDE_DIRS} + ${MINIZIP_INCLUDE_DIR} + ${TINYXML_INCLUDE_DIR} +diff --git a/processing/crashrptprobe/CrashRptProbe.rc b/processing/crashrptprobe/CrashRptProbe.rc +index a08f63e..1d2abea 100644 +--- a/processing/crashrptprobe/CrashRptProbe.rc ++++ b/processing/crashrptprobe/CrashRptProbe.rc +@@ -7,7 +7,7 @@ + // + // Generated from the TEXTINCLUDE 2 resource. + // +-#include "atlres.h" ++#include "wtl/atlres.h" + + ///////////////////////////////////////////////////////////////////////////// + #undef APSTUDIO_READONLY_SYMBOLS +diff --git a/processing/crashrptprobe/stdafx.h b/processing/crashrptprobe/stdafx.h +index 2b027b2..0b60659 100644 +--- a/processing/crashrptprobe/stdafx.h ++++ b/processing/crashrptprobe/stdafx.h +@@ -70,13 +70,13 @@ namespace ATL + }; + #endif // _WTL_SUPPORT_SDK_ATL3 + +-#include ++#include + extern CAppModule _Module; + #include + + // CString-related includes + #define _WTL_USE_CSTRING +-#include ++#include + + #if _MSC_VER<1400 + #define WCSNCPY_S(strDest, sizeInBytes, strSource, count) wcsncpy(strDest, strSource, count) +diff --git a/reporting/crashrpt/CMakeLists.txt b/reporting/crashrpt/CMakeLists.txt +index a335ca9..c7e4fd6 100644 +--- a/reporting/crashrpt/CMakeLists.txt ++++ b/reporting/crashrpt/CMakeLists.txt +@@ -18,7 +18,7 @@ add_definitions(-D_UNICODE -D_CRT_SECURE_NO_DEPRECATE) + fix_default_compiler_settings_() + + # Add include dir +-include_directories( ${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/thirdparty/wtl) ++include_directories( ${CMAKE_SOURCE_DIR}/include ${WTL_INCLUDE_DIR}) + + # Add library build target + if(CRASHRPT_BUILD_SHARED_LIBS) +diff --git a/reporting/crashrpt/CrashRpt.rc b/reporting/crashrpt/CrashRpt.rc +index 95e7502..2a13940 100644 +--- a/reporting/crashrpt/CrashRpt.rc ++++ b/reporting/crashrpt/CrashRpt.rc +@@ -7,7 +7,7 @@ + // + // Generated from the TEXTINCLUDE 2 resource. + // +-#include "atlres.h" ++#include "wtl/atlres.h" + + ///////////////////////////////////////////////////////////////////////////// + #undef APSTUDIO_READONLY_SYMBOLS +diff --git a/reporting/crashrpt/StdAfx.h b/reporting/crashrpt/StdAfx.h +index 77d8c36..f6a9b6e 100644 +--- a/reporting/crashrpt/StdAfx.h ++++ b/reporting/crashrpt/StdAfx.h +@@ -54,12 +54,12 @@ namespace ATL + }; + #endif // _WTL_SUPPORT_SDK_ATL3 + +-#include ++#include + extern CAppModule _Module; + #include + // CString-related includes + #define _WTL_USE_CSTRING +-#include ++#include + #include + #include + #include +diff --git a/reporting/crashsender/CMakeLists.txt b/reporting/crashsender/CMakeLists.txt +index 780b756..23f3ae7 100644 +--- a/reporting/crashsender/CMakeLists.txt ++++ b/reporting/crashsender/CMakeLists.txt +@@ -23,7 +23,7 @@ fix_default_compiler_settings_() + # Add include dir + include_directories( ${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/reporting/CrashRpt +- ${CMAKE_SOURCE_DIR}/thirdparty/wtl ++ ${WTL_INCLUDE_DIR} + ${ZLIB_INCLUDE_DIRS} + ${MINIZIP_INCLUDE_DIR} + ${CMAKE_SOURCE_DIR}/thirdparty/jpeg +diff --git a/reporting/crashsender/CrashSender.rc b/reporting/crashsender/CrashSender.rc +index 0502962..1731869 100644 +--- a/reporting/crashsender/CrashSender.rc ++++ b/reporting/crashsender/CrashSender.rc +@@ -7,7 +7,7 @@ + // + // Generated from the TEXTINCLUDE 2 resource. + // +-#include "atlres.h" ++#include "wtl/atlres.h" + + ///////////////////////////////////////////////////////////////////////////// + #undef APSTUDIO_READONLY_SYMBOLS +diff --git a/reporting/crashsender/stdafx.h b/reporting/crashsender/stdafx.h +index f087ff4..4494d3a 100644 +--- a/reporting/crashsender/stdafx.h ++++ b/reporting/crashsender/stdafx.h +@@ -19,7 +19,7 @@ be found in the Authors.txt file in the root of the source tree. + #define WINVER 0x0501 + #define _WIN32_WINNT 0x0501 + #define _WIN32_IE 0x0600 +-#define _RICHEDIT_VER 0x0200 ++#define _RICHEDIT_VER 0x0300 + + typedef __int64 off_t, _off_t; + #define _OFF_T_DEFINED +@@ -61,19 +61,19 @@ namespace ATL + }; + #endif // _WTL_SUPPORT_SDK_ATL3 + +-#include ++#include + + extern CAppModule _Module; + + #include + +-#include +-#include +-#include +-#include ++#include ++#include ++#include ++#include + + #define _WTL_USE_CSTRING +-#include ++#include + + #include + #include +diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt +index 402b024..e2b61be 100644 +--- a/tests/CMakeLists.txt ++++ b/tests/CMakeLists.txt +@@ -32,7 +32,7 @@ set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /DEBUG") + # Add include dir + include_directories( ${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/reporting/CrashRpt +- ${CMAKE_SOURCE_DIR}/thirdparty/wtl ) ++ ${WTL_INCLUDE_DIR} ) + + # Add executable build target + add_executable(Tests ${source_files} ${header_files}) diff --git a/ports/crashrpt/CONTROL b/ports/crashrpt/CONTROL index 2db0662bd21fea..cbb8aef82863aa 100644 --- a/ports/crashrpt/CONTROL +++ b/ports/crashrpt/CONTROL @@ -2,4 +2,4 @@ Source: crashrpt Version: 1.4.3 Description: A crash reporting system for Windows applications Homepage: http://crashrpt.sourceforge.net/ -Build-Depends: libogg, libpng, libtheora, minizip, tinyxml, zlib +Build-Depends: libogg, libpng, libtheora, minizip, tinyxml, wtl, zlib diff --git a/ports/crashrpt/portfile.cmake b/ports/crashrpt/portfile.cmake index f8d66dc9b79040..31410cd64be809 100644 --- a/ports/crashrpt/portfile.cmake +++ b/ports/crashrpt/portfile.cmake @@ -17,10 +17,11 @@ vcpkg_from_git( 002-find-minizip-png-zlib.patch 003-find-libogg-libtheora.patch 004-find-tinyxml.patch + 005-find-wtl.patch ) # Remove vendored dependencies to ensure they are not picked up by the build -foreach(DEPENDENCY libogg libpng libtheora minizip tinyxml zlib) +foreach(DEPENDENCY libogg libpng libtheora minizip tinyxml wtl zlib) if(EXISTS ${SOURCE_PATH}/thirdparty/${DEPENDENCY}) file(REMOVE_RECURSE ${SOURCE_PATH}/thirdparty/${DEPENDENCY}) endif() From 5165bbd0834cee32058764b0a888d03e3217f96b Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Fri, 24 Apr 2020 18:07:36 -0400 Subject: [PATCH 12/20] Replace vendored JPEG library with libjpeg-turbo from vcpkg --- ports/crashrpt/006-find-libjpeg-turbo.patch | 43 +++++++++++++++++++++ ports/crashrpt/CONTROL | 2 +- ports/crashrpt/portfile.cmake | 3 +- 3 files changed, 46 insertions(+), 2 deletions(-) create mode 100644 ports/crashrpt/006-find-libjpeg-turbo.patch diff --git a/ports/crashrpt/006-find-libjpeg-turbo.patch b/ports/crashrpt/006-find-libjpeg-turbo.patch new file mode 100644 index 00000000000000..fcc01d07627528 --- /dev/null +++ b/ports/crashrpt/006-find-libjpeg-turbo.patch @@ -0,0 +1,43 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index b95a781..5a14f12 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -100,6 +100,7 @@ find_package(ZLIB REQUIRED) + find_package(MINIZIP REQUIRED) + find_package(PNG REQUIRED) + find_package(Ogg REQUIRED) ++find_package(JPEG REQUIRED) + + find_library(THEORA_LIBRARY theora) + if(NOT THEORA_LIBRARY) +@@ -154,7 +155,7 @@ else(CMAKE_CL_64) + endif(CMAKE_CL_64) + + #add_subdirectory("thirdparty/tinyxml") +-add_subdirectory("thirdparty/jpeg") ++#add_subdirectory("thirdparty/jpeg") + #add_subdirectory("thirdparty/libpng") + #add_subdirectory("thirdparty/minizip") + #add_subdirectory("thirdparty/zlib") +diff --git a/reporting/crashsender/CMakeLists.txt b/reporting/crashsender/CMakeLists.txt +index 23f3ae7..088365f 100644 +--- a/reporting/crashsender/CMakeLists.txt ++++ b/reporting/crashsender/CMakeLists.txt +@@ -26,7 +26,7 @@ include_directories( ${CMAKE_SOURCE_DIR}/include + ${WTL_INCLUDE_DIR} + ${ZLIB_INCLUDE_DIRS} + ${MINIZIP_INCLUDE_DIR} +- ${CMAKE_SOURCE_DIR}/thirdparty/jpeg ++ ${JPEG_INCLUDE_DIR} + ${PNG_INCLUDE_DIRS} + ${TINYXML_INCLUDE_DIR} + ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include +@@ -43,7 +43,7 @@ endif(NOT CMAKE_CL_64) + add_executable(CrashSender WIN32 ${source_files} ${header_files}) + + # Add input link libraries +-target_link_libraries(CrashSender ZLIB::ZLIB minizip::minizip libjpeg PNG::PNG ${TINYXML_LIBRARY} Ogg::ogg ${THEORA_LIBRARY} WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) ++target_link_libraries(CrashSender ZLIB::ZLIB minizip::minizip ${JPEG_LIBRARIES} PNG::PNG ${TINYXML_LIBRARY} Ogg::ogg ${THEORA_LIBRARY} WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) + + # Add compiler flags (/MP for multi-processor compilation, /Os to favor small code) + set_target_properties(CrashRpt PROPERTIES COMPILE_FLAGS "/Os") diff --git a/ports/crashrpt/CONTROL b/ports/crashrpt/CONTROL index cbb8aef82863aa..1b49194c6f1c7c 100644 --- a/ports/crashrpt/CONTROL +++ b/ports/crashrpt/CONTROL @@ -2,4 +2,4 @@ Source: crashrpt Version: 1.4.3 Description: A crash reporting system for Windows applications Homepage: http://crashrpt.sourceforge.net/ -Build-Depends: libogg, libpng, libtheora, minizip, tinyxml, wtl, zlib +Build-Depends: libjpeg-turbo, libogg, libpng, libtheora, minizip, tinyxml, wtl, zlib diff --git a/ports/crashrpt/portfile.cmake b/ports/crashrpt/portfile.cmake index 31410cd64be809..85d6cc68636031 100644 --- a/ports/crashrpt/portfile.cmake +++ b/ports/crashrpt/portfile.cmake @@ -18,10 +18,11 @@ vcpkg_from_git( 003-find-libogg-libtheora.patch 004-find-tinyxml.patch 005-find-wtl.patch + 006-find-libjpeg-turbo.patch ) # Remove vendored dependencies to ensure they are not picked up by the build -foreach(DEPENDENCY libogg libpng libtheora minizip tinyxml wtl zlib) +foreach(DEPENDENCY jpeg libogg libpng libtheora minizip tinyxml wtl zlib) if(EXISTS ${SOURCE_PATH}/thirdparty/${DEPENDENCY}) file(REMOVE_RECURSE ${SOURCE_PATH}/thirdparty/${DEPENDENCY}) endif() From 31d834822594dd55869370a724b1a48c6646989c Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Sun, 26 Apr 2020 14:07:42 -0400 Subject: [PATCH 13/20] Add patch to install demos and test applications to tools directory and add vcpkg port features to enable building the tests and demos --- ...s-and-demos-dependencies-and-install.patch | 206 ++++++++++++++++++ ports/crashrpt/CONTROL | 7 + ports/crashrpt/portfile.cmake | 9 +- 3 files changed, 220 insertions(+), 2 deletions(-) create mode 100644 ports/crashrpt/007-fix-tests-and-demos-dependencies-and-install.patch diff --git a/ports/crashrpt/007-fix-tests-and-demos-dependencies-and-install.patch b/ports/crashrpt/007-fix-tests-and-demos-dependencies-and-install.patch new file mode 100644 index 00000000000000..fc3efad904dce7 --- /dev/null +++ b/ports/crashrpt/007-fix-tests-and-demos-dependencies-and-install.patch @@ -0,0 +1,206 @@ +diff --git a/demos/ConsoleDemo/CMakeLists.txt b/demos/ConsoleDemo/CMakeLists.txt +index e47ef4c..944fbf5 100644 +--- a/demos/ConsoleDemo/CMakeLists.txt ++++ b/demos/ConsoleDemo/CMakeLists.txt +@@ -12,12 +12,12 @@ fix_default_compiler_settings_() + # Add include dir + include_directories(${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/reporting/CrashRpt +- ${CMAKE_SOURCE_DIR}/thirdparty/wtl +- ${CMAKE_SOURCE_DIR}/thirdparty/zlib +- ${CMAKE_SOURCE_DIR}/thirdparty/minizip +- ${CMAKE_SOURCE_DIR}/thirdparty/jpeg +- ${CMAKE_SOURCE_DIR}/thirdparty/libpng +- ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml ) ++ ${WTL_INCLUDE_DIR} ++ ${ZLIB_INCLUDE_DIRS} ++ ${MINIZIP_INCLUDE_DIR} ++ ${JPEG_INCLUDE_DIR} ++ ${PNG_INCLUDE_DIRS} ++ ${TINYXML_INCLUDE_DIR} ) + + # Add executable build target + add_executable(ConsoleDemo ${source_files} ${header_files}) +@@ -26,3 +26,7 @@ add_executable(ConsoleDemo ${source_files} ${header_files}) + target_link_libraries(ConsoleDemo CrashRpt) + + set_target_properties(ConsoleDemo PROPERTIES DEBUG_POSTFIX d ) ++ ++install(TARGETS ConsoleDemo ++ RUNTIME DESTINATION tools/crashrpt ++) +diff --git a/demos/MFCDemo/CMakeLists.txt b/demos/MFCDemo/CMakeLists.txt +index a250ecc..ac68c85 100644 +--- a/demos/MFCDemo/CMakeLists.txt ++++ b/demos/MFCDemo/CMakeLists.txt +@@ -58,4 +58,8 @@ ADD_CUSTOM_COMMAND( + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\crashrpt_lang.ini\"" + ) +-endif(CMAKE_CL_64) +\ No newline at end of file ++endif(CMAKE_CL_64) ++ ++install(TARGETS MFCDemo ++ RUNTIME DESTINATION tools/crashrpt ++) +diff --git a/demos/WTLDemo/AboutDlg.h b/demos/WTLDemo/AboutDlg.h +index 83eaac0..e96d1c2 100644 +--- a/demos/WTLDemo/AboutDlg.h ++++ b/demos/WTLDemo/AboutDlg.h +@@ -33,7 +33,7 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #pragma once + #include "stdafx.h" + #include +-#include ++#include + #include "CrashRpt.h" + + class CAboutDlg : public CDialogImpl +diff --git a/demos/WTLDemo/CMakeLists.txt b/demos/WTLDemo/CMakeLists.txt +index 40aaefb..969e813 100644 +--- a/demos/WTLDemo/CMakeLists.txt ++++ b/demos/WTLDemo/CMakeLists.txt +@@ -19,7 +19,7 @@ fix_default_compiler_settings_() + + # Add include dir + include_directories(${CMAKE_SOURCE_DIR}/include +- ${CMAKE_SOURCE_DIR}/thirdparty/wtl) ++ ${WTL_INCLUDE_DIR}) + + # Add executable build target + add_executable(WTLDemo WIN32 ${source_files} ${header_files}) +@@ -50,4 +50,8 @@ ADD_CUSTOM_COMMAND( + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\crashrpt_lang.ini\"" + ) +-endif(CMAKE_CL_64) +\ No newline at end of file ++endif(CMAKE_CL_64) ++ ++install(TARGETS WTLDemo ++ RUNTIME DESTINATION tools/crashrpt ++) +diff --git a/demos/WTLDemo/DocumentDlg.h b/demos/WTLDemo/DocumentDlg.h +index afce8fe..9b47728 100644 +--- a/demos/WTLDemo/DocumentDlg.h ++++ b/demos/WTLDemo/DocumentDlg.h +@@ -33,7 +33,7 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #pragma once + #include "stdafx.h" + #include +-#include ++#include + #include "CrashRpt.h" + + class CDocumentDlg : public CDialogImpl +diff --git a/demos/WTLDemo/WTLDemo.rc b/demos/WTLDemo/WTLDemo.rc +index c651841..a056bb6 100644 +--- a/demos/WTLDemo/WTLDemo.rc ++++ b/demos/WTLDemo/WTLDemo.rc +@@ -7,7 +7,7 @@ + // + // Generated from the TEXTINCLUDE 2 resource. + // +-#include "atlres.h" ++#include "wtl/atlres.h" + + ///////////////////////////////////////////////////////////////////////////// + #undef APSTUDIO_READONLY_SYMBOLS +diff --git a/demos/WTLDemo/stdafx.h b/demos/WTLDemo/stdafx.h +index a601446..658d9e5 100644 +--- a/demos/WTLDemo/stdafx.h ++++ b/demos/WTLDemo/stdafx.h +@@ -16,10 +16,10 @@ be found in the Authors.txt file in the root of the source tree. + #pragma once + + // Change these values to use different versions +-#define WINVER 0x0500 ++#define WINVER 0x0501 + #define _WIN32_WINNT 0x0501 +-#define _WIN32_IE 0x0501 +-#define _RICHEDIT_VER 0x0200 ++#define _WIN32_IE 0x0600 ++#define _RICHEDIT_VER 0x0300 + + #include + #if ( _ATL_VER < 0x0800 ) +@@ -52,18 +52,18 @@ namespace ATL + }; + #endif // _WTL_SUPPORT_SDK_ATL3 + +-#include ++#include + + extern CAppModule _Module; + + #include + +-#include +-#include +-#include ++#include ++#include ++#include + + #define _WTL_USE_CSTRING +-#include ++#include + + #if _MSC_VER>=1400 + #if defined _M_IX86 +diff --git a/reporting/crashrpt/StdAfx.h b/reporting/crashrpt/StdAfx.h +index f6a9b6e..13bbe50 100644 +--- a/reporting/crashrpt/StdAfx.h ++++ b/reporting/crashrpt/StdAfx.h +@@ -19,7 +19,7 @@ be found in the Authors.txt file in the root of the source tree. + #define WINVER 0x0501 + #define _WIN32_WINNT 0x0501 + #define _WIN32_IE 0x0600 +-#define _RICHEDIT_VER 0x0200 ++#define _RICHEDIT_VER 0x0300 + + #include + #include +diff --git a/tests/stdafx.h b/tests/stdafx.h +index f12675b..0ec2117 100644 +--- a/tests/stdafx.h ++++ b/tests/stdafx.h +@@ -19,7 +19,7 @@ be found in the Authors.txt file in the root of the source tree. + #define WINVER 0x0501 + #define _WIN32_WINNT 0x0501 + #define _WIN32_IE 0x0600 +-#define _RICHEDIT_VER 0x0200 ++#define _RICHEDIT_VER 0x0300 + + #include + #include +@@ -58,15 +58,15 @@ namespace ATL + }; + #endif // _WTL_SUPPORT_SDK_ATL3 + +-#include ++#include + + extern CAppModule _Module; + + #include + +-#include +-#include +-#include ++#include ++#include ++#include + #include + #include + #include +@@ -75,7 +75,7 @@ extern CAppModule _Module; + #include + + #define _WTL_USE_CSTRING +-#include ++#include + + #if _MSC_VER<1400 + #define _TCSCPY_S(strDestination, numberOfElements, strSource) _tcscpy(strDestination, strSource) diff --git a/ports/crashrpt/CONTROL b/ports/crashrpt/CONTROL index 1b49194c6f1c7c..240d83bf83ef3d 100644 --- a/ports/crashrpt/CONTROL +++ b/ports/crashrpt/CONTROL @@ -3,3 +3,10 @@ Version: 1.4.3 Description: A crash reporting system for Windows applications Homepage: http://crashrpt.sourceforge.net/ Build-Depends: libjpeg-turbo, libogg, libpng, libtheora, minizip, tinyxml, wtl, zlib +Default-Features: + +Feature: tests +Description: Test application for crashrpt + +Feature: demos +Description: Demo applications for crashrpt diff --git a/ports/crashrpt/portfile.cmake b/ports/crashrpt/portfile.cmake index 85d6cc68636031..d0a8aafb8182ff 100644 --- a/ports/crashrpt/portfile.cmake +++ b/ports/crashrpt/portfile.cmake @@ -19,6 +19,7 @@ vcpkg_from_git( 004-find-tinyxml.patch 005-find-wtl.patch 006-find-libjpeg-turbo.patch + 007-fix-tests-and-demos-dependencies-and-install.patch ) # Remove vendored dependencies to ensure they are not picked up by the build @@ -31,6 +32,11 @@ endforeach() string(COMPARE EQUAL "${VCPKG_LIBRARY_LINKAGE}" "dynamic" CRASHRPT_BUILD_SHARED_LIBS) string(COMPARE EQUAL "${VCPKG_CRT_LINKAGE}" "dynamic" CRASHRPT_LINK_CRT_AS_DLL) +vcpkg_check_features(OUT_FEATURE_OPTIONS FEATURE_OPTIONS + tests CRASHRPT_BUILD_TESTS + demos CRASHRPT_BUILD_DEMOS +) + # PREFER_NINJA is not used below since CrashSender fails to build with errors like this one: # C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Tools\MSVC\14.23.28105\ATLMFC\include\atlconv.h(788): error C2440: 'return': cannot convert from 'LPCTSTR' to 'LPCOLESTR' vcpkg_configure_cmake( @@ -39,8 +45,7 @@ vcpkg_configure_cmake( OPTIONS -DCRASHRPT_BUILD_SHARED_LIBS=${CRASHRPT_BUILD_SHARED_LIBS} -DCRASHRPT_LINK_CRT_AS_DLL=${CRASHRPT_LINK_CRT_AS_DLL} - -DCRASHRPT_BUILD_DEMOS=OFF - -DCRASHRPT_BUILD_TESTS=OFF + ${FEATURE_OPTIONS} ) vcpkg_install_cmake() From ed1617d246f7c1432b938eb24717b368ffe9d66e Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Sun, 26 Apr 2020 15:02:33 -0400 Subject: [PATCH 14/20] Add port of dbghelp that copies files from Windows 10 SDK. Use this crashrpt to replace vendored dependency of dbghelp. --- ports/crashrpt/008-dbghelp.patch | 128 +++++++++++++++++++++++++++++++ ports/crashrpt/CONTROL | 2 +- ports/crashrpt/portfile.cmake | 3 +- ports/dbghelp/CONTROL | 3 + ports/dbghelp/portfile.cmake | 35 +++++++++ 5 files changed, 169 insertions(+), 2 deletions(-) create mode 100644 ports/crashrpt/008-dbghelp.patch create mode 100644 ports/dbghelp/CONTROL create mode 100644 ports/dbghelp/portfile.cmake diff --git a/ports/crashrpt/008-dbghelp.patch b/ports/crashrpt/008-dbghelp.patch new file mode 100644 index 00000000000000..70e333ad64d886 --- /dev/null +++ b/ports/crashrpt/008-dbghelp.patch @@ -0,0 +1,128 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 5a14f12..491f3aa 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -127,6 +127,16 @@ if(NOT WTL_INCLUDE_DIR) + message(FATAL_ERROR "WTL include dir not found") + endif() + ++find_library(DBGHELP_LIBRARY dbghelp) ++if(NOT DBGHELP_LIBRARY) ++ message(FATAL_ERROR "dbghelp library not found") ++endif() ++ ++find_path(DBGHELP_INCLUDE_DIR dbghelp.h) ++if(NOT DBGHELP_INCLUDE_DIR) ++ message(FATAL_ERROR "dbghelp include dir not found") ++endif() ++ + # Other CMakeLists are located in project subdirectories + + if(CRASHRPT_BUILD_DEMOS) +diff --git a/demos/MFCDemo/CMakeLists.txt b/demos/MFCDemo/CMakeLists.txt +index ac68c85..3483a79 100644 +--- a/demos/MFCDemo/CMakeLists.txt ++++ b/demos/MFCDemo/CMakeLists.txt +@@ -44,7 +44,7 @@ if(CMAKE_CL_64) + ADD_CUSTOM_COMMAND( + TARGET WTLDemo + POST_BUILD +- COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" ++# COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.ini\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\x64\\crashrpt_lang.ini\"" +@@ -53,7 +53,7 @@ else(CMAKE_CL_64) + ADD_CUSTOM_COMMAND( + TARGET WTLDemo + POST_BUILD +- COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\"" ++# COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.ini\" \"${CMAKE_BINARY_DIR}/bin\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\crashrpt_lang.ini\"" +diff --git a/demos/WTLDemo/CMakeLists.txt b/demos/WTLDemo/CMakeLists.txt +index 969e813..ce69e23 100644 +--- a/demos/WTLDemo/CMakeLists.txt ++++ b/demos/WTLDemo/CMakeLists.txt +@@ -36,7 +36,7 @@ if(CMAKE_CL_64) + ADD_CUSTOM_COMMAND( + TARGET WTLDemo + POST_BUILD +- COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" ++# COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.ini\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\x64\\crashrpt_lang.ini\"" +@@ -45,7 +45,7 @@ else(CMAKE_CL_64) + ADD_CUSTOM_COMMAND( + TARGET WTLDemo + POST_BUILD +- COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\"" ++# COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.ini\" \"${CMAKE_BINARY_DIR}/bin\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\crashrpt_lang.ini\"" +diff --git a/processing/crashrptprobe/CMakeLists.txt b/processing/crashrptprobe/CMakeLists.txt +index dafb007..71e5a43 100644 +--- a/processing/crashrptprobe/CMakeLists.txt ++++ b/processing/crashrptprobe/CMakeLists.txt +@@ -25,7 +25,7 @@ include_directories( ${CMAKE_SOURCE_DIR}/include + ${ZLIB_INCLUDE_DIRS} + ${MINIZIP_INCLUDE_DIR} + ${TINYXML_INCLUDE_DIR} +- ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include) ++ ${DBGHELP_INCLUDE_DIR}) + + # Add library build target + if(CRASHRPT_BUILD_SHARED_LIBS) +@@ -34,15 +34,15 @@ else(CRASHRPT_BUILD_SHARED_LIBS) + add_library(CrashRptProbe STATIC ${source_files} ${header_files}) + endif(CRASHRPT_BUILD_SHARED_LIBS) + +-if(CMAKE_CL_64) +- link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64 ) +- target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64/dbghelp.lib) +-else(CMAKE_CL_64) +- link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib ) +- target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/dbghelp.lib) +-endif(CMAKE_CL_64) ++#if(CMAKE_CL_64) ++# link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64 ) ++# target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64/dbghelp.lib) ++#else(CMAKE_CL_64) ++# link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib ) ++# target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/dbghelp.lib) ++#endif(CMAKE_CL_64) + +-target_link_libraries(CrashRptProbe ZLIB::ZLIB minizip::minizip ${TINYXML_LIBRARY} Rpcrt4.lib shell32.lib gdi32.lib version.lib psapi.lib) ++target_link_libraries(CrashRptProbe ZLIB::ZLIB minizip::minizip ${TINYXML_LIBRARY} ${DBGHELP_LIBRARY} Rpcrt4.lib shell32.lib gdi32.lib version.lib psapi.lib) + + if(CRASHRPT_BUILD_SHARED_LIBS) + +diff --git a/reporting/crashsender/CMakeLists.txt b/reporting/crashsender/CMakeLists.txt +index 088365f..8577452 100644 +--- a/reporting/crashsender/CMakeLists.txt ++++ b/reporting/crashsender/CMakeLists.txt +@@ -29,15 +29,15 @@ include_directories( ${CMAKE_SOURCE_DIR}/include + ${JPEG_INCLUDE_DIR} + ${PNG_INCLUDE_DIRS} + ${TINYXML_INCLUDE_DIR} +- ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include ++ ${DBGHELP_INCLUDE_DIR} + ${OGG_INCLUDE_DIRS} + ${THEORA_INCLUDE_DIR}) + +-if(NOT CMAKE_CL_64) +- link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib ) +-else(NOT CMAKE_CL_64) +- link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64 ) +-endif(NOT CMAKE_CL_64) ++#if(NOT CMAKE_CL_64) ++# link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib ) ++#else(NOT CMAKE_CL_64) ++# link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64 ) ++#endif(NOT CMAKE_CL_64) + + # Add executable build target + add_executable(CrashSender WIN32 ${source_files} ${header_files}) diff --git a/ports/crashrpt/CONTROL b/ports/crashrpt/CONTROL index 240d83bf83ef3d..192953a4b1cbc7 100644 --- a/ports/crashrpt/CONTROL +++ b/ports/crashrpt/CONTROL @@ -2,7 +2,7 @@ Source: crashrpt Version: 1.4.3 Description: A crash reporting system for Windows applications Homepage: http://crashrpt.sourceforge.net/ -Build-Depends: libjpeg-turbo, libogg, libpng, libtheora, minizip, tinyxml, wtl, zlib +Build-Depends: dbghelp, libjpeg-turbo, libogg, libpng, libtheora, minizip, tinyxml, wtl, zlib Default-Features: Feature: tests diff --git a/ports/crashrpt/portfile.cmake b/ports/crashrpt/portfile.cmake index d0a8aafb8182ff..e799dc1921b798 100644 --- a/ports/crashrpt/portfile.cmake +++ b/ports/crashrpt/portfile.cmake @@ -20,10 +20,11 @@ vcpkg_from_git( 005-find-wtl.patch 006-find-libjpeg-turbo.patch 007-fix-tests-and-demos-dependencies-and-install.patch + 008-dbghelp.patch ) # Remove vendored dependencies to ensure they are not picked up by the build -foreach(DEPENDENCY jpeg libogg libpng libtheora minizip tinyxml wtl zlib) +foreach(DEPENDENCY dbghelp jpeg libogg libpng libtheora minizip tinyxml wtl zlib) if(EXISTS ${SOURCE_PATH}/thirdparty/${DEPENDENCY}) file(REMOVE_RECURSE ${SOURCE_PATH}/thirdparty/${DEPENDENCY}) endif() diff --git a/ports/dbghelp/CONTROL b/ports/dbghelp/CONTROL new file mode 100644 index 00000000000000..2c91b4285e4579 --- /dev/null +++ b/ports/dbghelp/CONTROL @@ -0,0 +1,3 @@ +Source: dbghelp +Version: 0.0 +Description: Windows Debug Help Library diff --git a/ports/dbghelp/portfile.cmake b/ports/dbghelp/portfile.cmake new file mode 100644 index 00000000000000..6ad96d43ef9b36 --- /dev/null +++ b/ports/dbghelp/portfile.cmake @@ -0,0 +1,35 @@ +vcpkg_fail_port_install(ON_TARGET "OSX" "Linux") +vcpkg_check_linkage(ONLY_DYNAMIC_LIBRARY) + +vcpkg_get_program_files_32_bit(PROGRAM_FILES_32_BIT) +vcpkg_get_windows_sdk(WINDOWS_SDK) + +if (WINDOWS_SDK MATCHES "10.") + set(LIBFILEPATH "${PROGRAM_FILES_32_BIT}\\Windows Kits\\10\\Debuggers\\lib\\${TRIPLET_SYSTEM_ARCH}\\dbghelp.lib") + set(DLLFILEPATH "${PROGRAM_FILES_32_BIT}\\Windows Kits\\10\\Debuggers\\${TRIPLET_SYSTEM_ARCH}\\dbghelp.dll") + set(HEADERPATH "${PROGRAM_FILES_32_BIT}\\Windows Kits\\10\\Debuggers\\inc\\dbghelp.h") +else() + message(FATAL_ERROR "Portfile not yet configured for Windows SDK with version: ${WINDOWS_SDK}") +endif() + +if (NOT EXISTS "${LIBFILEPATH}") + message(FATAL_ERROR "Cannot find Windows ${WINDOWS_SDK} SDK. File does not exist: ${LIBFILEPATH}") +endif() + +if (NOT EXISTS "${DLLFILEPATH}") + message(FATAL_ERROR "Cannot find Windows ${WINDOWS_SDK} SDK. File does not exist: ${DLLFILEPATH}") +endif() + +if (NOT EXISTS "${HEADERPATH}") + message(FATAL_ERROR "Cannot find Windows ${WINDOWS_SDK} SDK. File does not exist: ${HEADERPATH}") +endif() + +file(INSTALL ${LIBFILEPATH} DESTINATION ${CURRENT_PACKAGES_DIR}/lib) +file(INSTALL ${LIBFILEPATH} DESTINATION ${CURRENT_PACKAGES_DIR}/debug/lib) +file(INSTALL ${DLLFILEPATH} DESTINATION ${CURRENT_PACKAGES_DIR}/bin) +file(INSTALL ${DLLFILEPATH} DESTINATION ${CURRENT_PACKAGES_DIR}/debug/bin) +file(INSTALL ${HEADERPATH} DESTINATION ${CURRENT_PACKAGES_DIR}/include) + +if (WINDOWS_SDK MATCHES "10.") + file(WRITE ${CURRENT_PACKAGES_DIR}/share/${PORT}/copyright "See https://developer.microsoft.com/windows/downloads/windows-10-sdk for the Windows 10 SDK license") +endif() From 69a24b712b69d812ea6413003a989de4d92d95a3 Mon Sep 17 00:00:00 2001 From: JackBoosY Date: Mon, 18 May 2020 22:48:31 -0700 Subject: [PATCH 15/20] [dbghelp] Improve portfile.cmake --- ports/dbghelp/CONTROL | 1 + ports/dbghelp/portfile.cmake | 22 ++++++++-------------- 2 files changed, 9 insertions(+), 14 deletions(-) diff --git a/ports/dbghelp/CONTROL b/ports/dbghelp/CONTROL index 2c91b4285e4579..ea8a3ebfaeed9a 100644 --- a/ports/dbghelp/CONTROL +++ b/ports/dbghelp/CONTROL @@ -1,3 +1,4 @@ Source: dbghelp Version: 0.0 Description: Windows Debug Help Library +Supports: Windows \ No newline at end of file diff --git a/ports/dbghelp/portfile.cmake b/ports/dbghelp/portfile.cmake index 6ad96d43ef9b36..e83f7fe22a01f8 100644 --- a/ports/dbghelp/portfile.cmake +++ b/ports/dbghelp/portfile.cmake @@ -1,27 +1,21 @@ vcpkg_fail_port_install(ON_TARGET "OSX" "Linux") vcpkg_check_linkage(ONLY_DYNAMIC_LIBRARY) -vcpkg_get_program_files_32_bit(PROGRAM_FILES_32_BIT) vcpkg_get_windows_sdk(WINDOWS_SDK) if (WINDOWS_SDK MATCHES "10.") - set(LIBFILEPATH "${PROGRAM_FILES_32_BIT}\\Windows Kits\\10\\Debuggers\\lib\\${TRIPLET_SYSTEM_ARCH}\\dbghelp.lib") - set(DLLFILEPATH "${PROGRAM_FILES_32_BIT}\\Windows Kits\\10\\Debuggers\\${TRIPLET_SYSTEM_ARCH}\\dbghelp.dll") - set(HEADERPATH "${PROGRAM_FILES_32_BIT}\\Windows Kits\\10\\Debuggers\\inc\\dbghelp.h") + set(LIBFILEPATH "$ENV{WindowsSdkDir}Debuggers\\lib\\${TRIPLET_SYSTEM_ARCH}\\dbghelp.lib") + message("LIBFILEPATH: ${LIBFILEPATH}") + set(DLLFILEPATH "$ENV{WindowsSdkDir}Debuggers\\${TRIPLET_SYSTEM_ARCH}\\dbghelp.dll") + message("DLLFILEPATH: ${DLLFILEPATH}") + set(HEADERPATH "$ENV{WindowsSdkDir}Debuggers\\inc\\dbghelp.h") + message("HEADERPATH: ${HEADERPATH}") else() message(FATAL_ERROR "Portfile not yet configured for Windows SDK with version: ${WINDOWS_SDK}") endif() -if (NOT EXISTS "${LIBFILEPATH}") - message(FATAL_ERROR "Cannot find Windows ${WINDOWS_SDK} SDK. File does not exist: ${LIBFILEPATH}") -endif() - -if (NOT EXISTS "${DLLFILEPATH}") - message(FATAL_ERROR "Cannot find Windows ${WINDOWS_SDK} SDK. File does not exist: ${DLLFILEPATH}") -endif() - -if (NOT EXISTS "${HEADERPATH}") - message(FATAL_ERROR "Cannot find Windows ${WINDOWS_SDK} SDK. File does not exist: ${HEADERPATH}") +if (NOT EXISTS "${LIBFILEPATH}" OR NOT EXISTS "${DLLFILEPATH}" OR NOT EXISTS "${HEADERPATH}") + message(FATAL_ERROR "Cannot find debugging tools in Windows SDK ${WINDOWS_SDK}. Please reinstall the Windows SDK and select \"Debugging Tool\".") endif() file(INSTALL ${LIBFILEPATH} DESTINATION ${CURRENT_PACKAGES_DIR}/lib) From 1f42c4a34876df32ad638b6e8a91511f8853d589 Mon Sep 17 00:00:00 2001 From: JackBoosY Date: Mon, 18 May 2020 22:56:43 -0700 Subject: [PATCH 16/20] Update baseline --- scripts/ci.baseline.txt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/scripts/ci.baseline.txt b/scripts/ci.baseline.txt index cc6ce072a90002..e175c32b121162 100644 --- a/scripts/ci.baseline.txt +++ b/scripts/ci.baseline.txt @@ -304,6 +304,8 @@ cudnn:x64-uwp=fail cudnn:x64-windows-static=fail cudnn:x86-windows=fail date:arm64-windows=fail +dbghelp:x64-linux=fail +dbghelp:x64-osx=fail dbow2:x64-osx=fail dcmtk:arm64-windows=fail dcmtk:arm-uwp=fail From aa180d22a333fb4cc885a9912be2ef3320d51c57 Mon Sep 17 00:00:00 2001 From: JackBoosY Date: Mon, 18 May 2020 22:57:46 -0700 Subject: [PATCH 17/20] update CONTROL file --- ports/dbghelp/CONTROL | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ports/dbghelp/CONTROL b/ports/dbghelp/CONTROL index ea8a3ebfaeed9a..e92599d577c28e 100644 --- a/ports/dbghelp/CONTROL +++ b/ports/dbghelp/CONTROL @@ -1,4 +1,4 @@ Source: dbghelp Version: 0.0 Description: Windows Debug Help Library -Supports: Windows \ No newline at end of file +Supports: windows \ No newline at end of file From 7a0ceae0bb761763cb85eab28f17a117782f1d9e Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Fri, 5 Jun 2020 13:01:30 -0400 Subject: [PATCH 18/20] Update ci.baseline.txt to skip dbghelp on Windows platforms --- scripts/ci.baseline.txt | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/scripts/ci.baseline.txt b/scripts/ci.baseline.txt index 730ce920dd94e2..80c020a22af6dc 100644 --- a/scripts/ci.baseline.txt +++ b/scripts/ci.baseline.txt @@ -312,8 +312,15 @@ cudnn:arm-uwp=fail cudnn:x64-uwp=fail cudnn:x64-windows-static=fail cudnn:x86-windows=fail +# Since pipeline cannot automatically install dbghelp dependency, skip this detection +dbghelp:arm-uwp=skip +dbghelp:arm64-windows=skip dbghelp:x64-linux=fail dbghelp:x64-osx=fail +dbghelp:x64-uwp=skip +dbghelp:x64-windows-static=skip +dbghelp:x64-windows=skip +dbghelp:x86-windows=skip dbow2:x64-osx=fail dcmtk:arm-uwp=fail dcmtk:arm64-windows=fail From 65d8d789a135fcb1fc99450103560aa96dd06591 Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Sun, 26 Jul 2020 10:13:54 -0400 Subject: [PATCH 19/20] * Combined patch files * Use vendored minizip since it has modifications to support Unicode file paths using wchar_t* which CrashRpt depends on * Add feature "probe" in order to allow excluding the CrashRptProbe library --- ...001-add-install-target-and-find-deps.patch | 809 ++++++++++++++++++ ports/crashrpt/001-cmake-install.patch | 112 --- .../crashrpt/002-find-minizip-png-zlib.patch | 189 ---- .../crashrpt/003-find-libogg-libtheora.patch | 57 -- ports/crashrpt/004-find-tinyxml.patch | 87 -- ports/crashrpt/005-find-wtl.patch | 185 ---- ports/crashrpt/006-find-libjpeg-turbo.patch | 43 - ...s-and-demos-dependencies-and-install.patch | 206 ----- ports/crashrpt/008-dbghelp.patch | 128 --- ports/crashrpt/CONTROL | 8 +- ports/crashrpt/portfile.cmake | 13 +- 11 files changed, 819 insertions(+), 1018 deletions(-) create mode 100644 ports/crashrpt/001-add-install-target-and-find-deps.patch delete mode 100644 ports/crashrpt/001-cmake-install.patch delete mode 100644 ports/crashrpt/002-find-minizip-png-zlib.patch delete mode 100644 ports/crashrpt/003-find-libogg-libtheora.patch delete mode 100644 ports/crashrpt/004-find-tinyxml.patch delete mode 100644 ports/crashrpt/005-find-wtl.patch delete mode 100644 ports/crashrpt/006-find-libjpeg-turbo.patch delete mode 100644 ports/crashrpt/007-fix-tests-and-demos-dependencies-and-install.patch delete mode 100644 ports/crashrpt/008-dbghelp.patch diff --git a/ports/crashrpt/001-add-install-target-and-find-deps.patch b/ports/crashrpt/001-add-install-target-and-find-deps.patch new file mode 100644 index 00000000000000..2d983800d4a58a --- /dev/null +++ b/ports/crashrpt/001-add-install-target-and-find-deps.patch @@ -0,0 +1,809 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 44d7df0..ed9e3d3 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -17,6 +17,9 @@ set (CRASHRPT_VER 1403) + # Build options + option(CRASHRPT_BUILD_SHARED_LIBS "If set (default), CrashRpt modules are built as dynamic-link libraries, otherwise as static libs." ON) + option(CRASHRPT_LINK_CRT_AS_DLL "If set (default), CrashRpt modules link C run-time (CRT) as multi-threaded dynamic libraries, otherwise as multi-threaded static libs." ON) ++option(CRASHRPT_BUILD_PROBE "If set (default), CrashRpt builds the CrashRptProbe project." ON) ++option(CRASHRPT_BUILD_DEMOS "If set (default), CrashRpt builds the demo projects." ON) ++option(CRASHRPT_BUILD_TESTS "If set (default), CrashRpt builds the test projects." ON) + + # Set output directory for executable files + if(CMAKE_CL_64) +@@ -94,19 +97,65 @@ macro(fix_default_compiler_settings_) + + endmacro() + ++find_package(ZLIB REQUIRED) ++find_package(PNG REQUIRED) ++find_package(Ogg REQUIRED) ++find_package(JPEG REQUIRED) ++ ++find_library(THEORA_LIBRARY theora) ++if(NOT THEORA_LIBRARY) ++ message(FATAL_ERROR "theora library not found") ++endif() ++ ++find_path(THEORA_INCLUDE_DIR theora/theora.h) ++if(NOT THEORA_INCLUDE_DIR) ++ message(FATAL_ERROR "theora include dir not found") ++endif() ++ ++find_library(TINYXML_LIBRARY NAMES tinyxml) ++if(NOT TINYXML_LIBRARY) ++ message(FATAL_ERROR "tinyxml library not found") ++endif() ++ ++find_path(TINYXML_INCLUDE_DIR tinyxml.h) ++if(NOT TINYXML_INCLUDE_DIR) ++ message(FATAL_ERROR "tinyxml include dir not found") ++endif() ++ ++find_path(WTL_INCLUDE_DIR wtl/atlapp.h) ++if(NOT WTL_INCLUDE_DIR) ++ message(FATAL_ERROR "WTL include dir not found") ++endif() ++ ++find_library(DBGHELP_LIBRARY dbghelp) ++if(NOT DBGHELP_LIBRARY) ++ message(FATAL_ERROR "dbghelp library not found") ++endif() ++ ++find_path(DBGHELP_INCLUDE_DIR dbghelp.h) ++if(NOT DBGHELP_INCLUDE_DIR) ++ message(FATAL_ERROR "dbghelp include dir not found") ++endif() ++ + # Other CMakeLists are located in project subdirectories + ++if(CRASHRPT_BUILD_DEMOS) + add_subdirectory("demos/ConsoleDemo") + add_subdirectory("demos/WTLDemo") + add_subdirectory("demos/MFCDemo") ++endif() + + add_subdirectory("reporting/crashrpt") + add_subdirectory("reporting/crashsender") + ++if(CRASHRPT_BUILD_PROBE) + add_subdirectory("processing/crashrptprobe") + add_subdirectory("processing/crprober") ++endif() + ++if(CRASHRPT_BUILD_TESTS) + add_subdirectory("tests") ++endif() + + # Set output directory for LIB files + if(CMAKE_CL_64) +@@ -117,13 +166,13 @@ else(CMAKE_CL_64) + set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/thirdparty/lib) + endif(CMAKE_CL_64) + +-add_subdirectory("thirdparty/tinyxml") +-add_subdirectory("thirdparty/jpeg") +-add_subdirectory("thirdparty/libpng") ++#add_subdirectory("thirdparty/tinyxml") ++#add_subdirectory("thirdparty/jpeg") ++#add_subdirectory("thirdparty/libpng") + add_subdirectory("thirdparty/minizip") +-add_subdirectory("thirdparty/zlib") +-add_subdirectory("thirdparty/libogg") +-add_subdirectory("thirdparty/libtheora") ++#add_subdirectory("thirdparty/zlib") ++#add_subdirectory("thirdparty/libogg") ++#add_subdirectory("thirdparty/libtheora") + + + +diff --git a/demos/ConsoleDemo/CMakeLists.txt b/demos/ConsoleDemo/CMakeLists.txt +index e47ef4c..4df7b12 100644 +--- a/demos/ConsoleDemo/CMakeLists.txt ++++ b/demos/ConsoleDemo/CMakeLists.txt +@@ -12,12 +12,12 @@ fix_default_compiler_settings_() + # Add include dir + include_directories(${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/reporting/CrashRpt +- ${CMAKE_SOURCE_DIR}/thirdparty/wtl +- ${CMAKE_SOURCE_DIR}/thirdparty/zlib ++ ${WTL_INCLUDE_DIR} ++ ${ZLIB_INCLUDE_DIRS} + ${CMAKE_SOURCE_DIR}/thirdparty/minizip +- ${CMAKE_SOURCE_DIR}/thirdparty/jpeg +- ${CMAKE_SOURCE_DIR}/thirdparty/libpng +- ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml ) ++ ${JPEG_INCLUDE_DIR} ++ ${PNG_INCLUDE_DIRS} ++ ${TINYXML_INCLUDE_DIR} ) + + # Add executable build target + add_executable(ConsoleDemo ${source_files} ${header_files}) +@@ -26,3 +26,7 @@ add_executable(ConsoleDemo ${source_files} ${header_files}) + target_link_libraries(ConsoleDemo CrashRpt) + + set_target_properties(ConsoleDemo PROPERTIES DEBUG_POSTFIX d ) ++ ++install(TARGETS ConsoleDemo ++ RUNTIME DESTINATION tools/crashrpt ++) +diff --git a/demos/MFCDemo/CMakeLists.txt b/demos/MFCDemo/CMakeLists.txt +index a250ecc..ade93cb 100644 +--- a/demos/MFCDemo/CMakeLists.txt ++++ b/demos/MFCDemo/CMakeLists.txt +@@ -44,7 +44,7 @@ if(CMAKE_CL_64) + ADD_CUSTOM_COMMAND( + TARGET WTLDemo + POST_BUILD +- COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" ++ #COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.ini\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\x64\\crashrpt_lang.ini\"" +@@ -53,9 +53,13 @@ else(CMAKE_CL_64) + ADD_CUSTOM_COMMAND( + TARGET WTLDemo + POST_BUILD +- COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\"" ++ #COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.ini\" \"${CMAKE_BINARY_DIR}/bin\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\crashrpt_lang.ini\"" + ) +-endif(CMAKE_CL_64) +\ No newline at end of file ++endif(CMAKE_CL_64) ++ ++install(TARGETS MFCDemo ++ RUNTIME DESTINATION tools/crashrpt ++) +diff --git a/demos/WTLDemo/AboutDlg.h b/demos/WTLDemo/AboutDlg.h +index 83eaac0..e96d1c2 100644 +--- a/demos/WTLDemo/AboutDlg.h ++++ b/demos/WTLDemo/AboutDlg.h +@@ -33,7 +33,7 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #pragma once + #include "stdafx.h" + #include +-#include ++#include + #include "CrashRpt.h" + + class CAboutDlg : public CDialogImpl +diff --git a/demos/WTLDemo/CMakeLists.txt b/demos/WTLDemo/CMakeLists.txt +index 40aaefb..42c0f5a 100644 +--- a/demos/WTLDemo/CMakeLists.txt ++++ b/demos/WTLDemo/CMakeLists.txt +@@ -19,7 +19,7 @@ fix_default_compiler_settings_() + + # Add include dir + include_directories(${CMAKE_SOURCE_DIR}/include +- ${CMAKE_SOURCE_DIR}/thirdparty/wtl) ++ ${WTL_INCLUDE_DIR}) + + # Add executable build target + add_executable(WTLDemo WIN32 ${source_files} ${header_files}) +@@ -36,7 +36,7 @@ if(CMAKE_CL_64) + ADD_CUSTOM_COMMAND( + TARGET WTLDemo + POST_BUILD +- COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" ++ #COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.ini\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\x64\\crashrpt_lang.ini\"" +@@ -45,9 +45,13 @@ else(CMAKE_CL_64) + ADD_CUSTOM_COMMAND( + TARGET WTLDemo + POST_BUILD +- COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\"" ++ #COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.ini\" \"${CMAKE_BINARY_DIR}/bin\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\"" + COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\crashrpt_lang.ini\"" + ) +-endif(CMAKE_CL_64) +\ No newline at end of file ++endif(CMAKE_CL_64) ++ ++install(TARGETS WTLDemo ++ RUNTIME DESTINATION tools/crashrpt ++) +diff --git a/demos/WTLDemo/DocumentDlg.h b/demos/WTLDemo/DocumentDlg.h +index afce8fe..9b47728 100644 +--- a/demos/WTLDemo/DocumentDlg.h ++++ b/demos/WTLDemo/DocumentDlg.h +@@ -33,7 +33,7 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #pragma once + #include "stdafx.h" + #include +-#include ++#include + #include "CrashRpt.h" + + class CDocumentDlg : public CDialogImpl +diff --git a/demos/WTLDemo/WTLDemo.rc b/demos/WTLDemo/WTLDemo.rc +index c651841..71f4b39 100644 +--- a/demos/WTLDemo/WTLDemo.rc ++++ b/demos/WTLDemo/WTLDemo.rc +@@ -7,7 +7,7 @@ + // + // Generated from the TEXTINCLUDE 2 resource. + // +-#include "atlres.h" ++#include "wtl/atlres.h" + + ///////////////////////////////////////////////////////////////////////////// + #undef APSTUDIO_READONLY_SYMBOLS +@@ -32,7 +32,7 @@ END + + 2 TEXTINCLUDE + BEGIN +- "#include ""atlres.h""\r\n" ++ "#include ""wtl/atlres.h""\r\n" + "\0" + END + +diff --git a/demos/WTLDemo/stdafx.h b/demos/WTLDemo/stdafx.h +index a601446..658d9e5 100644 +--- a/demos/WTLDemo/stdafx.h ++++ b/demos/WTLDemo/stdafx.h +@@ -16,10 +16,10 @@ be found in the Authors.txt file in the root of the source tree. + #pragma once + + // Change these values to use different versions +-#define WINVER 0x0500 ++#define WINVER 0x0501 + #define _WIN32_WINNT 0x0501 +-#define _WIN32_IE 0x0501 +-#define _RICHEDIT_VER 0x0200 ++#define _WIN32_IE 0x0600 ++#define _RICHEDIT_VER 0x0300 + + #include + #if ( _ATL_VER < 0x0800 ) +@@ -52,18 +52,18 @@ namespace ATL + }; + #endif // _WTL_SUPPORT_SDK_ATL3 + +-#include ++#include + + extern CAppModule _Module; + + #include + +-#include +-#include +-#include ++#include ++#include ++#include + + #define _WTL_USE_CSTRING +-#include ++#include + + #if _MSC_VER>=1400 + #if defined _M_IX86 +diff --git a/processing/crashrptprobe/CMakeLists.txt b/processing/crashrptprobe/CMakeLists.txt +index a6c692a..c513c6d 100644 +--- a/processing/crashrptprobe/CMakeLists.txt ++++ b/processing/crashrptprobe/CMakeLists.txt +@@ -21,11 +21,11 @@ fix_default_compiler_settings_() + include_directories( ${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/reporting/crashrpt + ${CMAKE_SOURCE_DIR}/reporting/crashsender +- ${CMAKE_SOURCE_DIR}/thirdparty/wtl +- ${CMAKE_SOURCE_DIR}/thirdparty/zlib ++ ${WTL_INCLUDE_DIR} ++ ${ZLIB_INCLUDE_DIRS} + ${CMAKE_SOURCE_DIR}/thirdparty/minizip +- ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml +- ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include) ++ ${TINYXML_INCLUDE_DIR} ++ ${DBGHELP_INCLUDE_DIR}) + + # Add library build target + if(CRASHRPT_BUILD_SHARED_LIBS) +@@ -34,15 +34,15 @@ else(CRASHRPT_BUILD_SHARED_LIBS) + add_library(CrashRptProbe STATIC ${source_files} ${header_files}) + endif(CRASHRPT_BUILD_SHARED_LIBS) + +-if(CMAKE_CL_64) +- link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64 ) +- target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64/dbghelp.lib) +-else(CMAKE_CL_64) +- link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib ) +- target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/dbghelp.lib) +-endif(CMAKE_CL_64) ++#if(CMAKE_CL_64) ++# link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64 ) ++# target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64/dbghelp.lib) ++#else(CMAKE_CL_64) ++# link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib ) ++# target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/dbghelp.lib) ++#endif(CMAKE_CL_64) + +-target_link_libraries(CrashRptProbe zlib minizip tinyxml Rpcrt4.lib shell32.lib gdi32.lib version.lib psapi.lib) ++target_link_libraries(CrashRptProbe ZLIB::ZLIB minizip ${TINYXML_LIBRARY} ${DBGHELP_LIBRARY} Rpcrt4.lib shell32.lib gdi32.lib version.lib psapi.lib) + + if(CRASHRPT_BUILD_SHARED_LIBS) + +@@ -58,4 +58,11 @@ else(CRASHRPT_BUILD_SHARED_LIBS) + + endif(CRASHRPT_BUILD_SHARED_LIBS) + ++set_target_properties(CrashRptProbe PROPERTIES PUBLIC_HEADER ${CMAKE_SOURCE_DIR}/include/CrashRptProbe.h) + ++INSTALL(TARGETS CrashRptProbe ++ PUBLIC_HEADER DESTINATION include/crashrpt ++ LIBRARY ++ ARCHIVE ++ RUNTIME ++) +diff --git a/processing/crashrptprobe/CrashRptProbe.rc b/processing/crashrptprobe/CrashRptProbe.rc +index a08f63e..e12b8e9 100644 +--- a/processing/crashrptprobe/CrashRptProbe.rc ++++ b/processing/crashrptprobe/CrashRptProbe.rc +@@ -7,7 +7,7 @@ + // + // Generated from the TEXTINCLUDE 2 resource. + // +-#include "atlres.h" ++#include "wtl/atlres.h" + + ///////////////////////////////////////////////////////////////////////////// + #undef APSTUDIO_READONLY_SYMBOLS +@@ -32,7 +32,7 @@ END + + 2 TEXTINCLUDE + BEGIN +- "#include ""atlres.h""\r\n" ++ "#include ""wtl/atlres.h""\r\n" + "\0" + END + +diff --git a/processing/crashrptprobe/stdafx.h b/processing/crashrptprobe/stdafx.h +index 2b027b2..0b60659 100644 +--- a/processing/crashrptprobe/stdafx.h ++++ b/processing/crashrptprobe/stdafx.h +@@ -70,13 +70,13 @@ namespace ATL + }; + #endif // _WTL_SUPPORT_SDK_ATL3 + +-#include ++#include + extern CAppModule _Module; + #include + + // CString-related includes + #define _WTL_USE_CSTRING +-#include ++#include + + #if _MSC_VER<1400 + #define WCSNCPY_S(strDest, sizeInBytes, strSource, count) wcsncpy(strDest, strSource, count) +diff --git a/processing/crprober/CMakeLists.txt b/processing/crprober/CMakeLists.txt +index 046ba57..255e200 100644 +--- a/processing/crprober/CMakeLists.txt ++++ b/processing/crprober/CMakeLists.txt +@@ -18,4 +18,8 @@ add_executable(crprober ${source_files} ${header_files}) + # Add input link libraries + target_link_libraries(crprober CrashRptProbe) + +-set_target_properties(crprober PROPERTIES DEBUG_POSTFIX d ) +\ No newline at end of file ++set_target_properties(crprober PROPERTIES DEBUG_POSTFIX d ) ++ ++install(TARGETS crprober ++ RUNTIME DESTINATION tools/crashrpt ++) +diff --git a/reporting/crashrpt/CMakeLists.txt b/reporting/crashrpt/CMakeLists.txt +index 42d40e2..c7e4fd6 100644 +--- a/reporting/crashrpt/CMakeLists.txt ++++ b/reporting/crashrpt/CMakeLists.txt +@@ -18,7 +18,7 @@ add_definitions(-D_UNICODE -D_CRT_SECURE_NO_DEPRECATE) + fix_default_compiler_settings_() + + # Add include dir +-include_directories( ${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/thirdparty/wtl) ++include_directories( ${CMAKE_SOURCE_DIR}/include ${WTL_INCLUDE_DIR}) + + # Add library build target + if(CRASHRPT_BUILD_SHARED_LIBS) +@@ -55,3 +55,11 @@ else(CRASHRPT_BUILD_SHARED_LIBS) + RELEASE_POSTFIX LIB ) + endif(CRASHRPT_BUILD_SHARED_LIBS) + ++set_target_properties(CrashRpt PROPERTIES PUBLIC_HEADER ${CMAKE_SOURCE_DIR}/include/CrashRpt.h) ++ ++INSTALL(TARGETS CrashRpt ++ PUBLIC_HEADER DESTINATION include/crashrpt ++ LIBRARY ++ ARCHIVE ++ RUNTIME ++) +diff --git a/reporting/crashrpt/CrashRpt.rc b/reporting/crashrpt/CrashRpt.rc +index 95e7502..a8c821b 100644 +--- a/reporting/crashrpt/CrashRpt.rc ++++ b/reporting/crashrpt/CrashRpt.rc +@@ -7,7 +7,7 @@ + // + // Generated from the TEXTINCLUDE 2 resource. + // +-#include "atlres.h" ++#include "wtl/atlres.h" + + ///////////////////////////////////////////////////////////////////////////// + #undef APSTUDIO_READONLY_SYMBOLS +@@ -32,7 +32,7 @@ END + + 2 TEXTINCLUDE + BEGIN +- "#include ""atlres.h""\r\n" ++ "#include ""wtl/atlres.h""\r\n" + "\0" + END + +diff --git a/reporting/crashrpt/StdAfx.h b/reporting/crashrpt/StdAfx.h +index 77d8c36..13bbe50 100644 +--- a/reporting/crashrpt/StdAfx.h ++++ b/reporting/crashrpt/StdAfx.h +@@ -19,7 +19,7 @@ be found in the Authors.txt file in the root of the source tree. + #define WINVER 0x0501 + #define _WIN32_WINNT 0x0501 + #define _WIN32_IE 0x0600 +-#define _RICHEDIT_VER 0x0200 ++#define _RICHEDIT_VER 0x0300 + + #include + #include +@@ -54,12 +54,12 @@ namespace ATL + }; + #endif // _WTL_SUPPORT_SDK_ATL3 + +-#include ++#include + extern CAppModule _Module; + #include + // CString-related includes + #define _WTL_USE_CSTRING +-#include ++#include + #include + #include + #include +diff --git a/reporting/crashsender/CMakeLists.txt b/reporting/crashsender/CMakeLists.txt +index 9b444c5..aa4ab8a 100644 +--- a/reporting/crashsender/CMakeLists.txt ++++ b/reporting/crashsender/CMakeLists.txt +@@ -22,27 +22,27 @@ fix_default_compiler_settings_() + # Add include dir + include_directories( ${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/reporting/CrashRpt +- ${CMAKE_SOURCE_DIR}/thirdparty/wtl +- ${CMAKE_SOURCE_DIR}/thirdparty/zlib ++ ${WTL_INCLUDE_DIR} + ${CMAKE_SOURCE_DIR}/thirdparty/minizip +- ${CMAKE_SOURCE_DIR}/thirdparty/jpeg +- ${CMAKE_SOURCE_DIR}/thirdparty/libpng +- ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml +- ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include +- ${CMAKE_SOURCE_DIR}/thirdparty/libogg/include +- ${CMAKE_SOURCE_DIR}/thirdparty/libtheora/include) +- +-if(NOT CMAKE_CL_64) +- link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib ) +-else(NOT CMAKE_CL_64) +- link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64 ) +-endif(NOT CMAKE_CL_64) ++ ${ZLIB_INCLUDE_DIRS} ++ ${JPEG_INCLUDE_DIR} ++ ${PNG_INCLUDE_DIRS} ++ ${TINYXML_INCLUDE_DIR} ++ ${DBGHELP_INCLUDE_DIR} ++ ${OGG_INCLUDE_DIRS} ++ ${THEORA_INCLUDE_DIR}) ++ ++#if(NOT CMAKE_CL_64) ++# link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib ) ++#else(NOT CMAKE_CL_64) ++# link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64 ) ++#endif(NOT CMAKE_CL_64) + + # Add executable build target + add_executable(CrashSender WIN32 ${source_files} ${header_files}) + + # Add input link libraries +-target_link_libraries(CrashSender zlib minizip libjpeg libpng tinyxml libogg libtheora WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) ++target_link_libraries(CrashSender ZLIB::ZLIB minizip ${JPEG_LIBRARIES} PNG::PNG ${TINYXML_LIBRARY} Ogg::ogg ${THEORA_LIBRARY} WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) + + # Add compiler flags (/MP for multi-processor compilation, /Os to favor small code) + set_target_properties(CrashRpt PROPERTIES COMPILE_FLAGS "/Os") +@@ -52,4 +52,12 @@ set_target_properties(CrashRpt PROPERTIES COMPILE_FLAGS "/Os") + + set_target_properties(CrashSender PROPERTIES + DEBUG_POSTFIX ${CRASHRPT_VER}d +- RELEASE_POSTFIX ${CRASHRPT_VER} ) +\ No newline at end of file ++ RELEASE_POSTFIX ${CRASHRPT_VER} ) ++ ++install(TARGETS CrashSender ++ RUNTIME DESTINATION tools/crashrpt ++) ++ ++file(GLOB LANG_FILES "${CMAKE_SOURCE_DIR}/lang_files/crashrpt_lang_*.ini") ++install(FILES ${LANG_FILES} DESTINATION tools/crashrpt) ++install(FILES "${CMAKE_SOURCE_DIR}/lang_files/crashrpt_lang_EN.ini" DESTINATION tools/crashrpt RENAME crashrpt_lang.ini) +diff --git a/reporting/crashsender/CrashSender.rc b/reporting/crashsender/CrashSender.rc +index 0502962..e10e269 100644 +--- a/reporting/crashsender/CrashSender.rc ++++ b/reporting/crashsender/CrashSender.rc +@@ -7,7 +7,7 @@ + // + // Generated from the TEXTINCLUDE 2 resource. + // +-#include "atlres.h" ++#include "wtl/atlres.h" + + ///////////////////////////////////////////////////////////////////////////// + #undef APSTUDIO_READONLY_SYMBOLS +@@ -243,7 +243,7 @@ END + + 2 TEXTINCLUDE + BEGIN +- "#include ""atlres.h""\r\n" ++ "#include ""wtl/atlres.h""\r\n" + "\0" + END + +diff --git a/reporting/crashsender/ErrorReportSender.cpp b/reporting/crashsender/ErrorReportSender.cpp +index ac9603c..64cf2b5 100644 +--- a/reporting/crashsender/ErrorReportSender.cpp ++++ b/reporting/crashsender/ErrorReportSender.cpp +@@ -722,9 +722,9 @@ BOOL CErrorReportSender::CreateMiniDump() + CompiledApiVer.Reserved = 0; + LPAPI_VERSION pActualApiVer = lpImagehlpApiVersionEx(&CompiledApiVer); + pActualApiVer; +- ATLASSERT(CompiledApiVer.MajorVersion==pActualApiVer->MajorVersion); +- ATLASSERT(CompiledApiVer.MinorVersion==pActualApiVer->MinorVersion); +- ATLASSERT(CompiledApiVer.Revision==pActualApiVer->Revision); ++ //ATLASSERT(CompiledApiVer.MajorVersion==pActualApiVer->MajorVersion); ++ //ATLASSERT(CompiledApiVer.MinorVersion==pActualApiVer->MinorVersion); ++ //ATLASSERT(CompiledApiVer.Revision==pActualApiVer->Revision); + } + + // Write minidump to the file +@@ -1086,7 +1086,7 @@ BOOL CErrorReportSender::CreateCrashDescriptionXML(CErrorReportInfo& eri) + goto cleanup; + } + +- doc.useMicrosoftBOM = true; ++ //doc.useMicrosoftBOM = true; + bool bSave = doc.SaveFile(f); + if(!bSave) + { +diff --git a/reporting/crashsender/FilePreviewCtrl.cpp b/reporting/crashsender/FilePreviewCtrl.cpp +index e71aafc..5650291 100644 +--- a/reporting/crashsender/FilePreviewCtrl.cpp ++++ b/reporting/crashsender/FilePreviewCtrl.cpp +@@ -365,7 +365,7 @@ BOOL CImage::LoadBitmapFromPNGFile(LPTSTR szFileName) + if (!png_ptr) + goto cleanup; + +- if (setjmp(png_ptr->jmpbuf)) ++ if (setjmp(png_jmpbuf(png_ptr))) + goto cleanup; + + info_ptr = png_create_info_struct(png_ptr); +@@ -389,7 +389,7 @@ BOOL CImage::LoadBitmapFromPNGFile(LPTSTR szFileName) + width = png_get_image_width(png_ptr, info_ptr); + height = png_get_image_height(png_ptr, info_ptr); + +- if(info_ptr->channels==3) ++ if (png_get_channels(png_ptr, info_ptr) == 3) + { + png_set_strip_16(png_ptr); + png_set_packing(png_ptr); +@@ -408,14 +408,14 @@ BOOL CImage::LoadBitmapFromPNGFile(LPTSTR szFileName) + pBMI = (BITMAPINFO*)new BYTE[sizeof(BITMAPINFO)+256*4]; + memset(pBMI, 0, sizeof(BITMAPINFO)+256*4); + pBMI->bmiHeader.biSize = sizeof(BITMAPINFO); +- pBMI->bmiHeader.biBitCount = 8*info_ptr->channels; ++ pBMI->bmiHeader.biBitCount = 8 * png_get_channels(png_ptr, info_ptr); + pBMI->bmiHeader.biWidth = width; + pBMI->bmiHeader.biHeight = height; + pBMI->bmiHeader.biPlanes = 1; + pBMI->bmiHeader.biCompression = BI_RGB; + pBMI->bmiHeader.biSizeImage = rowbytes*height; + +- if( info_ptr->channels == 1 ) ++ if (png_get_channels(png_ptr, info_ptr) == 1) + { + RGBQUAD* palette = pBMI->bmiColors; + +@@ -431,7 +431,7 @@ BOOL CImage::LoadBitmapFromPNGFile(LPTSTR szFileName) + + for(y=height-1; y>=0; y--) + { +- png_read_rows(png_ptr, &row, png_bytepp_NULL, 1); ++ png_read_rows(png_ptr, &row, NULL, 1); + + { + CAutoLock lock(&m_csLock); +diff --git a/reporting/crashsender/ScreenCap.cpp b/reporting/crashsender/ScreenCap.cpp +index c183c19..8f5643d 100644 +--- a/reporting/crashsender/ScreenCap.cpp ++++ b/reporting/crashsender/ScreenCap.cpp +@@ -11,6 +11,7 @@ be found in the Authors.txt file in the root of the source tree. + #include "stdafx.h" + #include "ScreenCap.h" + #include "Utility.h" ++#include "zlib.h" + + // Disable warning C4611: interaction between '_setjmp' and C++ object destruction is non-portable + #pragma warning(disable:4611) +diff --git a/reporting/crashsender/stdafx.h b/reporting/crashsender/stdafx.h +index f087ff4..4494d3a 100644 +--- a/reporting/crashsender/stdafx.h ++++ b/reporting/crashsender/stdafx.h +@@ -19,7 +19,7 @@ be found in the Authors.txt file in the root of the source tree. + #define WINVER 0x0501 + #define _WIN32_WINNT 0x0501 + #define _WIN32_IE 0x0600 +-#define _RICHEDIT_VER 0x0200 ++#define _RICHEDIT_VER 0x0300 + + typedef __int64 off_t, _off_t; + #define _OFF_T_DEFINED +@@ -61,19 +61,19 @@ namespace ATL + }; + #endif // _WTL_SUPPORT_SDK_ATL3 + +-#include ++#include + + extern CAppModule _Module; + + #include + +-#include +-#include +-#include +-#include ++#include ++#include ++#include ++#include + + #define _WTL_USE_CSTRING +-#include ++#include + + #include + #include +diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt +index f7bfede..9358bef 100644 +--- a/tests/CMakeLists.txt ++++ b/tests/CMakeLists.txt +@@ -32,7 +32,7 @@ set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /DEBUG") + # Add include dir + include_directories( ${CMAKE_SOURCE_DIR}/include + ${CMAKE_SOURCE_DIR}/reporting/CrashRpt +- ${CMAKE_SOURCE_DIR}/thirdparty/wtl ) ++ ${WTL_INCLUDE_DIR} ) + + # Add executable build target + add_executable(Tests ${source_files} ${header_files}) +@@ -42,3 +42,10 @@ target_link_libraries(Tests CrashRpt CrashRptProbe) + + set_target_properties(Tests PROPERTIES DEBUG_POSTFIX d ) + #set_target_properties(Tests PROPERTIES COMPILE_FLAGS "/Zi" LINK_FLAGS "/DEBUG") ++ ++install(TARGETS Tests ++ RUNTIME DESTINATION tools/crashrpt ++) ++ ++install(FILES "${CMAKE_SOURCE_DIR}/demos/WTLDemo/dummy.ini" DESTINATION tools/crashrpt) ++install(FILES "${CMAKE_SOURCE_DIR}/demos/WTLDemo/dummy.log" DESTINATION tools/crashrpt) +diff --git a/tests/stdafx.h b/tests/stdafx.h +index f12675b..0ec2117 100644 +--- a/tests/stdafx.h ++++ b/tests/stdafx.h +@@ -19,7 +19,7 @@ be found in the Authors.txt file in the root of the source tree. + #define WINVER 0x0501 + #define _WIN32_WINNT 0x0501 + #define _WIN32_IE 0x0600 +-#define _RICHEDIT_VER 0x0200 ++#define _RICHEDIT_VER 0x0300 + + #include + #include +@@ -58,15 +58,15 @@ namespace ATL + }; + #endif // _WTL_SUPPORT_SDK_ATL3 + +-#include ++#include + + extern CAppModule _Module; + + #include + +-#include +-#include +-#include ++#include ++#include ++#include + #include + #include + #include +@@ -75,7 +75,7 @@ extern CAppModule _Module; + #include + + #define _WTL_USE_CSTRING +-#include ++#include + + #if _MSC_VER<1400 + #define _TCSCPY_S(strDestination, numberOfElements, strSource) _tcscpy(strDestination, strSource) +diff --git a/thirdparty/libpng/CMakeLists.txt b/thirdparty/libpng/CMakeLists.txt +index b358c4e..e0f7a33 100644 +--- a/thirdparty/libpng/CMakeLists.txt ++++ b/thirdparty/libpng/CMakeLists.txt +@@ -7,7 +7,7 @@ aux_source_directory( . source_files ) + add_definitions(-D_UNICODE -D_CRT_SECURE_NO_DEPRECATE /wd4244 /wd4267) + + # Add include dir +-include_directories( ${CMAKE_SOURCE_DIR}/thirdparty/zlib ) ++include_directories( ${ZLIB_INCLUDE_DIRS} ) + + fix_default_compiler_settings_() + +@@ -15,6 +15,6 @@ fix_default_compiler_settings_() + add_library(libpng STATIC ${source_files}) + + # Add linker input libraries +-target_link_libraries(libpng zlib) ++target_link_libraries(libpng ZLIB::ZLIB) + + set_target_properties(libpng PROPERTIES DEBUG_POSTFIX d ) +\ No newline at end of file +diff --git a/thirdparty/libtheora/CMakeLists.txt b/thirdparty/libtheora/CMakeLists.txt +index 896fb47..f3cf5eb 100644 +--- a/thirdparty/libtheora/CMakeLists.txt ++++ b/thirdparty/libtheora/CMakeLists.txt +@@ -8,7 +8,7 @@ aux_source_directory( ./lib/x86_vc x86_source_files ) + add_definitions(-D_UNICODE -D_CRT_SECURE_NO_DEPRECATE /wd4244 /wd4700 /wd4214 /wd4554 /wd4018 /wd4100 /wd4132 /wd4389 /wd4127 /wd4701 /wd4245 /wd4267 /wd4334) + + # Add include dir +-include_directories( ${CMAKE_SOURCE_DIR}/thirdparty/libogg/include ++include_directories( ${OGG_INCLUDE_DIRS} + ${CMAKE_SOURCE_DIR}/thirdparty/libtheora/include) + + fix_default_compiler_settings_() +diff --git a/thirdparty/minizip/CMakeLists.txt b/thirdparty/minizip/CMakeLists.txt +index 5f4d0af..2b015c9 100644 +--- a/thirdparty/minizip/CMakeLists.txt ++++ b/thirdparty/minizip/CMakeLists.txt +@@ -7,7 +7,7 @@ aux_source_directory( . source_files ) + add_definitions(-D_UNICODE -D_CRT_SECURE_NO_DEPRECATE /wd4127 /wd4131 /wd4100 /wd4189 /wd4244) + + # Add include dir +-include_directories( ${CMAKE_SOURCE_DIR}/thirdparty/zlib ) ++include_directories( ${ZLIB_INCLUDE_DIRS} ) + + fix_default_compiler_settings_() + +@@ -15,6 +15,6 @@ fix_default_compiler_settings_() + add_library(minizip STATIC ${source_files}) + + # Add linker input libraries +-target_link_libraries(minizip zlib) ++target_link_libraries(minizip ZLIB::ZLIB) + + set_target_properties(minizip PROPERTIES DEBUG_POSTFIX d ) +\ No newline at end of file diff --git a/ports/crashrpt/001-cmake-install.patch b/ports/crashrpt/001-cmake-install.patch deleted file mode 100644 index c4d1710eeaed9d..00000000000000 --- a/ports/crashrpt/001-cmake-install.patch +++ /dev/null @@ -1,112 +0,0 @@ -diff --git a/CMakeLists.txt b/CMakeLists.txt -index 44d7df0..daf8352 100644 ---- a/CMakeLists.txt -+++ b/CMakeLists.txt -@@ -17,6 +17,8 @@ set (CRASHRPT_VER 1403) - # Build options - option(CRASHRPT_BUILD_SHARED_LIBS "If set (default), CrashRpt modules are built as dynamic-link libraries, otherwise as static libs." ON) - option(CRASHRPT_LINK_CRT_AS_DLL "If set (default), CrashRpt modules link C run-time (CRT) as multi-threaded dynamic libraries, otherwise as multi-threaded static libs." ON) -+option(CRASHRPT_BUILD_DEMOS "If set (default), CrashRpt builds the demo projects." ON) -+option(CRASHRPT_BUILD_TESTS "If set (default), CrashRpt builds the test projects." ON) - - # Set output directory for executable files - if(CMAKE_CL_64) -@@ -96,9 +98,11 @@ endmacro() - - # Other CMakeLists are located in project subdirectories - -+if(CRASHRPT_BUILD_DEMOS) - add_subdirectory("demos/ConsoleDemo") - add_subdirectory("demos/WTLDemo") - add_subdirectory("demos/MFCDemo") -+endif() - - add_subdirectory("reporting/crashrpt") - add_subdirectory("reporting/crashsender") -@@ -106,7 +110,9 @@ add_subdirectory("reporting/crashsender") - add_subdirectory("processing/crashrptprobe") - add_subdirectory("processing/crprober") - -+if(CRASHRPT_BUILD_TESTS) - add_subdirectory("tests") -+endif() - - # Set output directory for LIB files - if(CMAKE_CL_64) -diff --git a/processing/crashrptprobe/CMakeLists.txt b/processing/crashrptprobe/CMakeLists.txt -index a6c692a..35e06bb 100644 ---- a/processing/crashrptprobe/CMakeLists.txt -+++ b/processing/crashrptprobe/CMakeLists.txt -@@ -58,4 +58,11 @@ else(CRASHRPT_BUILD_SHARED_LIBS) - - endif(CRASHRPT_BUILD_SHARED_LIBS) - -+set_target_properties(CrashRptProbe PROPERTIES PUBLIC_HEADER ${CMAKE_SOURCE_DIR}/include/CrashRptProbe.h) - -+INSTALL(TARGETS CrashRptProbe -+ PUBLIC_HEADER DESTINATION include/crashrpt -+ LIBRARY -+ ARCHIVE -+ RUNTIME -+) -diff --git a/processing/crprober/CMakeLists.txt b/processing/crprober/CMakeLists.txt -index 046ba57..255e200 100644 ---- a/processing/crprober/CMakeLists.txt -+++ b/processing/crprober/CMakeLists.txt -@@ -18,4 +18,8 @@ add_executable(crprober ${source_files} ${header_files}) - # Add input link libraries - target_link_libraries(crprober CrashRptProbe) - --set_target_properties(crprober PROPERTIES DEBUG_POSTFIX d ) -\ No newline at end of file -+set_target_properties(crprober PROPERTIES DEBUG_POSTFIX d ) -+ -+install(TARGETS crprober -+ RUNTIME DESTINATION tools/crashrpt -+) -diff --git a/reporting/crashrpt/CMakeLists.txt b/reporting/crashrpt/CMakeLists.txt -index 42d40e2..a335ca9 100644 ---- a/reporting/crashrpt/CMakeLists.txt -+++ b/reporting/crashrpt/CMakeLists.txt -@@ -55,3 +55,11 @@ else(CRASHRPT_BUILD_SHARED_LIBS) - RELEASE_POSTFIX LIB ) - endif(CRASHRPT_BUILD_SHARED_LIBS) - -+set_target_properties(CrashRpt PROPERTIES PUBLIC_HEADER ${CMAKE_SOURCE_DIR}/include/CrashRpt.h) -+ -+INSTALL(TARGETS CrashRpt -+ PUBLIC_HEADER DESTINATION include/crashrpt -+ LIBRARY -+ ARCHIVE -+ RUNTIME -+) -diff --git a/reporting/crashsender/CMakeLists.txt b/reporting/crashsender/CMakeLists.txt -index 9b444c5..5b4b895 100644 ---- a/reporting/crashsender/CMakeLists.txt -+++ b/reporting/crashsender/CMakeLists.txt -@@ -52,4 +52,11 @@ set_target_properties(CrashRpt PROPERTIES COMPILE_FLAGS "/Os") - - set_target_properties(CrashSender PROPERTIES - DEBUG_POSTFIX ${CRASHRPT_VER}d -- RELEASE_POSTFIX ${CRASHRPT_VER} ) -\ No newline at end of file -+ RELEASE_POSTFIX ${CRASHRPT_VER} ) -+ -+install(TARGETS CrashSender -+ RUNTIME DESTINATION tools/crashrpt -+) -+ -+file(GLOB LANG_FILES "${CMAKE_SOURCE_DIR}/lang_files/crashrpt_lang_*.ini") -+install(FILES ${LANG_FILES} DESTINATION tools/crashrpt) -diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt -index f7bfede..402b024 100644 ---- a/tests/CMakeLists.txt -+++ b/tests/CMakeLists.txt -@@ -42,3 +42,7 @@ target_link_libraries(Tests CrashRpt CrashRptProbe) - - set_target_properties(Tests PROPERTIES DEBUG_POSTFIX d ) - #set_target_properties(Tests PROPERTIES COMPILE_FLAGS "/Zi" LINK_FLAGS "/DEBUG") -+ -+install(TARGETS Tests -+ RUNTIME DESTINATION tools/crashrpt -+) diff --git a/ports/crashrpt/002-find-minizip-png-zlib.patch b/ports/crashrpt/002-find-minizip-png-zlib.patch deleted file mode 100644 index 7294e317d2a190..00000000000000 --- a/ports/crashrpt/002-find-minizip-png-zlib.patch +++ /dev/null @@ -1,189 +0,0 @@ -diff --git a/CMakeLists.txt b/CMakeLists.txt -index daf8352..7a20e49 100644 ---- a/CMakeLists.txt -+++ b/CMakeLists.txt -@@ -96,6 +96,10 @@ macro(fix_default_compiler_settings_) - - endmacro() - -+find_package(ZLIB REQUIRED) -+find_package(MINIZIP REQUIRED) -+find_package(PNG REQUIRED) -+ - # Other CMakeLists are located in project subdirectories - - if(CRASHRPT_BUILD_DEMOS) -@@ -125,9 +129,9 @@ endif(CMAKE_CL_64) - - add_subdirectory("thirdparty/tinyxml") - add_subdirectory("thirdparty/jpeg") --add_subdirectory("thirdparty/libpng") --add_subdirectory("thirdparty/minizip") --add_subdirectory("thirdparty/zlib") -+#add_subdirectory("thirdparty/libpng") -+#add_subdirectory("thirdparty/minizip") -+#add_subdirectory("thirdparty/zlib") - add_subdirectory("thirdparty/libogg") - add_subdirectory("thirdparty/libtheora") - -diff --git a/processing/crashrptprobe/CMakeLists.txt b/processing/crashrptprobe/CMakeLists.txt -index 35e06bb..4a54302 100644 ---- a/processing/crashrptprobe/CMakeLists.txt -+++ b/processing/crashrptprobe/CMakeLists.txt -@@ -22,8 +22,8 @@ include_directories( ${CMAKE_SOURCE_DIR}/include - ${CMAKE_SOURCE_DIR}/reporting/crashrpt - ${CMAKE_SOURCE_DIR}/reporting/crashsender - ${CMAKE_SOURCE_DIR}/thirdparty/wtl -- ${CMAKE_SOURCE_DIR}/thirdparty/zlib -- ${CMAKE_SOURCE_DIR}/thirdparty/minizip -+ ${ZLIB_INCLUDE_DIRS} -+ ${MINIZIP_INCLUDE_DIR} - ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml - ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include) - -@@ -42,7 +42,7 @@ else(CMAKE_CL_64) - target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/dbghelp.lib) - endif(CMAKE_CL_64) - --target_link_libraries(CrashRptProbe zlib minizip tinyxml Rpcrt4.lib shell32.lib gdi32.lib version.lib psapi.lib) -+target_link_libraries(CrashRptProbe ZLIB::ZLIB minizip::minizip tinyxml Rpcrt4.lib shell32.lib gdi32.lib version.lib psapi.lib) - - if(CRASHRPT_BUILD_SHARED_LIBS) - -diff --git a/processing/crashrptprobe/CrashRptProbe.cpp b/processing/crashrptprobe/CrashRptProbe.cpp -index 8932c43..fdb8dac 100644 ---- a/processing/crashrptprobe/CrashRptProbe.cpp -+++ b/processing/crashrptprobe/CrashRptProbe.cpp -@@ -22,7 +22,7 @@ be found in the Authors.txt file in the root of the source tree. - #include "md5.h" - #include "Utility.h" - #include "strconv.h" --#include "unzip.h" -+#include "minizip/unzip.h" - - CComAutoCriticalSection g_crp_cs; // Critical section for thread-safe accessing error messages - std::map g_crp_sErrorMsg; // Last error messages for each calling thread. -diff --git a/reporting/crashsender/CMakeLists.txt b/reporting/crashsender/CMakeLists.txt -index 5b4b895..25cd467 100644 ---- a/reporting/crashsender/CMakeLists.txt -+++ b/reporting/crashsender/CMakeLists.txt -@@ -16,6 +16,7 @@ list(APPEND source_files - - # Define _UNICODE (use wide-char encoding) - add_definitions(-D_UNICODE ) -+add_definitions(${PNG_DEFINITIONS}) - - fix_default_compiler_settings_() - -@@ -23,10 +24,10 @@ fix_default_compiler_settings_() - include_directories( ${CMAKE_SOURCE_DIR}/include - ${CMAKE_SOURCE_DIR}/reporting/CrashRpt - ${CMAKE_SOURCE_DIR}/thirdparty/wtl -- ${CMAKE_SOURCE_DIR}/thirdparty/zlib -- ${CMAKE_SOURCE_DIR}/thirdparty/minizip -+ ${ZLIB_INCLUDE_DIRS} -+ ${MINIZIP_INCLUDE_DIR} - ${CMAKE_SOURCE_DIR}/thirdparty/jpeg -- ${CMAKE_SOURCE_DIR}/thirdparty/libpng -+ ${PNG_INCLUDE_DIRS} - ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml - ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include - ${CMAKE_SOURCE_DIR}/thirdparty/libogg/include -@@ -42,7 +43,7 @@ endif(NOT CMAKE_CL_64) - add_executable(CrashSender WIN32 ${source_files} ${header_files}) - - # Add input link libraries --target_link_libraries(CrashSender zlib minizip libjpeg libpng tinyxml libogg libtheora WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) -+target_link_libraries(CrashSender ZLIB::ZLIB minizip::minizip libjpeg PNG::PNG tinyxml libogg libtheora WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) - - # Add compiler flags (/MP for multi-processor compilation, /Os to favor small code) - set_target_properties(CrashRpt PROPERTIES COMPILE_FLAGS "/Os") -diff --git a/reporting/crashsender/ErrorReportDlg.cpp b/reporting/crashsender/ErrorReportDlg.cpp -index ab23aa0..d0d6d7f 100644 ---- a/reporting/crashsender/ErrorReportDlg.cpp -+++ b/reporting/crashsender/ErrorReportDlg.cpp -@@ -13,8 +13,8 @@ be found in the Authors.txt file in the root of the source tree. - #include "ErrorReportDlg.h" - #include "Utility.h" - #include "tinyxml.h" --#include "zip.h" --#include "unzip.h" -+#include "minizip/zip.h" -+#include "minizip/unzip.h" - #include "CrashInfoReader.h" - #include "strconv.h" - -diff --git a/reporting/crashsender/ErrorReportSender.cpp b/reporting/crashsender/ErrorReportSender.cpp -index ac9603c..369fd4d 100644 ---- a/reporting/crashsender/ErrorReportSender.cpp -+++ b/reporting/crashsender/ErrorReportSender.cpp -@@ -16,7 +16,7 @@ be found in the Authors.txt file in the root of the source tree. - #include "CrashRpt.h" - #include "md5.h" - #include "Utility.h" --#include "zip.h" -+#include "minizip/zip.h" - #include "CrashInfoReader.h" - #include "strconv.h" - #include "ScreenCap.h" -diff --git a/reporting/crashsender/FilePreviewCtrl.cpp b/reporting/crashsender/FilePreviewCtrl.cpp -index e71aafc..d9f1330 100644 ---- a/reporting/crashsender/FilePreviewCtrl.cpp -+++ b/reporting/crashsender/FilePreviewCtrl.cpp -@@ -365,7 +365,7 @@ BOOL CImage::LoadBitmapFromPNGFile(LPTSTR szFileName) - if (!png_ptr) - goto cleanup; - -- if (setjmp(png_ptr->jmpbuf)) -+ if (setjmp(png_jmpbuf(png_ptr))) - goto cleanup; - - info_ptr = png_create_info_struct(png_ptr); -@@ -389,7 +389,7 @@ BOOL CImage::LoadBitmapFromPNGFile(LPTSTR szFileName) - width = png_get_image_width(png_ptr, info_ptr); - height = png_get_image_height(png_ptr, info_ptr); - -- if(info_ptr->channels==3) -+ if(png_get_channels(png_ptr, info_ptr)==3) - { - png_set_strip_16(png_ptr); - png_set_packing(png_ptr); -@@ -408,14 +408,14 @@ BOOL CImage::LoadBitmapFromPNGFile(LPTSTR szFileName) - pBMI = (BITMAPINFO*)new BYTE[sizeof(BITMAPINFO)+256*4]; - memset(pBMI, 0, sizeof(BITMAPINFO)+256*4); - pBMI->bmiHeader.biSize = sizeof(BITMAPINFO); -- pBMI->bmiHeader.biBitCount = 8*info_ptr->channels; -+ pBMI->bmiHeader.biBitCount = 8*png_get_channels(png_ptr, info_ptr); - pBMI->bmiHeader.biWidth = width; - pBMI->bmiHeader.biHeight = height; - pBMI->bmiHeader.biPlanes = 1; - pBMI->bmiHeader.biCompression = BI_RGB; - pBMI->bmiHeader.biSizeImage = rowbytes*height; - -- if( info_ptr->channels == 1 ) -+ if( png_get_channels(png_ptr, info_ptr) == 1 ) - { - RGBQUAD* palette = pBMI->bmiColors; - -@@ -431,7 +431,7 @@ BOOL CImage::LoadBitmapFromPNGFile(LPTSTR szFileName) - - for(y=height-1; y>=0; y--) - { -- png_read_rows(png_ptr, &row, png_bytepp_NULL, 1); -+ png_read_rows(png_ptr, &row, NULL, 1); - - { - CAutoLock lock(&m_csLock); -diff --git a/reporting/crashsender/ScreenCap.cpp b/reporting/crashsender/ScreenCap.cpp -index c183c19..ca26160 100644 ---- a/reporting/crashsender/ScreenCap.cpp -+++ b/reporting/crashsender/ScreenCap.cpp -@@ -11,6 +11,8 @@ be found in the Authors.txt file in the root of the source tree. - #include "stdafx.h" - #include "ScreenCap.h" - #include "Utility.h" -+#include "zlib.h" -+#include "png.h" - - // Disable warning C4611: interaction between '_setjmp' and C++ object destruction is non-portable - #pragma warning(disable:4611) diff --git a/ports/crashrpt/003-find-libogg-libtheora.patch b/ports/crashrpt/003-find-libogg-libtheora.patch deleted file mode 100644 index e148ac946ebb5c..00000000000000 --- a/ports/crashrpt/003-find-libogg-libtheora.patch +++ /dev/null @@ -1,57 +0,0 @@ -diff --git a/CMakeLists.txt b/CMakeLists.txt -index 7a20e49..42a55fc 100644 ---- a/CMakeLists.txt -+++ b/CMakeLists.txt -@@ -99,6 +99,17 @@ endmacro() - find_package(ZLIB REQUIRED) - find_package(MINIZIP REQUIRED) - find_package(PNG REQUIRED) -+find_package(Ogg REQUIRED) -+ -+find_library(THEORA_LIBRARY theora) -+if(NOT THEORA_LIBRARY) -+ message(FATAL_ERROR "theora library not found") -+endif() -+ -+find_path(THEORA_INCLUDE_DIR theora/theora.h) -+if(NOT THEORA_INCLUDE_DIR) -+ message(FATAL_ERROR "theora include dir not found") -+endif() - - # Other CMakeLists are located in project subdirectories - -@@ -132,8 +143,8 @@ add_subdirectory("thirdparty/jpeg") - #add_subdirectory("thirdparty/libpng") - #add_subdirectory("thirdparty/minizip") - #add_subdirectory("thirdparty/zlib") --add_subdirectory("thirdparty/libogg") --add_subdirectory("thirdparty/libtheora") -+#add_subdirectory("thirdparty/libogg") -+#add_subdirectory("thirdparty/libtheora") - - - -diff --git a/reporting/crashsender/CMakeLists.txt b/reporting/crashsender/CMakeLists.txt -index 25cd467..9e191c4 100644 ---- a/reporting/crashsender/CMakeLists.txt -+++ b/reporting/crashsender/CMakeLists.txt -@@ -30,8 +30,8 @@ include_directories( ${CMAKE_SOURCE_DIR}/include - ${PNG_INCLUDE_DIRS} - ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml - ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include -- ${CMAKE_SOURCE_DIR}/thirdparty/libogg/include -- ${CMAKE_SOURCE_DIR}/thirdparty/libtheora/include) -+ ${OGG_INCLUDE_DIRS} -+ ${THEORA_INCLUDE_DIR}) - - if(NOT CMAKE_CL_64) - link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib ) -@@ -43,7 +43,7 @@ endif(NOT CMAKE_CL_64) - add_executable(CrashSender WIN32 ${source_files} ${header_files}) - - # Add input link libraries --target_link_libraries(CrashSender ZLIB::ZLIB minizip::minizip libjpeg PNG::PNG tinyxml libogg libtheora WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) -+target_link_libraries(CrashSender ZLIB::ZLIB minizip::minizip libjpeg PNG::PNG tinyxml Ogg::ogg ${THEORA_LIBRARY} WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) - - # Add compiler flags (/MP for multi-processor compilation, /Os to favor small code) - set_target_properties(CrashRpt PROPERTIES COMPILE_FLAGS "/Os") diff --git a/ports/crashrpt/004-find-tinyxml.patch b/ports/crashrpt/004-find-tinyxml.patch deleted file mode 100644 index 3ab1aa812cc7d5..00000000000000 --- a/ports/crashrpt/004-find-tinyxml.patch +++ /dev/null @@ -1,87 +0,0 @@ -diff --git a/CMakeLists.txt b/CMakeLists.txt -index 42a55fc..281f66b 100644 ---- a/CMakeLists.txt -+++ b/CMakeLists.txt -@@ -111,6 +111,16 @@ if(NOT THEORA_INCLUDE_DIR) - message(FATAL_ERROR "theora include dir not found") - endif() - -+find_library(TINYXML_LIBRARY NAMES tinyxml) -+if(NOT TINYXML_LIBRARY) -+ message(FATAL_ERROR "tinyxml library not found") -+endif() -+ -+find_path(TINYXML_INCLUDE_DIR tinyxml.h) -+if(NOT TINYXML_INCLUDE_DIR) -+ message(FATAL_ERROR "tinyxml include dir not found") -+endif() -+ - # Other CMakeLists are located in project subdirectories - - if(CRASHRPT_BUILD_DEMOS) -@@ -138,7 +148,7 @@ else(CMAKE_CL_64) - set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/thirdparty/lib) - endif(CMAKE_CL_64) - --add_subdirectory("thirdparty/tinyxml") -+#add_subdirectory("thirdparty/tinyxml") - add_subdirectory("thirdparty/jpeg") - #add_subdirectory("thirdparty/libpng") - #add_subdirectory("thirdparty/minizip") -diff --git a/processing/crashrptprobe/CMakeLists.txt b/processing/crashrptprobe/CMakeLists.txt -index 4a54302..2aeb395 100644 ---- a/processing/crashrptprobe/CMakeLists.txt -+++ b/processing/crashrptprobe/CMakeLists.txt -@@ -24,7 +24,7 @@ include_directories( ${CMAKE_SOURCE_DIR}/include - ${CMAKE_SOURCE_DIR}/thirdparty/wtl - ${ZLIB_INCLUDE_DIRS} - ${MINIZIP_INCLUDE_DIR} -- ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml -+ ${TINYXML_INCLUDE_DIR} - ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include) - - # Add library build target -@@ -42,7 +42,7 @@ else(CMAKE_CL_64) - target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/dbghelp.lib) - endif(CMAKE_CL_64) - --target_link_libraries(CrashRptProbe ZLIB::ZLIB minizip::minizip tinyxml Rpcrt4.lib shell32.lib gdi32.lib version.lib psapi.lib) -+target_link_libraries(CrashRptProbe ZLIB::ZLIB minizip::minizip ${TINYXML_LIBRARY} Rpcrt4.lib shell32.lib gdi32.lib version.lib psapi.lib) - - if(CRASHRPT_BUILD_SHARED_LIBS) - -diff --git a/reporting/crashsender/CMakeLists.txt b/reporting/crashsender/CMakeLists.txt -index 9e191c4..780b756 100644 ---- a/reporting/crashsender/CMakeLists.txt -+++ b/reporting/crashsender/CMakeLists.txt -@@ -28,7 +28,7 @@ include_directories( ${CMAKE_SOURCE_DIR}/include - ${MINIZIP_INCLUDE_DIR} - ${CMAKE_SOURCE_DIR}/thirdparty/jpeg - ${PNG_INCLUDE_DIRS} -- ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml -+ ${TINYXML_INCLUDE_DIR} - ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include - ${OGG_INCLUDE_DIRS} - ${THEORA_INCLUDE_DIR}) -@@ -43,7 +43,7 @@ endif(NOT CMAKE_CL_64) - add_executable(CrashSender WIN32 ${source_files} ${header_files}) - - # Add input link libraries --target_link_libraries(CrashSender ZLIB::ZLIB minizip::minizip libjpeg PNG::PNG tinyxml Ogg::ogg ${THEORA_LIBRARY} WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) -+target_link_libraries(CrashSender ZLIB::ZLIB minizip::minizip libjpeg PNG::PNG ${TINYXML_LIBRARY} Ogg::ogg ${THEORA_LIBRARY} WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) - - # Add compiler flags (/MP for multi-processor compilation, /Os to favor small code) - set_target_properties(CrashRpt PROPERTIES COMPILE_FLAGS "/Os") -diff --git a/reporting/crashsender/ErrorReportSender.cpp b/reporting/crashsender/ErrorReportSender.cpp -index 369fd4d..46d6d12 100644 ---- a/reporting/crashsender/ErrorReportSender.cpp -+++ b/reporting/crashsender/ErrorReportSender.cpp -@@ -1086,7 +1086,7 @@ BOOL CErrorReportSender::CreateCrashDescriptionXML(CErrorReportInfo& eri) - goto cleanup; - } - -- doc.useMicrosoftBOM = true; -+ //doc.useMicrosoftBOM = true; - bool bSave = doc.SaveFile(f); - if(!bSave) - { diff --git a/ports/crashrpt/005-find-wtl.patch b/ports/crashrpt/005-find-wtl.patch deleted file mode 100644 index c9c785bdca79a6..00000000000000 --- a/ports/crashrpt/005-find-wtl.patch +++ /dev/null @@ -1,185 +0,0 @@ -diff --git a/CMakeLists.txt b/CMakeLists.txt -index 281f66b..b95a781 100644 ---- a/CMakeLists.txt -+++ b/CMakeLists.txt -@@ -121,6 +121,11 @@ if(NOT TINYXML_INCLUDE_DIR) - message(FATAL_ERROR "tinyxml include dir not found") - endif() - -+find_path(WTL_INCLUDE_DIR wtl/atlapp.h) -+if(NOT WTL_INCLUDE_DIR) -+ message(FATAL_ERROR "WTL include dir not found") -+endif() -+ - # Other CMakeLists are located in project subdirectories - - if(CRASHRPT_BUILD_DEMOS) -diff --git a/processing/crashrptprobe/CMakeLists.txt b/processing/crashrptprobe/CMakeLists.txt -index 2aeb395..dafb007 100644 ---- a/processing/crashrptprobe/CMakeLists.txt -+++ b/processing/crashrptprobe/CMakeLists.txt -@@ -21,7 +21,7 @@ fix_default_compiler_settings_() - include_directories( ${CMAKE_SOURCE_DIR}/include - ${CMAKE_SOURCE_DIR}/reporting/crashrpt - ${CMAKE_SOURCE_DIR}/reporting/crashsender -- ${CMAKE_SOURCE_DIR}/thirdparty/wtl -+ ${WTL_INCLUDE_DIR} - ${ZLIB_INCLUDE_DIRS} - ${MINIZIP_INCLUDE_DIR} - ${TINYXML_INCLUDE_DIR} -diff --git a/processing/crashrptprobe/CrashRptProbe.rc b/processing/crashrptprobe/CrashRptProbe.rc -index a08f63e..1d2abea 100644 ---- a/processing/crashrptprobe/CrashRptProbe.rc -+++ b/processing/crashrptprobe/CrashRptProbe.rc -@@ -7,7 +7,7 @@ - // - // Generated from the TEXTINCLUDE 2 resource. - // --#include "atlres.h" -+#include "wtl/atlres.h" - - ///////////////////////////////////////////////////////////////////////////// - #undef APSTUDIO_READONLY_SYMBOLS -diff --git a/processing/crashrptprobe/stdafx.h b/processing/crashrptprobe/stdafx.h -index 2b027b2..0b60659 100644 ---- a/processing/crashrptprobe/stdafx.h -+++ b/processing/crashrptprobe/stdafx.h -@@ -70,13 +70,13 @@ namespace ATL - }; - #endif // _WTL_SUPPORT_SDK_ATL3 - --#include -+#include - extern CAppModule _Module; - #include - - // CString-related includes - #define _WTL_USE_CSTRING --#include -+#include - - #if _MSC_VER<1400 - #define WCSNCPY_S(strDest, sizeInBytes, strSource, count) wcsncpy(strDest, strSource, count) -diff --git a/reporting/crashrpt/CMakeLists.txt b/reporting/crashrpt/CMakeLists.txt -index a335ca9..c7e4fd6 100644 ---- a/reporting/crashrpt/CMakeLists.txt -+++ b/reporting/crashrpt/CMakeLists.txt -@@ -18,7 +18,7 @@ add_definitions(-D_UNICODE -D_CRT_SECURE_NO_DEPRECATE) - fix_default_compiler_settings_() - - # Add include dir --include_directories( ${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/thirdparty/wtl) -+include_directories( ${CMAKE_SOURCE_DIR}/include ${WTL_INCLUDE_DIR}) - - # Add library build target - if(CRASHRPT_BUILD_SHARED_LIBS) -diff --git a/reporting/crashrpt/CrashRpt.rc b/reporting/crashrpt/CrashRpt.rc -index 95e7502..2a13940 100644 ---- a/reporting/crashrpt/CrashRpt.rc -+++ b/reporting/crashrpt/CrashRpt.rc -@@ -7,7 +7,7 @@ - // - // Generated from the TEXTINCLUDE 2 resource. - // --#include "atlres.h" -+#include "wtl/atlres.h" - - ///////////////////////////////////////////////////////////////////////////// - #undef APSTUDIO_READONLY_SYMBOLS -diff --git a/reporting/crashrpt/StdAfx.h b/reporting/crashrpt/StdAfx.h -index 77d8c36..f6a9b6e 100644 ---- a/reporting/crashrpt/StdAfx.h -+++ b/reporting/crashrpt/StdAfx.h -@@ -54,12 +54,12 @@ namespace ATL - }; - #endif // _WTL_SUPPORT_SDK_ATL3 - --#include -+#include - extern CAppModule _Module; - #include - // CString-related includes - #define _WTL_USE_CSTRING --#include -+#include - #include - #include - #include -diff --git a/reporting/crashsender/CMakeLists.txt b/reporting/crashsender/CMakeLists.txt -index 780b756..23f3ae7 100644 ---- a/reporting/crashsender/CMakeLists.txt -+++ b/reporting/crashsender/CMakeLists.txt -@@ -23,7 +23,7 @@ fix_default_compiler_settings_() - # Add include dir - include_directories( ${CMAKE_SOURCE_DIR}/include - ${CMAKE_SOURCE_DIR}/reporting/CrashRpt -- ${CMAKE_SOURCE_DIR}/thirdparty/wtl -+ ${WTL_INCLUDE_DIR} - ${ZLIB_INCLUDE_DIRS} - ${MINIZIP_INCLUDE_DIR} - ${CMAKE_SOURCE_DIR}/thirdparty/jpeg -diff --git a/reporting/crashsender/CrashSender.rc b/reporting/crashsender/CrashSender.rc -index 0502962..1731869 100644 ---- a/reporting/crashsender/CrashSender.rc -+++ b/reporting/crashsender/CrashSender.rc -@@ -7,7 +7,7 @@ - // - // Generated from the TEXTINCLUDE 2 resource. - // --#include "atlres.h" -+#include "wtl/atlres.h" - - ///////////////////////////////////////////////////////////////////////////// - #undef APSTUDIO_READONLY_SYMBOLS -diff --git a/reporting/crashsender/stdafx.h b/reporting/crashsender/stdafx.h -index f087ff4..4494d3a 100644 ---- a/reporting/crashsender/stdafx.h -+++ b/reporting/crashsender/stdafx.h -@@ -19,7 +19,7 @@ be found in the Authors.txt file in the root of the source tree. - #define WINVER 0x0501 - #define _WIN32_WINNT 0x0501 - #define _WIN32_IE 0x0600 --#define _RICHEDIT_VER 0x0200 -+#define _RICHEDIT_VER 0x0300 - - typedef __int64 off_t, _off_t; - #define _OFF_T_DEFINED -@@ -61,19 +61,19 @@ namespace ATL - }; - #endif // _WTL_SUPPORT_SDK_ATL3 - --#include -+#include - - extern CAppModule _Module; - - #include - --#include --#include --#include --#include -+#include -+#include -+#include -+#include - - #define _WTL_USE_CSTRING --#include -+#include - - #include - #include -diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt -index 402b024..e2b61be 100644 ---- a/tests/CMakeLists.txt -+++ b/tests/CMakeLists.txt -@@ -32,7 +32,7 @@ set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /DEBUG") - # Add include dir - include_directories( ${CMAKE_SOURCE_DIR}/include - ${CMAKE_SOURCE_DIR}/reporting/CrashRpt -- ${CMAKE_SOURCE_DIR}/thirdparty/wtl ) -+ ${WTL_INCLUDE_DIR} ) - - # Add executable build target - add_executable(Tests ${source_files} ${header_files}) diff --git a/ports/crashrpt/006-find-libjpeg-turbo.patch b/ports/crashrpt/006-find-libjpeg-turbo.patch deleted file mode 100644 index fcc01d07627528..00000000000000 --- a/ports/crashrpt/006-find-libjpeg-turbo.patch +++ /dev/null @@ -1,43 +0,0 @@ -diff --git a/CMakeLists.txt b/CMakeLists.txt -index b95a781..5a14f12 100644 ---- a/CMakeLists.txt -+++ b/CMakeLists.txt -@@ -100,6 +100,7 @@ find_package(ZLIB REQUIRED) - find_package(MINIZIP REQUIRED) - find_package(PNG REQUIRED) - find_package(Ogg REQUIRED) -+find_package(JPEG REQUIRED) - - find_library(THEORA_LIBRARY theora) - if(NOT THEORA_LIBRARY) -@@ -154,7 +155,7 @@ else(CMAKE_CL_64) - endif(CMAKE_CL_64) - - #add_subdirectory("thirdparty/tinyxml") --add_subdirectory("thirdparty/jpeg") -+#add_subdirectory("thirdparty/jpeg") - #add_subdirectory("thirdparty/libpng") - #add_subdirectory("thirdparty/minizip") - #add_subdirectory("thirdparty/zlib") -diff --git a/reporting/crashsender/CMakeLists.txt b/reporting/crashsender/CMakeLists.txt -index 23f3ae7..088365f 100644 ---- a/reporting/crashsender/CMakeLists.txt -+++ b/reporting/crashsender/CMakeLists.txt -@@ -26,7 +26,7 @@ include_directories( ${CMAKE_SOURCE_DIR}/include - ${WTL_INCLUDE_DIR} - ${ZLIB_INCLUDE_DIRS} - ${MINIZIP_INCLUDE_DIR} -- ${CMAKE_SOURCE_DIR}/thirdparty/jpeg -+ ${JPEG_INCLUDE_DIR} - ${PNG_INCLUDE_DIRS} - ${TINYXML_INCLUDE_DIR} - ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include -@@ -43,7 +43,7 @@ endif(NOT CMAKE_CL_64) - add_executable(CrashSender WIN32 ${source_files} ${header_files}) - - # Add input link libraries --target_link_libraries(CrashSender ZLIB::ZLIB minizip::minizip libjpeg PNG::PNG ${TINYXML_LIBRARY} Ogg::ogg ${THEORA_LIBRARY} WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) -+target_link_libraries(CrashSender ZLIB::ZLIB minizip::minizip ${JPEG_LIBRARIES} PNG::PNG ${TINYXML_LIBRARY} Ogg::ogg ${THEORA_LIBRARY} WS2_32.lib Dnsapi.lib wininet.lib Rpcrt4.lib Gdi32.lib shell32.lib Comdlg32.lib version.lib psapi.lib) - - # Add compiler flags (/MP for multi-processor compilation, /Os to favor small code) - set_target_properties(CrashRpt PROPERTIES COMPILE_FLAGS "/Os") diff --git a/ports/crashrpt/007-fix-tests-and-demos-dependencies-and-install.patch b/ports/crashrpt/007-fix-tests-and-demos-dependencies-and-install.patch deleted file mode 100644 index fc3efad904dce7..00000000000000 --- a/ports/crashrpt/007-fix-tests-and-demos-dependencies-and-install.patch +++ /dev/null @@ -1,206 +0,0 @@ -diff --git a/demos/ConsoleDemo/CMakeLists.txt b/demos/ConsoleDemo/CMakeLists.txt -index e47ef4c..944fbf5 100644 ---- a/demos/ConsoleDemo/CMakeLists.txt -+++ b/demos/ConsoleDemo/CMakeLists.txt -@@ -12,12 +12,12 @@ fix_default_compiler_settings_() - # Add include dir - include_directories(${CMAKE_SOURCE_DIR}/include - ${CMAKE_SOURCE_DIR}/reporting/CrashRpt -- ${CMAKE_SOURCE_DIR}/thirdparty/wtl -- ${CMAKE_SOURCE_DIR}/thirdparty/zlib -- ${CMAKE_SOURCE_DIR}/thirdparty/minizip -- ${CMAKE_SOURCE_DIR}/thirdparty/jpeg -- ${CMAKE_SOURCE_DIR}/thirdparty/libpng -- ${CMAKE_SOURCE_DIR}/thirdparty/tinyxml ) -+ ${WTL_INCLUDE_DIR} -+ ${ZLIB_INCLUDE_DIRS} -+ ${MINIZIP_INCLUDE_DIR} -+ ${JPEG_INCLUDE_DIR} -+ ${PNG_INCLUDE_DIRS} -+ ${TINYXML_INCLUDE_DIR} ) - - # Add executable build target - add_executable(ConsoleDemo ${source_files} ${header_files}) -@@ -26,3 +26,7 @@ add_executable(ConsoleDemo ${source_files} ${header_files}) - target_link_libraries(ConsoleDemo CrashRpt) - - set_target_properties(ConsoleDemo PROPERTIES DEBUG_POSTFIX d ) -+ -+install(TARGETS ConsoleDemo -+ RUNTIME DESTINATION tools/crashrpt -+) -diff --git a/demos/MFCDemo/CMakeLists.txt b/demos/MFCDemo/CMakeLists.txt -index a250ecc..ac68c85 100644 ---- a/demos/MFCDemo/CMakeLists.txt -+++ b/demos/MFCDemo/CMakeLists.txt -@@ -58,4 +58,8 @@ ADD_CUSTOM_COMMAND( - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\"" - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\crashrpt_lang.ini\"" - ) --endif(CMAKE_CL_64) -\ No newline at end of file -+endif(CMAKE_CL_64) -+ -+install(TARGETS MFCDemo -+ RUNTIME DESTINATION tools/crashrpt -+) -diff --git a/demos/WTLDemo/AboutDlg.h b/demos/WTLDemo/AboutDlg.h -index 83eaac0..e96d1c2 100644 ---- a/demos/WTLDemo/AboutDlg.h -+++ b/demos/WTLDemo/AboutDlg.h -@@ -33,7 +33,7 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - #pragma once - #include "stdafx.h" - #include --#include -+#include - #include "CrashRpt.h" - - class CAboutDlg : public CDialogImpl -diff --git a/demos/WTLDemo/CMakeLists.txt b/demos/WTLDemo/CMakeLists.txt -index 40aaefb..969e813 100644 ---- a/demos/WTLDemo/CMakeLists.txt -+++ b/demos/WTLDemo/CMakeLists.txt -@@ -19,7 +19,7 @@ fix_default_compiler_settings_() - - # Add include dir - include_directories(${CMAKE_SOURCE_DIR}/include -- ${CMAKE_SOURCE_DIR}/thirdparty/wtl) -+ ${WTL_INCLUDE_DIR}) - - # Add executable build target - add_executable(WTLDemo WIN32 ${source_files} ${header_files}) -@@ -50,4 +50,8 @@ ADD_CUSTOM_COMMAND( - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\"" - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\crashrpt_lang.ini\"" - ) --endif(CMAKE_CL_64) -\ No newline at end of file -+endif(CMAKE_CL_64) -+ -+install(TARGETS WTLDemo -+ RUNTIME DESTINATION tools/crashrpt -+) -diff --git a/demos/WTLDemo/DocumentDlg.h b/demos/WTLDemo/DocumentDlg.h -index afce8fe..9b47728 100644 ---- a/demos/WTLDemo/DocumentDlg.h -+++ b/demos/WTLDemo/DocumentDlg.h -@@ -33,7 +33,7 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - #pragma once - #include "stdafx.h" - #include --#include -+#include - #include "CrashRpt.h" - - class CDocumentDlg : public CDialogImpl -diff --git a/demos/WTLDemo/WTLDemo.rc b/demos/WTLDemo/WTLDemo.rc -index c651841..a056bb6 100644 ---- a/demos/WTLDemo/WTLDemo.rc -+++ b/demos/WTLDemo/WTLDemo.rc -@@ -7,7 +7,7 @@ - // - // Generated from the TEXTINCLUDE 2 resource. - // --#include "atlres.h" -+#include "wtl/atlres.h" - - ///////////////////////////////////////////////////////////////////////////// - #undef APSTUDIO_READONLY_SYMBOLS -diff --git a/demos/WTLDemo/stdafx.h b/demos/WTLDemo/stdafx.h -index a601446..658d9e5 100644 ---- a/demos/WTLDemo/stdafx.h -+++ b/demos/WTLDemo/stdafx.h -@@ -16,10 +16,10 @@ be found in the Authors.txt file in the root of the source tree. - #pragma once - - // Change these values to use different versions --#define WINVER 0x0500 -+#define WINVER 0x0501 - #define _WIN32_WINNT 0x0501 --#define _WIN32_IE 0x0501 --#define _RICHEDIT_VER 0x0200 -+#define _WIN32_IE 0x0600 -+#define _RICHEDIT_VER 0x0300 - - #include - #if ( _ATL_VER < 0x0800 ) -@@ -52,18 +52,18 @@ namespace ATL - }; - #endif // _WTL_SUPPORT_SDK_ATL3 - --#include -+#include - - extern CAppModule _Module; - - #include - --#include --#include --#include -+#include -+#include -+#include - - #define _WTL_USE_CSTRING --#include -+#include - - #if _MSC_VER>=1400 - #if defined _M_IX86 -diff --git a/reporting/crashrpt/StdAfx.h b/reporting/crashrpt/StdAfx.h -index f6a9b6e..13bbe50 100644 ---- a/reporting/crashrpt/StdAfx.h -+++ b/reporting/crashrpt/StdAfx.h -@@ -19,7 +19,7 @@ be found in the Authors.txt file in the root of the source tree. - #define WINVER 0x0501 - #define _WIN32_WINNT 0x0501 - #define _WIN32_IE 0x0600 --#define _RICHEDIT_VER 0x0200 -+#define _RICHEDIT_VER 0x0300 - - #include - #include -diff --git a/tests/stdafx.h b/tests/stdafx.h -index f12675b..0ec2117 100644 ---- a/tests/stdafx.h -+++ b/tests/stdafx.h -@@ -19,7 +19,7 @@ be found in the Authors.txt file in the root of the source tree. - #define WINVER 0x0501 - #define _WIN32_WINNT 0x0501 - #define _WIN32_IE 0x0600 --#define _RICHEDIT_VER 0x0200 -+#define _RICHEDIT_VER 0x0300 - - #include - #include -@@ -58,15 +58,15 @@ namespace ATL - }; - #endif // _WTL_SUPPORT_SDK_ATL3 - --#include -+#include - - extern CAppModule _Module; - - #include - --#include --#include --#include -+#include -+#include -+#include - #include - #include - #include -@@ -75,7 +75,7 @@ extern CAppModule _Module; - #include - - #define _WTL_USE_CSTRING --#include -+#include - - #if _MSC_VER<1400 - #define _TCSCPY_S(strDestination, numberOfElements, strSource) _tcscpy(strDestination, strSource) diff --git a/ports/crashrpt/008-dbghelp.patch b/ports/crashrpt/008-dbghelp.patch deleted file mode 100644 index 70e333ad64d886..00000000000000 --- a/ports/crashrpt/008-dbghelp.patch +++ /dev/null @@ -1,128 +0,0 @@ -diff --git a/CMakeLists.txt b/CMakeLists.txt -index 5a14f12..491f3aa 100644 ---- a/CMakeLists.txt -+++ b/CMakeLists.txt -@@ -127,6 +127,16 @@ if(NOT WTL_INCLUDE_DIR) - message(FATAL_ERROR "WTL include dir not found") - endif() - -+find_library(DBGHELP_LIBRARY dbghelp) -+if(NOT DBGHELP_LIBRARY) -+ message(FATAL_ERROR "dbghelp library not found") -+endif() -+ -+find_path(DBGHELP_INCLUDE_DIR dbghelp.h) -+if(NOT DBGHELP_INCLUDE_DIR) -+ message(FATAL_ERROR "dbghelp include dir not found") -+endif() -+ - # Other CMakeLists are located in project subdirectories - - if(CRASHRPT_BUILD_DEMOS) -diff --git a/demos/MFCDemo/CMakeLists.txt b/demos/MFCDemo/CMakeLists.txt -index ac68c85..3483a79 100644 ---- a/demos/MFCDemo/CMakeLists.txt -+++ b/demos/MFCDemo/CMakeLists.txt -@@ -44,7 +44,7 @@ if(CMAKE_CL_64) - ADD_CUSTOM_COMMAND( - TARGET WTLDemo - POST_BUILD -- COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" -+# COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.ini\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\x64\\crashrpt_lang.ini\"" -@@ -53,7 +53,7 @@ else(CMAKE_CL_64) - ADD_CUSTOM_COMMAND( - TARGET WTLDemo - POST_BUILD -- COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\"" -+# COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\"" - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.ini\" \"${CMAKE_BINARY_DIR}/bin\"" - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\"" - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\crashrpt_lang.ini\"" -diff --git a/demos/WTLDemo/CMakeLists.txt b/demos/WTLDemo/CMakeLists.txt -index 969e813..ce69e23 100644 ---- a/demos/WTLDemo/CMakeLists.txt -+++ b/demos/WTLDemo/CMakeLists.txt -@@ -36,7 +36,7 @@ if(CMAKE_CL_64) - ADD_CUSTOM_COMMAND( - TARGET WTLDemo - POST_BUILD -- COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" -+# COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.ini\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\\x64\"" - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\x64\\crashrpt_lang.ini\"" -@@ -45,7 +45,7 @@ else(CMAKE_CL_64) - ADD_CUSTOM_COMMAND( - TARGET WTLDemo - POST_BUILD -- COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\"" -+# COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/bin\\dbghelp.dll\" \"${CMAKE_BINARY_DIR}/bin\"" - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.ini\" \"${CMAKE_BINARY_DIR}/bin\"" - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/demos/WTLDemo\\dummy.log\" \"${CMAKE_BINARY_DIR}/bin\"" - COMMAND copy ARGS "\"${CMAKE_SOURCE_DIR}/lang_files\\crashrpt_lang_EN.ini\" \"${CMAKE_BINARY_DIR}/bin\\crashrpt_lang.ini\"" -diff --git a/processing/crashrptprobe/CMakeLists.txt b/processing/crashrptprobe/CMakeLists.txt -index dafb007..71e5a43 100644 ---- a/processing/crashrptprobe/CMakeLists.txt -+++ b/processing/crashrptprobe/CMakeLists.txt -@@ -25,7 +25,7 @@ include_directories( ${CMAKE_SOURCE_DIR}/include - ${ZLIB_INCLUDE_DIRS} - ${MINIZIP_INCLUDE_DIR} - ${TINYXML_INCLUDE_DIR} -- ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include) -+ ${DBGHELP_INCLUDE_DIR}) - - # Add library build target - if(CRASHRPT_BUILD_SHARED_LIBS) -@@ -34,15 +34,15 @@ else(CRASHRPT_BUILD_SHARED_LIBS) - add_library(CrashRptProbe STATIC ${source_files} ${header_files}) - endif(CRASHRPT_BUILD_SHARED_LIBS) - --if(CMAKE_CL_64) -- link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64 ) -- target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64/dbghelp.lib) --else(CMAKE_CL_64) -- link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib ) -- target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/dbghelp.lib) --endif(CMAKE_CL_64) -+#if(CMAKE_CL_64) -+# link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64 ) -+# target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64/dbghelp.lib) -+#else(CMAKE_CL_64) -+# link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib ) -+# target_link_libraries(CrashRptProbe ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/dbghelp.lib) -+#endif(CMAKE_CL_64) - --target_link_libraries(CrashRptProbe ZLIB::ZLIB minizip::minizip ${TINYXML_LIBRARY} Rpcrt4.lib shell32.lib gdi32.lib version.lib psapi.lib) -+target_link_libraries(CrashRptProbe ZLIB::ZLIB minizip::minizip ${TINYXML_LIBRARY} ${DBGHELP_LIBRARY} Rpcrt4.lib shell32.lib gdi32.lib version.lib psapi.lib) - - if(CRASHRPT_BUILD_SHARED_LIBS) - -diff --git a/reporting/crashsender/CMakeLists.txt b/reporting/crashsender/CMakeLists.txt -index 088365f..8577452 100644 ---- a/reporting/crashsender/CMakeLists.txt -+++ b/reporting/crashsender/CMakeLists.txt -@@ -29,15 +29,15 @@ include_directories( ${CMAKE_SOURCE_DIR}/include - ${JPEG_INCLUDE_DIR} - ${PNG_INCLUDE_DIRS} - ${TINYXML_INCLUDE_DIR} -- ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/include -+ ${DBGHELP_INCLUDE_DIR} - ${OGG_INCLUDE_DIRS} - ${THEORA_INCLUDE_DIR}) - --if(NOT CMAKE_CL_64) -- link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib ) --else(NOT CMAKE_CL_64) -- link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64 ) --endif(NOT CMAKE_CL_64) -+#if(NOT CMAKE_CL_64) -+# link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib ) -+#else(NOT CMAKE_CL_64) -+# link_directories( ${CMAKE_SOURCE_DIR}/thirdparty/dbghelp/lib/amd64 ) -+#endif(NOT CMAKE_CL_64) - - # Add executable build target - add_executable(CrashSender WIN32 ${source_files} ${header_files}) diff --git a/ports/crashrpt/CONTROL b/ports/crashrpt/CONTROL index 192953a4b1cbc7..4b15e9d2336243 100644 --- a/ports/crashrpt/CONTROL +++ b/ports/crashrpt/CONTROL @@ -2,11 +2,15 @@ Source: crashrpt Version: 1.4.3 Description: A crash reporting system for Windows applications Homepage: http://crashrpt.sourceforge.net/ -Build-Depends: dbghelp, libjpeg-turbo, libogg, libpng, libtheora, minizip, tinyxml, wtl, zlib +Build-Depends: dbghelp, libjpeg-turbo, libogg, libpng, libtheora, tinyxml, wtl, zlib Default-Features: +Feature: probe +Description: The CrashRptProbe library + Feature: tests Description: Test application for crashrpt +Build-Depends: crashrpt[core,probe] Feature: demos -Description: Demo applications for crashrpt +Description: Demo applications for CrashRptProbe diff --git a/ports/crashrpt/portfile.cmake b/ports/crashrpt/portfile.cmake index e799dc1921b798..f52f8e19a24b8f 100644 --- a/ports/crashrpt/portfile.cmake +++ b/ports/crashrpt/portfile.cmake @@ -13,18 +13,12 @@ vcpkg_from_git( URL https://git.code.sf.net/p/crashrpt/code REF 4616504670be5a425a525376648d912a72ce18f2 PATCHES - 001-cmake-install.patch - 002-find-minizip-png-zlib.patch - 003-find-libogg-libtheora.patch - 004-find-tinyxml.patch - 005-find-wtl.patch - 006-find-libjpeg-turbo.patch - 007-fix-tests-and-demos-dependencies-and-install.patch - 008-dbghelp.patch + 001-add-install-target-and-find-deps.patch ) # Remove vendored dependencies to ensure they are not picked up by the build -foreach(DEPENDENCY dbghelp jpeg libogg libpng libtheora minizip tinyxml wtl zlib) +# Vendored minizip is still used since it contains modifications needed for CrashRpt +foreach(DEPENDENCY dbghelp jpeg libogg libpng libtheora tinyxml wtl zlib) if(EXISTS ${SOURCE_PATH}/thirdparty/${DEPENDENCY}) file(REMOVE_RECURSE ${SOURCE_PATH}/thirdparty/${DEPENDENCY}) endif() @@ -34,6 +28,7 @@ string(COMPARE EQUAL "${VCPKG_LIBRARY_LINKAGE}" "dynamic" CRASHRPT_BUILD_SHARED_ string(COMPARE EQUAL "${VCPKG_CRT_LINKAGE}" "dynamic" CRASHRPT_LINK_CRT_AS_DLL) vcpkg_check_features(OUT_FEATURE_OPTIONS FEATURE_OPTIONS + probe CRASHRPT_BUILD_PROBE tests CRASHRPT_BUILD_TESTS demos CRASHRPT_BUILD_DEMOS ) From 0bd500353b7cd18f5b371bf7bb412e079e5f1b97 Mon Sep 17 00:00:00 2001 From: Travis Drake Date: Sat, 8 Aug 2020 15:25:19 -0400 Subject: [PATCH 20/20] Use VERSION_GREATER instead of MATCHES to compare WINDOWS_SDK version in dbghelp portfile.cmake. Remove redundant check of WINDOWS_SDK version later in script. --- ports/dbghelp/portfile.cmake | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/ports/dbghelp/portfile.cmake b/ports/dbghelp/portfile.cmake index e83f7fe22a01f8..832bec6d74c498 100644 --- a/ports/dbghelp/portfile.cmake +++ b/ports/dbghelp/portfile.cmake @@ -3,7 +3,7 @@ vcpkg_check_linkage(ONLY_DYNAMIC_LIBRARY) vcpkg_get_windows_sdk(WINDOWS_SDK) -if (WINDOWS_SDK MATCHES "10.") +if (WINDOWS_SDK VERSION_GREATER "10") set(LIBFILEPATH "$ENV{WindowsSdkDir}Debuggers\\lib\\${TRIPLET_SYSTEM_ARCH}\\dbghelp.lib") message("LIBFILEPATH: ${LIBFILEPATH}") set(DLLFILEPATH "$ENV{WindowsSdkDir}Debuggers\\${TRIPLET_SYSTEM_ARCH}\\dbghelp.dll") @@ -15,7 +15,7 @@ else() endif() if (NOT EXISTS "${LIBFILEPATH}" OR NOT EXISTS "${DLLFILEPATH}" OR NOT EXISTS "${HEADERPATH}") - message(FATAL_ERROR "Cannot find debugging tools in Windows SDK ${WINDOWS_SDK}. Please reinstall the Windows SDK and select \"Debugging Tool\".") + message(FATAL_ERROR "Cannot find debugging tools in Windows SDK ${WINDOWS_SDK}. Please reinstall the Windows SDK and select \"Debugging Tools\".") endif() file(INSTALL ${LIBFILEPATH} DESTINATION ${CURRENT_PACKAGES_DIR}/lib) @@ -24,6 +24,4 @@ file(INSTALL ${DLLFILEPATH} DESTINATION ${CURRENT_PACKAGES_DIR}/bin) file(INSTALL ${DLLFILEPATH} DESTINATION ${CURRENT_PACKAGES_DIR}/debug/bin) file(INSTALL ${HEADERPATH} DESTINATION ${CURRENT_PACKAGES_DIR}/include) -if (WINDOWS_SDK MATCHES "10.") - file(WRITE ${CURRENT_PACKAGES_DIR}/share/${PORT}/copyright "See https://developer.microsoft.com/windows/downloads/windows-10-sdk for the Windows 10 SDK license") -endif() +file(WRITE ${CURRENT_PACKAGES_DIR}/share/${PORT}/copyright "See https://developer.microsoft.com/windows/downloads/windows-10-sdk for the Windows 10 SDK license")