mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-27 12:40:05 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

OpenJPEG 2000 update to version 2.5.0

Browse Source
This commit is contained in:
Alexander Smorkalov 2023-05-24 21:02:11 +03:00
parent d4861bfd1f
commit dbd1811d53
36 changed files with 7142 additions and 301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
3rdparty/openjpeg/CHANGELOG.md vendored
View File

@ -1,5 +1,124 @@
# Changelog
## [v2.5.0](https://github.com/uclouvain/openjpeg/releases/v2.5.0) (2022-05-13)
[Full Changelog](https://github.com/uclouvain/openjpeg/compare/v2.4.0...v2.5.0)
**Merged pull requests:**
- tools/travis-ci/install.sh: git clone with https:// to fix 'The unaut… [\#1419](https://github.com/uclouvain/openjpeg/pull/1419) ([rouault](https://github.com/rouault))
- Java Support 1.8 now... [\#1418](https://github.com/uclouvain/openjpeg/pull/1418) ([jiapei100](https://github.com/jiapei100))
- Separate fuzz targets to increase coverage [\#1416](https://github.com/uclouvain/openjpeg/pull/1416) ([Navidem](https://github.com/Navidem))
- CMakeLists.txt: do not set INSTALL\_NAME\_DIR for MacOS builds for CMake \>= 3.0 \(fixes \#1404\) [\#1410](https://github.com/uclouvain/openjpeg/pull/1410) ([rouault](https://github.com/rouault))
- Avoid integer overflows in DWT. Fixes https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=44544 [\#1408](https://github.com/uclouvain/openjpeg/pull/1408) ([rouault](https://github.com/rouault))
- Updated "added support for partial bitstream decoding" [\#1407](https://github.com/uclouvain/openjpeg/pull/1407) ([Neopallium](https://github.com/Neopallium))
- opj\_encoder\_set\_extra\_options\(\): add a GUARD\_BITS=value option [\#1403](https://github.com/uclouvain/openjpeg/pull/1403) ([rouault](https://github.com/rouault))
- More overflow related bug fixes [\#1402](https://github.com/uclouvain/openjpeg/pull/1402) ([Eharve14](https://github.com/Eharve14))
- opj\_j2k\_setup\_encoder\(\): validate number of tiles to avoid illegal values and potential overflow \(fixes \#1399\) [\#1401](https://github.com/uclouvain/openjpeg/pull/1401) ([rouault](https://github.com/rouault))
- Missed conversion from unsigned int to OPJ\_INT32 [\#1398](https://github.com/uclouvain/openjpeg/pull/1398) ([Eharve14](https://github.com/Eharve14))
- Added check for integer overflow in get\_num\_images [\#1397](https://github.com/uclouvain/openjpeg/pull/1397) ([Eharve14](https://github.com/Eharve14))
- Added overflow check for CVE-2021-29338 [\#1396](https://github.com/uclouvain/openjpeg/pull/1396) ([Eharve14](https://github.com/Eharve14))
- Fix integer overflow in num\_images [\#1395](https://github.com/uclouvain/openjpeg/pull/1395) ([baparham](https://github.com/baparham))
- Remove duplicate assignments in function tiftoimage [\#1392](https://github.com/uclouvain/openjpeg/pull/1392) ([stweil](https://github.com/stweil))
- Fix some typos \(found by codespell\) [\#1390](https://github.com/uclouvain/openjpeg/pull/1390) ([stweil](https://github.com/stweil))
- CI: Add CIFuzz action [\#1386](https://github.com/uclouvain/openjpeg/pull/1386) ([DavidKorczynski](https://github.com/DavidKorczynski))
- Feature/decimation [\#1384](https://github.com/uclouvain/openjpeg/pull/1384) ([msheby](https://github.com/msheby))
- API: deprecate 'bpp' member in favor of 'prec' [\#1383](https://github.com/uclouvain/openjpeg/pull/1383) ([rouault](https://github.com/rouault))
- Added support for high throughput \(HTJ2K\) decoding. [\#1381](https://github.com/uclouvain/openjpeg/pull/1381) ([rouault](https://github.com/rouault))
- verify-indentation.sh: fix for pull request from bar/master to foo/master [\#1380](https://github.com/uclouvain/openjpeg/pull/1380) ([rouault](https://github.com/rouault))
- Change integer for version libtiff 4.3.0 [\#1377](https://github.com/uclouvain/openjpeg/pull/1377) ([Jamaika1](https://github.com/Jamaika1))
- Port continuous integration to github actions [\#1376](https://github.com/uclouvain/openjpeg/pull/1376) ([rouault](https://github.com/rouault))
- Avoid integer overflows in DWT. [\#1375](https://github.com/uclouvain/openjpeg/pull/1375) ([rouault](https://github.com/rouault))
- LGTM warning: Comparison result is always the same [\#1373](https://github.com/uclouvain/openjpeg/pull/1373) ([DimitriPapadopoulos](https://github.com/DimitriPapadopoulos))
- A couple typos found by codespell [\#1371](https://github.com/uclouvain/openjpeg/pull/1371) ([DimitriPapadopoulos](https://github.com/DimitriPapadopoulos))
- cmake: add install interface include directory [\#1370](https://github.com/uclouvain/openjpeg/pull/1370) ([madebr](https://github.com/madebr))
- fix issues 1368: exist a issues of freeing uninitialized pointer in src/bin/jp2/opj\_decompress.c，that will cause a segfault [\#1369](https://github.com/uclouvain/openjpeg/pull/1369) ([xiaoxiaoafeifei](https://github.com/xiaoxiaoafeifei))
- opj\_j2k\_is\_imf\_compliant: Fix out of bounds access [\#1366](https://github.com/uclouvain/openjpeg/pull/1366) ([sebras](https://github.com/sebras))
- opj\_j2k\_is\_imf\_compliant: Fix argument formatting for warnings. [\#1365](https://github.com/uclouvain/openjpeg/pull/1365) ([sebras](https://github.com/sebras))
- CMakeLists.txt/appveyor.yml: update version number to 2.5.0… [\#1361](https://github.com/uclouvain/openjpeg/pull/1361) ([rouault](https://github.com/rouault))
- .travis.yml: try to fix gcc 4.8 config by updating to xenial [\#1360](https://github.com/uclouvain/openjpeg/pull/1360) ([rouault](https://github.com/rouault))
- Add support for enabling generation of TLM markers in encoder [\#1359](https://github.com/uclouvain/openjpeg/pull/1359) ([rouault](https://github.com/rouault))
- Fix various compiler warnings [\#1358](https://github.com/uclouvain/openjpeg/pull/1358) ([rouault](https://github.com/rouault))
- fix \#1345: don't remove big endian test for other platforms [\#1354](https://github.com/uclouvain/openjpeg/pull/1354) ([msabwat](https://github.com/msabwat))
- Remove obsolete components JPWL, JP3D and MJ2 [\#1350](https://github.com/uclouvain/openjpeg/pull/1350) ([rouault](https://github.com/rouault))
- tools/travis-ci/install.sh: fix links to Kakadu and jpylyzer binaries [\#1348](https://github.com/uclouvain/openjpeg/pull/1348) ([rouault](https://github.com/rouault))
- emscripten: disable big endian test [\#1345](https://github.com/uclouvain/openjpeg/pull/1345) ([msabwat](https://github.com/msabwat))
- Fix cmake file with DESTDIR [\#1321](https://github.com/uclouvain/openjpeg/pull/1321) ([ffontaine](https://github.com/ffontaine))
- CMakeLists.txt: Don't require a C++ compiler [\#1317](https://github.com/uclouvain/openjpeg/pull/1317) ([ffontaine](https://github.com/ffontaine))
- Import files tiff and yuv\(raw\) [\#1316](https://github.com/uclouvain/openjpeg/pull/1316) ([Jamaika1](https://github.com/Jamaika1))
- Fix year in NEWS [\#1312](https://github.com/uclouvain/openjpeg/pull/1312) ([stweil](https://github.com/stweil))
- Fix lcms2 static linking using pgk config [\#867](https://github.com/uclouvain/openjpeg/pull/867) ([pseiderer](https://github.com/pseiderer))
- fix static build only against tiff and its indirect dependencies [\#866](https://github.com/uclouvain/openjpeg/pull/866) ([tSed](https://github.com/tSed))
**Closed issues:**
- integer constant is too large for 'long' type [\#61](https://github.com/uclouvain/openjpeg/issues/61)
- Openjpeg3D lossy compression not working [\#501](https://github.com/uclouvain/openjpeg/issues/501)
- mj2: Array overflow [\#485](https://github.com/uclouvain/openjpeg/issues/485)
- OPJ fails to decode image that KDU manages correctly [\#419](https://github.com/uclouvain/openjpeg/issues/419)
- yuvtoimage\(\) bug in v1 and v2 for 16-Bit: please apply ASAP [\#384](https://github.com/uclouvain/openjpeg/issues/384)
- JP3D: Fix CVE-2013-4289 CVE-2013-4290 [\#298](https://github.com/uclouvain/openjpeg/issues/298)
- MJ2 libraries are installed in lib [\#204](https://github.com/uclouvain/openjpeg/issues/204)
- MJ2: realloc is misused and may leak memory [\#168](https://github.com/uclouvain/openjpeg/issues/168)
- MJ2 wrapper not functional [\#143](https://github.com/uclouvain/openjpeg/issues/143)
- JPWL is broken in trunk [\#137](https://github.com/uclouvain/openjpeg/issues/137)
- MJ2 files not using OPENJPEG API correctly [\#53](https://github.com/uclouvain/openjpeg/issues/53)
- Maximum bit depth supported by the OpenJPEG implementation of JP3D [\#9](https://github.com/uclouvain/openjpeg/issues/9)
- does openjpeg support either visually lossless or numerically lossless jpeg2000 compression? [\#1406](https://github.com/uclouvain/openjpeg/issues/1406)
- extract jpeg2000 tile without decompression [\#1405](https://github.com/uclouvain/openjpeg/issues/1405)
- openjpeg doesn't install a relocatable shared lib on macOS [\#1404](https://github.com/uclouvain/openjpeg/issues/1404)
- pull request - the cinema industry awaits! [\#1400](https://github.com/uclouvain/openjpeg/issues/1400)
- Integer overflows in j2K [\#1399](https://github.com/uclouvain/openjpeg/issues/1399)
- why lossly compression performance worse than jpeg when compress png？ [\#1393](https://github.com/uclouvain/openjpeg/issues/1393)
- cect [\#1389](https://github.com/uclouvain/openjpeg/issues/1389)
- the docs don't describe bpp and prec in opj\_image\_comp very well [\#1379](https://github.com/uclouvain/openjpeg/issues/1379)
- converting .png to .jp2 by opj\_compress is different from the original image [\#1378](https://github.com/uclouvain/openjpeg/issues/1378)
- Comparison result is always the same [\#1372](https://github.com/uclouvain/openjpeg/issues/1372)
- Exist a issues of freeing uninitialized pointer in src/bin/jp2/opj\_decompress.c，that will cause a segfault [\#1368](https://github.com/uclouvain/openjpeg/issues/1368)
- \[TEST NOT RUNNING\]: bigendian test [\#1355](https://github.com/uclouvain/openjpeg/issues/1355)
- opj\_decompress 2.4.0 built with library 2.3.0. [\#1352](https://github.com/uclouvain/openjpeg/issues/1352)
- New library htjpeg2000 [\#1351](https://github.com/uclouvain/openjpeg/issues/1351)
- Integer Overflow in num\_images [\#1338](https://github.com/uclouvain/openjpeg/issues/1338)
- All IMF Profile Selections Result in PART1 [\#1337](https://github.com/uclouvain/openjpeg/issues/1337)
- grayscale image [\#1334](https://github.com/uclouvain/openjpeg/issues/1334)
- error C2169: 'lrintf': intrinsic function, cannot be defined [\#1333](https://github.com/uclouvain/openjpeg/issues/1333)
- Generate lower-case extension [\#1332](https://github.com/uclouvain/openjpeg/issues/1332)
- color of reconstructed png file much darker [\#1330](https://github.com/uclouvain/openjpeg/issues/1330)
- CVE-2019-6988, CVE-2018-20846 and CVE-2018-16376 [\#1328](https://github.com/uclouvain/openjpeg/issues/1328)
- opj 2.4.0: opj\_free missing in opj3d [\#1327](https://github.com/uclouvain/openjpeg/issues/1327)
- Not able to compress volumetric data [\#1326](https://github.com/uclouvain/openjpeg/issues/1326)
- HTML documents are not installed in specified place [\#1322](https://github.com/uclouvain/openjpeg/issues/1322)
- Can't find openjpeg.h when cross-compile. [\#1320](https://github.com/uclouvain/openjpeg/issues/1320)
- OpenJPEG is available with EasyConfig [\#1319](https://github.com/uclouvain/openjpeg/issues/1319)
- Building Test Programs [\#1318](https://github.com/uclouvain/openjpeg/issues/1318)
- Builds are not reproducible [\#1275](https://github.com/uclouvain/openjpeg/issues/1275)
- strange behaviour of opj\_jp3d\_compress/decompress utility [\#1274](https://github.com/uclouvain/openjpeg/issues/1274)
- Potential heap-based buffer overflow in function t2\_encode\_packet in src/lib/openmj2/t2.c and src/lib/openjp3d/t2.c [\#1272](https://github.com/uclouvain/openjpeg/issues/1272)
- Function tgatoimage in src/bin/jpwl/convert.c need to check that the file is big enough to avoid excessive memory allocations [\#1271](https://github.com/uclouvain/openjpeg/issues/1271)
- memory & cpu are exhausted when converting jp2 file into png [\#1250](https://github.com/uclouvain/openjpeg/issues/1250)
- Cannot compress PGX into JP3D despite following the directions? [\#1134](https://github.com/uclouvain/openjpeg/issues/1134)
- sscanf buffer overflow in opj\_jp3d\_compress.c [\#1130](https://github.com/uclouvain/openjpeg/issues/1130)
- integer underflow may lead to writing garbage [\#1089](https://github.com/uclouvain/openjpeg/issues/1089)
- sscanf buffer overflow [\#1087](https://github.com/uclouvain/openjpeg/issues/1087)
- strcpy overflows [\#1086](https://github.com/uclouvain/openjpeg/issues/1086)
- sprintf buffer overflows [\#1084](https://github.com/uclouvain/openjpeg/issues/1084)
- strcpy buffer overflow [\#1083](https://github.com/uclouvain/openjpeg/issues/1083)
- integer overflow in malloc\(\) [\#1082](https://github.com/uclouvain/openjpeg/issues/1082)
- out of bounds writes [\#1078](https://github.com/uclouvain/openjpeg/issues/1078)
- out of bounds writes [\#1077](https://github.com/uclouvain/openjpeg/issues/1077)
- divide by zero, perhaps multiplication overflow [\#1076](https://github.com/uclouvain/openjpeg/issues/1076)
- missing format string parameter [\#1075](https://github.com/uclouvain/openjpeg/issues/1075)
- leaks from cppcheck in lib folder [\#1038](https://github.com/uclouvain/openjpeg/issues/1038)
- How to initialize DEBUG\_PROFILE in color.c? [\#958](https://github.com/uclouvain/openjpeg/issues/958)
- JP3D sample files [\#865](https://github.com/uclouvain/openjpeg/issues/865)
- BIG\_ENDIAN bug in jpwl.c [\#839](https://github.com/uclouvain/openjpeg/issues/839)
- OpenJPEG fails to decode partial j2c where kdu succeeds [\#715](https://github.com/uclouvain/openjpeg/issues/715)
- building mj2 binaries fails [\#652](https://github.com/uclouvain/openjpeg/issues/652)
- openmj2\mj2.c: Out of bounds [\#646](https://github.com/uclouvain/openjpeg/issues/646)
- bin\mj2\opj\_mj2\_decompress.c 101 wrong check / leak [\#608](https://github.com/uclouvain/openjpeg/issues/608)
## [v2.4.0](https://github.com/uclouvain/openjpeg/releases/v2.4.0) (2020-12-28)
[Full Changelog](https://github.com/uclouvain/openjpeg/compare/v2.3.1...v2.4.0)
@ -79,7 +198,7 @@
- tests/fuzzers: link fuzz binaries using $LIB\_FUZZING\_ENGINE. [\#1230](https://github.com/uclouvain/openjpeg/pull/1230) ([Dor1s](https://github.com/Dor1s))
- opj\_j2k\_update\_image\_dimensions\(\): reject images whose coordinates are beyond INT\_MAX \(fixes \#1228\) [\#1229](https://github.com/uclouvain/openjpeg/pull/1229) ([rouault](https://github.com/rouault))
- Fix resource leaks [\#1226](https://github.com/uclouvain/openjpeg/pull/1226) ([dodys](https://github.com/dodys))
- abi-check.sh: fix false postive ABI error, and display output error log [\#1218](https://github.com/uclouvain/openjpeg/pull/1218) ([rouault](https://github.com/rouault))
- abi-check.sh: fix false positive ABI error, and display output error log [\#1218](https://github.com/uclouvain/openjpeg/pull/1218) ([rouault](https://github.com/rouault))
- pi.c: avoid integer overflow, resulting in later invalid access to memory in opj\_t2\_decode\_packets\(\) [\#1217](https://github.com/uclouvain/openjpeg/pull/1217) ([rouault](https://github.com/rouault))
- Add check to validate SGcod/SPcoc/SPcod parameter values. [\#1211](https://github.com/uclouvain/openjpeg/pull/1211) ([sebras](https://github.com/sebras))
- Fix buffer overflow reading an image file less than four characters [\#1196](https://github.com/uclouvain/openjpeg/pull/1196) ([robert-ancell](https://github.com/robert-ancell))

342
3rdparty/openjpeg/CMakeLists.txt vendored
View File

@ -1,25 +1,38 @@
# Build scripts are adopted to OpenCV project
# Main CMakeLists.txt to build the OpenJPEG project using CMake (www.cmake.org)
# Written by Mathieu Malaterre
cmake_policy(SET CMP0003 NEW)
if(POLICY CMP0042)
cmake_policy(SET CMP0042 NEW)
# This CMake project will by default create a library called openjpeg
# But if you want to use this project within your own (CMake) project
# you will eventually like to prefix the library to avoid linking confusion
# For this purpose you can define a CMake var: OPENJPEG_NAMESPACE to whatever you like
# e.g.:
# set(OPENJPEG_NAMESPACE "GDCMOPENJPEG")
cmake_minimum_required(VERSION 2.8.2)
if(COMMAND CMAKE_POLICY)
cmake_policy(SET CMP0003 NEW)
if (NOT (${CMAKE_VERSION} VERSION_LESS 3.0))
cmake_policy(SET CMP0042 NEW)
endif()
endif()
set(OPENJPEG_LIBRARY_NAME libopenjp2)
if(NOT OPENJPEG_NAMESPACE)
set(OPENJPEG_NAMESPACE "OPENJPEG")
set(OPENJPEG_STANDALONE 1)
endif()
# In all cases:
#string(TOLOWER ${OPENJPEG_NAMESPACE} OPENJPEG_LIBRARY_NAME)
set(OPENJPEG_LIBRARY_NAME openjp2)
project(openjpeg C)
project(${OPENJPEG_NAMESPACE} C)
ocv_warnings_disable(CMAKE_C_FLAGS
-Wimplicit-const-int-float-conversion # clang
-Wunused-but-set-variable # clang15
)
# Do full dependency headers.
include_regular_expression("^.*$")
#-----------------------------------------------------------------------------
# OPENJPEG version number, useful for packaging and doxygen doc:
set(OPENJPEG_VERSION_MAJOR 2)
set(OPENJPEG_VERSION_MINOR 4)
set(OPENJPEG_VERSION_MINOR 5)
set(OPENJPEG_VERSION_BUILD 0)
set(OPENJPEG_VERSION
"${OPENJPEG_VERSION_MAJOR}.${OPENJPEG_VERSION_MINOR}.${OPENJPEG_VERSION_BUILD}")
@ -45,24 +58,23 @@ set(PACKAGE_VERSION
# 2.3.0 | 7
# 2.3.1 | 7
# 2.4.0 | 7
# 2.5.0 | 7
# above is the recommendation by the OPJ team. If you really need to override this default,
# you can specify your own OPENJPEG_SOVERSION at cmake configuration time:
# cmake -DOPENJPEG_SOVERSION:STRING=42 /path/to/openjpeg
if(NOT OPENJPEG_SOVERSION)
set(OPENJPEG_SOVERSION 7)
endif()
endif(NOT OPENJPEG_SOVERSION)
set(OPENJPEG_LIBRARY_PROPERTIES
VERSION "${OPENJPEG_VERSION_MAJOR}.${OPENJPEG_VERSION_MINOR}.${OPENJPEG_VERSION_BUILD}"
SOVERSION "${OPENJPEG_SOVERSION}"
)
set(OPENJPEG_BUILD "opencv-${OPENCV_VERSION}-openjp2-${OPENJPEG_VERSION}")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
set(OPENJPEG_BUILD "${OPENJPEG_BUILD}-debug")
endif()
message(STATUS "OpenJPEG: VERSION = ${OPENJPEG_VERSION}, BUILD = ${OPENJPEG_BUILD}")
# --------------------------------------------------------------------------
# Path to additional CMake modules
set(CMAKE_MODULE_PATH
${${OPENJPEG_NAMESPACE}_SOURCE_DIR}/cmake
${CMAKE_MODULE_PATH})
# --------------------------------------------------------------------------
# On Visual Studio 8 MS deprecated C. This removes all 1.276E1265 security
@ -90,30 +102,119 @@ if(WIN32)
endif()
endif()
# --------------------------------------------------------------------------
# Install directories
# Build DOCUMENTATION (not in ALL target and only if Doxygen is found)
option(BUILD_DOC "Build the HTML documentation (with doxygen if available)." OFF)
string(TOLOWER ${PROJECT_NAME} projectname)
set(OPENJPEG_INSTALL_SUBDIR "${projectname}-${OPENJPEG_VERSION_MAJOR}.${OPENJPEG_VERSION_MINOR}")
if(NOT OPENJPEG_INSTALL_BIN_DIR)
set(OPENJPEG_INSTALL_BIN_DIR "bin")
endif()
if(NOT OPENJPEG_INSTALL_LIB_DIR)
set(OPENJPEG_INSTALL_LIB_DIR "lib")
endif()
if(NOT OPENJPEG_INSTALL_SHARE_DIR)
set(OPENJPEG_INSTALL_SHARE_DIR "share")
endif()
if(NOT OPENJPEG_INSTALL_DATA_DIR)
set(OPENJPEG_INSTALL_DATA_DIR "${OPENJPEG_INSTALL_SHARE_DIR}/${OPENJPEG_INSTALL_SUBDIR}")
endif()
if(NOT OPENJPEG_INSTALL_INCLUDE_DIR)
set(OPENJPEG_INSTALL_INCLUDE_DIR "include/${OPENJPEG_INSTALL_SUBDIR}")
endif()
if(BUILD_DOC)
if(NOT OPENJPEG_INSTALL_MAN_DIR)
set(OPENJPEG_INSTALL_MAN_DIR "share/man/")
endif()
if(NOT OPENJPEG_INSTALL_DOC_DIR)
set(OPENJPEG_INSTALL_DOC_DIR "share/doc/${OPENJPEG_INSTALL_SUBDIR}")
endif()
endif()
if(NOT OPENJPEG_INSTALL_JNI_DIR)
if(WIN32)
set(OPENJPEG_INSTALL_JNI_DIR ${OPENJPEG_INSTALL_BIN_DIR})
else()
set(OPENJPEG_INSTALL_JNI_DIR ${OPENJPEG_INSTALL_LIB_DIR})
endif()
endif()
if(NOT OPENJPEG_INSTALL_PACKAGE_DIR)
# We could install *.cmake files in share/ however those files contains
# hardcoded path to libraries on a multi-arch system (fedora/debian) those
# path will be different (lib/i386-linux-gnu vs lib/x86_64-linux-gnu)
set(OPENJPEG_INSTALL_PACKAGE_DIR "${OPENJPEG_INSTALL_LIB_DIR}/${OPENJPEG_INSTALL_SUBDIR}")
endif()
if (APPLE)
if (${CMAKE_VERSION} VERSION_LESS 3.0)
# For cmake >= 3.0, we turn on CMP0042 and
# https://cmake.org/cmake/help/v3.0/policy/CMP0042.html mentions
# "Projects wanting @rpath in a target’s install name may remove any setting of the INSTALL_NAME_DIR and CMAKE_INSTALL_NAME_DIR variables"
list(APPEND OPENJPEG_LIBRARY_PROPERTIES INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/${OPENJPEG_INSTALL_LIB_DIR}")
endif()
option(OPJ_USE_DSYMUTIL "Call dsymutil on binaries after build." OFF)
endif()
#-----------------------------------------------------------------------------
# Big endian test:
include(TestBigEndian)
test_big_endian(OPJ_BIG_ENDIAN)
if (NOT EMSCRIPTEN)
include (${CMAKE_ROOT}/Modules/TestBigEndian.cmake)
TEST_BIG_ENDIAN(OPJ_BIG_ENDIAN)
endif()
#-----------------------------------------------------------------------------
# Setup file for setting custom ctest vars
configure_file(
${${OPENJPEG_NAMESPACE}_SOURCE_DIR}/cmake/CTestCustom.cmake.in
${${OPENJPEG_NAMESPACE}_BINARY_DIR}/CTestCustom.cmake
@ONLY
)
#-----------------------------------------------------------------------------
# OpenJPEG build configuration options.
option(BUILD_SHARED_LIBS "Build OpenJPEG shared library and link executables against it." ON)
option(BUILD_STATIC_LIBS "Build OpenJPEG static library." ON)
set (EXECUTABLE_OUTPUT_PATH ${OPENJPEG_BINARY_DIR}/bin CACHE PATH "Single output directory for building all executables.")
set (LIBRARY_OUTPUT_PATH ${OPENJPEG_BINARY_DIR}/bin CACHE PATH "Single output directory for building all libraries.")
mark_as_advanced(LIBRARY_OUTPUT_PATH EXECUTABLE_OUTPUT_PATH)
#-----------------------------------------------------------------------------
# configure name mangling to allow multiple libraries to coexist
# peacefully
if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/openjpeg_mangle.h.in)
set(MANGLE_PREFIX ${OPENJPEG_LIBRARY_NAME})
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/openjpeg_mangle.h.in
${CMAKE_CURRENT_BINARY_DIR}/openjpeg_mangle.h
@ONLY)
endif()
#-----------------------------------------------------------------------------
# Compiler specific flags:
if(CMAKE_COMPILER_IS_GNUCC)
# For all builds, make sure openjpeg is std99 compliant:
# set(CMAKE_C_FLAGS "-Wall -std=c99 ${CMAKE_C_FLAGS}") # FIXME: this setting prevented us from setting a coverage build.
# Do not use ffast-math for all build, it would produce incorrect results, only set for release:
set(OPENJPEG_LIBRARY_COMPILE_OPTIONS ${OPENJPEG_LIBRARY_COMPILE_OPTIONS} "$<$<CONFIG:Release>:-ffast-math>")
set(OPENJP2_COMPILE_OPTIONS ${OPENJP2_COMPILE_OPTIONS} "$<$<CONFIG:Release>:-ffast-math>" -Wall -Wextra -Wconversion -Wunused-parameter -Wdeclaration-after-statement -Werror=declaration-after-statement)
endif()
#-----------------------------------------------------------------------------
# opj_config.h generation (1/2)
# Check if some include files are provided by the system
# These files are mandatory, so if they are not provided OpenJPEG library can't be built
include(CheckIncludeFile)
macro(ensure_file_include INCLUDE_FILENAME VARIABLE_NAME MANDATORY_STATUS)
check_include_file(${INCLUDE_FILENAME} ${VARIABLE_NAME})
if(NOT ${VARIABLE_NAME})
if(${MANDATORY_STATUS})
message(STATUS "The file '${INCLUDE_FILENAME}' is mandatory for OpenJPEG build, but not found on your system")
return()
else()
message(STATUS "The file '${INCLUDE_FILENAME}' is optional for OpenJPEG build and not found on your system."
" Internal implementation will be used.")
endif()
endif()
endmacro()
include(EnsureFileInclude)
# These files are mandatory
ensure_file_include("string.h" HAVE_STRING_H YES)
ensure_file_include("memory.h" HAVE_MEMORY_H YES)
ensure_file_include("stdlib.h" HAVE_STDLIB_H YES)
@ -130,11 +231,16 @@ ensure_file_include("stdint.h" OPJ_HAVE_STDINT_H NO)
ensure_file_include("inttypes.h" OPJ_HAVE_INTTYPES_H NO)
# why check this one ? for openjpip ?
include (${CMAKE_ROOT}/Modules/CheckIncludeFile.cmake)
CHECK_INCLUDE_FILE("strings.h" HAVE_STRINGS_H)
CHECK_INCLUDE_FILE("sys/stat.h" HAVE_SYS_STAT_H)
CHECK_INCLUDE_FILE("sys/types.h" HAVE_SYS_TYPES_H)
CHECK_INCLUDE_FILE("unistd.h" HAVE_UNISTD_H)
# Enable Large file support
include(TestLargeFiles)
OPJ_TEST_LARGE_FILES(OPJ_HAVE_LARGEFILES)
# Allocating Aligned Memory Blocks
include(CheckIncludeFiles)
check_include_files(malloc.h OPJ_HAVE_MALLOC_H)
@ -142,58 +248,140 @@ include(CheckSymbolExists)
# _aligned_alloc https://msdn.microsoft.com/en-us/library/8z34s9c6.aspx
check_symbol_exists(_aligned_malloc malloc.h OPJ_HAVE__ALIGNED_MALLOC)
# posix_memalign (needs _POSIX_C_SOURCE >= 200112L on Linux)
set(_prev_CMAKE_REQUIRED_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS})
set(CMAKE_REQUIRED_DEFINITIONS -D_POSIX_C_SOURCE=200112L)
check_symbol_exists(posix_memalign stdlib.h OPJ_HAVE_POSIX_MEMALIGN)
set(CMAKE_REQUIRED_DEFINITIONS ${_prev_CMAKE_REQUIRED_DEFINITIONS})
unset(_prev_CMAKE_REQUIRED_DEFINITIONS)
unset(CMAKE_REQUIRED_DEFINITIONS)
# memalign (obsolete)
check_symbol_exists(memalign malloc.h OPJ_HAVE_MEMALIGN)
#-----------------------------------------------------------------------------
# Build Library
if(BUILD_JPIP_SERVER)
find_package(CURL REQUIRED)
find_package(FCGI REQUIRED)
find_package(Threads REQUIRED)
if(NOT CMAKE_USE_PTHREADS_INIT)
message(FATAL_ERROR "Only pthread are supported")
endif()
endif()
add_subdirectory(src/lib)
option(BUILD_LUTS_GENERATOR "Build utility to generate t1_luts.h" OFF)
if(UNIX)
option(BUILD_UNIT_TESTS "Build unit tests (bench_dwt, test_sparse_array, etc..)" OFF)
endif()
#-----------------------------------------------------------------------------
# Build Applications
option(BUILD_CODEC "Build the CODEC executables" ON)
option(BUILD_JPIP "Build the JPIP library and executables." OFF)
if(BUILD_JPIP)
option(BUILD_JPIP_SERVER "Build the JPIP server." OFF)
endif()
option(BUILD_VIEWER "Build the OPJViewer executable (C++)" OFF)
option(BUILD_JAVA "Build the openjpeg jar (Java)" OFF)
mark_as_advanced(BUILD_VIEWER)
mark_as_advanced(BUILD_JAVA)
if(BUILD_CODEC)
# OFF: It will only build 3rd party libs if they are not found on the system
# ON: 3rd party libs will ALWAYS be build, and used
option(BUILD_THIRDPARTY "Build the thirdparty executables if it is needed" OFF)
add_subdirectory(thirdparty)
add_subdirectory(src/bin)
endif ()
add_subdirectory(wrapping)
#-----------------------------------------------------------------------------
# opj_config.h generation (2/2)
configure_file(
${CMAKE_CURRENT_LIST_DIR}/openjp2/opj_config.h.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/openjp2/opj_config.h
@ONLY
)
${CMAKE_CURRENT_SOURCE_DIR}/src/lib/openjp2/opj_config.h.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/src/lib/openjp2/opj_config.h
@ONLY
)
configure_file(
${CMAKE_CURRENT_LIST_DIR}/openjp2/opj_config_private.h.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/openjp2/opj_config_private.h
@ONLY
)
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/src/lib/openjp2/opj_config_private.h.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/src/lib/openjp2/opj_config_private.h
@ONLY
)
add_subdirectory(openjp2)
set_target_properties(${OPENJPEG_LIBRARY_NAME}
PROPERTIES
OUTPUT_NAME ${OPENJPEG_LIBRARY_NAME}
DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
COMPILE_PDB_NAME ${OPENJPEG_LIBRARY_NAME}
COMPILE_PDB_NAME_DEBUG "${OPENJPEG_LIBRARY_NAME}${OPENCV_DEBUG_POSTFIX}"
ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH}
)
if(ENABLE_SOLUTION_FOLDERS)
set_target_properties(${OPENJPEG_LIBRARY_NAME}
PROPERTIES
FOLDER "3rdparty"
)
#-----------------------------------------------------------------------------
# build documentation in doc subdir:
if(BUILD_DOC)
add_subdirectory(doc)
endif()
ocv_install_3rdparty_licenses(${OPENJPEG_LIBRARY_NAME} README.md LICENSE)
#-----------------------------------------------------------------------------
# Build Testing
option(BUILD_TESTING "Build the tests." OFF)
if(BUILD_TESTING)
if(BUILD_CODEC)
enable_testing()
include(CTest)
# Setting all necessary variables
set(OPENJPEG_LIBRARIES ${OPENJPEG_LIBRARY_NAME} PARENT_SCOPE)
set(OPENJPEG_VERSION ${OPENJPEG_VERSION} PARENT_SCOPE)
set(OPENJPEG_MAJOR_VERSION ${OPENJPEG_VERSION_MAJOR} PARENT_SCOPE)
set(OPENJPEG_MINOR_VERSION ${OPENJPEG_VERSION_MINOR} PARENT_SCOPE)
set(OPENJPEG_BUILD_VERSION ${OPENJPEG_VERSION_BUILD} PARENT_SCOPE)
get_target_property(_openjpeg_include_dirs ${OPENJPEG_LIBRARY_NAME} INCLUDE_DIRECTORIES)
set(OPENJPEG_INCLUDE_DIRS ${_openjpeg_include_dirs} PARENT_SCOPE)
# Search openjpeg data needed for the tests
# They could be found via git on the OpenJPEG GitHub code project
# git clone https://github.com/uclouvain/openjpeg-data.git
find_path(OPJ_DATA_ROOT README-OPJ-Data
PATHS $ENV{OPJ_DATA_ROOT} ${CMAKE_SOURCE_DIR}/../data
NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH
)
# OpenJPEG can't be built only if configuration script doesn't encounter any problem
if(NOT DEFINED OCV_CAN_BUILD_OPENJPEG)
# all prerequisites are fulfilled
set(OCV_CAN_BUILD_OPENJPEG TRUE PARENT_SCOPE)
# Add repository where to find tests
add_subdirectory(tests)
else()
message(FATAL_ERROR "You need build codec to run the tests")
endif()
endif()
#-----------------------------------------------------------------------------
# install all targets referenced as OPENJPEGTargets
install(EXPORT OpenJPEGTargets DESTINATION ${OPENJPEG_INSTALL_PACKAGE_DIR})
configure_file( ${${OPENJPEG_NAMESPACE}_SOURCE_DIR}/cmake/OpenJPEGConfig.cmake.in
${${OPENJPEG_NAMESPACE}_BINARY_DIR}/OpenJPEGConfig.cmake
@ONLY
)
install( FILES ${OPENJPEG_BINARY_DIR}/OpenJPEGConfig.cmake
DESTINATION ${OPENJPEG_INSTALL_PACKAGE_DIR}
)
#-----------------------------------------------------------------------------
# install CHANGES and LICENSE
if(BUILD_DOC)
if(EXISTS ${OPENJPEG_SOURCE_DIR}/CHANGES)
install(FILES CHANGES DESTINATION ${OPENJPEG_INSTALL_DOC_DIR})
endif()
install(FILES LICENSE DESTINATION ${OPENJPEG_INSTALL_DOC_DIR})
endif()
include (cmake/OpenJPEGCPack.cmake)
#-----------------------------------------------------------------------------
# pkgconfig support
# enabled by default on Unix or if using GCC, disabled by default on other platforms
if(UNIX OR CMAKE_COMPILER_IS_GNUCC)
option(BUILD_PKGCONFIG_FILES "Build and install pkg-config files" ON)
else()
option(BUILD_PKGCONFIG_FILES "Build and install pkg-config files" OFF)
endif()
if(BUILD_PKGCONFIG_FILES)
# install in lib and not share (see multi-arch note above)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/lib/openjp2/libopenjp2.pc.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/libopenjp2.pc @ONLY)
install( FILES ${CMAKE_CURRENT_BINARY_DIR}/libopenjp2.pc DESTINATION
${OPENJPEG_INSTALL_LIB_DIR}/pkgconfig )
#
if(BUILD_JPIP)
# install in lib and not share (see multi-arch note above)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/lib/openjpip/libopenjpip.pc.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/libopenjpip.pc @ONLY)
install( FILES ${CMAKE_CURRENT_BINARY_DIR}/libopenjpip.pc DESTINATION
${OPENJPEG_INSTALL_LIB_DIR}/pkgconfig )
endif()
endif()
#-----------------------------------------------------------------------------
# build our version of astyle
SET (WITH_ASTYLE FALSE CACHE BOOL "If you plan to contribute you should reindent with scripts/prepare-commit.sh (using 'our' astyle)")

16
3rdparty/openjpeg/README.md vendored
View File

@ -29,18 +29,12 @@ The library is developed and maintained by the Image and Signal Processing Group
* src
* lib
* openjp2: contains the sources of the openjp2 library (Part 1 & 2)
* openjpwl: contains the additional sources if you want to build a JPWL-flavoured library.
* openjpip: complete client-server architecture for remote browsing of jpeg 2000 images.
* openjp3d: JP3D implementation
* openmj2: MJ2 implementation
* bin: contains all applications that use the openjpeg library
* common: common files to all applications
* jp2: a basic codec
* mj2: motion jpeg 2000 executables
* jpip: OpenJPIP applications (server and dec server)
* java: a Java client viewer for JPIP
* jp3d: JP3D applications
* tcltk: a test tool for JP3D
* wx
* OPJViewer: gui for displaying j2k files (based on wxWidget)
* wrapping
@ -57,6 +51,12 @@ See [INSTALL](https://github.com/uclouvain/openjpeg/blob/master/INSTALL.md) for
See [NEWS](https://github.com/uclouvain/openjpeg/blob/master/NEWS.md) for user visible changes in successive releases.
## Deprecated components
The openjpwl, openjp3d and openmj2 components have been removed after the
2.4.0 release. Their building and working state is unknown. People interested
in them should start from the 2.4.0 tag.
## API/ABI
An API/ABI timeline is automatically updated [here][link-api-timeline].
@ -74,8 +74,8 @@ API available is the one supported by OpenJPEG.
[comment-license]: https://img.shields.io/github/license/uclouvain/openjpeg.svg "https://img.shields.io/badge/license-BSD--2--Clause-blue.svg"
[badge-license]: https://img.shields.io/badge/license-BSD--2--Clause-blue.svg "BSD 2-clause \"Simplified\" License"
[link-license]: https://github.com/uclouvain/openjpeg/blob/master/LICENSE "BSD 2-clause \"Simplified\" License"
[badge-build]: https://travis-ci.org/uclouvain/openjpeg.svg?branch=master "Build Status"
[link-build]: https://travis-ci.org/uclouvain/openjpeg "Build Status"
[badge-build]: https://github.com/uclouvain/openjpeg/actions/workflows/build.yml/badge.svg "Build Status"
[link-build]: https://github.com/uclouvain/openjpeg/actions/workflows/build.yml "Build Status"
[badge-msvc-build]: https://ci.appveyor.com/api/projects/status/github/uclouvain/openjpeg?branch=master&svg=true "Windows Build Status"
[link-msvc-build]: https://ci.appveyor.com/project/detonin/openjpeg/branch/master "Windows Build Status"
[badge-coverity]: https://scan.coverity.com/projects/6383/badge.svg "Coverity Scan Build Status"

210
3rdparty/openjpeg/openjp2/CMakeLists.txt vendored
View File

@ -1,27 +1,76 @@
include_regular_expression("^.*$")
#
install( FILES ${CMAKE_CURRENT_BINARY_DIR}/opj_config.h
DESTINATION ${OPENJPEG_INSTALL_INCLUDE_DIR} COMPONENT Headers)
include_directories(
${${OPENJPEG_NAMESPACE}_BINARY_DIR}/src/lib/openjp2 # opj_config.h and opj_config_private.h
)
# Defines the source code for the library
set(OPENJPEG_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/thread.c
${CMAKE_CURRENT_SOURCE_DIR}/thread.h
${CMAKE_CURRENT_SOURCE_DIR}/bio.c
${CMAKE_CURRENT_SOURCE_DIR}/bio.h
${CMAKE_CURRENT_SOURCE_DIR}/cio.c
${CMAKE_CURRENT_SOURCE_DIR}/cio.h
${CMAKE_CURRENT_SOURCE_DIR}/dwt.c
${CMAKE_CURRENT_SOURCE_DIR}/dwt.h
${CMAKE_CURRENT_SOURCE_DIR}/event.c
${CMAKE_CURRENT_SOURCE_DIR}/event.h
${CMAKE_CURRENT_SOURCE_DIR}/ht_dec.c
${CMAKE_CURRENT_SOURCE_DIR}/image.c
${CMAKE_CURRENT_SOURCE_DIR}/image.h
${CMAKE_CURRENT_SOURCE_DIR}/invert.c
${CMAKE_CURRENT_SOURCE_DIR}/invert.h
${CMAKE_CURRENT_SOURCE_DIR}/j2k.c
${CMAKE_CURRENT_SOURCE_DIR}/j2k.h
${CMAKE_CURRENT_SOURCE_DIR}/jp2.c
${CMAKE_CURRENT_SOURCE_DIR}/jp2.h
${CMAKE_CURRENT_SOURCE_DIR}/mct.c
${CMAKE_CURRENT_SOURCE_DIR}/mct.h
${CMAKE_CURRENT_SOURCE_DIR}/mqc.c
${CMAKE_CURRENT_SOURCE_DIR}/mqc.h
${CMAKE_CURRENT_SOURCE_DIR}/mqc_inl.h
${CMAKE_CURRENT_SOURCE_DIR}/openjpeg.c
${CMAKE_CURRENT_SOURCE_DIR}/openjpeg.h
${CMAKE_CURRENT_SOURCE_DIR}/opj_clock.c
${CMAKE_CURRENT_SOURCE_DIR}/opj_clock.h
${CMAKE_CURRENT_SOURCE_DIR}/pi.c
${CMAKE_CURRENT_SOURCE_DIR}/pi.h
${CMAKE_CURRENT_SOURCE_DIR}/t1.c
${CMAKE_CURRENT_SOURCE_DIR}/t1.h
${CMAKE_CURRENT_SOURCE_DIR}/t2.c
${CMAKE_CURRENT_SOURCE_DIR}/t2.h
${CMAKE_CURRENT_SOURCE_DIR}/tcd.c
${CMAKE_CURRENT_SOURCE_DIR}/tcd.h
${CMAKE_CURRENT_SOURCE_DIR}/tgt.c
${CMAKE_CURRENT_SOURCE_DIR}/tgt.h
${CMAKE_CURRENT_SOURCE_DIR}/function_list.c
${CMAKE_CURRENT_SOURCE_DIR}/function_list.h
${CMAKE_CURRENT_SOURCE_DIR}/opj_codec.h
${CMAKE_CURRENT_SOURCE_DIR}/opj_includes.h
${CMAKE_CURRENT_SOURCE_DIR}/opj_intmath.h
${CMAKE_CURRENT_SOURCE_DIR}/opj_malloc.c
${CMAKE_CURRENT_SOURCE_DIR}/opj_malloc.h
${CMAKE_CURRENT_SOURCE_DIR}/opj_stdint.h
${CMAKE_CURRENT_SOURCE_DIR}/sparse_array.c
${CMAKE_CURRENT_SOURCE_DIR}/sparse_array.h
)
if(BUILD_JPIP)
add_definitions(-DUSE_JPIP)
set(OPENJPEG_SRCS
${OPENJPEG_SRCS}
${CMAKE_CURRENT_SOURCE_DIR}/cidx_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/cidx_manager.h
${CMAKE_CURRENT_SOURCE_DIR}/phix_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/ppix_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/thix_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/tpix_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/indexbox_manager.h
)
endif()
option(OPJ_DISABLE_TPSOT_FIX "Disable TPsot==TNsot fix. See https://github.com/uclouvain/openjpeg/issues/254." OFF)
if(OPJ_DISABLE_TPSOT_FIX)
@ -29,69 +78,144 @@ if(OPJ_DISABLE_TPSOT_FIX)
endif()
# Special case for old i586-mingw32msvc-gcc cross compiler
# if(NOT WIN32 AND CMAKE_COMPILER_IS_GNUCC AND CMAKE_C_COMPILER MATCHES ".*mingw32msvc.*" )
# set(WIN32 YES)
# endif()
ocv_warnings_disable(CMAKE_C_FLAGS
-Wundef -Wstrict-prototypes -Wcast-function-type
-Wshadow # v2.4.0: GCC
-Wunused-function # v2.4.0: Clang
)
ocv_warnings_disable(CMAKE_C_FLAGS /wd4819) # vs2019 Win64
add_library(${OPENJPEG_LIBRARY_NAME} STATIC ${OPENJPEG_SRCS})
target_compile_definitions(${OPENJPEG_LIBRARY_NAME} PUBLIC OPJ_STATIC)
ocv_include_directories("${CMAKE_CURRENT_LIST_DIR}" "${CMAKE_CURRENT_BINARY_DIR}")
if(UNIX)
target_link_libraries(${OPENJPEG_LIBRARY_NAME} PRIVATE m)
if(NOT WIN32 AND CMAKE_COMPILER_IS_GNUCC AND CMAKE_C_COMPILER MATCHES ".*mingw32msvc.*" )
set(WIN32 YES)
endif()
set_target_properties(${OPENJPEG_LIBRARY_NAME}
PROPERTIES
${OPENJPEG_LIBRARY_PROPERTIES}
# Build the library
if(WIN32)
if(BUILD_SHARED_LIBS)
add_definitions(-DOPJ_EXPORTS)
else()
add_definitions(-DOPJ_STATIC)
endif()
add_library(${OPENJPEG_LIBRARY_NAME} ${OPENJPEG_SRCS})
set(INSTALL_LIBS ${OPENJPEG_LIBRARY_NAME})
else()
if(BUILD_SHARED_LIBS AND BUILD_STATIC_LIBS)
# Builds both static and dynamic libs
add_library(${OPENJPEG_LIBRARY_NAME} SHARED ${OPENJPEG_SRCS})
add_library(openjp2_static STATIC ${OPENJPEG_SRCS})
set_target_properties(openjp2_static PROPERTIES OUTPUT_NAME ${OPENJPEG_LIBRARY_NAME})
set(INSTALL_LIBS ${OPENJPEG_LIBRARY_NAME} openjp2_static)
target_include_directories(openjp2_static PUBLIC $<INSTALL_INTERFACE:${OPENJPEG_INSTALL_INCLUDE_DIR}>)
else()
add_library(${OPENJPEG_LIBRARY_NAME} ${OPENJPEG_SRCS})
set(INSTALL_LIBS ${OPENJPEG_LIBRARY_NAME})
endif()
endif()
target_include_directories(${OPENJPEG_LIBRARY_NAME} PUBLIC $<INSTALL_INTERFACE:${OPENJPEG_INSTALL_INCLUDE_DIR}>)
if(UNIX)
target_link_libraries(${OPENJPEG_LIBRARY_NAME} m)
endif()
set_target_properties(${OPENJPEG_LIBRARY_NAME} PROPERTIES ${OPENJPEG_LIBRARY_PROPERTIES})
if(NOT ${CMAKE_VERSION} VERSION_LESS "2.8.12")
target_compile_options(${OPENJPEG_LIBRARY_NAME} PRIVATE ${OPENJP2_COMPILE_OPTIONS})
endif()
# Install library
install(TARGETS ${INSTALL_LIBS}
EXPORT OpenJPEGTargets
RUNTIME DESTINATION ${OPENJPEG_INSTALL_BIN_DIR} COMPONENT Applications
LIBRARY DESTINATION ${OPENJPEG_INSTALL_LIB_DIR} COMPONENT Libraries
ARCHIVE DESTINATION ${OPENJPEG_INSTALL_LIB_DIR} COMPONENT Libraries
)
# Install includes files
install(FILES openjpeg.h opj_stdint.h
DESTINATION ${OPENJPEG_INSTALL_INCLUDE_DIR} COMPONENT Headers
)
if(BUILD_DOC)
# install man page of the library
install(
FILES ${OPENJPEG_SOURCE_DIR}/doc/man/man3/libopenjp2.3
DESTINATION ${OPENJPEG_INSTALL_MAN_DIR}/man3)
endif()
if(BUILD_LUTS_GENERATOR)
# internal utility to generate t1_luts.h and t1_ht_luts.h (part of the jp2 lib)
# no need to install:
add_executable(t1_generate_luts t1_generate_luts.c t1_ht_generate_luts.c)
if(UNIX)
target_link_libraries(t1_generate_luts m)
endif()
endif()
# Experimental option; let's how cppcheck performs
# Implementation details:
# I could not figure out how to easily upload a file to CDash. Instead simply
# pretend cppcheck is part of the Build step. Technically cppcheck can even
# output gcc formatted error/warning report
# Another implementation detail: I could not redirect error to the error
# catching mechanism something is busted in cmake 2.8.5, I had to use the
# warning regex to catch them.
if(OPENJPEG_CPPCHECK)
find_package(CPPCHECK REQUIRED)
foreach(f ${OPENJPEG_SRCS})
# cppcheck complains about too many configuration, pretend to be WIN32:
add_custom_command(TARGET ${OPENJPEG_LIBRARY_NAME}
COMMAND ${CPPCHECK_EXECUTABLE} -DWIN32 ${f})
endforeach()
endif()
if(OPJ_USE_DSYMUTIL)
if(BUILD_SHARED_LIBS)
add_custom_command(TARGET ${OPENJPEG_LIBRARY_NAME} POST_BUILD
COMMAND "dsymutil" "$<TARGET_SONAME_FILE:${OPENJPEG_LIBRARY_NAME}>"
COMMENT "dsymutil $<TARGET_SONAME_FILE:${OPENJPEG_LIBRARY_NAME}>"
DEPENDS ${OPENJPEG_LIBRARY_NAME})
endif()
endif()
#################################################################################
# threading configuration
#################################################################################
set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
option(OPJ_USE_THREAD "Build with thread/mutex support " ON)
if(NOT OPJ_USE_THREAD)
add_definitions(-DMUTEX_stub)
endif()
add_definitions( -DMUTEX_stub)
endif(NOT OPJ_USE_THREAD)
find_package(Threads QUIET)
if(OPJ_USE_THREAD AND WIN32 AND NOT Threads_FOUND )
add_definitions(-DMUTEX_win32)
set(Threads_FOUND YES)
add_definitions( -DMUTEX_win32)
set(Threads_FOUND YES)
endif()
if(OPJ_USE_THREAD AND Threads_FOUND AND CMAKE_USE_WIN32_THREADS_INIT)
add_definitions(-DMUTEX_win32)
endif()
if(OPJ_USE_THREAD AND Threads_FOUND AND CMAKE_USE_WIN32_THREADS_INIT )
add_definitions( -DMUTEX_win32)
endif(OPJ_USE_THREAD AND Threads_FOUND AND CMAKE_USE_WIN32_THREADS_INIT )
if(OPJ_USE_THREAD AND Threads_FOUND AND CMAKE_USE_PTHREADS_INIT )
add_definitions(-DMUTEX_pthread)
endif()
add_definitions( -DMUTEX_pthread)
endif(OPJ_USE_THREAD AND Threads_FOUND AND CMAKE_USE_PTHREADS_INIT )
if(OPJ_USE_THREAD AND NOT Threads_FOUND)
message(STATUS "No thread library found and thread/mutex support is required by OPJ_USE_THREAD option")
set(OCV_CAN_BUILD_OPENJPEG FALSE PARENT_SCOPE)
endif()
message(FATAL_ERROR "No thread library found and thread/mutex support is required by OPJ_USE_THREAD option")
endif(OPJ_USE_THREAD AND NOT Threads_FOUND)
if(OPJ_USE_THREAD AND Threads_FOUND AND CMAKE_USE_PTHREADS_INIT)
target_link_libraries(${OPENJPEG_LIBRARY_NAME} PRIVATE ${CMAKE_THREAD_LIBS_INIT})
endif()
TARGET_LINK_LIBRARIES(${OPENJPEG_LIBRARY_NAME} ${CMAKE_THREAD_LIBS_INIT})
endif(OPJ_USE_THREAD AND Threads_FOUND AND CMAKE_USE_PTHREADS_INIT)
if(NOT BUILD_SHARED_LIBS)
ocv_install_target(${OPENJPEG_LIBRARY_NAME}
EXPORT OpenCVModules
ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev
)
endif()
if(BUILD_UNIT_TESTS AND UNIX)
add_executable(bench_dwt bench_dwt.c)
if(UNIX)
target_link_libraries(bench_dwt m ${OPENJPEG_LIBRARY_NAME})
endif()
if(OPJ_USE_THREAD AND Threads_FOUND AND CMAKE_USE_PTHREADS_INIT)
target_link_libraries(bench_dwt ${CMAKE_THREAD_LIBS_INIT})
endif(OPJ_USE_THREAD AND Threads_FOUND AND CMAKE_USE_PTHREADS_INIT)
add_executable(test_sparse_array test_sparse_array.c)
if(UNIX)
target_link_libraries(test_sparse_array m ${OPENJPEG_LIBRARY_NAME})
endif()
if(OPJ_USE_THREAD AND Threads_FOUND AND CMAKE_USE_PTHREADS_INIT)
target_link_libraries(test_sparse_array ${CMAKE_THREAD_LIBS_INIT})
endif(OPJ_USE_THREAD AND Threads_FOUND AND CMAKE_USE_PTHREADS_INIT)
endif(BUILD_UNIT_TESTS AND UNIX)

353
3rdparty/openjpeg/openjp2/bench_dwt.c vendored Normal file
View File

@ -0,0 +1,353 @@
/*
* The copyright in this software is being made available under the 2-clauses
* BSD License, included below. This software may be subject to other third
* party and contributor rights, including patent rights, and no such rights
* are granted under this license.
*
* Copyright (c) 2017, IntoPix SA <contact@intopix.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "opj_includes.h"
#ifdef _WIN32
#include <windows.h>
#else
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/times.h>
#endif /* _WIN32 */
OPJ_INT32 getValue(OPJ_UINT32 i)
{
return ((OPJ_INT32)i % 511) - 256;
}
void init_tilec(opj_tcd_tilecomp_t * l_tilec,
OPJ_INT32 x0,
OPJ_INT32 y0,
OPJ_INT32 x1,
OPJ_INT32 y1,
OPJ_UINT32 numresolutions,
OPJ_BOOL irreversible)
{
opj_tcd_resolution_t* l_res;
OPJ_UINT32 resno, l_level_no;
size_t i, nValues;
memset(l_tilec, 0, sizeof(*l_tilec));
l_tilec->x0 = x0;
l_tilec->y0 = y0;
l_tilec->x1 = x1;
l_tilec->y1 = y1;
nValues = (size_t)(l_tilec->x1 - l_tilec->x0) *
(size_t)(l_tilec->y1 - l_tilec->y0);
l_tilec->data = (OPJ_INT32*) opj_malloc(sizeof(OPJ_INT32) * nValues);
for (i = 0; i < nValues; i++) {
OPJ_INT32 val = getValue((OPJ_UINT32)i);
if (irreversible) {
OPJ_FLOAT32 fVal = (OPJ_FLOAT32)val;
memcpy(&l_tilec->data[i], &fVal, sizeof(OPJ_FLOAT32));
} else {
l_tilec->data[i] = val;
}
}
l_tilec->numresolutions = numresolutions;
l_tilec->minimum_num_resolutions = numresolutions;
l_tilec->resolutions = (opj_tcd_resolution_t*) opj_calloc(
l_tilec->numresolutions,
sizeof(opj_tcd_resolution_t));
l_level_no = l_tilec->numresolutions;
l_res = l_tilec->resolutions;
/* Adapted from opj_tcd_init_tile() */
for (resno = 0; resno < l_tilec->numresolutions; ++resno) {
--l_level_no;
/* border for each resolution level (global) */
l_res->x0 = opj_int_ceildivpow2(l_tilec->x0, (OPJ_INT32)l_level_no);
l_res->y0 = opj_int_ceildivpow2(l_tilec->y0, (OPJ_INT32)l_level_no);
l_res->x1 = opj_int_ceildivpow2(l_tilec->x1, (OPJ_INT32)l_level_no);
l_res->y1 = opj_int_ceildivpow2(l_tilec->y1, (OPJ_INT32)l_level_no);
++l_res;
}
}
void free_tilec(opj_tcd_tilecomp_t * l_tilec)
{
opj_free(l_tilec->data);
opj_free(l_tilec->resolutions);
}
void usage(void)
{
printf(
"bench_dwt [-decode|encode] [-I] [-size value] [-check] [-display]\n");
printf(
" [-num_resolutions val] [-offset x y] [-num_threads val]\n");
exit(1);
}
OPJ_FLOAT64 opj_clock(void)
{
#ifdef _WIN32
/* _WIN32: use QueryPerformance (very accurate) */
LARGE_INTEGER freq, t ;
/* freq is the clock speed of the CPU */
QueryPerformanceFrequency(&freq) ;
/* cout << "freq = " << ((double) freq.QuadPart) << endl; */
/* t is the high resolution performance counter (see MSDN) */
QueryPerformanceCounter(& t) ;
return freq.QuadPart ? (t.QuadPart / (OPJ_FLOAT64) freq.QuadPart) : 0 ;
#else
/* Unix or Linux: use resource usage */
struct rusage t;
OPJ_FLOAT64 procTime;
/* (1) Get the rusage data structure at this moment (man getrusage) */
getrusage(0, &t);
/* (2) What is the elapsed time ? - CPU time = User time + System time */
/* (2a) Get the seconds */
procTime = (OPJ_FLOAT64)(t.ru_utime.tv_sec + t.ru_stime.tv_sec);
/* (2b) More precisely! Get the microseconds part ! */
return (procTime + (OPJ_FLOAT64)(t.ru_utime.tv_usec + t.ru_stime.tv_usec) *
1e-6) ;
#endif
}
static OPJ_FLOAT64 opj_wallclock(void)
{
#ifdef _WIN32
return opj_clock();
#else
struct timeval tv;
gettimeofday(&tv, NULL);
return (OPJ_FLOAT64)tv.tv_sec + 1e-6 * (OPJ_FLOAT64)tv.tv_usec;
#endif
}
int main(int argc, char** argv)
{
int num_threads = 0;
opj_tcd_t tcd;
opj_tcd_image_t tcd_image;
opj_tcd_tile_t tcd_tile;
opj_tcd_tilecomp_t tilec;
opj_image_t image;
opj_image_comp_t image_comp;
opj_thread_pool_t* tp;
OPJ_INT32 i, j, k;
OPJ_BOOL display = OPJ_FALSE;
OPJ_BOOL check = OPJ_FALSE;
OPJ_INT32 size = 16384 - 1;
OPJ_FLOAT64 start, stop;
OPJ_FLOAT64 start_wc, stop_wc;
OPJ_UINT32 offset_x = ((OPJ_UINT32)size + 1) / 2 - 1;
OPJ_UINT32 offset_y = ((OPJ_UINT32)size + 1) / 2 - 1;
OPJ_UINT32 num_resolutions = 6;
OPJ_BOOL bench_decode = OPJ_TRUE;
OPJ_BOOL irreversible = OPJ_FALSE;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-encode") == 0) {
bench_decode = OPJ_FALSE;
} else if (strcmp(argv[i], "-decode") == 0) {
bench_decode = OPJ_TRUE;
} else if (strcmp(argv[i], "-display") == 0) {
display = OPJ_TRUE;
} else if (strcmp(argv[i], "-check") == 0) {
check = OPJ_TRUE;
} else if (strcmp(argv[i], "-I") == 0) {
irreversible = OPJ_TRUE;
} else if (strcmp(argv[i], "-size") == 0 && i + 1 < argc) {
size = atoi(argv[i + 1]);
i ++;
} else if (strcmp(argv[i], "-num_threads") == 0 && i + 1 < argc) {
num_threads = atoi(argv[i + 1]);
i ++;
} else if (strcmp(argv[i], "-num_resolutions") == 0 && i + 1 < argc) {
num_resolutions = (OPJ_UINT32)atoi(argv[i + 1]);
if (num_resolutions == 0 || num_resolutions > 32) {
fprintf(stderr,
"Invalid value for num_resolutions. Should be >= 1 and <= 32\n");
exit(1);
}
i ++;
} else if (strcmp(argv[i], "-offset") == 0 && i + 2 < argc) {
offset_x = (OPJ_UINT32)atoi(argv[i + 1]);
offset_y = (OPJ_UINT32)atoi(argv[i + 2]);
i += 2;
} else {
usage();
}
}
if (irreversible && check) {
/* Due to irreversible inverse DWT not being symmetric of forward */
/* See BUG_WEIRD_TWO_INVK in dwt.c */
printf("-I and -check aren't compatible\n");
exit(1);
}
tp = opj_thread_pool_create(num_threads);
init_tilec(&tilec, (OPJ_INT32)offset_x, (OPJ_INT32)offset_y,
(OPJ_INT32)offset_x + size, (OPJ_INT32)offset_y + size,
num_resolutions, irreversible);
if (display) {
printf("Before\n");
k = 0;
for (j = 0; j < tilec.y1 - tilec.y0; j++) {
for (i = 0; i < tilec.x1 - tilec.x0; i++) {
if (irreversible) {
printf("%f ", ((OPJ_FLOAT32*)tilec.data)[k]);
} else {
printf("%d ", tilec.data[k]);
}
k ++;
}
printf("\n");
}
}
memset(&tcd, 0, sizeof(tcd));
tcd.thread_pool = tp;
tcd.whole_tile_decoding = OPJ_TRUE;
tcd.win_x0 = (OPJ_UINT32)tilec.x0;
tcd.win_y0 = (OPJ_UINT32)tilec.y0;
tcd.win_x1 = (OPJ_UINT32)tilec.x1;
tcd.win_y1 = (OPJ_UINT32)tilec.y1;
tcd.tcd_image = &tcd_image;
memset(&tcd_image, 0, sizeof(tcd_image));
tcd_image.tiles = &tcd_tile;
memset(&tcd_tile, 0, sizeof(tcd_tile));
tcd_tile.x0 = tilec.x0;
tcd_tile.y0 = tilec.y0;
tcd_tile.x1 = tilec.x1;
tcd_tile.y1 = tilec.y1;
tcd_tile.numcomps = 1;
tcd_tile.comps = &tilec;
tcd.image = &image;
memset(&image, 0, sizeof(image));
image.numcomps = 1;
image.comps = &image_comp;
memset(&image_comp, 0, sizeof(image_comp));
image_comp.dx = 1;
image_comp.dy = 1;
start = opj_clock();
start_wc = opj_wallclock();
if (bench_decode) {
if (irreversible) {
opj_dwt_decode_real(&tcd, &tilec, tilec.numresolutions);
} else {
opj_dwt_decode(&tcd, &tilec, tilec.numresolutions);
}
} else {
if (irreversible) {
opj_dwt_encode_real(&tcd, &tilec);
} else {
opj_dwt_encode(&tcd, &tilec);
}
}
stop = opj_clock();
stop_wc = opj_wallclock();
printf("time for %s: total = %.03f s, wallclock = %.03f s\n",
bench_decode ? "dwt_decode" : "dwt_encode",
stop - start,
stop_wc - start_wc);
if (display) {
if (bench_decode) {
printf("After IDWT\n");
} else {
printf("After FDWT\n");
}
k = 0;
for (j = 0; j < tilec.y1 - tilec.y0; j++) {
for (i = 0; i < tilec.x1 - tilec.x0; i++) {
if (irreversible) {
printf("%f ", ((OPJ_FLOAT32*)tilec.data)[k]);
} else {
printf("%d ", tilec.data[k]);
}
k ++;
}
printf("\n");
}
}
if ((display || check) && !irreversible) {
if (bench_decode) {
opj_dwt_encode(&tcd, &tilec);
} else {
opj_dwt_decode(&tcd, &tilec, tilec.numresolutions);
}
if (display && !irreversible) {
if (bench_decode) {
printf("After FDWT\n");
} else {
printf("After IDWT\n");
}
k = 0;
for (j = 0; j < tilec.y1 - tilec.y0; j++) {
for (i = 0; i < tilec.x1 - tilec.x0; i++) {
if (irreversible) {
printf("%f ", ((OPJ_FLOAT32*)tilec.data)[k]);
} else {
printf("%d ", tilec.data[k]);
}
k ++;
}
printf("\n");
}
}
}
if (check) {
size_t idx;
size_t nValues = (size_t)(tilec.x1 - tilec.x0) *
(size_t)(tilec.y1 - tilec.y0);
for (idx = 0; idx < nValues; idx++) {
if (tilec.data[idx] != getValue((OPJ_UINT32)idx)) {
printf("Difference found at idx = %u\n", (OPJ_UINT32)idx);
exit(1);
}
}
}
free_tilec(&tilec);
opj_thread_pool_destroy(tp);
return 0;
}

259
3rdparty/openjpeg/openjp2/cidx_manager.c vendored Normal file
View File

@ -0,0 +1,259 @@
/*
* $Id: cidx_manager.c 897 2011-08-28 21:43:57Z Kaori.Hagihara@gmail.com $
*
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2014, Professor Benoit Macq
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "opj_includes.h"
/*
* Write CPTR Codestream finder box
*
* @param[in] coff offset of j2k codestream
* @param[in] clen length of j2k codestream
* @param[in] cio file output handle
*/
void opj_write_cptr(int coff, int clen, opj_stream_private_t *cio,
opj_event_mgr_t * p_manager);
int opj_write_cidx(int offset, opj_stream_private_t *cio,
opj_codestream_info_t cstr_info, int j2klen,
opj_event_mgr_t * p_manager)
{
int i;
OPJ_OFF_T lenp;
OPJ_UINT32 len;
opj_jp2_box_t *box;
int num_box = 0;
OPJ_BOOL EPHused;
OPJ_BYTE l_data_header [4];
lenp = -1;
box = (opj_jp2_box_t *)opj_calloc(32, sizeof(opj_jp2_box_t));
if (box == NULL) {
return 0;
}
for (i = 0; i < 2; i++) {
if (i) {
opj_stream_seek(cio, lenp, p_manager);
}
lenp = opj_stream_tell(cio);
opj_stream_skip(cio, 4, p_manager); /* L [at the end] */
opj_write_bytes(l_data_header, JPIP_CIDX, 4); /* CIDX */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_write_cptr(offset, cstr_info.codestream_size, cio, p_manager);
opj_write_manf(i, num_box, box, cio, p_manager);
num_box = 0;
box[num_box].length = (OPJ_UINT32)opj_write_mainmhix(offset, cstr_info, cio,
p_manager);
box[num_box].type = JPIP_MHIX;
num_box++;
box[num_box].length = (OPJ_UINT32)opj_write_tpix(offset, cstr_info, j2klen, cio,
p_manager);
box[num_box].type = JPIP_TPIX;
num_box++;
box[num_box].length = (OPJ_UINT32)opj_write_thix(offset, cstr_info, cio,
p_manager);
box[num_box].type = JPIP_THIX;
num_box++;
EPHused = opj_check_EPHuse(offset, cstr_info.marker, cstr_info.marknum, cio,
p_manager);
box[num_box].length = (OPJ_UINT32)opj_write_ppix(offset, cstr_info, EPHused,
j2klen, cio, p_manager);
box[num_box].type = JPIP_PPIX;
num_box++;
box[num_box].length = (OPJ_UINT32)opj_write_phix(offset, cstr_info, EPHused,
j2klen, cio, p_manager);
box[num_box].type = JPIP_PHIX;
num_box++;
len = (OPJ_UINT32)(opj_stream_tell(cio) - lenp);
opj_stream_seek(cio, lenp, p_manager);
opj_write_bytes(l_data_header, len, 4); /* L */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_stream_seek(cio, lenp + len, p_manager);
}
opj_free(box);
return (int)len;
}
void opj_write_cptr(int coff, int clen, opj_stream_private_t *cio,
opj_event_mgr_t * p_manager)
{
OPJ_BYTE l_data_header [3 * 8];
OPJ_UINT32 len;
OPJ_OFF_T lenp;
lenp = opj_stream_tell(cio);
opj_stream_skip(cio, 4, p_manager); /* L [at the end] */
opj_write_bytes(l_data_header, JPIP_CPTR, 4); /* T */
opj_write_bytes(l_data_header + 4, 0, 2); /* DR A PRECISER !! */
opj_write_bytes(l_data_header + 6, 0, 2); /* CONT */
opj_write_bytes(l_data_header + 8, (OPJ_UINT32)coff,
8); /* COFF A PRECISER !! */
opj_write_bytes(l_data_header + 16, (OPJ_UINT32)clen,
8); /* CLEN */
opj_stream_write_data(cio, l_data_header, 3 * 8, p_manager);
len = (OPJ_UINT32)(opj_stream_tell(cio) - lenp);
opj_stream_seek(cio, lenp, p_manager);
opj_write_bytes(l_data_header, len, 4); /* L */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_stream_seek(cio, lenp + len, p_manager);
}
void opj_write_manf(int second,
int v,
opj_jp2_box_t *box,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager)
{
OPJ_BYTE l_data_header [4];
int i;
OPJ_UINT32 len;
OPJ_OFF_T lenp;
lenp = opj_stream_tell(cio);
opj_stream_skip(cio, 4, p_manager); /* L [at the end] */
opj_write_bytes(l_data_header, JPIP_MANF, 4); /* T */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
if (second) { /* Write only during the second pass */
for (i = 0; i < v; i++) {
opj_write_bytes(l_data_header, box[i].length,
4); /* Box length */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_write_bytes(l_data_header, box[i].type,
4); /* Box type */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
}
}
len = (OPJ_UINT32)(opj_stream_tell(cio) - lenp);
opj_stream_seek(cio, lenp, p_manager);
opj_write_bytes(l_data_header, len, 4);/* L */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_stream_seek(cio, lenp + len, p_manager);
}
int opj_write_mainmhix(int coff, opj_codestream_info_t cstr_info,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager)
{
OPJ_BYTE l_data_header [8];
OPJ_UINT32 i;
OPJ_UINT32 len;
OPJ_OFF_T lenp;
lenp = opj_stream_tell(cio);
opj_stream_skip(cio, 4,
p_manager); /* L [at the end] */
opj_write_bytes(l_data_header, JPIP_MHIX,
4); /* MHIX */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_write_bytes(l_data_header,
(OPJ_UINT32)(cstr_info.main_head_end - cstr_info.main_head_start + 1),
8); /* TLEN */
opj_stream_write_data(cio, l_data_header, 8, p_manager);
for (i = 1; i < (OPJ_UINT32)cstr_info.marknum;
i++) { /* Marker restricted to 1 apparition, skip SOC marker */
opj_write_bytes(l_data_header, cstr_info.marker[i].type, 2);
opj_write_bytes(l_data_header + 2, 0, 2);
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_write_bytes(l_data_header, (OPJ_UINT32)(cstr_info.marker[i].pos - coff), 8);
opj_stream_write_data(cio, l_data_header, 8, p_manager);
opj_write_bytes(l_data_header, (OPJ_UINT32)cstr_info.marker[i].len, 2);
opj_stream_write_data(cio, l_data_header, 2, p_manager);
}
len = (OPJ_UINT32)(opj_stream_tell(cio) - lenp);
opj_stream_seek(cio, lenp, p_manager);
opj_write_bytes(l_data_header, len, 4); /* L */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_stream_seek(cio, lenp + len, p_manager);
return (int)len;
}
OPJ_BOOL opj_check_EPHuse(int coff, opj_marker_info_t *markers, int marknum,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager)
{
OPJ_BYTE l_data_header [4];
OPJ_BOOL EPHused = OPJ_FALSE;
int i = 0;
OPJ_OFF_T org_pos;
unsigned int Scod;
for (i = 0; i < marknum; i++) {
if (markers[i].type == J2K_MS_COD) {
org_pos = opj_stream_tell(cio);
opj_stream_seek(cio, coff + markers[i].pos + 2, p_manager);
opj_stream_read_data(cio, l_data_header, 1, p_manager);
opj_read_bytes(l_data_header, &Scod, 1);
if (((Scod >> 2) & 1)) {
EPHused = OPJ_TRUE;
}
opj_stream_seek(cio, org_pos, p_manager);
break;
}
}
return EPHused;
}

70
3rdparty/openjpeg/openjp2/cidx_manager.h vendored Normal file
View File

@ -0,0 +1,70 @@
/*
* $Id: cidx_manager.h 897 2011-08-28 21:43:57Z Kaori.Hagihara@gmail.com $
*
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2014, Professor Benoit Macq
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*! \file
* \brief Modification of jpip.h from 2KAN indexer
*/
#ifndef CIDX_MANAGER_H_
# define CIDX_MANAGER_H_
#include "openjpeg.h"
/*
* Write Codestream index box (superbox)
*
* @param[in] offset offset of j2k codestream
* @param[in] cio file output handle
* @param[in] image image data
* @param[in] cstr_info codestream information
* @param[in] j2klen length of j2k codestream
* @return length of cidx box
*/
int opj_write_cidx(int offset, opj_stream_private_t *cio,
opj_codestream_info_t cstr_info, int j2klen,
opj_event_mgr_t * p_manager);
/*
* Check if EPH option is used
*
* @param[in] coff offset of j2k codestream
* @param[in] markers marker information
* @param[in] marknum number of markers
* @param[in] cio file output handle
* @return true if EPH is used
*/
OPJ_BOOL opj_check_EPHuse(int coff, opj_marker_info_t *markers, int marknum,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager);
#endif /* !CIDX_MANAGER_H_ */

2
3rdparty/openjpeg/openjp2/cio.h vendored
View File

@ -118,7 +118,7 @@ typedef struct opj_stream_private {
opj_stream_seek_fn m_seek_fn;
/**
* Actual data stored into the stream if readed from. Data is read by chunk of fixed size.
* Actual data stored into the stream if read from. Data is read by chunk of fixed size.
* you should never access this data directly.
*/
OPJ_BYTE * m_stored_data;

29
3rdparty/openjpeg/openjp2/dwt.c vendored
View File

@ -385,7 +385,8 @@ static void opj_idwt53_h_cas0(OPJ_INT32* tmp,
s0n = s1n - ((d1c + d1n + 2) >> 2);
tmp[i ] = s0c;
tmp[i + 1] = d1c + ((s0c + s0n) >> 1);
tmp[i + 1] = opj_int_add_no_overflow(d1c, opj_int_add_no_overflow(s0c,
s0n) >> 1);
}
tmp[i] = s0n;
@ -450,7 +451,7 @@ static void opj_idwt53_h_cas1(OPJ_INT32* tmp,
dn = in_odd[j] - ((s1 + s2 + 2) >> 2);
tmp[i ] = dc;
tmp[i + 1] = s1 + ((dn + dc) >> 1);
tmp[i + 1] = opj_int_add_no_overflow(s1, opj_int_add_no_overflow(dn, dc) >> 1);
dc = dn;
s1 = s2;
@ -512,7 +513,7 @@ static void opj_idwt53_h(const opj_dwt_t *dwt,
#if (defined(__SSE2__) || defined(__AVX2__)) && !defined(STANDARD_SLOW_VERSION)
/* Conveniency macros to improve the readabilty of the formulas */
/* Conveniency macros to improve the readability of the formulas */
#if __AVX2__
#define VREG __m256i
#define LOAD_CST(x) _mm256_set1_epi32(x)
@ -796,10 +797,12 @@ static void opj_idwt3_v_cas0(OPJ_INT32* tmp,
s1n = tiledp_col[(OPJ_SIZE_T)(j + 1) * stride];
d1n = tiledp_col[(OPJ_SIZE_T)(sn + j + 1) * stride];
s0n = s1n - ((d1c + d1n + 2) >> 2);
s0n = opj_int_sub_no_overflow(s1n,
opj_int_add_no_overflow(opj_int_add_no_overflow(d1c, d1n), 2) >> 2);
tmp[i ] = s0c;
tmp[i + 1] = d1c + ((s0c + s0n) >> 1);
tmp[i + 1] = opj_int_add_no_overflow(d1c, opj_int_add_no_overflow(s0c,
s0n) >> 1);
}
tmp[i] = s0n;
@ -2343,10 +2346,13 @@ static void opj_dwt_decode_partial_1(OPJ_INT32 *a, OPJ_INT32 dn, OPJ_INT32 sn,
OPJ_S(0) /= 2;
} else {
for (i = win_l_x0; i < win_l_x1; i++) {
OPJ_D(i) -= (OPJ_SS_(i) + OPJ_SS_(i + 1) + 2) >> 2;
OPJ_D(i) = opj_int_sub_no_overflow(OPJ_D(i),
opj_int_add_no_overflow(opj_int_add_no_overflow(OPJ_SS_(i), OPJ_SS_(i + 1)),
2) >> 2);
}
for (i = win_h_x0; i < win_h_x1; i++) {
OPJ_S(i) += (OPJ_DD_(i) + OPJ_DD_(i - 1)) >> 1;
OPJ_S(i) = opj_int_add_no_overflow(OPJ_S(i),
opj_int_add_no_overflow(OPJ_DD_(i), OPJ_DD_(i - 1)) >> 1);
}
}
}
@ -2484,12 +2490,17 @@ static void opj_dwt_decode_partial_1_parallel(OPJ_INT32 *a,
} else {
for (i = win_l_x0; i < win_l_x1; i++) {
for (off = 0; off < 4; off++) {
OPJ_D_off(i, off) -= (OPJ_SS__off(i, off) + OPJ_SS__off(i + 1, off) + 2) >> 2;
OPJ_D_off(i, off) = opj_int_sub_no_overflow(
OPJ_D_off(i, off),
opj_int_add_no_overflow(
opj_int_add_no_overflow(OPJ_SS__off(i, off), OPJ_SS__off(i + 1, off)), 2) >> 2);
}
}
for (i = win_h_x0; i < win_h_x1; i++) {
for (off = 0; off < 4; off++) {
OPJ_S_off(i, off) += (OPJ_DD__off(i, off) + OPJ_DD__off(i - 1, off)) >> 1;
OPJ_S_off(i, off) = opj_int_add_no_overflow(
OPJ_S_off(i, off),
opj_int_add_no_overflow(OPJ_DD__off(i, off), OPJ_DD__off(i - 1, off)) >> 1);
}
}
}

2640
3rdparty/openjpeg/openjp2/ht_dec.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1
3rdparty/openjpeg/openjp2/image.c vendored
View File

@ -66,7 +66,6 @@ opj_image_t* OPJ_CALLCONV opj_image_create(OPJ_UINT32 numcmpts,
comp->x0 = cmptparms[compno].x0;
comp->y0 = cmptparms[compno].y0;
comp->prec = cmptparms[compno].prec;
comp->bpp = cmptparms[compno].bpp;
comp->sgnd = cmptparms[compno].sgnd;
if (comp->h != 0 &&
(OPJ_SIZE_T)comp->w > SIZE_MAX / comp->h / sizeof(OPJ_INT32)) {

157
3rdparty/openjpeg/openjp2/indexbox_manager.h vendored Normal file
View File

@ -0,0 +1,157 @@
/*
* $Id: indexbox_manager.h 897 2011-08-28 21:43:57Z Kaori.Hagihara@gmail.com $
*
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2014, Professor Benoit Macq
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*! \file
* \brief Modification of jpip.c from 2KAN indexer
*/
#ifndef INDEXBOX_MANAGER_H_
# define INDEXBOX_MANAGER_H_
#include "openjpeg.h"
#include "j2k.h" /* needed to use jp2.h */
#include "jp2.h"
#define JPIP_CIDX 0x63696478 /* Codestream index */
#define JPIP_CPTR 0x63707472 /* Codestream Finder Box */
#define JPIP_MANF 0x6d616e66 /* Manifest Box */
#define JPIP_FAIX 0x66616978 /* Fragment array Index box */
#define JPIP_MHIX 0x6d686978 /* Main Header Index Table */
#define JPIP_TPIX 0x74706978 /* Tile-part Index Table box */
#define JPIP_THIX 0x74686978 /* Tile header Index Table box */
#define JPIP_PPIX 0x70706978 /* Precinct Packet Index Table box */
#define JPIP_PHIX 0x70686978 /* Packet Header index Table */
#define JPIP_FIDX 0x66696478 /* File Index */
#define JPIP_FPTR 0x66707472 /* File Finder */
#define JPIP_PRXY 0x70727879 /* Proxy boxes */
#define JPIP_IPTR 0x69707472 /* Index finder box */
#define JPIP_PHLD 0x70686c64 /* Place holder */
/*
* Write tile-part Index table box (superbox)
*
* @param[in] coff offset of j2k codestream
* @param[in] cstr_info codestream information
* @param[in] j2klen length of j2k codestream
* @param[in] cio file output handle
* @return length of tpix box
*/
int opj_write_tpix(int coff, opj_codestream_info_t cstr_info, int j2klen,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager);
/*
* Write tile header index table box (superbox)
*
* @param[in] coff offset of j2k codestream
* @param[in] cstr_info codestream information pointer
* @param[in] cio file output handle
* @return length of thix box
*/
int opj_write_thix(int coff, opj_codestream_info_t cstr_info,
opj_stream_private_t *cio, opj_event_mgr_t * p_manager);
/*
* Write precinct packet index table box (superbox)
*
* @param[in] coff offset of j2k codestream
* @param[in] cstr_info codestream information
* @param[in] EPHused true if EPH option used
* @param[in] j2klen length of j2k codestream
* @param[in] cio file output handle
* @return length of ppix box
*/
int opj_write_ppix(int coff, opj_codestream_info_t cstr_info, OPJ_BOOL EPHused,
int j2klen, opj_stream_private_t *cio,
opj_event_mgr_t * p_manager);
/*
* Write packet header index table box (superbox)
*
* @param[in] coff offset of j2k codestream
* @param[in] cstr_info codestream information
* @param[in] EPHused true if EPH option used
* @param[in] j2klen length of j2k codestream
* @param[in] cio file output handle
* @return length of ppix box
*/
int opj_write_phix(int coff, opj_codestream_info_t cstr_info, OPJ_BOOL EPHused,
int j2klen, opj_stream_private_t *cio,
opj_event_mgr_t * p_manager);
/*
* Write manifest box (box)
*
* @param[in] second number to be visited
* @param[in] v number of boxes
* @param[in] box box to be manifested
* @param[in] cio file output handle
*/
void opj_write_manf(int second,
int v,
opj_jp2_box_t *box,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager);
/*
* Write main header index table (box)
*
* @param[in] coff offset of j2k codestream
* @param[in] cstr_info codestream information
* @param[in] cio file output handle
* @return length of mainmhix box
*/
int opj_write_mainmhix(int coff, opj_codestream_info_t cstr_info,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager);
int opj_write_phixfaix(int coff, int compno, opj_codestream_info_t cstr_info,
OPJ_BOOL EPHused, int j2klen, opj_stream_private_t *cio,
opj_event_mgr_t * p_manager);
int opj_write_ppixfaix(int coff, int compno, opj_codestream_info_t cstr_info,
OPJ_BOOL EPHused, int j2klen, opj_stream_private_t *cio,
opj_event_mgr_t * p_manager);
int opj_write_tilemhix(int coff, opj_codestream_info_t cstr_info, int tileno,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager);
int opj_write_tpixfaix(int coff, int compno, opj_codestream_info_t cstr_info,
int j2klen, opj_stream_private_t *cio,
opj_event_mgr_t * p_manager);
#endif /* !INDEXBOX_MANAGER_H_ */

297
3rdparty/openjpeg/openjp2/j2k.c vendored
View File

@ -50,7 +50,7 @@
/*@{*/
/**
* Sets up the procedures to do on reading header. Developpers wanting to extend the library can add their own reading procedures.
* Sets up the procedures to do on reading header. Developers wanting to extend the library can add their own reading procedures.
*/
static OPJ_BOOL opj_j2k_setup_header_reading(opj_j2k_t *p_j2k,
opj_event_mgr_t * p_manager);
@ -89,22 +89,22 @@ static OPJ_BOOL opj_j2k_decoding_validation(opj_j2k_t * p_j2k,
opj_event_mgr_t * p_manager);
/**
* Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
* are valid. Developpers wanting to extend the library can add their own validation procedures.
* Sets up the validation ,i.e. adds the procedures to launch to make sure the codec parameters
* are valid. Developers wanting to extend the library can add their own validation procedures.
*/
static OPJ_BOOL opj_j2k_setup_encoding_validation(opj_j2k_t *p_j2k,
opj_event_mgr_t * p_manager);
/**
* Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
* are valid. Developpers wanting to extend the library can add their own validation procedures.
* Sets up the validation ,i.e. adds the procedures to launch to make sure the codec parameters
* are valid. Developers wanting to extend the library can add their own validation procedures.
*/
static OPJ_BOOL opj_j2k_setup_decoding_validation(opj_j2k_t *p_j2k,
opj_event_mgr_t * p_manager);
/**
* Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
* are valid. Developpers wanting to extend the library can add their own validation procedures.
* Sets up the validation ,i.e. adds the procedures to launch to make sure the codec parameters
* are valid. Developers wanting to extend the library can add their own validation procedures.
*/
static OPJ_BOOL opj_j2k_setup_end_compress(opj_j2k_t *p_j2k,
opj_event_mgr_t * p_manager);
@ -147,7 +147,7 @@ static OPJ_BOOL opj_j2k_create_tcd(opj_j2k_t *p_j2k,
opj_event_mgr_t * p_manager);
/**
* Excutes the given procedures on the given codec.
* Executes the given procedures on the given codec.
*
* @param p_procedure_list the list of procedures to execute
* @param p_j2k the jpeg2000 codec to execute the procedures on.
@ -910,9 +910,15 @@ static OPJ_BOOL opj_j2k_read_sod(opj_j2k_t *p_j2k,
static void opj_j2k_update_tlm(opj_j2k_t * p_j2k, OPJ_UINT32 p_tile_part_size)
{
opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,
p_j2k->m_current_tile_number, 1); /* PSOT */
++p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current;
if (p_j2k->m_specific_param.m_encoder.m_Ttlmi_is_byte) {
opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,
p_j2k->m_current_tile_number, 1);
p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current += 1;
} else {
opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,
p_j2k->m_current_tile_number, 2);
p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current += 2;
}
opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,
p_tile_part_size, 4); /* PSOT */
@ -1171,6 +1177,32 @@ static OPJ_BOOL opj_j2k_read_cbd(opj_j2k_t *p_j2k,
OPJ_UINT32 p_header_size,
opj_event_mgr_t * p_manager);
/**
* Reads a CAP marker (extended capabilities definition). Empty implementation.
* Found in HTJ2K files
*
* @param p_header_data the data contained in the CAP box.
* @param p_j2k the jpeg2000 codec.
* @param p_header_size the size of the data contained in the CAP marker.
* @param p_manager the user event manager.
*/
static OPJ_BOOL opj_j2k_read_cap(opj_j2k_t *p_j2k,
OPJ_BYTE * p_header_data,
OPJ_UINT32 p_header_size,
opj_event_mgr_t * p_manager);
/**
* Reads a CPF marker (corresponding profile). Empty implementation. Found in HTJ2K files
* @param p_header_data the data contained in the CPF box.
* @param p_j2k the jpeg2000 codec.
* @param p_header_size the size of the data contained in the CPF marker.
* @param p_manager the user event manager.
*/
static OPJ_BOOL opj_j2k_read_cpf(opj_j2k_t *p_j2k,
OPJ_BYTE * p_header_data,
OPJ_UINT32 p_header_size,
opj_event_mgr_t * p_manager);
/**
* Writes COC marker for each component.
@ -1393,10 +1425,12 @@ static const opj_dec_memory_marker_handler_t j2k_memory_marker_handler_tab [] =
{J2K_MS_COM, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_com},
{J2K_MS_MCT, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_mct},
{J2K_MS_CBD, J2K_STATE_MH, opj_j2k_read_cbd},
{J2K_MS_CAP, J2K_STATE_MH, opj_j2k_read_cap},
{J2K_MS_CPF, J2K_STATE_MH, opj_j2k_read_cpf},
{J2K_MS_MCC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_mcc},
{J2K_MS_MCO, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_mco},
#ifdef USE_JPWL
#ifdef TODO_MS /* remove these functions which are not commpatible with the v2 API */
#ifdef TODO_MS /* remove these functions which are not compatible with the v2 API */
{J2K_MS_EPC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epc},
{J2K_MS_EPB, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epb},
{J2K_MS_ESD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_esd},
@ -1643,7 +1677,7 @@ static OPJ_BOOL opj_j2k_check_poc_val(const opj_poc_t *p_pocs,
assert(p_nb_pocs > 0);
packet_array = (OPJ_UINT32*) opj_calloc(step_l * p_num_layers,
packet_array = (OPJ_UINT32*) opj_calloc((size_t)step_l * p_num_layers,
sizeof(OPJ_UINT32));
if (packet_array == 00) {
opj_event_msg(p_manager, EVT_ERROR,
@ -1756,7 +1790,7 @@ static OPJ_UINT32 opj_j2k_get_num_tp(opj_cp_t *cp, OPJ_UINT32 pino,
tpnum *= l_current_poc->layE;
break;
}
/* whould we split here ? */
/* would we split here ? */
if (cp->m_specific_param.m_enc.m_tp_flag == prog[i]) {
cp->m_specific_param.m_enc.m_tp_pos = i;
break;
@ -4170,13 +4204,33 @@ static OPJ_BOOL opj_j2k_write_tlm(opj_j2k_t *p_j2k,
{
OPJ_BYTE * l_current_data = 00;
OPJ_UINT32 l_tlm_size;
OPJ_UINT32 size_per_tile_part;
/* preconditions */
assert(p_j2k != 00);
assert(p_manager != 00);
assert(p_stream != 00);
l_tlm_size = 6 + (5 * p_j2k->m_specific_param.m_encoder.m_total_tile_parts);
/* 10921 = (65535 - header_size) / size_per_tile_part where */
/* header_size = 4 and size_per_tile_part = 6 */
if (p_j2k->m_specific_param.m_encoder.m_total_tile_parts > 10921) {
/* We could do more but it would require writing several TLM markers */
opj_event_msg(p_manager, EVT_ERROR,
"A maximum of 10921 tile-parts are supported currently "
"when writing TLM marker\n");
return OPJ_FALSE;
}
if (p_j2k->m_specific_param.m_encoder.m_total_tile_parts <= 255) {
size_per_tile_part = 5;
p_j2k->m_specific_param.m_encoder.m_Ttlmi_is_byte = OPJ_TRUE;
} else {
size_per_tile_part = 6;
p_j2k->m_specific_param.m_encoder.m_Ttlmi_is_byte = OPJ_FALSE;
}
l_tlm_size = 2 + 4 + (size_per_tile_part *
p_j2k->m_specific_param.m_encoder.m_total_tile_parts);
if (l_tlm_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(
@ -4191,6 +4245,7 @@ static OPJ_BOOL opj_j2k_write_tlm(opj_j2k_t *p_j2k,
p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data;
p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_tlm_size;
}
memset(p_j2k->m_specific_param.m_encoder.m_header_tile_data, 0, l_tlm_size);
l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
@ -4210,11 +4265,14 @@ static OPJ_BOOL opj_j2k_write_tlm(opj_j2k_t *p_j2k,
1); /* Ztlm=0*/
++l_current_data;
opj_write_bytes(l_current_data, 0x50,
1); /* Stlm ST=1(8bits-255 tiles max),SP=1(Ptlm=32bits) */
/* Stlm 0x50= ST=1(8bits-255 tiles max),SP=1(Ptlm=32bits) */
/* Stlm 0x60= ST=2(16bits-65535 tiles max),SP=1(Ptlm=32bits) */
opj_write_bytes(l_current_data,
size_per_tile_part == 5 ? 0x50 : 0x60,
1);
++l_current_data;
/* do nothing on the 5 * l_j2k->m_specific_param.m_encoder.m_total_tile_parts remaining data */
/* do nothing on the size_per_tile_part * l_j2k->m_specific_param.m_encoder.m_total_tile_parts remaining data */
if (opj_stream_write_data(p_stream,
p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_tlm_size,
p_manager) != l_tlm_size) {
@ -4906,9 +4964,14 @@ static OPJ_BOOL opj_j2k_read_sod(opj_j2k_t *p_j2k,
/* Check enough bytes left in stream before allocation */
if ((OPJ_OFF_T)p_j2k->m_specific_param.m_decoder.m_sot_length >
opj_stream_get_number_byte_left(p_stream)) {
opj_event_msg(p_manager, EVT_ERROR,
"Tile part length size inconsistent with stream length\n");
return OPJ_FALSE;
if (p_j2k->m_cp.strict) {
opj_event_msg(p_manager, EVT_ERROR,
"Tile part length size inconsistent with stream length\n");
return OPJ_FALSE;
} else {
opj_event_msg(p_manager, EVT_WARNING,
"Tile part length size inconsistent with stream length\n");
}
}
if (p_j2k->m_specific_param.m_decoder.m_sot_length >
UINT_MAX - OPJ_COMMON_CBLK_DATA_EXTRA) {
@ -5354,9 +5417,9 @@ static OPJ_BOOL opj_j2k_update_rates(opj_j2k_t *p_j2k,
return OPJ_FALSE;
}
if (OPJ_IS_CINEMA(l_cp->rsiz) || OPJ_IS_IMF(l_cp->rsiz)) {
if (p_j2k->m_specific_param.m_encoder.m_TLM) {
p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer =
(OPJ_BYTE *) opj_malloc(5 *
(OPJ_BYTE *) opj_malloc(6 *
p_j2k->m_specific_param.m_encoder.m_total_tile_parts);
if (! p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer) {
return OPJ_FALSE;
@ -6564,6 +6627,60 @@ static OPJ_BOOL opj_j2k_read_cbd(opj_j2k_t *p_j2k,
return OPJ_TRUE;
}
/**
* Reads a CAP marker (extended capabilities definition). Empty implementation.
* Found in HTJ2K files.
*
* @param p_header_data the data contained in the CAP box.
* @param p_j2k the jpeg2000 codec.
* @param p_header_size the size of the data contained in the CAP marker.
* @param p_manager the user event manager.
*/
static OPJ_BOOL opj_j2k_read_cap(opj_j2k_t *p_j2k,
OPJ_BYTE * p_header_data,
OPJ_UINT32 p_header_size,
opj_event_mgr_t * p_manager
)
{
/* preconditions */
assert(p_header_data != 00);
assert(p_j2k != 00);
assert(p_manager != 00);
(void)p_j2k;
(void)p_header_data;
(void)p_header_size;
(void)p_manager;
return OPJ_TRUE;
}
/**
* Reads a CPF marker (corresponding profile). Empty implementation. Found in HTJ2K files
* @param p_header_data the data contained in the CPF box.
* @param p_j2k the jpeg2000 codec.
* @param p_header_size the size of the data contained in the CPF marker.
* @param p_manager the user event manager.
*/
static OPJ_BOOL opj_j2k_read_cpf(opj_j2k_t *p_j2k,
OPJ_BYTE * p_header_data,
OPJ_UINT32 p_header_size,
opj_event_mgr_t * p_manager
)
{
/* preconditions */
assert(p_header_data != 00);
assert(p_j2k != 00);
assert(p_manager != 00);
(void)p_j2k;
(void)p_header_data;
(void)p_header_size;
(void)p_manager;
return OPJ_TRUE;
}
/* ----------------------------------------------------------------------- */
/* J2K / JPT decoder interface */
/* ----------------------------------------------------------------------- */
@ -6583,6 +6700,13 @@ void opj_j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters)
}
}
void opj_j2k_decoder_set_strict_mode(opj_j2k_t *j2k, OPJ_BOOL strict)
{
if (j2k) {
j2k->m_cp.strict = strict;
}
}
OPJ_BOOL opj_j2k_set_threads(opj_j2k_t *j2k, OPJ_UINT32 num_threads)
{
/* Currently we pass the thread-pool to the tcd, so we cannot re-set it */
@ -6863,7 +6987,7 @@ static OPJ_BOOL opj_j2k_is_cinema_compliant(opj_image_t *image, OPJ_UINT16 rsiz,
/* Bitdepth */
for (i = 0; i < image->numcomps; i++) {
if ((image->comps[i].bpp != 12) | (image->comps[i].sgnd)) {
if ((image->comps[i].prec != 12) | (image->comps[i].sgnd)) {
char signed_str[] = "signed";
char unsigned_str[] = "unsigned";
char *tmp_str = image->comps[i].sgnd ? signed_str : unsigned_str;
@ -6872,7 +6996,7 @@ static OPJ_BOOL opj_j2k_is_cinema_compliant(opj_image_t *image, OPJ_UINT16 rsiz,
"Precision of each component shall be 12 bits unsigned"
"-> At least component %d of input image (%d bits, %s) is not compliant\n"
"-> Non-profile-3 codestream will be generated\n",
i, image->comps[i].bpp, tmp_str);
i, image->comps[i].prec, tmp_str);
return OPJ_FALSE;
}
}
@ -7070,20 +7194,20 @@ static OPJ_BOOL opj_j2k_is_imf_compliant(opj_cparameters_t *parameters,
"-> Non-IMF codestream will be generated\n",
mainlevel);
ret = OPJ_FALSE;
}
/* Validate sublevel */
assert(sizeof(tabMaxSubLevelFromMainLevel) ==
(OPJ_IMF_MAINLEVEL_MAX + 1) * sizeof(tabMaxSubLevelFromMainLevel[0]));
if (sublevel > tabMaxSubLevelFromMainLevel[mainlevel]) {
opj_event_msg(p_manager, EVT_WARNING,
"IMF profile require sublevel <= %d for mainlevel = %d.\n"
"-> %d is thus not compliant\n"
"-> Non-IMF codestream will be generated\n",
tabMaxSubLevelFromMainLevel[mainlevel],
mainlevel,
sublevel);
ret = OPJ_FALSE;
} else {
/* Validate sublevel */
assert(sizeof(tabMaxSubLevelFromMainLevel) ==
(OPJ_IMF_MAINLEVEL_MAX + 1) * sizeof(tabMaxSubLevelFromMainLevel[0]));
if (sublevel > tabMaxSubLevelFromMainLevel[mainlevel]) {
opj_event_msg(p_manager, EVT_WARNING,
"IMF profile require sublevel <= %d for mainlevel = %d.\n"
"-> %d is thus not compliant\n"
"-> Non-IMF codestream will be generated\n",
tabMaxSubLevelFromMainLevel[mainlevel],
mainlevel,
sublevel);
ret = OPJ_FALSE;
}
}
/* Number of components */
@ -7163,7 +7287,7 @@ static OPJ_BOOL opj_j2k_is_imf_compliant(opj_cparameters_t *parameters,
/* Bitdepth */
for (i = 0; i < image->numcomps; i++) {
if (!(image->comps[i].bpp >= 8 && image->comps[i].bpp <= 16) ||
if (!(image->comps[i].prec >= 8 && image->comps[i].prec <= 16) ||
(image->comps[i].sgnd)) {
char signed_str[] = "signed";
char unsigned_str[] = "unsigned";
@ -7172,7 +7296,7 @@ static OPJ_BOOL opj_j2k_is_imf_compliant(opj_cparameters_t *parameters,
"IMF profiles require precision of each component to b in [8-16] bits unsigned"
"-> At least component %d of input image (%d bits, %s) is not compliant\n"
"-> Non-IMF codestream will be generated\n",
i, image->comps[i].bpp, tmp_str);
i, image->comps[i].prec, tmp_str);
ret = OPJ_FALSE;
}
}
@ -7204,7 +7328,7 @@ static OPJ_BOOL opj_j2k_is_imf_compliant(opj_cparameters_t *parameters,
if (image->comps[i].dy != 1) {
opj_event_msg(p_manager, EVT_WARNING,
"IMF profiles require YRsiz == 1. "
"Here it is set to %d for component i.\n"
"Here it is set to %d for component %d.\n"
"-> Non-IMF codestream will be generated\n",
image->comps[i].dy, i);
ret = OPJ_FALSE;
@ -7468,8 +7592,7 @@ static OPJ_BOOL opj_j2k_is_imf_compliant(opj_cparameters_t *parameters,
opj_event_msg(p_manager, EVT_WARNING,
"IMF profiles require PPx = PPy = 7 for NLLL band, else 8.\n"
"-> Supplied values are different from that.\n"
"-> Non-IMF codestream will be generated\n",
NL);
"-> Non-IMF codestream will be generated\n");
ret = OPJ_FALSE;
}
} else {
@ -7480,8 +7603,7 @@ static OPJ_BOOL opj_j2k_is_imf_compliant(opj_cparameters_t *parameters,
opj_event_msg(p_manager, EVT_WARNING,
"IMF profiles require PPx = PPy = 7 for NLLL band, else 8.\n"
"-> Supplied values are different from that.\n"
"-> Non-IMF codestream will be generated\n",
NL);
"-> Non-IMF codestream will be generated\n");
ret = OPJ_FALSE;
}
}
@ -7544,6 +7666,8 @@ OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k,
return OPJ_FALSE;
}
p_j2k->m_specific_param.m_encoder.m_nb_comps = image->numcomps;
/* keep a link to cp so that we can destroy it later in j2k_destroy_compress */
cp = &(p_j2k->m_cp);
@ -7709,6 +7833,10 @@ OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k,
}
}
if (OPJ_IS_CINEMA(parameters->rsiz) || OPJ_IS_IMF(parameters->rsiz)) {
p_j2k->m_specific_param.m_encoder.m_TLM = OPJ_TRUE;
}
/* Manage profiles and applications and set RSIZ */
/* set cinema parameters if required */
if (OPJ_IS_CINEMA(parameters->rsiz)) {
@ -7839,6 +7967,13 @@ OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k,
(OPJ_INT32)cp->tdx);
cp->th = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(image->y1 - cp->ty0),
(OPJ_INT32)cp->tdy);
/* Check that the number of tiles is valid */
if (cp->tw > 65535 / cp->th) {
opj_event_msg(p_manager, EVT_ERROR,
"Invalid number of tiles : %u x %u (maximum fixed by jpeg2000 norm is 65535 tiles)\n",
cp->tw, cp->th);
return OPJ_FALSE;
}
} else {
cp->tdx = image->x1 - cp->tx0;
cp->tdy = image->y1 - cp->ty0;
@ -7905,7 +8040,7 @@ OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k,
}
#endif /* USE_JPWL */
/* initialize the mutiple tiles */
/* initialize the multiple tiles */
/* ---------------------------- */
cp->tcps = (opj_tcp_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tcp_t));
if (!cp->tcps) {
@ -8715,7 +8850,7 @@ static OPJ_BOOL opj_j2k_read_header_procedure(opj_j2k_t *p_j2k,
if (l_marker_handler->id == J2K_MS_UNK) {
if (! opj_j2k_read_unk(p_j2k, p_stream, &l_current_marker, p_manager)) {
opj_event_msg(p_manager, EVT_ERROR,
"Unknow marker have been detected and generated error.\n");
"Unknown marker has been detected and generated error.\n");
return OPJ_FALSE;
}
@ -9720,7 +9855,7 @@ OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k,
/* When using the opj_read_tile_header / opj_decode_tile_data API */
/* such as in test_tile_decoder, m_output_image is NULL, so fall back */
/* to the full image dimension. This is a bit surprising that */
/* opj_set_decode_area() is only used to determinte intersecting tiles, */
/* opj_set_decode_area() is only used to determine intersecting tiles, */
/* but full tile decoding is done */
l_image_for_bounds = p_j2k->m_output_image ? p_j2k->m_output_image :
p_j2k->m_private_image;
@ -9766,10 +9901,10 @@ OPJ_BOOL opj_j2k_decode_tile(opj_j2k_t * p_j2k,
if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_EOC) {
if (opj_stream_read_data(p_stream, l_data, 2, p_manager) != 2) {
opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
return OPJ_FALSE;
opj_event_msg(p_manager, p_j2k->m_cp.strict ? EVT_ERROR : EVT_WARNING,
"Stream too short\n");
return p_j2k->m_cp.strict ? OPJ_FALSE : OPJ_TRUE;
}
opj_read_bytes(l_data, &l_current_marker, 2);
if (l_current_marker == J2K_MS_EOC) {
@ -10286,6 +10421,9 @@ opj_j2k_t* opj_j2k_create_decompress(void)
/* per component is allowed */
l_j2k->m_cp.allow_different_bit_depth_sign = 1;
/* Default to using strict mode. */
l_j2k->m_cp.strict = OPJ_TRUE;
#ifdef OPJ_DISABLE_TPSOT_FIX
l_j2k->m_specific_param.m_decoder.m_nb_tile_parts_correction_checked = 1;
#endif
@ -10585,9 +10723,10 @@ static OPJ_BOOL opj_j2k_read_SPCod_SPCoc(opj_j2k_t *p_j2k,
/* SPcod (G) / SPcoc (D) */
opj_read_bytes(l_current_ptr, &l_tccp->cblksty, 1);
++l_current_ptr;
if (l_tccp->cblksty & 0xC0U) { /* 2 msb are reserved, assume we can't read */
if ((l_tccp->cblksty & J2K_CCP_CBLKSTY_HTMIXED) != 0) {
/* We do not support HT mixed mode yet. For conformance, it should be supported.*/
opj_event_msg(p_manager, EVT_ERROR,
"Error reading SPCod SPCoc element, Invalid code-block style found\n");
"Error reading SPCod SPCoc element. Unsupported Mixed HT code-block style found\n");
return OPJ_FALSE;
}
@ -11610,7 +11749,7 @@ static OPJ_BOOL opj_j2k_decode_tiles(opj_j2k_t *p_j2k,
}
/**
* Sets up the procedures to do on decoding data. Developpers wanting to extend the library can add their own reading procedures.
* Sets up the procedures to do on decoding data. Developers wanting to extend the library can add their own reading procedures.
*/
static OPJ_BOOL opj_j2k_setup_decoding(opj_j2k_t *p_j2k,
opj_event_mgr_t * p_manager)
@ -11742,7 +11881,7 @@ static OPJ_BOOL opj_j2k_decode_one_tile(opj_j2k_t *p_j2k,
}
/**
* Sets up the procedures to do on decoding one tile. Developpers wanting to extend the library can add their own reading procedures.
* Sets up the procedures to do on decoding one tile. Developers wanting to extend the library can add their own reading procedures.
*/
static OPJ_BOOL opj_j2k_setup_decoding_tile(opj_j2k_t *p_j2k,
opj_event_mgr_t * p_manager)
@ -11968,7 +12107,7 @@ OPJ_BOOL opj_j2k_get_tile(opj_j2k_t *p_j2k,
opj_image_destroy(p_j2k->m_output_image);
}
/* Create the ouput image from the information previously computed*/
/* Create the output image from the information previously computed*/
p_j2k->m_output_image = opj_image_create0();
if (!(p_j2k->m_output_image)) {
return OPJ_FALSE;
@ -12048,6 +12187,35 @@ OPJ_BOOL opj_j2k_encoder_set_extra_options(
"Invalid value for option: %s.\n", *p_option_iter);
return OPJ_FALSE;
}
} else if (strncmp(*p_option_iter, "TLM=", 4) == 0) {
if (strcmp(*p_option_iter, "TLM=YES") == 0) {
p_j2k->m_specific_param.m_encoder.m_TLM = OPJ_TRUE;
} else if (strcmp(*p_option_iter, "TLM=NO") == 0) {
p_j2k->m_specific_param.m_encoder.m_TLM = OPJ_FALSE;
} else {
opj_event_msg(p_manager, EVT_ERROR,
"Invalid value for option: %s.\n", *p_option_iter);
return OPJ_FALSE;
}
} else if (strncmp(*p_option_iter, "GUARD_BITS=", strlen("GUARD_BITS=")) == 0) {
OPJ_UINT32 tileno;
opj_cp_t *cp = cp = &(p_j2k->m_cp);
int numgbits = atoi(*p_option_iter + strlen("GUARD_BITS="));
if (numgbits < 0 || numgbits > 7) {
opj_event_msg(p_manager, EVT_ERROR,
"Invalid value for option: %s. Should be in [0,7]\n", *p_option_iter);
return OPJ_FALSE;
}
for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
OPJ_UINT32 i;
opj_tcp_t *tcp = &cp->tcps[tileno];
for (i = 0; i < p_j2k->m_specific_param.m_encoder.m_nb_comps; i++) {
opj_tccp_t *tccp = &tcp->tccps[i];
tccp->numgbits = (OPJ_UINT32)numgbits;
}
}
} else {
opj_event_msg(p_manager, EVT_ERROR,
"Invalid option: %s.\n", *p_option_iter);
@ -12445,7 +12613,7 @@ static OPJ_BOOL opj_j2k_setup_end_compress(opj_j2k_t *p_j2k,
return OPJ_FALSE;
}
if (OPJ_IS_CINEMA(p_j2k->m_cp.rsiz) || OPJ_IS_IMF(p_j2k->m_cp.rsiz)) {
if (p_j2k->m_specific_param.m_encoder.m_TLM) {
if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
(opj_procedure)opj_j2k_write_updated_tlm, p_manager)) {
return OPJ_FALSE;
@ -12528,7 +12696,7 @@ static OPJ_BOOL opj_j2k_setup_header_writing(opj_j2k_t *p_j2k,
return OPJ_FALSE;
}
if (OPJ_IS_CINEMA(p_j2k->m_cp.rsiz) || OPJ_IS_IMF(p_j2k->m_cp.rsiz)) {
if (p_j2k->m_specific_param.m_encoder.m_TLM) {
if (! opj_procedure_list_add_procedure(p_j2k->m_procedure_list,
(opj_procedure)opj_j2k_write_tlm, p_manager)) {
return OPJ_FALSE;
@ -12661,7 +12829,7 @@ static OPJ_BOOL opj_j2k_write_first_tile_part(opj_j2k_t *p_j2k,
opj_write_bytes(l_begin_data + 6, l_nb_bytes_written,
4); /* PSOT */
if (OPJ_IS_CINEMA(l_cp->rsiz) || OPJ_IS_IMF(l_cp->rsiz)) {
if (p_j2k->m_specific_param.m_encoder.m_TLM) {
opj_j2k_update_tlm(p_j2k, l_nb_bytes_written);
}
@ -12731,7 +12899,7 @@ static OPJ_BOOL opj_j2k_write_all_tile_parts(opj_j2k_t *p_j2k,
opj_write_bytes(l_begin_data + 6, l_part_tile_size,
4); /* PSOT */
if (OPJ_IS_CINEMA(l_cp->rsiz) || OPJ_IS_IMF(l_cp->rsiz)) {
if (p_j2k->m_specific_param.m_encoder.m_TLM) {
opj_j2k_update_tlm(p_j2k, l_part_tile_size);
}
@ -12777,7 +12945,7 @@ static OPJ_BOOL opj_j2k_write_all_tile_parts(opj_j2k_t *p_j2k,
opj_write_bytes(l_begin_data + 6, l_part_tile_size,
4); /* PSOT */
if (OPJ_IS_CINEMA(l_cp->rsiz) || OPJ_IS_IMF(l_cp->rsiz)) {
if (p_j2k->m_specific_param.m_encoder.m_TLM) {
opj_j2k_update_tlm(p_j2k, l_part_tile_size);
}
@ -12796,13 +12964,16 @@ static OPJ_BOOL opj_j2k_write_updated_tlm(opj_j2k_t *p_j2k,
{
OPJ_UINT32 l_tlm_size;
OPJ_OFF_T l_tlm_position, l_current_position;
OPJ_UINT32 size_per_tile_part;
/* preconditions */
assert(p_j2k != 00);
assert(p_manager != 00);
assert(p_stream != 00);
l_tlm_size = 5 * p_j2k->m_specific_param.m_encoder.m_total_tile_parts;
size_per_tile_part = p_j2k->m_specific_param.m_encoder.m_Ttlmi_is_byte ? 5 : 6;
l_tlm_size = size_per_tile_part *
p_j2k->m_specific_param.m_encoder.m_total_tile_parts;
l_tlm_position = 6 + p_j2k->m_specific_param.m_encoder.m_tlm_start;
l_current_position = opj_stream_tell(p_stream);

17
3rdparty/openjpeg/openjp2/j2k.h vendored
View File

@ -61,6 +61,8 @@ The functions in J2K.C have for goal to read/write the several parts of the code
#define J2K_CCP_CBLKSTY_VSC 0x08 /**< Vertically stripe causal context */
#define J2K_CCP_CBLKSTY_PTERM 0x10 /**< Predictable termination */
#define J2K_CCP_CBLKSTY_SEGSYM 0x20 /**< Segmentation symbols are used */
#define J2K_CCP_CBLKSTY_HT 0x40 /**< (high throughput) HT codeblocks */
#define J2K_CCP_CBLKSTY_HTMIXED 0x80 /**< MIXED mode HT codeblocks */
#define J2K_CCP_QNTSTY_NOQNT 0
#define J2K_CCP_QNTSTY_SIQNT 1
#define J2K_CCP_QNTSTY_SEQNT 2
@ -71,9 +73,11 @@ The functions in J2K.C have for goal to read/write the several parts of the code
#define J2K_MS_SOT 0xff90 /**< SOT marker value */
#define J2K_MS_SOD 0xff93 /**< SOD marker value */
#define J2K_MS_EOC 0xffd9 /**< EOC marker value */
#define J2K_MS_CAP 0xff50 /**< CAP marker value */
#define J2K_MS_SIZ 0xff51 /**< SIZ marker value */
#define J2K_MS_COD 0xff52 /**< COD marker value */
#define J2K_MS_COC 0xff53 /**< COC marker value */
#define J2K_MS_CPF 0xff59 /**< CPF marker value */
#define J2K_MS_RGN 0xff5e /**< RGN marker value */
#define J2K_MS_QCD 0xff5c /**< QCD marker value */
#define J2K_MS_QCC 0xff5d /**< QCC marker value */
@ -398,6 +402,8 @@ typedef struct opj_cp {
}
m_specific_param;
/** OPJ_TRUE if entire bit stream must be decoded, OPJ_FALSE if partial bitstream decoding allowed */
OPJ_BOOL strict;
/* UniPG>> */
#ifdef USE_JPWL
@ -503,6 +509,12 @@ typedef struct opj_j2k_enc {
/** Tile part number currently coding, taking into account POC. m_current_tile_part_number holds the total number of tile parts while encoding the last tile part.*/
OPJ_UINT32 m_current_tile_part_number; /*cur_tp_num */
/* whether to generate TLM markers */
OPJ_BOOL m_TLM;
/* whether the Ttlmi field in a TLM marker is a byte (otherwise a uint16) */
OPJ_BOOL m_Ttlmi_is_byte;
/**
locate the start position of the TLM marker
after encoding the tilepart, a jump (in j2k_write_sod) is done to the TLM marker to store the value of its length.
@ -540,6 +552,9 @@ typedef struct opj_j2k_enc {
/* reserved bytes in m_encoded_tile_size for PLT markers */
OPJ_UINT32 m_reserved_bytes_for_PLT;
/** Number of components */
OPJ_UINT32 m_nb_comps;
} opj_j2k_enc_t;
@ -612,6 +627,8 @@ Decoding parameters are returned in j2k->cp.
*/
void opj_j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters);
void opj_j2k_decoder_set_strict_mode(opj_j2k_t *j2k, OPJ_BOOL strict);
OPJ_BOOL opj_j2k_set_threads(opj_j2k_t *j2k, OPJ_UINT32 num_threads);
/**

25
3rdparty/openjpeg/openjp2/jp2.c vendored
View File

@ -331,14 +331,14 @@ static OPJ_BOOL opj_jp2_read_colr(opj_jp2_t *jp2,
/**
* Sets up the procedures to do on writing header after the codestream.
* Developpers wanting to extend the library can add their own writing procedures.
* Developers wanting to extend the library can add their own writing procedures.
*/
static OPJ_BOOL opj_jp2_setup_end_header_writing(opj_jp2_t *jp2,
opj_event_mgr_t * p_manager);
/**
* Sets up the procedures to do on reading header after the codestream.
* Developpers wanting to extend the library can add their own writing procedures.
* Developers wanting to extend the library can add their own writing procedures.
*/
static OPJ_BOOL opj_jp2_setup_end_header_reading(opj_jp2_t *jp2,
opj_event_mgr_t * p_manager);
@ -388,13 +388,13 @@ static OPJ_BOOL opj_jp2_read_boxhdr(opj_jp2_box_t *box,
/**
* Sets up the validation ,i.e. adds the procedures to launch to make sure the codec parameters
* are valid. Developpers wanting to extend the library can add their own validation procedures.
* are valid. Developers wanting to extend the library can add their own validation procedures.
*/
static OPJ_BOOL opj_jp2_setup_encoding_validation(opj_jp2_t *jp2,
opj_event_mgr_t * p_manager);
/**
* Sets up the procedures to do on writing header. Developpers wanting to extend the library can add their own writing procedures.
* Sets up the procedures to do on writing header. Developers wanting to extend the library can add their own writing procedures.
*/
static OPJ_BOOL opj_jp2_setup_header_writing(opj_jp2_t *jp2,
opj_event_mgr_t * p_manager);
@ -457,14 +457,14 @@ static OPJ_BOOL opj_jp2_read_boxhdr_char(opj_jp2_box_t *box,
/**
* Sets up the validation ,i.e. adds the procedures to launch to make sure the codec parameters
* are valid. Developpers wanting to extend the library can add their own validation procedures.
* are valid. Developers wanting to extend the library can add their own validation procedures.
*/
static OPJ_BOOL opj_jp2_setup_decoding_validation(opj_jp2_t *jp2,
opj_event_mgr_t * p_manager);
/**
* Sets up the procedures to do on reading header.
* Developpers wanting to extend the library can add their own writing procedures.
* Developers wanting to extend the library can add their own writing procedures.
*/
static OPJ_BOOL opj_jp2_setup_header_reading(opj_jp2_t *jp2,
opj_event_mgr_t * p_manager);
@ -1108,7 +1108,7 @@ static OPJ_BOOL opj_jp2_apply_pclr(opj_image_t *image,
pcol = cmap[i].pcol;
src = old_comps[cmp].data;
assert(src); /* verified above */
max = new_comps[i].w * new_comps[i].h;
max = new_comps[pcol].w * new_comps[pcol].h;
/* Direct use: */
if (cmap[i].mtyp == 0) {
@ -1136,9 +1136,9 @@ static OPJ_BOOL opj_jp2_apply_pclr(opj_image_t *image,
}
max = image->numcomps;
for (i = 0; i < max; ++i) {
if (old_comps[i].data) {
opj_image_data_free(old_comps[i].data);
for (j = 0; j < max; ++j) {
if (old_comps[j].data) {
opj_image_data_free(old_comps[j].data);
}
}
@ -1901,6 +1901,11 @@ void opj_jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters)
OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG;
}
void opj_jp2_decoder_set_strict_mode(opj_jp2_t *jp2, OPJ_BOOL strict)
{
opj_j2k_decoder_set_strict_mode(jp2->j2k, strict);
}
OPJ_BOOL opj_jp2_set_threads(opj_jp2_t *jp2, OPJ_UINT32 num_threads)
{
return opj_j2k_set_threads(jp2->j2k, num_threads);

9
3rdparty/openjpeg/openjp2/jp2.h vendored
View File

@ -235,6 +235,15 @@ Decoding parameters are returned in jp2->j2k->cp.
*/
void opj_jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters);
/**
Set the strict mode parameter. When strict mode is enabled, the entire
bitstream must be decoded or an error is returned. When it is disabled,
the decoder will decode partial bitstreams.
@param jp2 JP2 decompressor handle
@param strict OPJ_TRUE for strict mode
*/
void opj_jp2_decoder_set_strict_mode(opj_jp2_t *jp2, OPJ_BOOL strict);
/** Allocates worker threads for the compressor/decompressor.
*
* @param jp2 JP2 decompressor handle

14
3rdparty/openjpeg/openjp2/libopenjp2.pc.cmake.in vendored Normal file
View File

@ -0,0 +1,14 @@
prefix=@CMAKE_INSTALL_PREFIX@
bindir=${prefix}/@OPENJPEG_INSTALL_BIN_DIR@
mandir=${prefix}/@OPENJPEG_INSTALL_MAN_DIR@
docdir=${prefix}/@OPENJPEG_INSTALL_DOC_DIR@
libdir=${prefix}/@OPENJPEG_INSTALL_LIB_DIR@
includedir=${prefix}/@OPENJPEG_INSTALL_INCLUDE_DIR@
Name: openjp2
Description: JPEG2000 library (Part 1 and 2)
URL: http://www.openjpeg.org/
Version: @OPENJPEG_VERSION@
Libs: -L${libdir} -lopenjp2
Libs.private: -lm
Cflags: -I${includedir}

2
3rdparty/openjpeg/openjp2/mct.c vendored
View File

@ -457,7 +457,7 @@ void opj_calculate_norms(OPJ_FLOAT64 * pNorms,
for (j = 0; j < pNbComps; ++j) {
lCurrentValue = lMatrix[lIndex];
lIndex += pNbComps;
lNorms[i] += lCurrentValue * lCurrentValue;
lNorms[i] += (OPJ_FLOAT64) lCurrentValue * lCurrentValue;
}
lNorms[i] = sqrt(lNorms[i]);
}

63
3rdparty/openjpeg/openjp2/openjpeg.c vendored
View File

@ -89,14 +89,16 @@ OPJ_BOOL OPJ_CALLCONV opj_set_error_handler(opj_codec_t * p_codec,
/* ---------------------------------------------------------------------- */
static OPJ_SIZE_T opj_read_from_file(void * p_buffer, OPJ_SIZE_T p_nb_bytes,
FILE * p_file)
void * p_user_data)
{
OPJ_SIZE_T l_nb_read = fread(p_buffer, 1, p_nb_bytes, p_file);
FILE* p_file = (FILE*)p_user_data;
OPJ_SIZE_T l_nb_read = fread(p_buffer, 1, p_nb_bytes, (FILE*)p_file);
return l_nb_read ? l_nb_read : (OPJ_SIZE_T) - 1;
}
static OPJ_UINT64 opj_get_data_length_from_file(FILE * p_file)
static OPJ_UINT64 opj_get_data_length_from_file(void * p_user_data)
{
FILE* p_file = (FILE*)p_user_data;
OPJ_OFF_T file_length = 0;
OPJ_FSEEK(p_file, 0, SEEK_END);
@ -107,29 +109,38 @@ static OPJ_UINT64 opj_get_data_length_from_file(FILE * p_file)
}
static OPJ_SIZE_T opj_write_from_file(void * p_buffer, OPJ_SIZE_T p_nb_bytes,
FILE * p_file)
void * p_user_data)
{
FILE* p_file = (FILE*)p_user_data;
return fwrite(p_buffer, 1, p_nb_bytes, p_file);
}
static OPJ_OFF_T opj_skip_from_file(OPJ_OFF_T p_nb_bytes, FILE * p_user_data)
static OPJ_OFF_T opj_skip_from_file(OPJ_OFF_T p_nb_bytes, void * p_user_data)
{
if (OPJ_FSEEK(p_user_data, p_nb_bytes, SEEK_CUR)) {
FILE* p_file = (FILE*)p_user_data;
if (OPJ_FSEEK(p_file, p_nb_bytes, SEEK_CUR)) {
return -1;
}
return p_nb_bytes;
}
static OPJ_BOOL opj_seek_from_file(OPJ_OFF_T p_nb_bytes, FILE * p_user_data)
static OPJ_BOOL opj_seek_from_file(OPJ_OFF_T p_nb_bytes, void * p_user_data)
{
if (OPJ_FSEEK(p_user_data, p_nb_bytes, SEEK_SET)) {
FILE* p_file = (FILE*)p_user_data;
if (OPJ_FSEEK(p_file, p_nb_bytes, SEEK_SET)) {
return OPJ_FALSE;
}
return OPJ_TRUE;
}
static void opj_close_from_file(void* p_user_data)
{
FILE* p_file = (FILE*)p_user_data;
fclose(p_file);
}
/* ---------------------------------------------------------------------- */
#ifdef _WIN32
#ifndef OPJ_STATIC
@ -208,6 +219,10 @@ opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT p_format)
l_codec->m_codec_data.m_decompression.opj_setup_decoder =
(void (*)(void *, opj_dparameters_t *)) opj_j2k_setup_decoder;
l_codec->m_codec_data.m_decompression.opj_decoder_set_strict_mode =
(void (*)(void *, OPJ_BOOL)) opj_j2k_decoder_set_strict_mode;
l_codec->m_codec_data.m_decompression.opj_read_tile_header =
(OPJ_BOOL(*)(void *,
OPJ_UINT32*,
@ -315,6 +330,9 @@ opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT p_format)
l_codec->m_codec_data.m_decompression.opj_setup_decoder =
(void (*)(void *, opj_dparameters_t *)) opj_jp2_setup_decoder;
l_codec->m_codec_data.m_decompression.opj_decoder_set_strict_mode =
(void (*)(void *, OPJ_BOOL)) opj_jp2_decoder_set_strict_mode;
l_codec->m_codec_data.m_decompression.opj_set_decode_area =
(OPJ_BOOL(*)(void *,
opj_image_t*,
@ -415,6 +433,26 @@ OPJ_BOOL OPJ_CALLCONV opj_setup_decoder(opj_codec_t *p_codec,
return OPJ_FALSE;
}
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_decoder_set_strict_mode(opj_codec_t *p_codec,
OPJ_BOOL strict)
{
if (p_codec) {
opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
if (! l_codec->is_decompressor) {
opj_event_msg(&(l_codec->m_event_mgr), EVT_ERROR,
"Codec provided to the opj_decoder_set_strict_mode function is not a decompressor handler.\n");
return OPJ_FALSE;
}
l_codec->m_codec_data.m_decompression.opj_decoder_set_strict_mode(
l_codec->m_codec,
strict);
return OPJ_TRUE;
}
return OPJ_FALSE;
}
OPJ_BOOL OPJ_CALLCONV opj_read_header(opj_stream_t *p_stream,
opj_codec_t *p_codec,
opj_image_t **p_image)
@ -1074,15 +1112,14 @@ opj_stream_t* OPJ_CALLCONV opj_stream_create_file_stream(
return NULL;
}
opj_stream_set_user_data(l_stream, p_file,
(opj_stream_free_user_data_fn) fclose);
opj_stream_set_user_data(l_stream, p_file, opj_close_from_file);
opj_stream_set_user_data_length(l_stream,
opj_get_data_length_from_file(p_file));
opj_stream_set_read_function(l_stream, (opj_stream_read_fn) opj_read_from_file);
opj_stream_set_read_function(l_stream, opj_read_from_file);
opj_stream_set_write_function(l_stream,
(opj_stream_write_fn) opj_write_from_file);
opj_stream_set_skip_function(l_stream, (opj_stream_skip_fn) opj_skip_from_file);
opj_stream_set_seek_function(l_stream, (opj_stream_seek_fn) opj_seek_from_file);
opj_stream_set_skip_function(l_stream, opj_skip_from_file);
opj_stream_set_seek_function(l_stream, opj_seek_from_file);
return l_stream;
}

48
3rdparty/openjpeg/openjp2/openjpeg.h vendored
View File

@ -76,6 +76,12 @@ Most compilers implement their own version of this keyword ...
#define OPJ_DEPRECATED(func) func
#endif
#if defined(__GNUC__) && __GNUC__ >= 6
#define OPJ_DEPRECATED_STRUCT_MEMBER(memb, msg) __attribute__ ((deprecated(msg))) memb
#else
#define OPJ_DEPRECATED_STRUCT_MEMBER(memb, msg) memb
#endif
#if defined(OPJ_STATIC) || !defined(_WIN32)
/* http://gcc.gnu.org/wiki/Visibility */
# if !defined(_WIN32) && __GNUC__ >= 4
@ -449,9 +455,9 @@ typedef struct opj_cparameters {
char infile[OPJ_PATH_LEN];
/** output file name */
char outfile[OPJ_PATH_LEN];
/** DEPRECATED. Index generation is now handeld with the opj_encode_with_info() function. Set to NULL */
/** DEPRECATED. Index generation is now handled with the opj_encode_with_info() function. Set to NULL */
int index_on;
/** DEPRECATED. Index generation is now handeld with the opj_encode_with_info() function. Set to NULL */
/** DEPRECATED. Index generation is now handled with the opj_encode_with_info() function. Set to NULL */
char index[OPJ_PATH_LEN];
/** subimage encoding: origin image offset in x direction */
int image_offset_x0;
@ -681,10 +687,10 @@ typedef struct opj_image_comp {
OPJ_UINT32 x0;
/** y component offset compared to the whole image */
OPJ_UINT32 y0;
/** precision */
/** precision: number of bits per component per pixel */
OPJ_UINT32 prec;
/** image depth in bits */
OPJ_UINT32 bpp;
/** obsolete: use prec instead */
OPJ_DEPRECATED_STRUCT_MEMBER(OPJ_UINT32 bpp, "Use prec instead");
/** signed (1) / unsigned (0) */
OPJ_UINT32 sgnd;
/** number of decoded resolution */
@ -738,10 +744,10 @@ typedef struct opj_image_comptparm {
OPJ_UINT32 x0;
/** y component offset compared to the whole image */
OPJ_UINT32 y0;
/** precision */
/** precision: number of bits per component per pixel */
OPJ_UINT32 prec;
/** image depth in bits */
OPJ_UINT32 bpp;
/** obsolete: use prec instead */
OPJ_DEPRECATED_STRUCT_MEMBER(OPJ_UINT32 bpp, "Use prec instead");
/** signed (1) / unsigned (0) */
OPJ_UINT32 sgnd;
} opj_image_cmptparm_t;
@ -1339,6 +1345,20 @@ OPJ_API void OPJ_CALLCONV opj_set_default_decoder_parameters(
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_setup_decoder(opj_codec_t *p_codec,
opj_dparameters_t *parameters);
/**
* Set strict decoding parameter for this decoder. If strict decoding is enabled, partial bit
* streams will fail to decode. If strict decoding is disabled, the decoder will decode partial
* bitstreams as much as possible without erroring
*
* @param p_codec decompressor handler
* @param strict OPJ_TRUE to enable strict decoding, OPJ_FALSE to disable
*
* @return true if the decoder is correctly set
*/
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_decoder_set_strict_mode(opj_codec_t *p_codec,
OPJ_BOOL strict);
/**
* Allocates worker threads for the compressor/decompressor.
*
@ -1447,7 +1467,7 @@ OPJ_API OPJ_BOOL OPJ_CALLCONV opj_decode(opj_codec_t *p_decompressor,
* Get the decoded tile from the codec
*
* @param p_codec the jpeg2000 codec.
* @param p_stream input streamm
* @param p_stream input stream
* @param p_image output image
* @param tile_index index of the tile which will be decode
*
@ -1592,7 +1612,13 @@ OPJ_API OPJ_BOOL OPJ_CALLCONV opj_setup_encoder(opj_codec_t *p_codec,
* <ul>
* <li>PLT=YES/NO. Defaults to NO. If set to YES, PLT marker segments,
* indicating the length of each packet in the tile-part header, will be
* written. Since 2.3.2</li>
* written. Since 2.4.0</li>
* <li>TLM=YES/NO. Defaults to NO (except for Cinema and IMF profiles).
* If set to YES, TLM marker segments, indicating the length of each
* tile-part part will be written. Since 2.4.0</li>
* <li>GUARD_BITS=value. Number of guard bits in [0,7] range. Default value is 2.
* 1 may be used sometimes (like in SMPTE DCP Bv2.1 Application Profile for 2K images).
* Since 2.5.0</li>
* </ul>
*
* @param p_codec Compressor handle
@ -1600,7 +1626,7 @@ OPJ_API OPJ_BOOL OPJ_CALLCONV opj_setup_encoder(opj_codec_t *p_codec,
* array of strings. Each string is of the form KEY=VALUE.
*
* @return OPJ_TRUE in case of success.
* @since 2.3.2
* @since 2.4.0
*/
OPJ_API OPJ_BOOL OPJ_CALLCONV opj_encoder_set_extra_options(
opj_codec_t *p_codec,

3
3rdparty/openjpeg/openjp2/opj_codec.h vendored
View File

@ -90,6 +90,9 @@ typedef struct opj_codec_private {
/** Setup decoder function handler */
void (*opj_setup_decoder)(void * p_codec, opj_dparameters_t * p_param);
/** Strict mode function handler */
void (*opj_decoder_set_strict_mode)(void * p_codec, OPJ_BOOL strict);
/** Set decode area function handler */
OPJ_BOOL(*opj_set_decode_area)(void * p_codec,
opj_image_t * p_image,

38
3rdparty/openjpeg/openjp2/opj_intmath.h vendored
View File

@ -276,6 +276,44 @@ static INLINE OPJ_INT32 opj_int_fix_mul_t1(OPJ_INT32 a, OPJ_INT32 b)
return (OPJ_INT32)(temp >> (13 + 11 - T1_NMSEDEC_FRACBITS)) ;
}
/**
Addition two signed integers with a wrap-around behaviour.
Assumes complement-to-two signed integers.
@param a
@param b
@return Returns a + b
*/
static INLINE OPJ_INT32 opj_int_add_no_overflow(OPJ_INT32 a, OPJ_INT32 b)
{
void* pa = &a;
void* pb = &b;
OPJ_UINT32* upa = (OPJ_UINT32*)pa;
OPJ_UINT32* upb = (OPJ_UINT32*)pb;
OPJ_UINT32 ures = *upa + *upb;
void* pures = &ures;
OPJ_INT32* ipres = (OPJ_INT32*)pures;
return *ipres;
}
/**
Subtract two signed integers with a wrap-around behaviour.
Assumes complement-to-two signed integers.
@param a
@param b
@return Returns a - b
*/
static INLINE OPJ_INT32 opj_int_sub_no_overflow(OPJ_INT32 a, OPJ_INT32 b)
{
void* pa = &a;
void* pb = &b;
OPJ_UINT32* upa = (OPJ_UINT32*)pa;
OPJ_UINT32* upb = (OPJ_UINT32*)pb;
OPJ_UINT32 ures = *upa - *upb;
void* pures = &ures;
OPJ_INT32* ipres = (OPJ_INT32*)pures;
return *ipres;
}
/* ----------------------------------------------------------------------- */
/*@}*/

210
3rdparty/openjpeg/openjp2/phix_manager.c vendored Normal file
View File

@ -0,0 +1,210 @@
/*
* $Id: phix_manager.c 897 2011-08-28 21:43:57Z Kaori.Hagihara@gmail.com $
*
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2014, Professor Benoit Macq
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*! \file
* \brief Modification of jpip.c from 2KAN indexer
*/
#include "opj_includes.h"
/*
* Write faix box of phix
*
* @param[in] coff offset of j2k codestream
* @param[in] compno component number
* @param[in] cstr_info codestream information
* @param[in] EPHused true if if EPH option used
* @param[in] j2klen length of j2k codestream
* @param[in] cio file output handle
* @return length of faix box
*/
int opj_write_phix(int coff, opj_codestream_info_t cstr_info, OPJ_BOOL EPHused,
int j2klen, opj_stream_private_t *cio,
opj_event_mgr_t * p_manager)
{
OPJ_BYTE l_data_header [8];
OPJ_UINT32 len, compno, i;
opj_jp2_box_t *box;
OPJ_OFF_T lenp = 0;
box = (opj_jp2_box_t *)opj_calloc((size_t)cstr_info.numcomps,
sizeof(opj_jp2_box_t));
if (box == NULL) {
return 0;
}
for (i = 0; i < 2; i++) {
if (i) {
opj_stream_seek(cio, lenp, p_manager);
}
lenp = opj_stream_tell(cio);
opj_stream_skip(cio, 4, p_manager); /* L [at the end] */
opj_write_bytes(l_data_header, JPIP_PHIX, 4); /* PHIX */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_write_manf((int)i, cstr_info.numcomps, box, cio, p_manager);
for (compno = 0; compno < (OPJ_UINT32)cstr_info.numcomps; compno++) {
box[compno].length = (OPJ_UINT32)opj_write_phixfaix(coff, (int)compno,
cstr_info, EPHused, j2klen, cio, p_manager);
box[compno].type = JPIP_FAIX;
}
len = (OPJ_UINT32)(opj_stream_tell(cio) - lenp);
opj_stream_seek(cio, 4, p_manager);
opj_write_bytes(l_data_header, len, 4); /* L */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_stream_seek(cio, lenp + len, p_manager);
}
opj_free(box);
return (int)len;
}
int opj_write_phixfaix(int coff, int compno, opj_codestream_info_t cstr_info,
OPJ_BOOL EPHused, int j2klen, opj_stream_private_t *cio,
opj_event_mgr_t * p_manager)
{
OPJ_UINT32 tileno, version, i, nmax, size_of_coding; /* 4 or 8 */
opj_tile_info_t *tile_Idx;
opj_packet_info_t packet;
int resno, precno, layno;
OPJ_UINT32 num_packet;
int numOfres, numOfprec, numOflayers;
OPJ_BYTE l_data_header [8];
OPJ_OFF_T lenp;
OPJ_UINT32 len;
packet.end_ph_pos = packet.start_pos = -1;
(void)EPHused; /* unused ? */
if (j2klen > pow(2, 32)) {
size_of_coding = 8;
version = 1;
} else {
size_of_coding = 4;
version = 0;
}
lenp = opj_stream_tell(cio);
opj_stream_skip(cio, 4, p_manager); /* L [at the end] */
opj_write_bytes(l_data_header, JPIP_FAIX, 4); /* FAIX */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_write_bytes(l_data_header, version, 1); /* Version 0 = 4 bytes */
opj_stream_write_data(cio, l_data_header, 1, p_manager);
nmax = 0;
for (i = 0; i <= (OPJ_UINT32)cstr_info.numdecompos[compno]; i++) {
nmax += (OPJ_UINT32)(cstr_info.tile[0].ph[i] * cstr_info.tile[0].pw[i] *
cstr_info.numlayers);
}
opj_write_bytes(l_data_header, nmax, size_of_coding); /* NMAX */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
opj_write_bytes(l_data_header, (OPJ_UINT32)(cstr_info.tw * cstr_info.th),
size_of_coding); /* M */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
for (tileno = 0; tileno < (OPJ_UINT32)(cstr_info.tw * cstr_info.th); tileno++) {
tile_Idx = &cstr_info.tile[ tileno];
num_packet = 0;
numOfres = cstr_info.numdecompos[compno] + 1;
for (resno = 0; resno < numOfres ; resno++) {
numOfprec = tile_Idx->pw[resno] * tile_Idx->ph[resno];
for (precno = 0; precno < numOfprec; precno++) {
numOflayers = cstr_info.numlayers;
for (layno = 0; layno < numOflayers; layno++) {
switch (cstr_info.prog) {
case OPJ_LRCP:
packet = tile_Idx->packet[((layno * numOfres + resno) * cstr_info.numcomps +
compno) * numOfprec + precno];
break;
case OPJ_RLCP:
packet = tile_Idx->packet[((resno * numOflayers + layno) * cstr_info.numcomps +
compno) * numOfprec + precno];
break;
case OPJ_RPCL:
packet = tile_Idx->packet[((resno * numOfprec + precno) * cstr_info.numcomps +
compno) * numOflayers + layno];
break;
case OPJ_PCRL:
packet = tile_Idx->packet[((precno * cstr_info.numcomps + compno) * numOfres +
resno) * numOflayers + layno];
break;
case OPJ_CPRL:
packet = tile_Idx->packet[((compno * numOfprec + precno) * numOfres + resno) *
numOflayers + layno];
break;
default:
fprintf(stderr, "failed to ppix indexing\n");
}
opj_write_bytes(l_data_header, (OPJ_UINT32)(packet.start_pos - coff),
size_of_coding); /* start position */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
opj_write_bytes(l_data_header,
(OPJ_UINT32)(packet.end_ph_pos - packet.start_pos + 1),
size_of_coding); /* length */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
num_packet++;
}
}
}
/* PADDING */
while (num_packet < nmax) {
opj_write_bytes(l_data_header, 0,
size_of_coding); /* start position */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
opj_write_bytes(l_data_header, 0,
size_of_coding); /* length */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
num_packet++;
}
}
len = (OPJ_UINT32)(opj_stream_tell(cio) - lenp);
opj_stream_seek(cio, lenp, p_manager);
opj_write_bytes(l_data_header, len, 4); /* L */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_stream_seek(cio, lenp + len, p_manager);
return (int)len;
}

16
3rdparty/openjpeg/openjp2/pi.c vendored
View File

@ -943,7 +943,7 @@ static void opj_get_all_encoding_parameters(const opj_image_t *p_image,
*p_dy_min = 0x7fffffff;
for (compno = 0; compno < p_image->numcomps; ++compno) {
/* aritmetic variables to calculate*/
/* arithmetic variables to calculate*/
OPJ_UINT32 l_level_no;
OPJ_UINT32 l_rx0, l_ry0, l_rx1, l_ry1;
OPJ_UINT32 l_px0, l_py0, l_px1, py1;
@ -1225,7 +1225,7 @@ static void opj_pi_update_decode_poc(opj_pi_iterator_t * p_pi,
/* loop*/
OPJ_UINT32 pino;
/* encoding prameters to set*/
/* encoding parameters to set*/
OPJ_UINT32 l_bound;
opj_pi_iterator_t * l_current_pi = 00;
@ -1272,7 +1272,7 @@ static void opj_pi_update_decode_not_poc(opj_pi_iterator_t * p_pi,
/* loop*/
OPJ_UINT32 pino;
/* encoding prameters to set*/
/* encoding parameters to set*/
OPJ_UINT32 l_bound;
opj_pi_iterator_t * l_current_pi = 00;
@ -1312,7 +1312,7 @@ static OPJ_BOOL opj_pi_check_next_level(OPJ_INT32 pos,
opj_poc_t *tcp = &tcps->pocs[pino];
if (pos >= 0) {
for (i = pos; pos >= 0; i--) {
for (i = pos; i >= 0; i--) {
switch (prog[i]) {
case 'R':
if (tcp->res_t == tcp->resE) {
@ -1401,11 +1401,11 @@ opj_pi_iterator_t *opj_pi_create_decode(opj_image_t *p_image,
OPJ_UINT32 pino;
OPJ_UINT32 compno, resno;
/* to store w, h, dx and dy fro all components and resolutions */
/* to store w, h, dx and dy for all components and resolutions */
OPJ_UINT32 * l_tmp_data;
OPJ_UINT32 ** l_tmp_ptr;
/* encoding prameters to set */
/* encoding parameters to set */
OPJ_UINT32 l_max_res;
OPJ_UINT32 l_max_prec;
OPJ_UINT32 l_tx0, l_tx1, l_ty0, l_ty1;
@ -1624,11 +1624,11 @@ opj_pi_iterator_t *opj_pi_initialise_encode(const opj_image_t *p_image,
OPJ_UINT32 pino;
OPJ_UINT32 compno, resno;
/* to store w, h, dx and dy fro all components and resolutions*/
/* to store w, h, dx and dy for all components and resolutions*/
OPJ_UINT32 * l_tmp_data;
OPJ_UINT32 ** l_tmp_ptr;
/* encoding prameters to set*/
/* encoding parameters to set*/
OPJ_UINT32 l_max_res;
OPJ_UINT32 l_max_prec;
OPJ_UINT32 l_tx0, l_tx1, l_ty0, l_ty1;

215
3rdparty/openjpeg/openjp2/ppix_manager.c vendored Normal file
View File

@ -0,0 +1,215 @@
/*
* $Id: ppix_manager.c 897 2011-08-28 21:43:57Z Kaori.Hagihara@gmail.com $
*
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2014, Professor Benoit Macq
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*! \file
* \brief Modification of jpip.c from 2KAN indexer
*/
#include "opj_includes.h"
/*
* Write faix box of ppix
*
* @param[in] coff offset of j2k codestream
* @param[in] compno component number
* @param[in] cstr_info codestream information
* @param[in] EPHused true if if EPH option used
* @param[in] j2klen length of j2k codestream
* @param[in] cio file output handle
* @return length of faix box
*/
int opj_write_ppix(int coff, opj_codestream_info_t cstr_info, OPJ_BOOL EPHused,
int j2klen, opj_stream_private_t *cio,
opj_event_mgr_t * p_manager)
{
OPJ_BYTE l_data_header [4];
int compno, i;
opj_jp2_box_t *box;
OPJ_OFF_T lenp;
OPJ_UINT32 len;
/* printf("cstr_info.packno %d\n", cstr_info.packno); //NMAX? */
lenp = -1;
box = (opj_jp2_box_t *)opj_calloc((size_t)cstr_info.numcomps,
sizeof(opj_jp2_box_t));
if (box == NULL) {
return 0;
}
for (i = 0; i < 2; i++) {
if (i)
{
opj_stream_seek(cio, lenp, p_manager);
}
lenp = (OPJ_UINT32)(opj_stream_tell(cio));
opj_stream_skip(cio, 4, p_manager); /* L [at the end] */
opj_write_bytes(l_data_header, JPIP_PPIX, 4); /* PPIX */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_write_manf(i, cstr_info.numcomps, box, cio, p_manager);
for (compno = 0; compno < cstr_info.numcomps; compno++) {
box[compno].length = (OPJ_UINT32)opj_write_ppixfaix(coff, compno, cstr_info,
EPHused, j2klen, cio, p_manager);
box[compno].type = JPIP_FAIX;
}
len = (OPJ_UINT32)(opj_stream_tell(cio) - lenp);
opj_stream_seek(cio, lenp, p_manager);
opj_write_bytes(l_data_header, len, 4); /* L */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_stream_seek(cio, lenp + len, p_manager);
}
opj_free(box);
return (int)len;
}
int opj_write_ppixfaix(int coff, int compno, opj_codestream_info_t cstr_info,
OPJ_BOOL EPHused, int j2klen, opj_stream_private_t *cio,
opj_event_mgr_t * p_manager)
{
OPJ_BYTE l_data_header [8];
OPJ_UINT32 tileno, version, i, nmax, size_of_coding; /* 4 or 8*/
OPJ_UINT32 len;
OPJ_OFF_T lenp;
opj_tile_info_t *tile_Idx;
opj_packet_info_t packet;
int resno, precno, layno;
OPJ_UINT32 num_packet;
int numOfres, numOfprec, numOflayers;
packet.end_pos = packet.end_ph_pos = packet.start_pos = -1;
(void)EPHused; /* unused ? */
if (j2klen > pow(2, 32)) {
size_of_coding = 8;
version = 1;
} else {
size_of_coding = 4;
version = 0;
}
lenp = opj_stream_tell(cio);
opj_stream_skip(cio, 4, p_manager); /* L [at the end] */
opj_write_bytes(l_data_header, JPIP_FAIX, 4); /* FAIX */
opj_write_bytes(l_data_header, version, 1);
opj_stream_write_data(cio, l_data_header, 1,
p_manager); /* Version 0 = 4 bytes */
nmax = 0;
for (i = 0; i <= (OPJ_UINT32)cstr_info.numdecompos[compno]; i++) {
nmax += (OPJ_UINT32)(cstr_info.tile[0].ph[i] * cstr_info.tile[0].pw[i] *
cstr_info.numlayers);
}
opj_write_bytes(l_data_header, nmax, size_of_coding); /* NMAX */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
opj_write_bytes(l_data_header, (OPJ_UINT32)(cstr_info.tw * cstr_info.th),
size_of_coding); /* M */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
for (tileno = 0; tileno < (OPJ_UINT32)(cstr_info.tw * cstr_info.th); tileno++) {
tile_Idx = &cstr_info.tile[ tileno];
num_packet = 0;
numOfres = cstr_info.numdecompos[compno] + 1;
for (resno = 0; resno < numOfres ; resno++) {
numOfprec = tile_Idx->pw[resno] * tile_Idx->ph[resno];
for (precno = 0; precno < numOfprec; precno++) {
numOflayers = cstr_info.numlayers;
for (layno = 0; layno < numOflayers; layno++) {
switch (cstr_info.prog) {
case OPJ_LRCP:
packet = tile_Idx->packet[((layno * numOfres + resno) * cstr_info.numcomps +
compno) * numOfprec + precno];
break;
case OPJ_RLCP:
packet = tile_Idx->packet[((resno * numOflayers + layno) * cstr_info.numcomps +
compno) * numOfprec + precno];
break;
case OPJ_RPCL:
packet = tile_Idx->packet[((resno * numOfprec + precno) * cstr_info.numcomps +
compno) * numOflayers + layno];
break;
case OPJ_PCRL:
packet = tile_Idx->packet[((precno * cstr_info.numcomps + compno) * numOfres +
resno) * numOflayers + layno];
break;
case OPJ_CPRL:
packet = tile_Idx->packet[((compno * numOfprec + precno) * numOfres + resno) *
numOflayers + layno];
break;
default:
fprintf(stderr, "failed to ppix indexing\n");
}
opj_write_bytes(l_data_header, (OPJ_UINT32)(packet.start_pos - coff),
size_of_coding); /* start position */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
opj_write_bytes(l_data_header,
(OPJ_UINT32)(packet.end_pos - packet.start_pos + 1),
size_of_coding); /* length */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
num_packet++;
}
}
}
while (num_packet < nmax) { /* PADDING */
opj_write_bytes(l_data_header, 0,
size_of_coding); /* start position */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
opj_write_bytes(l_data_header, 0,
size_of_coding); /* length */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
num_packet++;
}
}
len = (OPJ_UINT32)(opj_stream_tell(cio) - lenp);
opj_stream_seek(cio, lenp, p_manager);
opj_write_bytes(l_data_header, len, 4); /* L */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_stream_seek(cio, lenp + len, p_manager);
return (int)len;
}

4
3rdparty/openjpeg/openjp2/sparse_array.c vendored
View File

@ -69,7 +69,7 @@ opj_sparse_array_int32_t* opj_sparse_array_int32_create(OPJ_UINT32 width,
return NULL;
}
sa->data_blocks = (OPJ_INT32**) opj_calloc(sizeof(OPJ_INT32*),
sa->block_count_hor * sa->block_count_ver);
(size_t) sa->block_count_hor * sa->block_count_ver);
if (sa->data_blocks == NULL) {
opj_free(sa);
return NULL;
@ -235,7 +235,7 @@ static OPJ_BOOL opj_sparse_array_int32_read_or_write(
} else {
if (src_block == NULL) {
src_block = (OPJ_INT32*) opj_calloc(1,
sa->block_width * sa->block_height * sizeof(OPJ_INT32));
(size_t) sa->block_width * sa->block_height * sizeof(OPJ_INT32));
if (src_block == NULL) {
return OPJ_FALSE;
}

61
3rdparty/openjpeg/openjp2/t1.c vendored
View File

@ -217,6 +217,27 @@ static OPJ_BOOL opj_t1_decode_cblk(opj_t1_t *t1,
opj_mutex_t* p_manager_mutex,
OPJ_BOOL check_pterm);
/**
Decode 1 HT code-block
@param t1 T1 handle
@param cblk Code-block coding parameters
@param orient
@param roishift Region of interest shifting value
@param cblksty Code-block style
@param p_manager the event manager
@param p_manager_mutex mutex for the event manager
@param check_pterm whether PTERM correct termination should be checked
*/
OPJ_BOOL opj_t1_ht_decode_cblk(opj_t1_t *t1,
opj_tcd_cblk_dec_t* cblk,
OPJ_UINT32 orient,
OPJ_UINT32 roishift,
OPJ_UINT32 cblksty,
opj_event_mgr_t *p_manager,
opj_mutex_t* p_manager_mutex,
OPJ_BOOL check_pterm);
static OPJ_BOOL opj_t1_allocate_buffers(opj_t1_t *t1,
OPJ_UINT32 w,
OPJ_UINT32 h);
@ -1665,18 +1686,34 @@ static void opj_t1_clbl_decode_processor(void* user_data, opj_tls_t* tls)
}
t1->mustuse_cblkdatabuffer = job->mustuse_cblkdatabuffer;
if (OPJ_FALSE == opj_t1_decode_cblk(
t1,
cblk,
band->bandno,
(OPJ_UINT32)tccp->roishift,
tccp->cblksty,
job->p_manager,
job->p_manager_mutex,
job->check_pterm)) {
*(job->pret) = OPJ_FALSE;
opj_free(job);
return;
if ((tccp->cblksty & J2K_CCP_CBLKSTY_HT) != 0) {
if (OPJ_FALSE == opj_t1_ht_decode_cblk(
t1,
cblk,
band->bandno,
(OPJ_UINT32)tccp->roishift,
tccp->cblksty,
job->p_manager,
job->p_manager_mutex,
job->check_pterm)) {
*(job->pret) = OPJ_FALSE;
opj_free(job);
return;
}
} else {
if (OPJ_FALSE == opj_t1_decode_cblk(
t1,
cblk,
band->bandno,
(OPJ_UINT32)tccp->roishift,
tccp->cblksty,
job->p_manager,
job->p_manager_mutex,
job->check_pterm)) {
*(job->pret) = OPJ_FALSE;
opj_free(job);
return;
}
}
x = cblk->x0 - band->x0;

2
3rdparty/openjpeg/openjp2/t1.h vendored
View File

@ -200,7 +200,7 @@ typedef struct opj_t1 {
OPJ_UINT32 flagssize;
OPJ_BOOL encoder;
/* Thre 3 variables below are only used by the decoder */
/* The 3 variables below are only used by the decoder */
/* set to TRUE in multithreaded context */
OPJ_BOOL mustuse_cblkdatabuffer;
/* Temporary buffer to concatenate all chunks of a codebock */

323
3rdparty/openjpeg/openjp2/t1_generate_luts.c vendored Normal file
View File

@ -0,0 +1,323 @@
/*
* The copyright in this software is being made available under the 2-clauses
* BSD License, included below. This software may be subject to other third
* party and contributor rights, including patent rights, and no such rights
* are granted under this license.
*
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2014, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux
* Copyright (c) 2003-2014, Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
* Copyright (c) 2012, Carl Hetherington
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "opj_includes.h"
// defined elsewhere
extern OPJ_BOOL vlc_init_tables();
extern OPJ_BOOL vlc_tables_initialized;
extern int vlc_tbl0[1024];
extern int vlc_tbl1[1024];
static int t1_init_ctxno_zc(OPJ_UINT32 f, OPJ_UINT32 orient)
{
int h, v, d, n, t, hv;
n = 0;
h = ((f & T1_SIGMA_3) != 0) + ((f & T1_SIGMA_5) != 0);
v = ((f & T1_SIGMA_1) != 0) + ((f & T1_SIGMA_7) != 0);
d = ((f & T1_SIGMA_0) != 0) + ((f & T1_SIGMA_2) != 0) + ((
f & T1_SIGMA_8) != 0) + ((f & T1_SIGMA_6) != 0);
switch (orient) {
case 2:
t = h;
h = v;
v = t;
case 0:
case 1:
if (!h) {
if (!v) {
if (!d) {
n = 0;
} else if (d == 1) {
n = 1;
} else {
n = 2;
}
} else if (v == 1) {
n = 3;
} else {
n = 4;
}
} else if (h == 1) {
if (!v) {
if (!d) {
n = 5;
} else {
n = 6;
}
} else {
n = 7;
}
} else {
n = 8;
}
break;
case 3:
hv = h + v;
if (!d) {
if (!hv) {
n = 0;
} else if (hv == 1) {
n = 1;
} else {
n = 2;
}
} else if (d == 1) {
if (!hv) {
n = 3;
} else if (hv == 1) {
n = 4;
} else {
n = 5;
}
} else if (d == 2) {
if (!hv) {
n = 6;
} else {
n = 7;
}
} else {
n = 8;
}
break;
}
return (T1_CTXNO_ZC + n);
}
static int t1_init_ctxno_sc(OPJ_UINT32 f)
{
int hc, vc, n;
n = 0;
hc = opj_int_min(((f & (T1_LUT_SIG_E | T1_LUT_SGN_E)) ==
T1_LUT_SIG_E) + ((f & (T1_LUT_SIG_W | T1_LUT_SGN_W)) == T1_LUT_SIG_W),
1) - opj_int_min(((f & (T1_LUT_SIG_E | T1_LUT_SGN_E)) ==
(T1_LUT_SIG_E | T1_LUT_SGN_E)) +
((f & (T1_LUT_SIG_W | T1_LUT_SGN_W)) ==
(T1_LUT_SIG_W | T1_LUT_SGN_W)), 1);
vc = opj_int_min(((f & (T1_LUT_SIG_N | T1_LUT_SGN_N)) ==
T1_LUT_SIG_N) + ((f & (T1_LUT_SIG_S | T1_LUT_SGN_S)) == T1_LUT_SIG_S),
1) - opj_int_min(((f & (T1_LUT_SIG_N | T1_LUT_SGN_N)) ==
(T1_LUT_SIG_N | T1_LUT_SGN_N)) +
((f & (T1_LUT_SIG_S | T1_LUT_SGN_S)) ==
(T1_LUT_SIG_S | T1_LUT_SGN_S)), 1);
if (hc < 0) {
hc = -hc;
vc = -vc;
}
if (!hc) {
if (vc == -1) {
n = 1;
} else if (!vc) {
n = 0;
} else {
n = 1;
}
} else if (hc == 1) {
if (vc == -1) {
n = 2;
} else if (!vc) {
n = 3;
} else {
n = 4;
}
}
return (T1_CTXNO_SC + n);
}
static int t1_init_spb(OPJ_UINT32 f)
{
int hc, vc, n;
hc = opj_int_min(((f & (T1_LUT_SIG_E | T1_LUT_SGN_E)) ==
T1_LUT_SIG_E) + ((f & (T1_LUT_SIG_W | T1_LUT_SGN_W)) == T1_LUT_SIG_W),
1) - opj_int_min(((f & (T1_LUT_SIG_E | T1_LUT_SGN_E)) ==
(T1_LUT_SIG_E | T1_LUT_SGN_E)) +
((f & (T1_LUT_SIG_W | T1_LUT_SGN_W)) ==
(T1_LUT_SIG_W | T1_LUT_SGN_W)), 1);
vc = opj_int_min(((f & (T1_LUT_SIG_N | T1_LUT_SGN_N)) ==
T1_LUT_SIG_N) + ((f & (T1_LUT_SIG_S | T1_LUT_SGN_S)) == T1_LUT_SIG_S),
1) - opj_int_min(((f & (T1_LUT_SIG_N | T1_LUT_SGN_N)) ==
(T1_LUT_SIG_N | T1_LUT_SGN_N)) +
((f & (T1_LUT_SIG_S | T1_LUT_SGN_S)) ==
(T1_LUT_SIG_S | T1_LUT_SGN_S)), 1);
if (!hc && !vc) {
n = 0;
} else {
n = (!(hc > 0 || (!hc && vc > 0)));
}
return n;
}
static void dump_array16(int array[], int size)
{
int i;
--size;
for (i = 0; i < size; ++i) {
printf("0x%04x,", array[i]);
if (!((i + 1) & 0x7)) {
printf("\n ");
} else {
printf(" ");
}
}
printf("0x%04x\n};\n\n", array[size]);
}
int main(int argc, char **argv)
{
unsigned int i, j;
double u, v, t;
int lut_ctxno_zc[2048];
int lut_nmsedec_sig[1 << T1_NMSEDEC_BITS];
int lut_nmsedec_sig0[1 << T1_NMSEDEC_BITS];
int lut_nmsedec_ref[1 << T1_NMSEDEC_BITS];
int lut_nmsedec_ref0[1 << T1_NMSEDEC_BITS];
(void)argc;
(void)argv;
printf("/* This file was automatically generated by t1_generate_luts.c */\n\n");
/* lut_ctxno_zc */
for (j = 0; j < 4; ++j) {
for (i = 0; i < 512; ++i) {
OPJ_UINT32 orient = j;
if (orient == 2) {
orient = 1;
} else if (orient == 1) {
orient = 2;
}
lut_ctxno_zc[(orient << 9) | i] = t1_init_ctxno_zc(i, j);
}
}
printf("static const OPJ_BYTE lut_ctxno_zc[2048] = {\n ");
for (i = 0; i < 2047; ++i) {
printf("%i,", lut_ctxno_zc[i]);
if (!((i + 1) & 0x1f)) {
printf("\n ");
} else {
printf(" ");
}
}
printf("%i\n};\n\n", lut_ctxno_zc[2047]);
/* lut_ctxno_sc */
printf("static const OPJ_BYTE lut_ctxno_sc[256] = {\n ");
for (i = 0; i < 255; ++i) {
printf("0x%x,", t1_init_ctxno_sc(i));
if (!((i + 1) & 0xf)) {
printf("\n ");
} else {
printf(" ");
}
}
printf("0x%x\n};\n\n", t1_init_ctxno_sc(255));
/* lut_spb */
printf("static const OPJ_BYTE lut_spb[256] = {\n ");
for (i = 0; i < 255; ++i) {
printf("%i,", t1_init_spb(i));
if (!((i + 1) & 0x1f)) {
printf("\n ");
} else {
printf(" ");
}
}
printf("%i\n};\n\n", t1_init_spb(255));
/* FIXME FIXME FIXME */
/* fprintf(stdout,"nmsedec luts:\n"); */
for (i = 0U; i < (1U << T1_NMSEDEC_BITS); ++i) {
t = i / pow(2, T1_NMSEDEC_FRACBITS);
u = t;
v = t - 1.5;
lut_nmsedec_sig[i] =
opj_int_max(0,
(int)(floor((u * u - v * v) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2,
T1_NMSEDEC_FRACBITS) * 8192.0));
lut_nmsedec_sig0[i] =
opj_int_max(0,
(int)(floor((u * u) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2,
T1_NMSEDEC_FRACBITS) * 8192.0));
u = t - 1.0;
if (i & (1 << (T1_NMSEDEC_BITS - 1))) {
v = t - 1.5;
} else {
v = t - 0.5;
}
lut_nmsedec_ref[i] =
opj_int_max(0,
(int)(floor((u * u - v * v) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2,
T1_NMSEDEC_FRACBITS) * 8192.0));
lut_nmsedec_ref0[i] =
opj_int_max(0,
(int)(floor((u * u) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2,
T1_NMSEDEC_FRACBITS) * 8192.0));
}
printf("static const OPJ_INT16 lut_nmsedec_sig[1U << T1_NMSEDEC_BITS] = {\n ");
dump_array16(lut_nmsedec_sig, 1U << T1_NMSEDEC_BITS);
printf("static const OPJ_INT16 lut_nmsedec_sig0[1U << T1_NMSEDEC_BITS] = {\n ");
dump_array16(lut_nmsedec_sig0, 1U << T1_NMSEDEC_BITS);
printf("static const OPJ_INT16 lut_nmsedec_ref[1U << T1_NMSEDEC_BITS] = {\n ");
dump_array16(lut_nmsedec_ref, 1U << T1_NMSEDEC_BITS);
printf("static const OPJ_INT16 lut_nmsedec_ref0[1U << T1_NMSEDEC_BITS] = {\n ");
dump_array16(lut_nmsedec_ref0, 1U << T1_NMSEDEC_BITS);
vlc_tables_initialized = vlc_init_tables();
printf("static const OPJ_UINT16 vlc_tbl0[1024] = {\n ");
dump_array16(vlc_tbl0, 1024);
printf("static const OPJ_UINT16 vlc_tbl1[1024] = {\n ");
dump_array16(vlc_tbl1, 1024);
return 0;
}

973
3rdparty/openjpeg/openjp2/t1_ht_generate_luts.c vendored Normal file
View File

@ -0,0 +1,973 @@
//***************************************************************************/
// This software is released under the 2-Clause BSD license, included
// below.
//
// Copyright (c) 2021, Aous Naman
// Copyright (c) 2021, Kakadu Software Pty Ltd, Australia
// Copyright (c) 2021, The University of New South Wales, Australia
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//***************************************************************************/
// This file is part of the OpenJpeg software implementation.
// File: t1_ht_generate_luts.c
// Author: Aous Naman
// Date: 01 September 2021
//***************************************************************************/
#include <string.h>
#include <stdio.h>
#include <assert.h>
typedef int OPJ_BOOL;
#define OPJ_TRUE 1
#define OPJ_FALSE 0
#include "opj_stdint.h"
typedef int8_t OPJ_INT8;
typedef uint8_t OPJ_UINT8;
typedef int16_t OPJ_INT16;
typedef uint16_t OPJ_UINT16;
typedef int32_t OPJ_INT32;
typedef uint32_t OPJ_UINT32;
typedef int64_t OPJ_INT64;
typedef uint64_t OPJ_UINT64;
//************************************************************************/
/** @brief HT decoding tables, as given in the standard
*
* Data in the table is arranged in this format:
* c_q is the context for a quad
* rho is the signficance pattern for a quad
* u_off indicate if u value is 0 (u_off is 0), or communicated
* e_k, e_1 EMB patterns
* cwd VLC codeword
* cwd VLC codeword length
*/
typedef struct vlc_src_table {
int c_q, rho, u_off, e_k, e_1, cwd, cwd_len;
}
vlc_src_table_t;
// initial quad rows
static vlc_src_table_t tbl0[] = {
{0, 0x1, 0x0, 0x0, 0x0, 0x06, 4},
{0, 0x1, 0x1, 0x1, 0x1, 0x3F, 7},
{0, 0x2, 0x0, 0x0, 0x0, 0x00, 3},
{0, 0x2, 0x1, 0x2, 0x2, 0x7F, 7},
{0, 0x3, 0x0, 0x0, 0x0, 0x11, 5},
{0, 0x3, 0x1, 0x2, 0x2, 0x5F, 7},
{0, 0x3, 0x1, 0x3, 0x1, 0x1F, 7},
{0, 0x4, 0x0, 0x0, 0x0, 0x02, 3},
{0, 0x4, 0x1, 0x4, 0x4, 0x13, 6},
{0, 0x5, 0x0, 0x0, 0x0, 0x0E, 5},
{0, 0x5, 0x1, 0x4, 0x4, 0x23, 6},
{0, 0x5, 0x1, 0x5, 0x1, 0x0F, 7},
{0, 0x6, 0x0, 0x0, 0x0, 0x03, 6},
{0, 0x6, 0x1, 0x0, 0x0, 0x6F, 7},
{0, 0x7, 0x0, 0x0, 0x0, 0x2F, 7},
{0, 0x7, 0x1, 0x2, 0x2, 0x4F, 7},
{0, 0x7, 0x1, 0x2, 0x0, 0x0D, 6},
{0, 0x8, 0x0, 0x0, 0x0, 0x04, 3},
{0, 0x8, 0x1, 0x8, 0x8, 0x3D, 6},
{0, 0x9, 0x0, 0x0, 0x0, 0x1D, 6},
{0, 0x9, 0x1, 0x0, 0x0, 0x2D, 6},
{0, 0xA, 0x0, 0x0, 0x0, 0x01, 5},
{0, 0xA, 0x1, 0x8, 0x8, 0x35, 6},
{0, 0xA, 0x1, 0xA, 0x2, 0x77, 7},
{0, 0xB, 0x0, 0x0, 0x0, 0x37, 7},
{0, 0xB, 0x1, 0x1, 0x1, 0x57, 7},
{0, 0xB, 0x1, 0x1, 0x0, 0x09, 6},
{0, 0xC, 0x0, 0x0, 0x0, 0x1E, 5},
{0, 0xC, 0x1, 0xC, 0xC, 0x17, 7},
{0, 0xC, 0x1, 0xC, 0x4, 0x15, 6},
{0, 0xC, 0x1, 0xC, 0x8, 0x25, 6},
{0, 0xD, 0x0, 0x0, 0x0, 0x67, 7},
{0, 0xD, 0x1, 0x1, 0x1, 0x27, 7},
{0, 0xD, 0x1, 0x5, 0x4, 0x47, 7},
{0, 0xD, 0x1, 0xD, 0x8, 0x07, 7},
{0, 0xE, 0x0, 0x0, 0x0, 0x7B, 7},
{0, 0xE, 0x1, 0x2, 0x2, 0x4B, 7},
{0, 0xE, 0x1, 0xA, 0x8, 0x05, 6},
{0, 0xE, 0x1, 0xE, 0x4, 0x3B, 7},
{0, 0xF, 0x0, 0x0, 0x0, 0x5B, 7},
{0, 0xF, 0x1, 0x9, 0x9, 0x1B, 7},
{0, 0xF, 0x1, 0xB, 0xA, 0x6B, 7},
{0, 0xF, 0x1, 0xF, 0xC, 0x2B, 7},
{0, 0xF, 0x1, 0xF, 0x8, 0x39, 6},
{0, 0xF, 0x1, 0xE, 0x6, 0x73, 7},
{0, 0xF, 0x1, 0xE, 0x2, 0x19, 6},
{0, 0xF, 0x1, 0xF, 0x5, 0x0B, 7},
{0, 0xF, 0x1, 0xF, 0x4, 0x29, 6},
{0, 0xF, 0x1, 0xF, 0x1, 0x33, 7},
{1, 0x0, 0x0, 0x0, 0x0, 0x00, 2},
{1, 0x1, 0x0, 0x0, 0x0, 0x0E, 4},
{1, 0x1, 0x1, 0x1, 0x1, 0x1F, 7},
{1, 0x2, 0x0, 0x0, 0x0, 0x06, 4},
{1, 0x2, 0x1, 0x2, 0x2, 0x3B, 6},
{1, 0x3, 0x0, 0x0, 0x0, 0x1B, 6},
{1, 0x3, 0x1, 0x0, 0x0, 0x3D, 6},
{1, 0x4, 0x0, 0x0, 0x0, 0x0A, 4},
{1, 0x4, 0x1, 0x4, 0x4, 0x2B, 6},
{1, 0x5, 0x0, 0x0, 0x0, 0x0B, 6},
{1, 0x5, 0x1, 0x4, 0x4, 0x33, 6},
{1, 0x5, 0x1, 0x5, 0x1, 0x7F, 7},
{1, 0x6, 0x0, 0x0, 0x0, 0x13, 6},
{1, 0x6, 0x1, 0x0, 0x0, 0x23, 6},
{1, 0x7, 0x0, 0x0, 0x0, 0x3F, 7},
{1, 0x7, 0x1, 0x2, 0x2, 0x5F, 7},
{1, 0x7, 0x1, 0x2, 0x0, 0x03, 6},
{1, 0x8, 0x0, 0x0, 0x0, 0x02, 4},
{1, 0x8, 0x1, 0x8, 0x8, 0x1D, 6},
{1, 0x9, 0x0, 0x0, 0x0, 0x2D, 6},
{1, 0x9, 0x1, 0x0, 0x0, 0x0D, 6},
{1, 0xA, 0x0, 0x0, 0x0, 0x35, 6},
{1, 0xA, 0x1, 0x8, 0x8, 0x15, 6},
{1, 0xA, 0x1, 0xA, 0x2, 0x6F, 7},
{1, 0xB, 0x0, 0x0, 0x0, 0x2F, 7},
{1, 0xB, 0x1, 0x1, 0x1, 0x4F, 7},
{1, 0xB, 0x1, 0x1, 0x0, 0x11, 6},
{1, 0xC, 0x0, 0x0, 0x0, 0x01, 5},
{1, 0xC, 0x1, 0x8, 0x8, 0x25, 6},
{1, 0xC, 0x1, 0xC, 0x4, 0x05, 6},
{1, 0xD, 0x0, 0x0, 0x0, 0x0F, 7},
{1, 0xD, 0x1, 0x1, 0x1, 0x17, 7},
{1, 0xD, 0x1, 0x5, 0x4, 0x39, 6},
{1, 0xD, 0x1, 0xD, 0x8, 0x77, 7},
{1, 0xE, 0x0, 0x0, 0x0, 0x37, 7},
{1, 0xE, 0x1, 0x2, 0x2, 0x57, 7},
{1, 0xE, 0x1, 0xA, 0x8, 0x19, 6},
{1, 0xE, 0x1, 0xE, 0x4, 0x67, 7},
{1, 0xF, 0x0, 0x0, 0x0, 0x07, 7},
{1, 0xF, 0x1, 0xB, 0x8, 0x29, 6},
{1, 0xF, 0x1, 0x8, 0x8, 0x27, 7},
{1, 0xF, 0x1, 0xA, 0x2, 0x09, 6},
{1, 0xF, 0x1, 0xE, 0x4, 0x31, 6},
{1, 0xF, 0x1, 0xF, 0x1, 0x47, 7},
{2, 0x0, 0x0, 0x0, 0x0, 0x00, 2},
{2, 0x1, 0x0, 0x0, 0x0, 0x0E, 4},
{2, 0x1, 0x1, 0x1, 0x1, 0x1B, 6},
{2, 0x2, 0x0, 0x0, 0x0, 0x06, 4},
{2, 0x2, 0x1, 0x2, 0x2, 0x3F, 7},
{2, 0x3, 0x0, 0x0, 0x0, 0x2B, 6},
{2, 0x3, 0x1, 0x1, 0x1, 0x33, 6},
{2, 0x3, 0x1, 0x3, 0x2, 0x7F, 7},
{2, 0x4, 0x0, 0x0, 0x0, 0x0A, 4},
{2, 0x4, 0x1, 0x4, 0x4, 0x0B, 6},
{2, 0x5, 0x0, 0x0, 0x0, 0x01, 5},
{2, 0x5, 0x1, 0x5, 0x5, 0x2F, 7},
{2, 0x5, 0x1, 0x5, 0x1, 0x13, 6},
{2, 0x5, 0x1, 0x5, 0x4, 0x23, 6},
{2, 0x6, 0x0, 0x0, 0x0, 0x03, 6},
{2, 0x6, 0x1, 0x0, 0x0, 0x5F, 7},
{2, 0x7, 0x0, 0x0, 0x0, 0x1F, 7},
{2, 0x7, 0x1, 0x2, 0x2, 0x6F, 7},
{2, 0x7, 0x1, 0x3, 0x1, 0x11, 6},
{2, 0x7, 0x1, 0x7, 0x4, 0x37, 7},
{2, 0x8, 0x0, 0x0, 0x0, 0x02, 4},
{2, 0x8, 0x1, 0x8, 0x8, 0x4F, 7},
{2, 0x9, 0x0, 0x0, 0x0, 0x3D, 6},
{2, 0x9, 0x1, 0x0, 0x0, 0x1D, 6},
{2, 0xA, 0x0, 0x0, 0x0, 0x2D, 6},
{2, 0xA, 0x1, 0x0, 0x0, 0x0D, 6},
{2, 0xB, 0x0, 0x0, 0x0, 0x0F, 7},
{2, 0xB, 0x1, 0x2, 0x2, 0x77, 7},
{2, 0xB, 0x1, 0x2, 0x0, 0x35, 6},
{2, 0xC, 0x0, 0x0, 0x0, 0x15, 6},
{2, 0xC, 0x1, 0x4, 0x4, 0x25, 6},
{2, 0xC, 0x1, 0xC, 0x8, 0x57, 7},
{2, 0xD, 0x0, 0x0, 0x0, 0x17, 7},
{2, 0xD, 0x1, 0x8, 0x8, 0x05, 6},
{2, 0xD, 0x1, 0xC, 0x4, 0x39, 6},
{2, 0xD, 0x1, 0xD, 0x1, 0x67, 7},
{2, 0xE, 0x0, 0x0, 0x0, 0x27, 7},
{2, 0xE, 0x1, 0x2, 0x2, 0x7B, 7},
{2, 0xE, 0x1, 0x2, 0x0, 0x19, 6},
{2, 0xF, 0x0, 0x0, 0x0, 0x47, 7},
{2, 0xF, 0x1, 0xF, 0x1, 0x29, 6},
{2, 0xF, 0x1, 0x1, 0x1, 0x09, 6},
{2, 0xF, 0x1, 0x3, 0x2, 0x07, 7},
{2, 0xF, 0x1, 0x7, 0x4, 0x31, 6},
{2, 0xF, 0x1, 0xF, 0x8, 0x3B, 7},
{3, 0x0, 0x0, 0x0, 0x0, 0x00, 3},
{3, 0x1, 0x0, 0x0, 0x0, 0x04, 4},
{3, 0x1, 0x1, 0x1, 0x1, 0x3D, 6},
{3, 0x2, 0x0, 0x0, 0x0, 0x0C, 5},
{3, 0x2, 0x1, 0x2, 0x2, 0x4F, 7},
{3, 0x3, 0x0, 0x0, 0x0, 0x1D, 6},
{3, 0x3, 0x1, 0x1, 0x1, 0x05, 6},
{3, 0x3, 0x1, 0x3, 0x2, 0x7F, 7},
{3, 0x4, 0x0, 0x0, 0x0, 0x16, 5},
{3, 0x4, 0x1, 0x4, 0x4, 0x2D, 6},
{3, 0x5, 0x0, 0x0, 0x0, 0x06, 5},
{3, 0x5, 0x1, 0x5, 0x5, 0x1A, 5},
{3, 0x5, 0x1, 0x5, 0x1, 0x0D, 6},
{3, 0x5, 0x1, 0x5, 0x4, 0x35, 6},
{3, 0x6, 0x0, 0x0, 0x0, 0x3F, 7},
{3, 0x6, 0x1, 0x4, 0x4, 0x5F, 7},
{3, 0x6, 0x1, 0x6, 0x2, 0x1F, 7},
{3, 0x7, 0x0, 0x0, 0x0, 0x6F, 7},
{3, 0x7, 0x1, 0x6, 0x6, 0x2F, 7},
{3, 0x7, 0x1, 0x6, 0x4, 0x15, 6},
{3, 0x7, 0x1, 0x7, 0x3, 0x77, 7},
{3, 0x7, 0x1, 0x7, 0x1, 0x25, 6},
{3, 0x7, 0x1, 0x7, 0x2, 0x0F, 7},
{3, 0x8, 0x0, 0x0, 0x0, 0x0A, 5},
{3, 0x8, 0x1, 0x8, 0x8, 0x07, 7},
{3, 0x9, 0x0, 0x0, 0x0, 0x39, 6},
{3, 0x9, 0x1, 0x1, 0x1, 0x37, 7},
{3, 0x9, 0x1, 0x9, 0x8, 0x57, 7},
{3, 0xA, 0x0, 0x0, 0x0, 0x19, 6},
{3, 0xA, 0x1, 0x8, 0x8, 0x29, 6},
{3, 0xA, 0x1, 0xA, 0x2, 0x17, 7},
{3, 0xB, 0x0, 0x0, 0x0, 0x67, 7},
{3, 0xB, 0x1, 0xB, 0x1, 0x27, 7},
{3, 0xB, 0x1, 0x1, 0x1, 0x47, 7},
{3, 0xB, 0x1, 0x3, 0x2, 0x09, 6},
{3, 0xB, 0x1, 0xB, 0x8, 0x7B, 7},
{3, 0xC, 0x0, 0x0, 0x0, 0x31, 6},
{3, 0xC, 0x1, 0x4, 0x4, 0x11, 6},
{3, 0xC, 0x1, 0xC, 0x8, 0x3B, 7},
{3, 0xD, 0x0, 0x0, 0x0, 0x5B, 7},
{3, 0xD, 0x1, 0x9, 0x9, 0x1B, 7},
{3, 0xD, 0x1, 0xD, 0x5, 0x2B, 7},
{3, 0xD, 0x1, 0xD, 0x1, 0x21, 6},
{3, 0xD, 0x1, 0xD, 0xC, 0x6B, 7},
{3, 0xD, 0x1, 0xD, 0x4, 0x01, 6},
{3, 0xD, 0x1, 0xD, 0x8, 0x4B, 7},
{3, 0xE, 0x0, 0x0, 0x0, 0x0B, 7},
{3, 0xE, 0x1, 0xE, 0x4, 0x73, 7},
{3, 0xE, 0x1, 0x4, 0x4, 0x13, 7},
{3, 0xE, 0x1, 0xC, 0x8, 0x3E, 6},
{3, 0xE, 0x1, 0xE, 0x2, 0x33, 7},
{3, 0xF, 0x0, 0x0, 0x0, 0x53, 7},
{3, 0xF, 0x1, 0xA, 0xA, 0x0E, 6},
{3, 0xF, 0x1, 0xB, 0x9, 0x63, 7},
{3, 0xF, 0x1, 0xF, 0xC, 0x03, 7},
{3, 0xF, 0x1, 0xF, 0x8, 0x12, 5},
{3, 0xF, 0x1, 0xE, 0x6, 0x23, 7},
{3, 0xF, 0x1, 0xF, 0x5, 0x1E, 6},
{3, 0xF, 0x1, 0xF, 0x4, 0x02, 5},
{3, 0xF, 0x1, 0xF, 0x3, 0x43, 7},
{3, 0xF, 0x1, 0xF, 0x1, 0x1C, 5},
{3, 0xF, 0x1, 0xF, 0x2, 0x2E, 6},
{4, 0x0, 0x0, 0x0, 0x0, 0x00, 2},
{4, 0x1, 0x0, 0x0, 0x0, 0x0E, 4},
{4, 0x1, 0x1, 0x1, 0x1, 0x3F, 7},
{4, 0x2, 0x0, 0x0, 0x0, 0x06, 4},
{4, 0x2, 0x1, 0x2, 0x2, 0x1B, 6},
{4, 0x3, 0x0, 0x0, 0x0, 0x2B, 6},
{4, 0x3, 0x1, 0x2, 0x2, 0x3D, 6},
{4, 0x3, 0x1, 0x3, 0x1, 0x7F, 7},
{4, 0x4, 0x0, 0x0, 0x0, 0x0A, 4},
{4, 0x4, 0x1, 0x4, 0x4, 0x5F, 7},
{4, 0x5, 0x0, 0x0, 0x0, 0x0B, 6},
{4, 0x5, 0x1, 0x0, 0x0, 0x33, 6},
{4, 0x6, 0x0, 0x0, 0x0, 0x13, 6},
{4, 0x6, 0x1, 0x0, 0x0, 0x23, 6},
{4, 0x7, 0x0, 0x0, 0x0, 0x1F, 7},
{4, 0x7, 0x1, 0x4, 0x4, 0x6F, 7},
{4, 0x7, 0x1, 0x4, 0x0, 0x03, 6},
{4, 0x8, 0x0, 0x0, 0x0, 0x02, 4},
{4, 0x8, 0x1, 0x8, 0x8, 0x1D, 6},
{4, 0x9, 0x0, 0x0, 0x0, 0x11, 6},
{4, 0x9, 0x1, 0x0, 0x0, 0x77, 7},
{4, 0xA, 0x0, 0x0, 0x0, 0x01, 5},
{4, 0xA, 0x1, 0xA, 0xA, 0x2F, 7},
{4, 0xA, 0x1, 0xA, 0x2, 0x2D, 6},
{4, 0xA, 0x1, 0xA, 0x8, 0x0D, 6},
{4, 0xB, 0x0, 0x0, 0x0, 0x4F, 7},
{4, 0xB, 0x1, 0xB, 0x2, 0x0F, 7},
{4, 0xB, 0x1, 0x0, 0x0, 0x35, 6},
{4, 0xC, 0x0, 0x0, 0x0, 0x15, 6},
{4, 0xC, 0x1, 0x8, 0x8, 0x25, 6},
{4, 0xC, 0x1, 0xC, 0x4, 0x37, 7},
{4, 0xD, 0x0, 0x0, 0x0, 0x57, 7},
{4, 0xD, 0x1, 0x1, 0x1, 0x07, 7},
{4, 0xD, 0x1, 0x1, 0x0, 0x05, 6},
{4, 0xE, 0x0, 0x0, 0x0, 0x17, 7},
{4, 0xE, 0x1, 0x4, 0x4, 0x39, 6},
{4, 0xE, 0x1, 0xC, 0x8, 0x19, 6},
{4, 0xE, 0x1, 0xE, 0x2, 0x67, 7},
{4, 0xF, 0x0, 0x0, 0x0, 0x27, 7},
{4, 0xF, 0x1, 0x9, 0x9, 0x47, 7},
{4, 0xF, 0x1, 0x9, 0x1, 0x29, 6},
{4, 0xF, 0x1, 0x7, 0x6, 0x7B, 7},
{4, 0xF, 0x1, 0x7, 0x2, 0x09, 6},
{4, 0xF, 0x1, 0xB, 0x8, 0x31, 6},
{4, 0xF, 0x1, 0xF, 0x4, 0x3B, 7},
{5, 0x0, 0x0, 0x0, 0x0, 0x00, 3},
{5, 0x1, 0x0, 0x0, 0x0, 0x1A, 5},
{5, 0x1, 0x1, 0x1, 0x1, 0x7F, 7},
{5, 0x2, 0x0, 0x0, 0x0, 0x0A, 5},
{5, 0x2, 0x1, 0x2, 0x2, 0x1D, 6},
{5, 0x3, 0x0, 0x0, 0x0, 0x2D, 6},
{5, 0x3, 0x1, 0x3, 0x3, 0x5F, 7},
{5, 0x3, 0x1, 0x3, 0x2, 0x39, 6},
{5, 0x3, 0x1, 0x3, 0x1, 0x3F, 7},
{5, 0x4, 0x0, 0x0, 0x0, 0x12, 5},
{5, 0x4, 0x1, 0x4, 0x4, 0x1F, 7},
{5, 0x5, 0x0, 0x0, 0x0, 0x0D, 6},
{5, 0x5, 0x1, 0x4, 0x4, 0x35, 6},
{5, 0x5, 0x1, 0x5, 0x1, 0x6F, 7},
{5, 0x6, 0x0, 0x0, 0x0, 0x15, 6},
{5, 0x6, 0x1, 0x2, 0x2, 0x25, 6},
{5, 0x6, 0x1, 0x6, 0x4, 0x2F, 7},
{5, 0x7, 0x0, 0x0, 0x0, 0x4F, 7},
{5, 0x7, 0x1, 0x6, 0x6, 0x57, 7},
{5, 0x7, 0x1, 0x6, 0x4, 0x05, 6},
{5, 0x7, 0x1, 0x7, 0x3, 0x0F, 7},
{5, 0x7, 0x1, 0x7, 0x2, 0x77, 7},
{5, 0x7, 0x1, 0x7, 0x1, 0x37, 7},
{5, 0x8, 0x0, 0x0, 0x0, 0x02, 5},
{5, 0x8, 0x1, 0x8, 0x8, 0x19, 6},
{5, 0x9, 0x0, 0x0, 0x0, 0x26, 6},
{5, 0x9, 0x1, 0x8, 0x8, 0x17, 7},
{5, 0x9, 0x1, 0x9, 0x1, 0x67, 7},
{5, 0xA, 0x0, 0x0, 0x0, 0x1C, 5},
{5, 0xA, 0x1, 0xA, 0xA, 0x29, 6},
{5, 0xA, 0x1, 0xA, 0x2, 0x09, 6},
{5, 0xA, 0x1, 0xA, 0x8, 0x31, 6},
{5, 0xB, 0x0, 0x0, 0x0, 0x27, 7},
{5, 0xB, 0x1, 0x9, 0x9, 0x07, 7},
{5, 0xB, 0x1, 0x9, 0x8, 0x11, 6},
{5, 0xB, 0x1, 0xB, 0x3, 0x47, 7},
{5, 0xB, 0x1, 0xB, 0x2, 0x21, 6},
{5, 0xB, 0x1, 0xB, 0x1, 0x7B, 7},
{5, 0xC, 0x0, 0x0, 0x0, 0x01, 6},
{5, 0xC, 0x1, 0x8, 0x8, 0x3E, 6},
{5, 0xC, 0x1, 0xC, 0x4, 0x3B, 7},
{5, 0xD, 0x0, 0x0, 0x0, 0x5B, 7},
{5, 0xD, 0x1, 0x9, 0x9, 0x6B, 7},
{5, 0xD, 0x1, 0x9, 0x8, 0x1E, 6},
{5, 0xD, 0x1, 0xD, 0x5, 0x1B, 7},
{5, 0xD, 0x1, 0xD, 0x4, 0x2E, 6},
{5, 0xD, 0x1, 0xD, 0x1, 0x2B, 7},
{5, 0xE, 0x0, 0x0, 0x0, 0x4B, 7},
{5, 0xE, 0x1, 0x6, 0x6, 0x0B, 7},
{5, 0xE, 0x1, 0xE, 0xA, 0x33, 7},
{5, 0xE, 0x1, 0xE, 0x2, 0x0E, 6},
{5, 0xE, 0x1, 0xE, 0xC, 0x73, 7},
{5, 0xE, 0x1, 0xE, 0x8, 0x36, 6},
{5, 0xE, 0x1, 0xE, 0x4, 0x53, 7},
{5, 0xF, 0x0, 0x0, 0x0, 0x13, 7},
{5, 0xF, 0x1, 0x7, 0x7, 0x43, 7},
{5, 0xF, 0x1, 0x7, 0x6, 0x16, 6},
{5, 0xF, 0x1, 0x7, 0x5, 0x63, 7},
{5, 0xF, 0x1, 0xF, 0xC, 0x23, 7},
{5, 0xF, 0x1, 0xF, 0x4, 0x0C, 5},
{5, 0xF, 0x1, 0xD, 0x9, 0x03, 7},
{5, 0xF, 0x1, 0xF, 0xA, 0x3D, 7},
{5, 0xF, 0x1, 0xF, 0x8, 0x14, 5},
{5, 0xF, 0x1, 0xF, 0x3, 0x7D, 7},
{5, 0xF, 0x1, 0xF, 0x2, 0x04, 5},
{5, 0xF, 0x1, 0xF, 0x1, 0x06, 6},
{6, 0x0, 0x0, 0x0, 0x0, 0x00, 3},
{6, 0x1, 0x0, 0x0, 0x0, 0x04, 4},
{6, 0x1, 0x1, 0x1, 0x1, 0x03, 6},
{6, 0x2, 0x0, 0x0, 0x0, 0x0C, 5},
{6, 0x2, 0x1, 0x2, 0x2, 0x0D, 6},
{6, 0x3, 0x0, 0x0, 0x0, 0x1A, 5},
{6, 0x3, 0x1, 0x3, 0x3, 0x3D, 6},
{6, 0x3, 0x1, 0x3, 0x1, 0x1D, 6},
{6, 0x3, 0x1, 0x3, 0x2, 0x2D, 6},
{6, 0x4, 0x0, 0x0, 0x0, 0x0A, 5},
{6, 0x4, 0x1, 0x4, 0x4, 0x3F, 7},
{6, 0x5, 0x0, 0x0, 0x0, 0x35, 6},
{6, 0x5, 0x1, 0x1, 0x1, 0x15, 6},
{6, 0x5, 0x1, 0x5, 0x4, 0x7F, 7},
{6, 0x6, 0x0, 0x0, 0x0, 0x25, 6},
{6, 0x6, 0x1, 0x2, 0x2, 0x5F, 7},
{6, 0x6, 0x1, 0x6, 0x4, 0x1F, 7},
{6, 0x7, 0x0, 0x0, 0x0, 0x6F, 7},
{6, 0x7, 0x1, 0x6, 0x6, 0x4F, 7},
{6, 0x7, 0x1, 0x6, 0x4, 0x05, 6},
{6, 0x7, 0x1, 0x7, 0x3, 0x2F, 7},
{6, 0x7, 0x1, 0x7, 0x1, 0x36, 6},
{6, 0x7, 0x1, 0x7, 0x2, 0x77, 7},
{6, 0x8, 0x0, 0x0, 0x0, 0x12, 5},
{6, 0x8, 0x1, 0x8, 0x8, 0x0F, 7},
{6, 0x9, 0x0, 0x0, 0x0, 0x39, 6},
{6, 0x9, 0x1, 0x1, 0x1, 0x37, 7},
{6, 0x9, 0x1, 0x9, 0x8, 0x57, 7},
{6, 0xA, 0x0, 0x0, 0x0, 0x19, 6},
{6, 0xA, 0x1, 0x2, 0x2, 0x29, 6},
{6, 0xA, 0x1, 0xA, 0x8, 0x17, 7},
{6, 0xB, 0x0, 0x0, 0x0, 0x67, 7},
{6, 0xB, 0x1, 0x9, 0x9, 0x47, 7},
{6, 0xB, 0x1, 0x9, 0x1, 0x09, 6},
{6, 0xB, 0x1, 0xB, 0xA, 0x27, 7},
{6, 0xB, 0x1, 0xB, 0x2, 0x31, 6},
{6, 0xB, 0x1, 0xB, 0x8, 0x7B, 7},
{6, 0xC, 0x0, 0x0, 0x0, 0x11, 6},
{6, 0xC, 0x1, 0xC, 0xC, 0x07, 7},
{6, 0xC, 0x1, 0xC, 0x8, 0x21, 6},
{6, 0xC, 0x1, 0xC, 0x4, 0x3B, 7},
{6, 0xD, 0x0, 0x0, 0x0, 0x5B, 7},
{6, 0xD, 0x1, 0x5, 0x5, 0x33, 7},
{6, 0xD, 0x1, 0x5, 0x4, 0x01, 6},
{6, 0xD, 0x1, 0xC, 0x8, 0x1B, 7},
{6, 0xD, 0x1, 0xD, 0x1, 0x6B, 7},
{6, 0xE, 0x0, 0x0, 0x0, 0x2B, 7},
{6, 0xE, 0x1, 0xE, 0x2, 0x4B, 7},
{6, 0xE, 0x1, 0x2, 0x2, 0x0B, 7},
{6, 0xE, 0x1, 0xE, 0xC, 0x73, 7},
{6, 0xE, 0x1, 0xE, 0x8, 0x3E, 6},
{6, 0xE, 0x1, 0xE, 0x4, 0x53, 7},
{6, 0xF, 0x0, 0x0, 0x0, 0x13, 7},
{6, 0xF, 0x1, 0x6, 0x6, 0x1E, 6},
{6, 0xF, 0x1, 0xE, 0xA, 0x2E, 6},
{6, 0xF, 0x1, 0xF, 0x3, 0x0E, 6},
{6, 0xF, 0x1, 0xF, 0x2, 0x02, 5},
{6, 0xF, 0x1, 0xB, 0x9, 0x63, 7},
{6, 0xF, 0x1, 0xF, 0xC, 0x16, 6},
{6, 0xF, 0x1, 0xF, 0x8, 0x06, 6},
{6, 0xF, 0x1, 0xF, 0x5, 0x23, 7},
{6, 0xF, 0x1, 0xF, 0x1, 0x1C, 5},
{6, 0xF, 0x1, 0xF, 0x4, 0x26, 6},
{7, 0x0, 0x0, 0x0, 0x0, 0x12, 5},
{7, 0x1, 0x0, 0x0, 0x0, 0x05, 6},
{7, 0x1, 0x1, 0x1, 0x1, 0x7F, 7},
{7, 0x2, 0x0, 0x0, 0x0, 0x39, 6},
{7, 0x2, 0x1, 0x2, 0x2, 0x3F, 7},
{7, 0x3, 0x0, 0x0, 0x0, 0x5F, 7},
{7, 0x3, 0x1, 0x3, 0x3, 0x1F, 7},
{7, 0x3, 0x1, 0x3, 0x2, 0x6F, 7},
{7, 0x3, 0x1, 0x3, 0x1, 0x2F, 7},
{7, 0x4, 0x0, 0x0, 0x0, 0x4F, 7},
{7, 0x4, 0x1, 0x4, 0x4, 0x0F, 7},
{7, 0x5, 0x0, 0x0, 0x0, 0x57, 7},
{7, 0x5, 0x1, 0x1, 0x1, 0x19, 6},
{7, 0x5, 0x1, 0x5, 0x4, 0x77, 7},
{7, 0x6, 0x0, 0x0, 0x0, 0x37, 7},
{7, 0x6, 0x1, 0x0, 0x0, 0x29, 6},
{7, 0x7, 0x0, 0x0, 0x0, 0x17, 7},
{7, 0x7, 0x1, 0x6, 0x6, 0x67, 7},
{7, 0x7, 0x1, 0x7, 0x3, 0x27, 7},
{7, 0x7, 0x1, 0x7, 0x2, 0x47, 7},
{7, 0x7, 0x1, 0x7, 0x5, 0x1B, 7},
{7, 0x7, 0x1, 0x7, 0x1, 0x09, 6},
{7, 0x7, 0x1, 0x7, 0x4, 0x07, 7},
{7, 0x8, 0x0, 0x0, 0x0, 0x7B, 7},
{7, 0x8, 0x1, 0x8, 0x8, 0x3B, 7},
{7, 0x9, 0x0, 0x0, 0x0, 0x5B, 7},
{7, 0x9, 0x1, 0x0, 0x0, 0x31, 6},
{7, 0xA, 0x0, 0x0, 0x0, 0x53, 7},
{7, 0xA, 0x1, 0x2, 0x2, 0x11, 6},
{7, 0xA, 0x1, 0xA, 0x8, 0x6B, 7},
{7, 0xB, 0x0, 0x0, 0x0, 0x2B, 7},
{7, 0xB, 0x1, 0x9, 0x9, 0x4B, 7},
{7, 0xB, 0x1, 0xB, 0x3, 0x0B, 7},
{7, 0xB, 0x1, 0xB, 0x1, 0x73, 7},
{7, 0xB, 0x1, 0xB, 0xA, 0x33, 7},
{7, 0xB, 0x1, 0xB, 0x2, 0x21, 6},
{7, 0xB, 0x1, 0xB, 0x8, 0x13, 7},
{7, 0xC, 0x0, 0x0, 0x0, 0x63, 7},
{7, 0xC, 0x1, 0x8, 0x8, 0x23, 7},
{7, 0xC, 0x1, 0xC, 0x4, 0x43, 7},
{7, 0xD, 0x0, 0x0, 0x0, 0x03, 7},
{7, 0xD, 0x1, 0x9, 0x9, 0x7D, 7},
{7, 0xD, 0x1, 0xD, 0x5, 0x5D, 7},
{7, 0xD, 0x1, 0xD, 0x1, 0x01, 6},
{7, 0xD, 0x1, 0xD, 0xC, 0x3D, 7},
{7, 0xD, 0x1, 0xD, 0x4, 0x3E, 6},
{7, 0xD, 0x1, 0xD, 0x8, 0x1D, 7},
{7, 0xE, 0x0, 0x0, 0x0, 0x6D, 7},
{7, 0xE, 0x1, 0x6, 0x6, 0x2D, 7},
{7, 0xE, 0x1, 0xE, 0xA, 0x0D, 7},
{7, 0xE, 0x1, 0xE, 0x2, 0x1E, 6},
{7, 0xE, 0x1, 0xE, 0xC, 0x4D, 7},
{7, 0xE, 0x1, 0xE, 0x8, 0x0E, 6},
{7, 0xE, 0x1, 0xE, 0x4, 0x75, 7},
{7, 0xF, 0x0, 0x0, 0x0, 0x15, 7},
{7, 0xF, 0x1, 0xF, 0xF, 0x06, 5},
{7, 0xF, 0x1, 0xF, 0xD, 0x35, 7},
{7, 0xF, 0x1, 0xF, 0x7, 0x55, 7},
{7, 0xF, 0x1, 0xF, 0x5, 0x1A, 5},
{7, 0xF, 0x1, 0xF, 0xB, 0x25, 7},
{7, 0xF, 0x1, 0xF, 0x3, 0x0A, 5},
{7, 0xF, 0x1, 0xF, 0x9, 0x2E, 6},
{7, 0xF, 0x1, 0xF, 0x1, 0x00, 4},
{7, 0xF, 0x1, 0xF, 0xE, 0x65, 7},
{7, 0xF, 0x1, 0xF, 0x6, 0x36, 6},
{7, 0xF, 0x1, 0xF, 0xA, 0x02, 5},
{7, 0xF, 0x1, 0xF, 0x2, 0x0C, 4},
{7, 0xF, 0x1, 0xF, 0xC, 0x16, 6},
{7, 0xF, 0x1, 0xF, 0x8, 0x04, 4},
{7, 0xF, 0x1, 0xF, 0x4, 0x08, 4}
};
// nono-initial quad rows
static vlc_src_table_t tbl1[] = {
{0, 0x1, 0x0, 0x0, 0x0, 0x00, 3},
{0, 0x1, 0x1, 0x1, 0x1, 0x27, 6},
{0, 0x2, 0x0, 0x0, 0x0, 0x06, 3},
{0, 0x2, 0x1, 0x2, 0x2, 0x17, 6},
{0, 0x3, 0x0, 0x0, 0x0, 0x0D, 5},
{0, 0x3, 0x1, 0x0, 0x0, 0x3B, 6},
{0, 0x4, 0x0, 0x0, 0x0, 0x02, 3},
{0, 0x4, 0x1, 0x4, 0x4, 0x07, 6},
{0, 0x5, 0x0, 0x0, 0x0, 0x15, 5},
{0, 0x5, 0x1, 0x0, 0x0, 0x2B, 6},
{0, 0x6, 0x0, 0x0, 0x0, 0x01, 5},
{0, 0x6, 0x1, 0x0, 0x0, 0x7F, 7},
{0, 0x7, 0x0, 0x0, 0x0, 0x1F, 7},
{0, 0x7, 0x1, 0x0, 0x0, 0x1B, 6},
{0, 0x8, 0x0, 0x0, 0x0, 0x04, 3},
{0, 0x8, 0x1, 0x8, 0x8, 0x05, 5},
{0, 0x9, 0x0, 0x0, 0x0, 0x19, 5},
{0, 0x9, 0x1, 0x0, 0x0, 0x13, 6},
{0, 0xA, 0x0, 0x0, 0x0, 0x09, 5},
{0, 0xA, 0x1, 0x8, 0x8, 0x0B, 6},
{0, 0xA, 0x1, 0xA, 0x2, 0x3F, 7},
{0, 0xB, 0x0, 0x0, 0x0, 0x5F, 7},
{0, 0xB, 0x1, 0x0, 0x0, 0x33, 6},
{0, 0xC, 0x0, 0x0, 0x0, 0x11, 5},
{0, 0xC, 0x1, 0x8, 0x8, 0x23, 6},
{0, 0xC, 0x1, 0xC, 0x4, 0x6F, 7},
{0, 0xD, 0x0, 0x0, 0x0, 0x0F, 7},
{0, 0xD, 0x1, 0x0, 0x0, 0x03, 6},
{0, 0xE, 0x0, 0x0, 0x0, 0x2F, 7},
{0, 0xE, 0x1, 0x4, 0x4, 0x4F, 7},
{0, 0xE, 0x1, 0x4, 0x0, 0x3D, 6},
{0, 0xF, 0x0, 0x0, 0x0, 0x77, 7},
{0, 0xF, 0x1, 0x1, 0x1, 0x37, 7},
{0, 0xF, 0x1, 0x1, 0x0, 0x1D, 6},
{1, 0x0, 0x0, 0x0, 0x0, 0x00, 1},
{1, 0x1, 0x0, 0x0, 0x0, 0x05, 4},
{1, 0x1, 0x1, 0x1, 0x1, 0x7F, 7},
{1, 0x2, 0x0, 0x0, 0x0, 0x09, 4},
{1, 0x2, 0x1, 0x2, 0x2, 0x1F, 7},
{1, 0x3, 0x0, 0x0, 0x0, 0x1D, 5},
{1, 0x3, 0x1, 0x1, 0x1, 0x3F, 7},
{1, 0x3, 0x1, 0x3, 0x2, 0x5F, 7},
{1, 0x4, 0x0, 0x0, 0x0, 0x0D, 5},
{1, 0x4, 0x1, 0x4, 0x4, 0x37, 7},
{1, 0x5, 0x0, 0x0, 0x0, 0x03, 6},
{1, 0x5, 0x1, 0x0, 0x0, 0x6F, 7},
{1, 0x6, 0x0, 0x0, 0x0, 0x2F, 7},
{1, 0x6, 0x1, 0x0, 0x0, 0x4F, 7},
{1, 0x7, 0x0, 0x0, 0x0, 0x0F, 7},
{1, 0x7, 0x1, 0x0, 0x0, 0x77, 7},
{1, 0x8, 0x0, 0x0, 0x0, 0x01, 4},
{1, 0x8, 0x1, 0x8, 0x8, 0x17, 7},
{1, 0x9, 0x0, 0x0, 0x0, 0x0B, 6},
{1, 0x9, 0x1, 0x0, 0x0, 0x57, 7},
{1, 0xA, 0x0, 0x0, 0x0, 0x33, 6},
{1, 0xA, 0x1, 0x0, 0x0, 0x67, 7},
{1, 0xB, 0x0, 0x0, 0x0, 0x27, 7},
{1, 0xB, 0x1, 0x0, 0x0, 0x2B, 7},
{1, 0xC, 0x0, 0x0, 0x0, 0x13, 6},
{1, 0xC, 0x1, 0x0, 0x0, 0x47, 7},
{1, 0xD, 0x0, 0x0, 0x0, 0x07, 7},
{1, 0xD, 0x1, 0x0, 0x0, 0x7B, 7},
{1, 0xE, 0x0, 0x0, 0x0, 0x3B, 7},
{1, 0xE, 0x1, 0x0, 0x0, 0x5B, 7},
{1, 0xF, 0x0, 0x0, 0x0, 0x1B, 7},
{1, 0xF, 0x1, 0x4, 0x4, 0x6B, 7},
{1, 0xF, 0x1, 0x4, 0x0, 0x23, 6},
{2, 0x0, 0x0, 0x0, 0x0, 0x00, 1},
{2, 0x1, 0x0, 0x0, 0x0, 0x09, 4},
{2, 0x1, 0x1, 0x1, 0x1, 0x7F, 7},
{2, 0x2, 0x0, 0x0, 0x0, 0x01, 4},
{2, 0x2, 0x1, 0x2, 0x2, 0x23, 6},
{2, 0x3, 0x0, 0x0, 0x0, 0x3D, 6},
{2, 0x3, 0x1, 0x2, 0x2, 0x3F, 7},
{2, 0x3, 0x1, 0x3, 0x1, 0x1F, 7},
{2, 0x4, 0x0, 0x0, 0x0, 0x15, 5},
{2, 0x4, 0x1, 0x4, 0x4, 0x5F, 7},
{2, 0x5, 0x0, 0x0, 0x0, 0x03, 6},
{2, 0x5, 0x1, 0x0, 0x0, 0x6F, 7},
{2, 0x6, 0x0, 0x0, 0x0, 0x2F, 7},
{2, 0x6, 0x1, 0x0, 0x0, 0x4F, 7},
{2, 0x7, 0x0, 0x0, 0x0, 0x0F, 7},
{2, 0x7, 0x1, 0x0, 0x0, 0x17, 7},
{2, 0x8, 0x0, 0x0, 0x0, 0x05, 5},
{2, 0x8, 0x1, 0x8, 0x8, 0x77, 7},
{2, 0x9, 0x0, 0x0, 0x0, 0x37, 7},
{2, 0x9, 0x1, 0x0, 0x0, 0x57, 7},
{2, 0xA, 0x0, 0x0, 0x0, 0x1D, 6},
{2, 0xA, 0x1, 0xA, 0xA, 0x7B, 7},
{2, 0xA, 0x1, 0xA, 0x2, 0x2D, 6},
{2, 0xA, 0x1, 0xA, 0x8, 0x67, 7},
{2, 0xB, 0x0, 0x0, 0x0, 0x27, 7},
{2, 0xB, 0x1, 0xB, 0x2, 0x47, 7},
{2, 0xB, 0x1, 0x0, 0x0, 0x07, 7},
{2, 0xC, 0x0, 0x0, 0x0, 0x0D, 6},
{2, 0xC, 0x1, 0x0, 0x0, 0x3B, 7},
{2, 0xD, 0x0, 0x0, 0x0, 0x5B, 7},
{2, 0xD, 0x1, 0x0, 0x0, 0x1B, 7},
{2, 0xE, 0x0, 0x0, 0x0, 0x6B, 7},
{2, 0xE, 0x1, 0x4, 0x4, 0x2B, 7},
{2, 0xE, 0x1, 0x4, 0x0, 0x4B, 7},
{2, 0xF, 0x0, 0x0, 0x0, 0x0B, 7},
{2, 0xF, 0x1, 0x4, 0x4, 0x73, 7},
{2, 0xF, 0x1, 0x5, 0x1, 0x33, 7},
{2, 0xF, 0x1, 0x7, 0x2, 0x53, 7},
{2, 0xF, 0x1, 0xF, 0x8, 0x13, 7},
{3, 0x0, 0x0, 0x0, 0x0, 0x00, 2},
{3, 0x1, 0x0, 0x0, 0x0, 0x0A, 4},
{3, 0x1, 0x1, 0x1, 0x1, 0x0B, 6},
{3, 0x2, 0x0, 0x0, 0x0, 0x02, 4},
{3, 0x2, 0x1, 0x2, 0x2, 0x23, 6},
{3, 0x3, 0x0, 0x0, 0x0, 0x0E, 5},
{3, 0x3, 0x1, 0x3, 0x3, 0x7F, 7},
{3, 0x3, 0x1, 0x3, 0x2, 0x33, 6},
{3, 0x3, 0x1, 0x3, 0x1, 0x13, 6},
{3, 0x4, 0x0, 0x0, 0x0, 0x16, 5},
{3, 0x4, 0x1, 0x4, 0x4, 0x3F, 7},
{3, 0x5, 0x0, 0x0, 0x0, 0x03, 6},
{3, 0x5, 0x1, 0x1, 0x1, 0x3D, 6},
{3, 0x5, 0x1, 0x5, 0x4, 0x1F, 7},
{3, 0x6, 0x0, 0x0, 0x0, 0x1D, 6},
{3, 0x6, 0x1, 0x0, 0x0, 0x5F, 7},
{3, 0x7, 0x0, 0x0, 0x0, 0x2D, 6},
{3, 0x7, 0x1, 0x4, 0x4, 0x2F, 7},
{3, 0x7, 0x1, 0x5, 0x1, 0x1E, 6},
{3, 0x7, 0x1, 0x7, 0x2, 0x6F, 7},
{3, 0x8, 0x0, 0x0, 0x0, 0x06, 5},
{3, 0x8, 0x1, 0x8, 0x8, 0x4F, 7},
{3, 0x9, 0x0, 0x0, 0x0, 0x0D, 6},
{3, 0x9, 0x1, 0x0, 0x0, 0x35, 6},
{3, 0xA, 0x0, 0x0, 0x0, 0x15, 6},
{3, 0xA, 0x1, 0x2, 0x2, 0x25, 6},
{3, 0xA, 0x1, 0xA, 0x8, 0x0F, 7},
{3, 0xB, 0x0, 0x0, 0x0, 0x05, 6},
{3, 0xB, 0x1, 0x8, 0x8, 0x39, 6},
{3, 0xB, 0x1, 0xB, 0x3, 0x17, 7},
{3, 0xB, 0x1, 0xB, 0x2, 0x19, 6},
{3, 0xB, 0x1, 0xB, 0x1, 0x77, 7},
{3, 0xC, 0x0, 0x0, 0x0, 0x29, 6},
{3, 0xC, 0x1, 0x0, 0x0, 0x09, 6},
{3, 0xD, 0x0, 0x0, 0x0, 0x37, 7},
{3, 0xD, 0x1, 0x4, 0x4, 0x57, 7},
{3, 0xD, 0x1, 0x4, 0x0, 0x31, 6},
{3, 0xE, 0x0, 0x0, 0x0, 0x67, 7},
{3, 0xE, 0x1, 0x4, 0x4, 0x27, 7},
{3, 0xE, 0x1, 0xC, 0x8, 0x47, 7},
{3, 0xE, 0x1, 0xE, 0x2, 0x6B, 7},
{3, 0xF, 0x0, 0x0, 0x0, 0x11, 6},
{3, 0xF, 0x1, 0x6, 0x6, 0x07, 7},
{3, 0xF, 0x1, 0x7, 0x3, 0x7B, 7},
{3, 0xF, 0x1, 0xF, 0xA, 0x3B, 7},
{3, 0xF, 0x1, 0xF, 0x2, 0x21, 6},
{3, 0xF, 0x1, 0xF, 0x8, 0x01, 6},
{3, 0xF, 0x1, 0xA, 0x8, 0x5B, 7},
{3, 0xF, 0x1, 0xF, 0x5, 0x1B, 7},
{3, 0xF, 0x1, 0xF, 0x1, 0x3E, 6},
{3, 0xF, 0x1, 0xF, 0x4, 0x2B, 7},
{4, 0x0, 0x0, 0x0, 0x0, 0x00, 1},
{4, 0x1, 0x0, 0x0, 0x0, 0x0D, 5},
{4, 0x1, 0x1, 0x1, 0x1, 0x7F, 7},
{4, 0x2, 0x0, 0x0, 0x0, 0x15, 5},
{4, 0x2, 0x1, 0x2, 0x2, 0x3F, 7},
{4, 0x3, 0x0, 0x0, 0x0, 0x5F, 7},
{4, 0x3, 0x1, 0x0, 0x0, 0x6F, 7},
{4, 0x4, 0x0, 0x0, 0x0, 0x09, 4},
{4, 0x4, 0x1, 0x4, 0x4, 0x23, 6},
{4, 0x5, 0x0, 0x0, 0x0, 0x33, 6},
{4, 0x5, 0x1, 0x0, 0x0, 0x1F, 7},
{4, 0x6, 0x0, 0x0, 0x0, 0x13, 6},
{4, 0x6, 0x1, 0x0, 0x0, 0x2F, 7},
{4, 0x7, 0x0, 0x0, 0x0, 0x4F, 7},
{4, 0x7, 0x1, 0x0, 0x0, 0x57, 7},
{4, 0x8, 0x0, 0x0, 0x0, 0x01, 4},
{4, 0x8, 0x1, 0x8, 0x8, 0x0F, 7},
{4, 0x9, 0x0, 0x0, 0x0, 0x77, 7},
{4, 0x9, 0x1, 0x0, 0x0, 0x37, 7},
{4, 0xA, 0x0, 0x0, 0x0, 0x1D, 6},
{4, 0xA, 0x1, 0x0, 0x0, 0x17, 7},
{4, 0xB, 0x0, 0x0, 0x0, 0x67, 7},
{4, 0xB, 0x1, 0x0, 0x0, 0x6B, 7},
{4, 0xC, 0x0, 0x0, 0x0, 0x05, 5},
{4, 0xC, 0x1, 0xC, 0xC, 0x27, 7},
{4, 0xC, 0x1, 0xC, 0x8, 0x47, 7},
{4, 0xC, 0x1, 0xC, 0x4, 0x07, 7},
{4, 0xD, 0x0, 0x0, 0x0, 0x7B, 7},
{4, 0xD, 0x1, 0x0, 0x0, 0x3B, 7},
{4, 0xE, 0x0, 0x0, 0x0, 0x5B, 7},
{4, 0xE, 0x1, 0x2, 0x2, 0x1B, 7},
{4, 0xE, 0x1, 0x2, 0x0, 0x03, 6},
{4, 0xF, 0x0, 0x0, 0x0, 0x2B, 7},
{4, 0xF, 0x1, 0x1, 0x1, 0x4B, 7},
{4, 0xF, 0x1, 0x3, 0x2, 0x0B, 7},
{4, 0xF, 0x1, 0x3, 0x0, 0x3D, 6},
{5, 0x0, 0x0, 0x0, 0x0, 0x00, 2},
{5, 0x1, 0x0, 0x0, 0x0, 0x1E, 5},
{5, 0x1, 0x1, 0x1, 0x1, 0x3B, 6},
{5, 0x2, 0x0, 0x0, 0x0, 0x0A, 5},
{5, 0x2, 0x1, 0x2, 0x2, 0x3F, 7},
{5, 0x3, 0x0, 0x0, 0x0, 0x1B, 6},
{5, 0x3, 0x1, 0x0, 0x0, 0x0B, 6},
{5, 0x4, 0x0, 0x0, 0x0, 0x02, 4},
{5, 0x4, 0x1, 0x4, 0x4, 0x2B, 6},
{5, 0x5, 0x0, 0x0, 0x0, 0x0E, 5},
{5, 0x5, 0x1, 0x4, 0x4, 0x33, 6},
{5, 0x5, 0x1, 0x5, 0x1, 0x7F, 7},
{5, 0x6, 0x0, 0x0, 0x0, 0x13, 6},
{5, 0x6, 0x1, 0x0, 0x0, 0x6F, 7},
{5, 0x7, 0x0, 0x0, 0x0, 0x23, 6},
{5, 0x7, 0x1, 0x2, 0x2, 0x5F, 7},
{5, 0x7, 0x1, 0x2, 0x0, 0x15, 6},
{5, 0x8, 0x0, 0x0, 0x0, 0x16, 5},
{5, 0x8, 0x1, 0x8, 0x8, 0x03, 6},
{5, 0x9, 0x0, 0x0, 0x0, 0x3D, 6},
{5, 0x9, 0x1, 0x0, 0x0, 0x1F, 7},
{5, 0xA, 0x0, 0x0, 0x0, 0x1D, 6},
{5, 0xA, 0x1, 0x0, 0x0, 0x2D, 6},
{5, 0xB, 0x0, 0x0, 0x0, 0x0D, 6},
{5, 0xB, 0x1, 0x1, 0x1, 0x4F, 7},
{5, 0xB, 0x1, 0x1, 0x0, 0x35, 6},
{5, 0xC, 0x0, 0x0, 0x0, 0x06, 5},
{5, 0xC, 0x1, 0x4, 0x4, 0x25, 6},
{5, 0xC, 0x1, 0xC, 0x8, 0x2F, 7},
{5, 0xD, 0x0, 0x0, 0x0, 0x05, 6},
{5, 0xD, 0x1, 0x1, 0x1, 0x77, 7},
{5, 0xD, 0x1, 0x5, 0x4, 0x39, 6},
{5, 0xD, 0x1, 0xD, 0x8, 0x0F, 7},
{5, 0xE, 0x0, 0x0, 0x0, 0x19, 6},
{5, 0xE, 0x1, 0x2, 0x2, 0x57, 7},
{5, 0xE, 0x1, 0xA, 0x8, 0x01, 6},
{5, 0xE, 0x1, 0xE, 0x4, 0x37, 7},
{5, 0xF, 0x0, 0x0, 0x0, 0x1A, 5},
{5, 0xF, 0x1, 0x9, 0x9, 0x17, 7},
{5, 0xF, 0x1, 0xD, 0x5, 0x67, 7},
{5, 0xF, 0x1, 0xF, 0x3, 0x07, 7},
{5, 0xF, 0x1, 0xF, 0x1, 0x29, 6},
{5, 0xF, 0x1, 0x7, 0x6, 0x27, 7},
{5, 0xF, 0x1, 0xF, 0xC, 0x09, 6},
{5, 0xF, 0x1, 0xF, 0x4, 0x31, 6},
{5, 0xF, 0x1, 0xF, 0xA, 0x47, 7},
{5, 0xF, 0x1, 0xF, 0x8, 0x11, 6},
{5, 0xF, 0x1, 0xF, 0x2, 0x21, 6},
{6, 0x0, 0x0, 0x0, 0x0, 0x00, 3},
{6, 0x1, 0x0, 0x0, 0x0, 0x02, 4},
{6, 0x1, 0x1, 0x1, 0x1, 0x03, 6},
{6, 0x2, 0x0, 0x0, 0x0, 0x0C, 4},
{6, 0x2, 0x1, 0x2, 0x2, 0x3D, 6},
{6, 0x3, 0x0, 0x0, 0x0, 0x1D, 6},
{6, 0x3, 0x1, 0x2, 0x2, 0x0D, 6},
{6, 0x3, 0x1, 0x3, 0x1, 0x7F, 7},
{6, 0x4, 0x0, 0x0, 0x0, 0x04, 4},
{6, 0x4, 0x1, 0x4, 0x4, 0x2D, 6},
{6, 0x5, 0x0, 0x0, 0x0, 0x0A, 5},
{6, 0x5, 0x1, 0x4, 0x4, 0x35, 6},
{6, 0x5, 0x1, 0x5, 0x1, 0x2F, 7},
{6, 0x6, 0x0, 0x0, 0x0, 0x15, 6},
{6, 0x6, 0x1, 0x2, 0x2, 0x3F, 7},
{6, 0x6, 0x1, 0x6, 0x4, 0x5F, 7},
{6, 0x7, 0x0, 0x0, 0x0, 0x25, 6},
{6, 0x7, 0x1, 0x2, 0x2, 0x29, 6},
{6, 0x7, 0x1, 0x3, 0x1, 0x1F, 7},
{6, 0x7, 0x1, 0x7, 0x4, 0x6F, 7},
{6, 0x8, 0x0, 0x0, 0x0, 0x16, 5},
{6, 0x8, 0x1, 0x8, 0x8, 0x05, 6},
{6, 0x9, 0x0, 0x0, 0x0, 0x39, 6},
{6, 0x9, 0x1, 0x0, 0x0, 0x19, 6},
{6, 0xA, 0x0, 0x0, 0x0, 0x06, 5},
{6, 0xA, 0x1, 0xA, 0xA, 0x0F, 7},
{6, 0xA, 0x1, 0xA, 0x2, 0x09, 6},
{6, 0xA, 0x1, 0xA, 0x8, 0x4F, 7},
{6, 0xB, 0x0, 0x0, 0x0, 0x0E, 6},
{6, 0xB, 0x1, 0xB, 0x2, 0x77, 7},
{6, 0xB, 0x1, 0x2, 0x2, 0x37, 7},
{6, 0xB, 0x1, 0xA, 0x8, 0x57, 7},
{6, 0xB, 0x1, 0xB, 0x1, 0x47, 7},
{6, 0xC, 0x0, 0x0, 0x0, 0x1A, 5},
{6, 0xC, 0x1, 0xC, 0xC, 0x17, 7},
{6, 0xC, 0x1, 0xC, 0x8, 0x67, 7},
{6, 0xC, 0x1, 0xC, 0x4, 0x27, 7},
{6, 0xD, 0x0, 0x0, 0x0, 0x31, 6},
{6, 0xD, 0x1, 0xD, 0x4, 0x07, 7},
{6, 0xD, 0x1, 0x4, 0x4, 0x7B, 7},
{6, 0xD, 0x1, 0xC, 0x8, 0x3B, 7},
{6, 0xD, 0x1, 0xD, 0x1, 0x2B, 7},
{6, 0xE, 0x0, 0x0, 0x0, 0x11, 6},
{6, 0xE, 0x1, 0xE, 0x4, 0x5B, 7},
{6, 0xE, 0x1, 0x4, 0x4, 0x1B, 7},
{6, 0xE, 0x1, 0xE, 0xA, 0x6B, 7},
{6, 0xE, 0x1, 0xE, 0x8, 0x21, 6},
{6, 0xE, 0x1, 0xE, 0x2, 0x33, 7},
{6, 0xF, 0x0, 0x0, 0x0, 0x01, 6},
{6, 0xF, 0x1, 0x3, 0x3, 0x4B, 7},
{6, 0xF, 0x1, 0x7, 0x6, 0x0B, 7},
{6, 0xF, 0x1, 0xF, 0xA, 0x73, 7},
{6, 0xF, 0x1, 0xF, 0x2, 0x3E, 6},
{6, 0xF, 0x1, 0xB, 0x9, 0x53, 7},
{6, 0xF, 0x1, 0xF, 0xC, 0x63, 7},
{6, 0xF, 0x1, 0xF, 0x8, 0x1E, 6},
{6, 0xF, 0x1, 0xF, 0x5, 0x13, 7},
{6, 0xF, 0x1, 0xF, 0x4, 0x2E, 6},
{6, 0xF, 0x1, 0xF, 0x1, 0x23, 7},
{7, 0x0, 0x0, 0x0, 0x0, 0x04, 4},
{7, 0x1, 0x0, 0x0, 0x0, 0x33, 6},
{7, 0x1, 0x1, 0x1, 0x1, 0x13, 6},
{7, 0x2, 0x0, 0x0, 0x0, 0x23, 6},
{7, 0x2, 0x1, 0x2, 0x2, 0x7F, 7},
{7, 0x3, 0x0, 0x0, 0x0, 0x03, 6},
{7, 0x3, 0x1, 0x1, 0x1, 0x3F, 7},
{7, 0x3, 0x1, 0x3, 0x2, 0x6F, 7},
{7, 0x4, 0x0, 0x0, 0x0, 0x2D, 6},
{7, 0x4, 0x1, 0x4, 0x4, 0x5F, 7},
{7, 0x5, 0x0, 0x0, 0x0, 0x16, 5},
{7, 0x5, 0x1, 0x1, 0x1, 0x3D, 6},
{7, 0x5, 0x1, 0x5, 0x4, 0x1F, 7},
{7, 0x6, 0x0, 0x0, 0x0, 0x1D, 6},
{7, 0x6, 0x1, 0x0, 0x0, 0x77, 7},
{7, 0x7, 0x0, 0x0, 0x0, 0x06, 5},
{7, 0x7, 0x1, 0x7, 0x4, 0x2F, 7},
{7, 0x7, 0x1, 0x4, 0x4, 0x4F, 7},
{7, 0x7, 0x1, 0x7, 0x3, 0x0F, 7},
{7, 0x7, 0x1, 0x7, 0x1, 0x0D, 6},
{7, 0x7, 0x1, 0x7, 0x2, 0x57, 7},
{7, 0x8, 0x0, 0x0, 0x0, 0x35, 6},
{7, 0x8, 0x1, 0x8, 0x8, 0x37, 7},
{7, 0x9, 0x0, 0x0, 0x0, 0x15, 6},
{7, 0x9, 0x1, 0x0, 0x0, 0x27, 7},
{7, 0xA, 0x0, 0x0, 0x0, 0x25, 6},
{7, 0xA, 0x1, 0x0, 0x0, 0x29, 6},
{7, 0xB, 0x0, 0x0, 0x0, 0x1A, 5},
{7, 0xB, 0x1, 0xB, 0x1, 0x17, 7},
{7, 0xB, 0x1, 0x1, 0x1, 0x67, 7},
{7, 0xB, 0x1, 0x3, 0x2, 0x05, 6},
{7, 0xB, 0x1, 0xB, 0x8, 0x7B, 7},
{7, 0xC, 0x0, 0x0, 0x0, 0x39, 6},
{7, 0xC, 0x1, 0x0, 0x0, 0x19, 6},
{7, 0xD, 0x0, 0x0, 0x0, 0x0C, 5},
{7, 0xD, 0x1, 0xD, 0x1, 0x47, 7},
{7, 0xD, 0x1, 0x1, 0x1, 0x07, 7},
{7, 0xD, 0x1, 0x5, 0x4, 0x09, 6},
{7, 0xD, 0x1, 0xD, 0x8, 0x1B, 7},
{7, 0xE, 0x0, 0x0, 0x0, 0x31, 6},
{7, 0xE, 0x1, 0xE, 0x2, 0x3B, 7},
{7, 0xE, 0x1, 0x2, 0x2, 0x5B, 7},
{7, 0xE, 0x1, 0xA, 0x8, 0x3E, 6},
{7, 0xE, 0x1, 0xE, 0x4, 0x0B, 7},
{7, 0xF, 0x0, 0x0, 0x0, 0x00, 3},
{7, 0xF, 0x1, 0xF, 0xF, 0x6B, 7},
{7, 0xF, 0x1, 0xF, 0x7, 0x2B, 7},
{7, 0xF, 0x1, 0xF, 0xB, 0x4B, 7},
{7, 0xF, 0x1, 0xF, 0x3, 0x11, 6},
{7, 0xF, 0x1, 0x7, 0x6, 0x21, 6},
{7, 0xF, 0x1, 0xF, 0xA, 0x01, 6},
{7, 0xF, 0x1, 0xF, 0x2, 0x0A, 5},
{7, 0xF, 0x1, 0xB, 0x9, 0x1E, 6},
{7, 0xF, 0x1, 0xF, 0xC, 0x0E, 6},
{7, 0xF, 0x1, 0xF, 0x8, 0x12, 5},
{7, 0xF, 0x1, 0xF, 0x5, 0x2E, 6},
{7, 0xF, 0x1, 0xF, 0x1, 0x02, 5},
{7, 0xF, 0x1, 0xF, 0x4, 0x1C, 5}
};
//************************************************************************/
/** @defgroup vlc_decoding_tables_grp VLC decoding tables
* @{
* VLC tables to decode VLC codewords to these fields: (in order) \n
* \li \c cwd_len : 3bits -> the codeword length of the VLC codeword;
* the VLC cwd is in the LSB of bitstream \n
* \li \c u_off : 1bit -> u_offset, which is 1 if u value is not 0 \n
* \li \c rho : 4bits -> significant samples within a quad \n
* \li \c e_1 : 4bits -> EMB e_1 \n
* \li \c e_k : 4bits -> EMB e_k \n
* \n
* The table index is 10 bits and composed of two parts: \n
* The 7 LSBs contain a codeword which might be shorter than 7 bits;
* this word is the next decoable bits in the bitstream. \n
* The 3 MSB is the context of for the codeword. \n
*/
/// @brief vlc_tbl0 contains decoding information for initial row of quads
int vlc_tbl0[1024] = { 0 };
/// @brief vlc_tbl1 contains decoding information for non-initial row of
/// quads
int vlc_tbl1[1024] = { 0 };
/// @}
//************************************************************************/
/** @ingroup vlc_decoding_tables_grp
* @brief Initializes vlc_tbl0 and vlc_tbl1 tables, from table0.h and
* table1.h
*/
OPJ_BOOL vlc_init_tables()
{
const OPJ_BOOL debug = OPJ_FALSE; //useful for checking
// number of entries in the table
size_t tbl0_size = sizeof(tbl0) / sizeof(vlc_src_table_t);
// number of entries in the table
size_t tbl1_size = sizeof(tbl1) / sizeof(vlc_src_table_t);
if (debug) {
memset(vlc_tbl0, 0, sizeof(vlc_tbl0)); //unnecessary
}
// this is to convert table entries into values for decoder look up
// There can be at most 1024 possibilities, not all of them are valid.
//
for (int i = 0; i < 1024; ++i) {
int cwd = i & 0x7F; // from i extract codeword
int c_q = i >> 7; // from i extract context
// See if this case exist in the table, if so then set the entry in
// vlc_tbl0
for (size_t j = 0; j < tbl0_size; ++j)
if (tbl0[j].c_q == c_q) // this is an and operation
if (tbl0[j].cwd == (cwd & ((1 << tbl0[j].cwd_len) - 1))) {
if (debug) {
assert(vlc_tbl0[i] == 0);
}
// Put this entry into the table
vlc_tbl0[i] = (tbl0[j].rho << 4) | (tbl0[j].u_off << 3)
| (tbl0[j].e_k << 12) | (tbl0[j].e_1 << 8) | tbl0[j].cwd_len;
}
}
if (debug) {
memset(vlc_tbl1, 0, sizeof(vlc_tbl1)); //unnecessary
}
// this the same as above but for non-initial rows
for (int i = 0; i < 1024; ++i) {
int cwd = i & 0x7F; //7 bits
int c_q = i >> 7;
for (size_t j = 0; j < tbl1_size; ++j)
if (tbl1[j].c_q == c_q) // this is an and operation
if (tbl1[j].cwd == (cwd & ((1 << tbl1[j].cwd_len) - 1))) {
if (debug) {
assert(vlc_tbl1[i] == 0);
}
vlc_tbl1[i] = (tbl1[j].rho << 4) | (tbl1[j].u_off << 3)
| (tbl1[j].e_k << 12) | (tbl1[j].e_1 << 8) | tbl1[j].cwd_len;
}
}
return OPJ_TRUE;
}
//************************************************************************/
/** @ingroup vlc_decoding_tables_grp
* @brief Initializes VLC tables vlc_tbl0 and vlc_tbl1
*/
OPJ_BOOL vlc_tables_initialized = OPJ_FALSE;

261
3rdparty/openjpeg/openjp2/t1_ht_luts.h vendored Normal file
View File

@ -0,0 +1,261 @@
static const OPJ_UINT16 vlc_tbl0[1024] = {
0x0023, 0x00a5, 0x0043, 0x0066, 0x0083, 0xa8ee, 0x0014, 0xd8df,
0x0023, 0x10be, 0x0043, 0xf5ff, 0x0083, 0x207e, 0x0055, 0x515f,
0x0023, 0x0035, 0x0043, 0x444e, 0x0083, 0xc4ce, 0x0014, 0xcccf,
0x0023, 0xe2fe, 0x0043, 0x99ff, 0x0083, 0x0096, 0x00c5, 0x313f,
0x0023, 0x00a5, 0x0043, 0x445e, 0x0083, 0xc8ce, 0x0014, 0x11df,
0x0023, 0xf4fe, 0x0043, 0xfcff, 0x0083, 0x009e, 0x0055, 0x0077,
0x0023, 0x0035, 0x0043, 0xf1ff, 0x0083, 0x88ae, 0x0014, 0x00b7,
0x0023, 0xf8fe, 0x0043, 0xe4ef, 0x0083, 0x888e, 0x00c5, 0x111f,
0x0023, 0x00a5, 0x0043, 0x0066, 0x0083, 0xa8ee, 0x0014, 0x54df,
0x0023, 0x10be, 0x0043, 0x22ef, 0x0083, 0x207e, 0x0055, 0x227f,
0x0023, 0x0035, 0x0043, 0x444e, 0x0083, 0xc4ce, 0x0014, 0x11bf,
0x0023, 0xe2fe, 0x0043, 0x00f7, 0x0083, 0x0096, 0x00c5, 0x223f,
0x0023, 0x00a5, 0x0043, 0x445e, 0x0083, 0xc8ce, 0x0014, 0x00d7,
0x0023, 0xf4fe, 0x0043, 0xbaff, 0x0083, 0x009e, 0x0055, 0x006f,
0x0023, 0x0035, 0x0043, 0xe6ff, 0x0083, 0x88ae, 0x0014, 0xa2af,
0x0023, 0xf8fe, 0x0043, 0x00e7, 0x0083, 0x888e, 0x00c5, 0x222f,
0x0002, 0x00c5, 0x0084, 0x207e, 0x0002, 0xc4ce, 0x0024, 0x00f7,
0x0002, 0xa2fe, 0x0044, 0x0056, 0x0002, 0x009e, 0x0014, 0x00d7,
0x0002, 0x10be, 0x0084, 0x0066, 0x0002, 0x88ae, 0x0024, 0x11df,
0x0002, 0xa8ee, 0x0044, 0x0036, 0x0002, 0x888e, 0x0014, 0x111f,
0x0002, 0x00c5, 0x0084, 0x006e, 0x0002, 0x88ce, 0x0024, 0x88ff,
0x0002, 0xb8fe, 0x0044, 0x444e, 0x0002, 0x0096, 0x0014, 0x00b7,
0x0002, 0xe4fe, 0x0084, 0x445e, 0x0002, 0x00a6, 0x0024, 0x00e7,
0x0002, 0x54de, 0x0044, 0x222e, 0x0002, 0x003e, 0x0014, 0x0077,
0x0002, 0x00c5, 0x0084, 0x207e, 0x0002, 0xc4ce, 0x0024, 0xf1ff,
0x0002, 0xa2fe, 0x0044, 0x0056, 0x0002, 0x009e, 0x0014, 0x11bf,
0x0002, 0x10be, 0x0084, 0x0066, 0x0002, 0x88ae, 0x0024, 0x22ef,
0x0002, 0xa8ee, 0x0044, 0x0036, 0x0002, 0x888e, 0x0014, 0x227f,
0x0002, 0x00c5, 0x0084, 0x006e, 0x0002, 0x88ce, 0x0024, 0xe4ef,
0x0002, 0xb8fe, 0x0044, 0x444e, 0x0002, 0x0096, 0x0014, 0xa2af,
0x0002, 0xe4fe, 0x0084, 0x445e, 0x0002, 0x00a6, 0x0024, 0xd8df,
0x0002, 0x54de, 0x0044, 0x222e, 0x0002, 0x003e, 0x0014, 0x515f,
0x0002, 0x0055, 0x0084, 0x0066, 0x0002, 0x88de, 0x0024, 0x32ff,
0x0002, 0x11fe, 0x0044, 0x444e, 0x0002, 0x00ae, 0x0014, 0x00b7,
0x0002, 0x317e, 0x0084, 0x515e, 0x0002, 0x00c6, 0x0024, 0x00d7,
0x0002, 0x20ee, 0x0044, 0x111e, 0x0002, 0x009e, 0x0014, 0x0077,
0x0002, 0x0055, 0x0084, 0x545e, 0x0002, 0x44ce, 0x0024, 0x00e7,
0x0002, 0xf1fe, 0x0044, 0x0036, 0x0002, 0x00a6, 0x0014, 0x555f,
0x0002, 0x74fe, 0x0084, 0x113e, 0x0002, 0x20be, 0x0024, 0x747f,
0x0002, 0xc4de, 0x0044, 0xf8ff, 0x0002, 0x0096, 0x0014, 0x222f,
0x0002, 0x0055, 0x0084, 0x0066, 0x0002, 0x88de, 0x0024, 0x00f7,
0x0002, 0x11fe, 0x0044, 0x444e, 0x0002, 0x00ae, 0x0014, 0x888f,
0x0002, 0x317e, 0x0084, 0x515e, 0x0002, 0x00c6, 0x0024, 0xc8cf,
0x0002, 0x20ee, 0x0044, 0x111e, 0x0002, 0x009e, 0x0014, 0x006f,
0x0002, 0x0055, 0x0084, 0x545e, 0x0002, 0x44ce, 0x0024, 0xd1df,
0x0002, 0xf1fe, 0x0044, 0x0036, 0x0002, 0x00a6, 0x0014, 0x227f,
0x0002, 0x74fe, 0x0084, 0x113e, 0x0002, 0x20be, 0x0024, 0x22bf,
0x0002, 0xc4de, 0x0044, 0x22ef, 0x0002, 0x0096, 0x0014, 0x323f,
0x0003, 0xd4de, 0xf4fd, 0xfcff, 0x0014, 0x113e, 0x0055, 0x888f,
0x0003, 0x32be, 0x0085, 0x00e7, 0x0025, 0x515e, 0xaafe, 0x727f,
0x0003, 0x44ce, 0xf8fd, 0x44ef, 0x0014, 0x647e, 0x0045, 0xa2af,
0x0003, 0x00a6, 0x555d, 0x99df, 0xf1fd, 0x0036, 0xf5fe, 0x626f,
0x0003, 0xd1de, 0xf4fd, 0xe6ff, 0x0014, 0x717e, 0x0055, 0xb1bf,
0x0003, 0x88ae, 0x0085, 0xd5df, 0x0025, 0x444e, 0xf2fe, 0x667f,
0x0003, 0x00c6, 0xf8fd, 0xe2ef, 0x0014, 0x545e, 0x0045, 0x119f,
0x0003, 0x0096, 0x555d, 0xc8cf, 0xf1fd, 0x111e, 0xc8ee, 0x0067,
0x0003, 0xd4de, 0xf4fd, 0xf3ff, 0x0014, 0x113e, 0x0055, 0x11bf,
0x0003, 0x32be, 0x0085, 0xd8df, 0x0025, 0x515e, 0xaafe, 0x222f,
0x0003, 0x44ce, 0xf8fd, 0x00f7, 0x0014, 0x647e, 0x0045, 0x989f,
0x0003, 0x00a6, 0x555d, 0x00d7, 0xf1fd, 0x0036, 0xf5fe, 0x446f,
0x0003, 0xd1de, 0xf4fd, 0xb9ff, 0x0014, 0x717e, 0x0055, 0x00b7,
0x0003, 0x88ae, 0x0085, 0xdcdf, 0x0025, 0x444e, 0xf2fe, 0x0077,
0x0003, 0x00c6, 0xf8fd, 0xe4ef, 0x0014, 0x545e, 0x0045, 0x737f,
0x0003, 0x0096, 0x555d, 0xb8bf, 0xf1fd, 0x111e, 0xc8ee, 0x323f,
0x0002, 0x00a5, 0x0084, 0x407e, 0x0002, 0x10de, 0x0024, 0x11df,
0x0002, 0x72fe, 0x0044, 0x0056, 0x0002, 0xa8ae, 0x0014, 0xb2bf,
0x0002, 0x0096, 0x0084, 0x0066, 0x0002, 0x00c6, 0x0024, 0x00e7,
0x0002, 0xc8ee, 0x0044, 0x222e, 0x0002, 0x888e, 0x0014, 0x0077,
0x0002, 0x00a5, 0x0084, 0x006e, 0x0002, 0x88ce, 0x0024, 0x00f7,
0x0002, 0x91fe, 0x0044, 0x0036, 0x0002, 0xa2ae, 0x0014, 0xaaaf,
0x0002, 0xb8fe, 0x0084, 0x005e, 0x0002, 0x00be, 0x0024, 0xc4cf,
0x0002, 0x44ee, 0x0044, 0xf4ff, 0x0002, 0x223e, 0x0014, 0x111f,
0x0002, 0x00a5, 0x0084, 0x407e, 0x0002, 0x10de, 0x0024, 0x99ff,
0x0002, 0x72fe, 0x0044, 0x0056, 0x0002, 0xa8ae, 0x0014, 0x00b7,
0x0002, 0x0096, 0x0084, 0x0066, 0x0002, 0x00c6, 0x0024, 0x00d7,
0x0002, 0xc8ee, 0x0044, 0x222e, 0x0002, 0x888e, 0x0014, 0x444f,
0x0002, 0x00a5, 0x0084, 0x006e, 0x0002, 0x88ce, 0x0024, 0xe2ef,
0x0002, 0x91fe, 0x0044, 0x0036, 0x0002, 0xa2ae, 0x0014, 0x447f,
0x0002, 0xb8fe, 0x0084, 0x005e, 0x0002, 0x00be, 0x0024, 0x009f,
0x0002, 0x44ee, 0x0044, 0x76ff, 0x0002, 0x223e, 0x0014, 0x313f,
0x0003, 0x00c6, 0x0085, 0xd9ff, 0xf2fd, 0x647e, 0xf1fe, 0x99bf,
0x0003, 0xa2ae, 0x0025, 0x66ef, 0xf4fd, 0x0056, 0xe2ee, 0x737f,
0x0003, 0x98be, 0x0045, 0x00f7, 0xf8fd, 0x0066, 0x76fe, 0x889f,
0x0003, 0x888e, 0x0015, 0xd5df, 0x00a5, 0x222e, 0x98de, 0x444f,
0x0003, 0xb2be, 0x0085, 0xfcff, 0xf2fd, 0x226e, 0x0096, 0x00b7,
0x0003, 0xaaae, 0x0025, 0xd1df, 0xf4fd, 0x0036, 0xd4de, 0x646f,
0x0003, 0xa8ae, 0x0045, 0xeaef, 0xf8fd, 0x445e, 0xe8ee, 0x717f,
0x0003, 0x323e, 0x0015, 0xc4cf, 0x00a5, 0xfaff, 0x88ce, 0x313f,
0x0003, 0x00c6, 0x0085, 0x77ff, 0xf2fd, 0x647e, 0xf1fe, 0xb3bf,
0x0003, 0xa2ae, 0x0025, 0x00e7, 0xf4fd, 0x0056, 0xe2ee, 0x0077,
0x0003, 0x98be, 0x0045, 0xe4ef, 0xf8fd, 0x0066, 0x76fe, 0x667f,
0x0003, 0x888e, 0x0015, 0x00d7, 0x00a5, 0x222e, 0x98de, 0x333f,
0x0003, 0xb2be, 0x0085, 0x75ff, 0xf2fd, 0x226e, 0x0096, 0x919f,
0x0003, 0xaaae, 0x0025, 0x99df, 0xf4fd, 0x0036, 0xd4de, 0x515f,
0x0003, 0xa8ae, 0x0045, 0xecef, 0xf8fd, 0x445e, 0xe8ee, 0x727f,
0x0003, 0x323e, 0x0015, 0xb1bf, 0x00a5, 0xf3ff, 0x88ce, 0x111f,
0x0003, 0x54de, 0xf2fd, 0x111e, 0x0014, 0x647e, 0xf8fe, 0xcccf,
0x0003, 0x91be, 0x0045, 0x22ef, 0x0025, 0x222e, 0xf3fe, 0x888f,
0x0003, 0x00c6, 0x0085, 0x00f7, 0x0014, 0x115e, 0xfcfe, 0xa8af,
0x0003, 0x00a6, 0x0035, 0xc8df, 0xf1fd, 0x313e, 0x66fe, 0x646f,
0x0003, 0xc8ce, 0xf2fd, 0xf5ff, 0x0014, 0x0066, 0xf4fe, 0xbabf,
0x0003, 0x22ae, 0x0045, 0x00e7, 0x0025, 0x323e, 0xeafe, 0x737f,
0x0003, 0xb2be, 0x0085, 0x55df, 0x0014, 0x0056, 0x717e, 0x119f,
0x0003, 0x0096, 0x0035, 0xc4cf, 0xf1fd, 0x333e, 0xe8ee, 0x444f,
0x0003, 0x54de, 0xf2fd, 0x111e, 0x0014, 0x647e, 0xf8fe, 0x99bf,
0x0003, 0x91be, 0x0045, 0xe2ef, 0x0025, 0x222e, 0xf3fe, 0x667f,
0x0003, 0x00c6, 0x0085, 0xe4ef, 0x0014, 0x115e, 0xfcfe, 0x989f,
0x0003, 0x00a6, 0x0035, 0x00d7, 0xf1fd, 0x313e, 0x66fe, 0x226f,
0x0003, 0xc8ce, 0xf2fd, 0xb9ff, 0x0014, 0x0066, 0xf4fe, 0x00b7,
0x0003, 0x22ae, 0x0045, 0xd1df, 0x0025, 0x323e, 0xeafe, 0x0077,
0x0003, 0xb2be, 0x0085, 0xecef, 0x0014, 0x0056, 0x717e, 0x727f,
0x0003, 0x0096, 0x0035, 0xb8bf, 0xf1fd, 0x333e, 0xe8ee, 0x545f,
0xf1fc, 0xd1de, 0xfafd, 0x00d7, 0xf8fc, 0x0016, 0xfffd, 0x747f,
0xf4fc, 0x717e, 0xf3fd, 0xb3bf, 0xf2fc, 0xeaef, 0xe8ee, 0x444f,
0xf1fc, 0x22ae, 0x0005, 0xb8bf, 0xf8fc, 0x00f7, 0xfcfe, 0x0077,
0xf4fc, 0x115e, 0xf5fd, 0x757f, 0xf2fc, 0xd8df, 0xe2ee, 0x333f,
0xf1fc, 0xb2be, 0xfafd, 0x88cf, 0xf8fc, 0xfbff, 0xfffd, 0x737f,
0xf4fc, 0x006e, 0xf3fd, 0x00b7, 0xf2fc, 0x66ef, 0xf9fe, 0x313f,
0xf1fc, 0x009e, 0x0005, 0xbabf, 0xf8fc, 0xfdff, 0xf6fe, 0x0067,
0xf4fc, 0x0026, 0xf5fd, 0x888f, 0xf2fc, 0xdcdf, 0xd4de, 0x222f,
0xf1fc, 0xd1de, 0xfafd, 0xc4cf, 0xf8fc, 0x0016, 0xfffd, 0x727f,
0xf4fc, 0x717e, 0xf3fd, 0x99bf, 0xf2fc, 0xecef, 0xe8ee, 0x0047,
0xf1fc, 0x22ae, 0x0005, 0x00a7, 0xf8fc, 0xf7ff, 0xfcfe, 0x0057,
0xf4fc, 0x115e, 0xf5fd, 0x0097, 0xf2fc, 0xd5df, 0xe2ee, 0x0037,
0xf1fc, 0xb2be, 0xfafd, 0x00c7, 0xf8fc, 0xfeff, 0xfffd, 0x667f,
0xf4fc, 0x006e, 0xf3fd, 0xa8af, 0xf2fc, 0x00e7, 0xf9fe, 0x323f,
0xf1fc, 0x009e, 0x0005, 0xb1bf, 0xf8fc, 0xe4ef, 0xf6fe, 0x545f,
0xf4fc, 0x0026, 0xf5fd, 0x0087, 0xf2fc, 0x99df, 0xd4de, 0x111f
};
static const OPJ_UINT16 vlc_tbl1[1024] = {
0x0013, 0x0065, 0x0043, 0x00de, 0x0083, 0x888d, 0x0023, 0x444e,
0x0013, 0x00a5, 0x0043, 0x88ae, 0x0083, 0x0035, 0x0023, 0x00d7,
0x0013, 0x00c5, 0x0043, 0x009e, 0x0083, 0x0055, 0x0023, 0x222e,
0x0013, 0x0095, 0x0043, 0x007e, 0x0083, 0x10fe, 0x0023, 0x0077,
0x0013, 0x0065, 0x0043, 0x88ce, 0x0083, 0x888d, 0x0023, 0x111e,
0x0013, 0x00a5, 0x0043, 0x005e, 0x0083, 0x0035, 0x0023, 0x00e7,
0x0013, 0x00c5, 0x0043, 0x00be, 0x0083, 0x0055, 0x0023, 0x11ff,
0x0013, 0x0095, 0x0043, 0x003e, 0x0083, 0x40ee, 0x0023, 0xa2af,
0x0013, 0x0065, 0x0043, 0x00de, 0x0083, 0x888d, 0x0023, 0x444e,
0x0013, 0x00a5, 0x0043, 0x88ae, 0x0083, 0x0035, 0x0023, 0x44ef,
0x0013, 0x00c5, 0x0043, 0x009e, 0x0083, 0x0055, 0x0023, 0x222e,
0x0013, 0x0095, 0x0043, 0x007e, 0x0083, 0x10fe, 0x0023, 0x00b7,
0x0013, 0x0065, 0x0043, 0x88ce, 0x0083, 0x888d, 0x0023, 0x111e,
0x0013, 0x00a5, 0x0043, 0x005e, 0x0083, 0x0035, 0x0023, 0xc4cf,
0x0013, 0x00c5, 0x0043, 0x00be, 0x0083, 0x0055, 0x0023, 0x00f7,
0x0013, 0x0095, 0x0043, 0x003e, 0x0083, 0x40ee, 0x0023, 0x006f,
0x0001, 0x0084, 0x0001, 0x0056, 0x0001, 0x0014, 0x0001, 0x00d7,
0x0001, 0x0024, 0x0001, 0x0096, 0x0001, 0x0045, 0x0001, 0x0077,
0x0001, 0x0084, 0x0001, 0x00c6, 0x0001, 0x0014, 0x0001, 0x888f,
0x0001, 0x0024, 0x0001, 0x00f7, 0x0001, 0x0035, 0x0001, 0x222f,
0x0001, 0x0084, 0x0001, 0x40fe, 0x0001, 0x0014, 0x0001, 0x00b7,
0x0001, 0x0024, 0x0001, 0x00bf, 0x0001, 0x0045, 0x0001, 0x0067,
0x0001, 0x0084, 0x0001, 0x00a6, 0x0001, 0x0014, 0x0001, 0x444f,
0x0001, 0x0024, 0x0001, 0x00e7, 0x0001, 0x0035, 0x0001, 0x113f,
0x0001, 0x0084, 0x0001, 0x0056, 0x0001, 0x0014, 0x0001, 0x00cf,
0x0001, 0x0024, 0x0001, 0x0096, 0x0001, 0x0045, 0x0001, 0x006f,
0x0001, 0x0084, 0x0001, 0x00c6, 0x0001, 0x0014, 0x0001, 0x009f,
0x0001, 0x0024, 0x0001, 0x00ef, 0x0001, 0x0035, 0x0001, 0x323f,
0x0001, 0x0084, 0x0001, 0x40fe, 0x0001, 0x0014, 0x0001, 0x00af,
0x0001, 0x0024, 0x0001, 0x44ff, 0x0001, 0x0045, 0x0001, 0x005f,
0x0001, 0x0084, 0x0001, 0x00a6, 0x0001, 0x0014, 0x0001, 0x007f,
0x0001, 0x0024, 0x0001, 0x00df, 0x0001, 0x0035, 0x0001, 0x111f,
0x0001, 0x0024, 0x0001, 0x0056, 0x0001, 0x0085, 0x0001, 0x00bf,
0x0001, 0x0014, 0x0001, 0x00f7, 0x0001, 0x00c6, 0x0001, 0x0077,
0x0001, 0x0024, 0x0001, 0xf8ff, 0x0001, 0x0045, 0x0001, 0x007f,
0x0001, 0x0014, 0x0001, 0x00df, 0x0001, 0x00a6, 0x0001, 0x313f,
0x0001, 0x0024, 0x0001, 0x222e, 0x0001, 0x0085, 0x0001, 0x00b7,
0x0001, 0x0014, 0x0001, 0x44ef, 0x0001, 0xa2ae, 0x0001, 0x0067,
0x0001, 0x0024, 0x0001, 0x51ff, 0x0001, 0x0045, 0x0001, 0x0097,
0x0001, 0x0014, 0x0001, 0x00cf, 0x0001, 0x0036, 0x0001, 0x223f,
0x0001, 0x0024, 0x0001, 0x0056, 0x0001, 0x0085, 0x0001, 0xb2bf,
0x0001, 0x0014, 0x0001, 0x40ef, 0x0001, 0x00c6, 0x0001, 0x006f,
0x0001, 0x0024, 0x0001, 0x72ff, 0x0001, 0x0045, 0x0001, 0x009f,
0x0001, 0x0014, 0x0001, 0x00d7, 0x0001, 0x00a6, 0x0001, 0x444f,
0x0001, 0x0024, 0x0001, 0x222e, 0x0001, 0x0085, 0x0001, 0xa8af,
0x0001, 0x0014, 0x0001, 0x00e7, 0x0001, 0xa2ae, 0x0001, 0x005f,
0x0001, 0x0024, 0x0001, 0x44ff, 0x0001, 0x0045, 0x0001, 0x888f,
0x0001, 0x0014, 0x0001, 0xaaaf, 0x0001, 0x0036, 0x0001, 0x111f,
0x0002, 0xf8fe, 0x0024, 0x0056, 0x0002, 0x00b6, 0x0085, 0x66ff,
0x0002, 0x00ce, 0x0014, 0x111e, 0x0002, 0x0096, 0x0035, 0xa8af,
0x0002, 0x00f6, 0x0024, 0x313e, 0x0002, 0x00a6, 0x0045, 0xb3bf,
0x0002, 0xb2be, 0x0014, 0xf5ff, 0x0002, 0x0066, 0x517e, 0x545f,
0x0002, 0xf2fe, 0x0024, 0x222e, 0x0002, 0x22ae, 0x0085, 0x44ef,
0x0002, 0x00c6, 0x0014, 0xf4ff, 0x0002, 0x0076, 0x0035, 0x447f,
0x0002, 0x40de, 0x0024, 0x323e, 0x0002, 0x009e, 0x0045, 0x00d7,
0x0002, 0x88be, 0x0014, 0xfaff, 0x0002, 0x115e, 0xf1fe, 0x444f,
0x0002, 0xf8fe, 0x0024, 0x0056, 0x0002, 0x00b6, 0x0085, 0xc8ef,
0x0002, 0x00ce, 0x0014, 0x111e, 0x0002, 0x0096, 0x0035, 0x888f,
0x0002, 0x00f6, 0x0024, 0x313e, 0x0002, 0x00a6, 0x0045, 0x44df,
0x0002, 0xb2be, 0x0014, 0xa8ff, 0x0002, 0x0066, 0x517e, 0x006f,
0x0002, 0xf2fe, 0x0024, 0x222e, 0x0002, 0x22ae, 0x0085, 0x00e7,
0x0002, 0x00c6, 0x0014, 0xe2ef, 0x0002, 0x0076, 0x0035, 0x727f,
0x0002, 0x40de, 0x0024, 0x323e, 0x0002, 0x009e, 0x0045, 0xb1bf,
0x0002, 0x88be, 0x0014, 0x73ff, 0x0002, 0x115e, 0xf1fe, 0x333f,
0x0001, 0x0084, 0x0001, 0x20ee, 0x0001, 0x00c5, 0x0001, 0xc4cf,
0x0001, 0x0044, 0x0001, 0x32ff, 0x0001, 0x0015, 0x0001, 0x888f,
0x0001, 0x0084, 0x0001, 0x0066, 0x0001, 0x0025, 0x0001, 0x00af,
0x0001, 0x0044, 0x0001, 0x22ef, 0x0001, 0x00a6, 0x0001, 0x005f,
0x0001, 0x0084, 0x0001, 0x444e, 0x0001, 0x00c5, 0x0001, 0xcccf,
0x0001, 0x0044, 0x0001, 0x00f7, 0x0001, 0x0015, 0x0001, 0x006f,
0x0001, 0x0084, 0x0001, 0x0056, 0x0001, 0x0025, 0x0001, 0x009f,
0x0001, 0x0044, 0x0001, 0x00df, 0x0001, 0x30fe, 0x0001, 0x222f,
0x0001, 0x0084, 0x0001, 0x20ee, 0x0001, 0x00c5, 0x0001, 0xc8cf,
0x0001, 0x0044, 0x0001, 0x11ff, 0x0001, 0x0015, 0x0001, 0x0077,
0x0001, 0x0084, 0x0001, 0x0066, 0x0001, 0x0025, 0x0001, 0x007f,
0x0001, 0x0044, 0x0001, 0x00e7, 0x0001, 0x00a6, 0x0001, 0x0037,
0x0001, 0x0084, 0x0001, 0x444e, 0x0001, 0x00c5, 0x0001, 0x00b7,
0x0001, 0x0044, 0x0001, 0x00bf, 0x0001, 0x0015, 0x0001, 0x003f,
0x0001, 0x0084, 0x0001, 0x0056, 0x0001, 0x0025, 0x0001, 0x0097,
0x0001, 0x0044, 0x0001, 0x00d7, 0x0001, 0x30fe, 0x0001, 0x111f,
0x0002, 0xa8ee, 0x0044, 0x888e, 0x0002, 0x00d6, 0x00c5, 0xf3ff,
0x0002, 0xfcfe, 0x0025, 0x003e, 0x0002, 0x00b6, 0x0055, 0xd8df,
0x0002, 0xf8fe, 0x0044, 0x0066, 0x0002, 0x207e, 0x0085, 0x99ff,
0x0002, 0x00e6, 0x00f5, 0x0036, 0x0002, 0x00a6, 0x0015, 0x009f,
0x0002, 0xf2fe, 0x0044, 0x0076, 0x0002, 0x44ce, 0x00c5, 0x76ff,
0x0002, 0xf1fe, 0x0025, 0x444e, 0x0002, 0x00ae, 0x0055, 0xc8cf,
0x0002, 0xf4fe, 0x0044, 0x445e, 0x0002, 0x10be, 0x0085, 0xe4ef,
0x0002, 0x54de, 0x00f5, 0x111e, 0x0002, 0x0096, 0x0015, 0x222f,
0x0002, 0xa8ee, 0x0044, 0x888e, 0x0002, 0x00d6, 0x00c5, 0xfaff,
0x0002, 0xfcfe, 0x0025, 0x003e, 0x0002, 0x00b6, 0x0055, 0x11bf,
0x0002, 0xf8fe, 0x0044, 0x0066, 0x0002, 0x207e, 0x0085, 0x22ef,
0x0002, 0x00e6, 0x00f5, 0x0036, 0x0002, 0x00a6, 0x0015, 0x227f,
0x0002, 0xf2fe, 0x0044, 0x0076, 0x0002, 0x44ce, 0x00c5, 0xd5ff,
0x0002, 0xf1fe, 0x0025, 0x444e, 0x0002, 0x00ae, 0x0055, 0x006f,
0x0002, 0xf4fe, 0x0044, 0x445e, 0x0002, 0x10be, 0x0085, 0x11df,
0x0002, 0x54de, 0x00f5, 0x111e, 0x0002, 0x0096, 0x0015, 0x515f,
0x0003, 0x00f6, 0x0014, 0x111e, 0x0044, 0x888e, 0x00a5, 0xd4df,
0x0003, 0xa2ae, 0x0055, 0x76ff, 0x0024, 0x223e, 0x00b6, 0xaaaf,
0x0003, 0x00e6, 0x0014, 0xf5ff, 0x0044, 0x0066, 0x0085, 0xcccf,
0x0003, 0x009e, 0x00c5, 0x44ef, 0x0024, 0x0036, 0xf8fe, 0x317f,
0x0003, 0xe8ee, 0x0014, 0xf1ff, 0x0044, 0x0076, 0x00a5, 0xc4cf,
0x0003, 0x227e, 0x0055, 0xd1df, 0x0024, 0x444e, 0xf4fe, 0x515f,
0x0003, 0x00d6, 0x0014, 0xe2ef, 0x0044, 0x445e, 0x0085, 0x22bf,
0x0003, 0x0096, 0x00c5, 0xc8df, 0x0024, 0x222e, 0xf2fe, 0x226f,
0x0003, 0x00f6, 0x0014, 0x111e, 0x0044, 0x888e, 0x00a5, 0xb1bf,
0x0003, 0xa2ae, 0x0055, 0x33ff, 0x0024, 0x223e, 0x00b6, 0xa8af,
0x0003, 0x00e6, 0x0014, 0xb9ff, 0x0044, 0x0066, 0x0085, 0xa8bf,
0x0003, 0x009e, 0x00c5, 0xe4ef, 0x0024, 0x0036, 0xf8fe, 0x646f,
0x0003, 0xe8ee, 0x0014, 0xfcff, 0x0044, 0x0076, 0x00a5, 0xc8cf,
0x0003, 0x227e, 0x0055, 0xeaef, 0x0024, 0x444e, 0xf4fe, 0x747f,
0x0003, 0x00d6, 0x0014, 0xfaff, 0x0044, 0x445e, 0x0085, 0xb2bf,
0x0003, 0x0096, 0x00c5, 0x44df, 0x0024, 0x222e, 0xf2fe, 0x313f,
0x00f3, 0xfafe, 0xf1fd, 0x0036, 0x0004, 0x32be, 0x0075, 0x11df,
0x00f3, 0x54de, 0xf2fd, 0xe4ef, 0x00d5, 0x717e, 0xfcfe, 0x737f,
0x00f3, 0xf3fe, 0xf8fd, 0x111e, 0x0004, 0x0096, 0x0055, 0xb1bf,
0x00f3, 0x00ce, 0x00b5, 0xd8df, 0xf4fd, 0x0066, 0xb9fe, 0x545f,
0x00f3, 0x76fe, 0xf1fd, 0x0026, 0x0004, 0x00a6, 0x0075, 0x009f,
0x00f3, 0x00ae, 0xf2fd, 0xf7ff, 0x00d5, 0x0046, 0xf5fe, 0x747f,
0x00f3, 0x00e6, 0xf8fd, 0x0016, 0x0004, 0x0086, 0x0055, 0x888f,
0x00f3, 0x00c6, 0x00b5, 0xe2ef, 0xf4fd, 0x115e, 0xa8ee, 0x113f,
0x00f3, 0xfafe, 0xf1fd, 0x0036, 0x0004, 0x32be, 0x0075, 0xd1df,
0x00f3, 0x54de, 0xf2fd, 0xfbff, 0x00d5, 0x717e, 0xfcfe, 0x447f,
0x00f3, 0xf3fe, 0xf8fd, 0x111e, 0x0004, 0x0096, 0x0055, 0x727f,
0x00f3, 0x00ce, 0x00b5, 0x22ef, 0xf4fd, 0x0066, 0xb9fe, 0x444f,
0x00f3, 0x76fe, 0xf1fd, 0x0026, 0x0004, 0x00a6, 0x0075, 0x11bf,
0x00f3, 0x00ae, 0xf2fd, 0xffff, 0x00d5, 0x0046, 0xf5fe, 0x323f,
0x00f3, 0x00e6, 0xf8fd, 0x0016, 0x0004, 0x0086, 0x0055, 0x006f,
0x00f3, 0x00c6, 0x00b5, 0xb8bf, 0xf4fd, 0x115e, 0xa8ee, 0x222f
};

147
3rdparty/openjpeg/openjp2/t2.c vendored
View File

@ -502,7 +502,6 @@ OPJ_BOOL opj_t2_decode_packets(opj_tcd_t* tcd,
l_current_pi->precno, l_current_pi->layno, skip_packet ? "skipped" : "kept");
*/
}
if (!skip_packet) {
l_nb_bytes_read = 0;
@ -1124,7 +1123,7 @@ static OPJ_BOOL opj_t2_read_packet_header(opj_t2_t* p_t2,
/*
When the marker PPT/PPM is used the packet header are store in PPT/PPM marker
This part deal with this caracteristic
This part deal with this characteristic
step 1: Read packet header in the saved structure
step 2: Return to codestream for decoding
*/
@ -1229,6 +1228,7 @@ static OPJ_BOOL opj_t2_read_packet_header(opj_t2_t* p_t2,
++i;
}
l_cblk->Mb = (OPJ_UINT32)l_band->numbps;
l_cblk->numbps = (OPJ_UINT32)l_band->numbps + 1 - i;
l_cblk->numlenbits = 3;
}
@ -1258,34 +1258,63 @@ static OPJ_BOOL opj_t2_read_packet_header(opj_t2_t* p_t2,
}
n = (OPJ_INT32)l_cblk->numnewpasses;
do {
OPJ_UINT32 bit_number;
l_cblk->segs[l_segno].numnewpasses = (OPJ_UINT32)opj_int_min((OPJ_INT32)(
l_cblk->segs[l_segno].maxpasses - l_cblk->segs[l_segno].numpasses), n);
bit_number = l_cblk->numlenbits + opj_uint_floorlog2(
l_cblk->segs[l_segno].numnewpasses);
if (bit_number > 32) {
opj_event_msg(p_manager, EVT_ERROR,
"Invalid bit number %d in opj_t2_read_packet_header()\n",
bit_number);
opj_bio_destroy(l_bio);
return OPJ_FALSE;
}
l_cblk->segs[l_segno].newlen = opj_bio_read(l_bio, bit_number);
JAS_FPRINTF(stderr, "included=%d numnewpasses=%d increment=%d len=%d \n",
l_included, l_cblk->segs[l_segno].numnewpasses, l_increment,
l_cblk->segs[l_segno].newlen);
n -= (OPJ_INT32)l_cblk->segs[l_segno].numnewpasses;
if (n > 0) {
++l_segno;
if (! opj_t2_init_seg(l_cblk, l_segno, p_tcp->tccps[p_pi->compno].cblksty, 0)) {
if ((p_tcp->tccps[p_pi->compno].cblksty & J2K_CCP_CBLKSTY_HT) != 0)
do {
OPJ_UINT32 bit_number;
l_cblk->segs[l_segno].numnewpasses = l_segno == 0 ? 1 : (OPJ_UINT32)n;
bit_number = l_cblk->numlenbits + opj_uint_floorlog2(
l_cblk->segs[l_segno].numnewpasses);
if (bit_number > 32) {
opj_event_msg(p_manager, EVT_ERROR,
"Invalid bit number %d in opj_t2_read_packet_header()\n",
bit_number);
opj_bio_destroy(l_bio);
return OPJ_FALSE;
}
}
} while (n > 0);
l_cblk->segs[l_segno].newlen = opj_bio_read(l_bio, bit_number);
JAS_FPRINTF(stderr, "included=%d numnewpasses=%d increment=%d len=%d \n",
l_included, l_cblk->segs[l_segno].numnewpasses, l_increment,
l_cblk->segs[l_segno].newlen);
n -= (OPJ_INT32)l_cblk->segs[l_segno].numnewpasses;
if (n > 0) {
++l_segno;
if (! opj_t2_init_seg(l_cblk, l_segno, p_tcp->tccps[p_pi->compno].cblksty, 0)) {
opj_bio_destroy(l_bio);
return OPJ_FALSE;
}
}
} while (n > 0);
else
do {
OPJ_UINT32 bit_number;
l_cblk->segs[l_segno].numnewpasses = (OPJ_UINT32)opj_int_min((OPJ_INT32)(
l_cblk->segs[l_segno].maxpasses - l_cblk->segs[l_segno].numpasses), n);
bit_number = l_cblk->numlenbits + opj_uint_floorlog2(
l_cblk->segs[l_segno].numnewpasses);
if (bit_number > 32) {
opj_event_msg(p_manager, EVT_ERROR,
"Invalid bit number %d in opj_t2_read_packet_header()\n",
bit_number);
opj_bio_destroy(l_bio);
return OPJ_FALSE;
}
l_cblk->segs[l_segno].newlen = opj_bio_read(l_bio, bit_number);
JAS_FPRINTF(stderr, "included=%d numnewpasses=%d increment=%d len=%d \n",
l_included, l_cblk->segs[l_segno].numnewpasses, l_increment,
l_cblk->segs[l_segno].newlen);
n -= (OPJ_INT32)l_cblk->segs[l_segno].numnewpasses;
if (n > 0) {
++l_segno;
if (! opj_t2_init_seg(l_cblk, l_segno, p_tcp->tccps[p_pi->compno].cblksty, 0)) {
opj_bio_destroy(l_bio);
return OPJ_FALSE;
}
}
} while (n > 0);
++l_cblk;
}
@ -1348,6 +1377,7 @@ static OPJ_BOOL opj_t2_read_packet_data(opj_t2_t* p_t2,
opj_tcd_cblk_dec_t* l_cblk = 00;
opj_tcd_resolution_t* l_res =
&p_tile->comps[p_pi->compno].resolutions[p_pi->resno];
OPJ_BOOL partial_buffer = OPJ_FALSE;
OPJ_ARG_NOT_USED(p_t2);
OPJ_ARG_NOT_USED(pack_info);
@ -1367,6 +1397,12 @@ static OPJ_BOOL opj_t2_read_packet_data(opj_t2_t* p_t2,
for (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno) {
opj_tcd_seg_t *l_seg = 00;
// if we have a partial data stream, set numchunks to zero
// since we have no data to actually decode.
if (partial_buffer) {
l_cblk->numchunks = 0;
}
if (!l_cblk->numnewpasses) {
/* nothing to do */
++l_cblk;
@ -1389,12 +1425,32 @@ static OPJ_BOOL opj_t2_read_packet_data(opj_t2_t* p_t2,
/* Check possible overflow (on l_current_data only, assumes input args already checked) then size */
if ((((OPJ_SIZE_T)l_current_data + (OPJ_SIZE_T)l_seg->newlen) <
(OPJ_SIZE_T)l_current_data) ||
(l_current_data + l_seg->newlen > p_src_data + p_max_length)) {
opj_event_msg(p_manager, EVT_ERROR,
"read: segment too long (%d) with max (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
l_seg->newlen, p_max_length, cblkno, p_pi->precno, bandno, p_pi->resno,
p_pi->compno);
return OPJ_FALSE;
(l_current_data + l_seg->newlen > p_src_data + p_max_length) ||
(partial_buffer)) {
if (p_t2->cp->strict) {
opj_event_msg(p_manager, EVT_ERROR,
"read: segment too long (%d) with max (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
l_seg->newlen, p_max_length, cblkno, p_pi->precno, bandno, p_pi->resno,
p_pi->compno);
return OPJ_FALSE;
} else {
opj_event_msg(p_manager, EVT_WARNING,
"read: segment too long (%d) with max (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
l_seg->newlen, p_max_length, cblkno, p_pi->precno, bandno, p_pi->resno,
p_pi->compno);
// skip this codeblock since it is a partial read
partial_buffer = OPJ_TRUE;
l_cblk->numchunks = 0;
l_seg->numpasses += l_seg->numnewpasses;
l_cblk->numnewpasses -= l_seg->numnewpasses;
if (l_cblk->numnewpasses > 0) {
++l_seg;
++l_cblk->numsegs;
break;
}
continue;
}
}
#ifdef USE_JPWL
@ -1456,8 +1512,12 @@ static OPJ_BOOL opj_t2_read_packet_data(opj_t2_t* p_t2,
++l_band;
}
*(p_data_read) = (OPJ_UINT32)(l_current_data - p_src_data);
// return the number of bytes read
if (partial_buffer) {
*(p_data_read) = p_max_length;
} else {
*(p_data_read) = (OPJ_UINT32)(l_current_data - p_src_data);
}
return OPJ_TRUE;
}
@ -1519,11 +1579,18 @@ static OPJ_BOOL opj_t2_skip_packet_data(opj_t2_t* p_t2,
/* Check possible overflow then size */
if (((*p_data_read + l_seg->newlen) < (*p_data_read)) ||
((*p_data_read + l_seg->newlen) > p_max_length)) {
opj_event_msg(p_manager, EVT_ERROR,
"skip: segment too long (%d) with max (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
l_seg->newlen, p_max_length, cblkno, p_pi->precno, bandno, p_pi->resno,
p_pi->compno);
return OPJ_FALSE;
if (p_t2->cp->strict) {
opj_event_msg(p_manager, EVT_ERROR,
"skip: segment too long (%d) with max (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
l_seg->newlen, p_max_length, cblkno, p_pi->precno, bandno, p_pi->resno,
p_pi->compno);
return OPJ_FALSE;
} else {
opj_event_msg(p_manager, EVT_WARNING,
"skip: segment too long (%d) with max (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
l_seg->newlen, p_max_length, cblkno, p_pi->precno, bandno, p_pi->resno,
p_pi->compno);
}
}
#ifdef USE_JPWL

5
3rdparty/openjpeg/openjp2/tcd.h vendored
View File

@ -122,6 +122,11 @@ typedef struct opj_tcd_cblk_dec {
opj_tcd_seg_data_chunk_t* chunks; /* Array of chunks */
/* position of the code-blocks : left upper corner (x0, y0) right low corner (x1,y1) */
OPJ_INT32 x0, y0, x1, y1;
/* Mb is The maximum number of bit-planes available for the representation of
coefficients in any sub-band, b, as defined in Equation (E-2). See
Section B.10.5 of the standard */
OPJ_UINT32 Mb; /* currently used only to check if HT decoding is correct */
/* numbps is Mb - P as defined in Section B.10.5 of the standard */
OPJ_UINT32 numbps;
/* number of bits for len, for the current packet. Transitory value */
OPJ_UINT32 numlenbits;

174
3rdparty/openjpeg/openjp2/test_sparse_array.c vendored Normal file
View File

@ -0,0 +1,174 @@
/*
* The copyright in this software is being made available under the 2-clauses
* BSD License, included below. This software may be subject to other third
* party and contributor rights, including patent rights, and no such rights
* are granted under this license.
*
* Copyright (c) 2017, IntoPix SA <contact@intopix.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#undef NDEBUG
#include "opj_includes.h"
int main()
{
OPJ_UINT32 i, j, w, h;
OPJ_INT32 buffer[ 99 * 101 ];
OPJ_BOOL ret;
opj_sparse_array_int32_t* sa;
sa = opj_sparse_array_int32_create(0, 1, 1, 1);
assert(sa == NULL);
opj_sparse_array_int32_free(sa);
sa = opj_sparse_array_int32_create(1, 0, 1, 1);
assert(sa == NULL);
sa = opj_sparse_array_int32_create(1, 1, 0, 1);
assert(sa == NULL);
sa = opj_sparse_array_int32_create(1, 1, 1, 0);
assert(sa == NULL);
sa = opj_sparse_array_int32_create(99, 101, ~0U, ~0U);
assert(sa == NULL);
sa = opj_sparse_array_int32_create(99, 101, 15, 17);
opj_sparse_array_int32_free(sa);
sa = opj_sparse_array_int32_create(99, 101, 15, 17);
ret = opj_sparse_array_int32_read(sa, 0, 0, 0, 1, buffer, 1, 1, OPJ_FALSE);
assert(!ret);
ret = opj_sparse_array_int32_read(sa, 0, 0, 1, 0, buffer, 1, 1, OPJ_FALSE);
assert(!ret);
ret = opj_sparse_array_int32_read(sa, 0, 0, 100, 1, buffer, 1, 1, OPJ_FALSE);
assert(!ret);
ret = opj_sparse_array_int32_read(sa, 0, 0, 1, 102, buffer, 1, 1, OPJ_FALSE);
assert(!ret);
ret = opj_sparse_array_int32_read(sa, 1, 0, 0, 1, buffer, 1, 1, OPJ_FALSE);
assert(!ret);
ret = opj_sparse_array_int32_read(sa, 0, 1, 1, 0, buffer, 1, 1, OPJ_FALSE);
assert(!ret);
ret = opj_sparse_array_int32_read(sa, 99, 101, 99, 101, buffer, 1, 1,
OPJ_FALSE);
assert(!ret);
buffer[0] = 1;
ret = opj_sparse_array_int32_read(sa, 0, 0, 1, 1, buffer, 1, 1, OPJ_FALSE);
assert(ret);
assert(buffer[0] == 0);
memset(buffer, 0xFF, sizeof(buffer));
ret = opj_sparse_array_int32_read(sa, 0, 0, 99, 101, buffer, 1, 99, OPJ_FALSE);
assert(ret);
for (i = 0; i < 99 * 101; i++) {
assert(buffer[i] == 0);
}
buffer[0] = 1;
ret = opj_sparse_array_int32_write(sa, 4, 5, 4 + 1, 5 + 1, buffer, 1, 1,
OPJ_FALSE);
assert(ret);
buffer[0] = 2;
ret = opj_sparse_array_int32_write(sa, 4, 5, 4 + 1, 5 + 1, buffer, 1, 1,
OPJ_FALSE);
assert(ret);
buffer[0] = 0;
buffer[1] = 0xFF;
ret = opj_sparse_array_int32_read(sa, 4, 5, 4 + 1, 5 + 1, buffer, 1, 1,
OPJ_FALSE);
assert(ret);
assert(buffer[0] == 2);
assert(buffer[1] == 0xFF);
buffer[0] = 0xFF;
buffer[1] = 0xFF;
buffer[2] = 0xFF;
ret = opj_sparse_array_int32_read(sa, 4, 5, 4 + 1, 5 + 2, buffer, 0, 1,
OPJ_FALSE);
assert(ret);
assert(buffer[0] == 2);
assert(buffer[1] == 0);
assert(buffer[2] == 0xFF);
buffer[0] = 3;
ret = opj_sparse_array_int32_write(sa, 4, 5, 4 + 1, 5 + 1, buffer, 0, 1,
OPJ_FALSE);
assert(ret);
buffer[0] = 0;
buffer[1] = 0xFF;
ret = opj_sparse_array_int32_read(sa, 4, 5, 4 + 1, 5 + 1, buffer, 1, 1,
OPJ_FALSE);
assert(ret);
assert(buffer[0] == 3);
assert(buffer[1] == 0xFF);
w = 15 + 1;
h = 17 + 1;
memset(buffer, 0xFF, sizeof(buffer));
ret = opj_sparse_array_int32_read(sa, 2, 1, 2 + w, 1 + h, buffer, 1, w,
OPJ_FALSE);
assert(ret);
for (j = 0; j < h; j++) {
for (i = 0; i < w; i++) {
if (i == 4 - 2 && j == 5 - 1) {
assert(buffer[ j * w + i ] == 3);
} else {
assert(buffer[ j * w + i ] == 0);
}
}
}
opj_sparse_array_int32_free(sa);
sa = opj_sparse_array_int32_create(99, 101, 15, 17);
memset(buffer, 0xFF, sizeof(buffer));
ret = opj_sparse_array_int32_read(sa, 0, 0, 2, 1, buffer, 2, 4, OPJ_FALSE);
assert(ret);
assert(buffer[0] == 0);
assert(buffer[1] == -1);
assert(buffer[2] == 0);
buffer[0] = 1;
buffer[2] = 3;
ret = opj_sparse_array_int32_write(sa, 0, 0, 2, 1, buffer, 2, 4, OPJ_FALSE);
assert(ret);
memset(buffer, 0xFF, sizeof(buffer));
ret = opj_sparse_array_int32_read(sa, 0, 0, 2, 1, buffer, 2, 4, OPJ_FALSE);
assert(ret);
assert(buffer[0] == 1);
assert(buffer[1] == -1);
assert(buffer[2] == 3);
opj_sparse_array_int32_free(sa);
return 0;
}

146
3rdparty/openjpeg/openjp2/thix_manager.c vendored Normal file
View File

@ -0,0 +1,146 @@
/*
* $Id: thix_manager.c 897 2011-08-28 21:43:57Z Kaori.Hagihara@gmail.com $
*
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2014, Professor Benoit Macq
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*! \file
* \brief Modification of jpip.c from 2KAN indexer
*/
#include "opj_includes.h"
int opj_write_thix(int coff, opj_codestream_info_t cstr_info,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager)
{
OPJ_BYTE l_data_header [4];
int i;
int tileno;
opj_jp2_box_t *box;
OPJ_UINT32 len;
OPJ_OFF_T lenp;
lenp = 0;
box = (opj_jp2_box_t *)opj_calloc((size_t)(cstr_info.tw * cstr_info.th),
sizeof(opj_jp2_box_t));
if (box == NULL) {
return 0;
}
for (i = 0; i < 2 ; i++) {
if (i) {
opj_stream_seek(cio, lenp, p_manager);
}
lenp = opj_stream_tell(cio);
opj_stream_skip(cio, 4, p_manager); /* L [at the end] */
opj_write_bytes(l_data_header, JPIP_THIX, 4); /* THIX */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_write_manf(i, cstr_info.tw * cstr_info.th, box, cio, p_manager);
for (tileno = 0; tileno < cstr_info.tw * cstr_info.th; tileno++) {
box[tileno].length = (OPJ_UINT32)opj_write_tilemhix(coff, cstr_info, tileno,
cio, p_manager);
box[tileno].type = JPIP_MHIX;
}
len = (OPJ_UINT32)(opj_stream_tell(cio) - lenp);
opj_stream_seek(cio, lenp, p_manager);
opj_write_bytes(l_data_header, len, 4); /* L */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_stream_seek(cio, lenp + len, p_manager);
}
opj_free(box);
return (int)len;
}
/*
* Write tile-part headers mhix box
*
* @param[in] coff offset of j2k codestream
* @param[in] cstr_info codestream information
* @param[in] tileno tile number
* @param[in] cio file output handle
* @return length of mhix box
*/
int opj_write_tilemhix(int coff, opj_codestream_info_t cstr_info, int tileno,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager)
{
OPJ_BYTE l_data_header [8];
int i;
opj_tile_info_t tile;
opj_tp_info_t tp;
opj_marker_info_t *marker;
OPJ_UINT32 len;
OPJ_OFF_T lenp;
lenp = opj_stream_tell(cio);
opj_stream_skip(cio, 4,
p_manager); /* L [at the end] */
opj_write_bytes(l_data_header, JPIP_MHIX,
4); /* MHIX */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
tile = cstr_info.tile[tileno];
tp = tile.tp[0];
opj_write_bytes(l_data_header,
(OPJ_UINT32)(tp.tp_end_header - tp.tp_start_pos + 1),
8); /* TLEN */
opj_stream_write_data(cio, l_data_header, 8, p_manager);
marker = cstr_info.tile[tileno].marker;
for (i = 0; i < cstr_info.tile[tileno].marknum;
i++) { /* Marker restricted to 1 apparition */
opj_write_bytes(l_data_header, marker[i].type, 2);
opj_write_bytes(l_data_header + 2, 0, 2);
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_write_bytes(l_data_header, (OPJ_UINT32)(marker[i].pos - coff), 8);
opj_stream_write_data(cio, l_data_header, 8, p_manager);
opj_write_bytes(l_data_header, (OPJ_UINT32)marker[i].len, 2);
opj_stream_write_data(cio, l_data_header, 2, p_manager);
}
/* free( marker);*/
len = (OPJ_UINT32)(opj_stream_tell(cio) - lenp);
opj_stream_seek(cio, lenp, p_manager);
opj_write_bytes(l_data_header, len, 4); /* L */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_stream_seek(cio, lenp + len, p_manager);
return (int)len;
}

190
3rdparty/openjpeg/openjp2/tpix_manager.c vendored Normal file
View File

@ -0,0 +1,190 @@
/*
* $Id: tpix_manager.c 897 2011-08-28 21:43:57Z Kaori.Hagihara@gmail.com $
*
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2014, Professor Benoit Macq
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*! \file
* \brief Modification of jpip.c from 2KAN indexer
*/
#include "opj_includes.h"
#define MAX(a,b) ((a)>(b)?(a):(b))
/*
* Get number of maximum tile parts per tile
*
* @param[in] cstr_info codestream information
* @return number of maximum tile parts per tile
*/
int get_num_max_tile_parts(opj_codestream_info_t cstr_info);
/*
* Write faix box of tpix
*
* @param[in] coff offset of j2k codestream
* @param[in] compno component number
* @param[in] cstr_info codestream information
* @param[in] j2klen length of j2k codestream
* @param[in] cio file output handle
* @return length of faix box
*/
int opj_write_tpix(int coff,
opj_codestream_info_t cstr_info,
int j2klen, opj_stream_private_t *cio,
opj_event_mgr_t * p_manager)
{
OPJ_BYTE l_data_header [4];
OPJ_UINT32 len;
OPJ_OFF_T lenp;
lenp = opj_stream_tell(cio);
opj_stream_skip(cio, 4, p_manager);
opj_write_bytes(l_data_header, JPIP_TPIX, 4); /* TPIX */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_write_tpixfaix(coff, 0, cstr_info, j2klen, cio, p_manager);
len = (OPJ_UINT32)(opj_stream_tell(cio) - lenp);
opj_stream_skip(cio, lenp, p_manager);
opj_write_bytes(l_data_header, len, 4); /* L */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_stream_seek(cio, lenp + len, p_manager);
return (int)len;
}
int opj_write_tpixfaix(int coff,
int compno,
opj_codestream_info_t cstr_info,
int j2klen,
opj_stream_private_t *cio,
opj_event_mgr_t * p_manager)
{
OPJ_UINT32 len;
OPJ_OFF_T lenp;
OPJ_UINT32 i, j;
OPJ_UINT32 Aux;
OPJ_UINT32 num_max_tile_parts;
OPJ_UINT32 size_of_coding; /* 4 or 8 */
opj_tp_info_t tp;
OPJ_BYTE l_data_header [8];
OPJ_UINT32 version;
num_max_tile_parts = (OPJ_UINT32)get_num_max_tile_parts(cstr_info);
if (j2klen > pow(2, 32)) {
size_of_coding = 8;
version = num_max_tile_parts == 1 ? 1 : 3;
} else {
size_of_coding = 4;
version = num_max_tile_parts == 1 ? 0 : 2;
}
lenp = opj_stream_tell(cio);
opj_stream_skip(cio, 4, p_manager); /* L [at the end] */
opj_write_bytes(l_data_header, JPIP_FAIX, 4); /* FAIX */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_write_bytes(l_data_header, version, 1); /* Version 0 = 4 bytes */
opj_stream_write_data(cio, l_data_header, 1, p_manager);
opj_write_bytes(l_data_header, num_max_tile_parts,
size_of_coding); /* NMAX */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
opj_write_bytes(l_data_header, (OPJ_UINT32)(cstr_info.tw * cstr_info.th),
size_of_coding); /* M */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
for (i = 0; i < (OPJ_UINT32)(cstr_info.tw * cstr_info.th); i++) {
for (j = 0; j < (OPJ_UINT32)cstr_info.tile[i].num_tps; j++) {
tp = cstr_info.tile[i].tp[j];
opj_write_bytes(l_data_header, (OPJ_UINT32)(tp.tp_start_pos - coff),
size_of_coding); /* start position */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
opj_write_bytes(l_data_header,
(OPJ_UINT32)(tp.tp_end_pos - tp.tp_start_pos + 1),
size_of_coding); /* length */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
if (version & 0x02) {
if (cstr_info.tile[i].num_tps == 1 && cstr_info.numdecompos[compno] > 1) {
Aux = (OPJ_UINT32)(cstr_info.numdecompos[compno] + 1);
} else {
Aux = j + 1;
}
opj_write_bytes(l_data_header, Aux, 4);
opj_stream_write_data(cio, l_data_header, 4, p_manager);
/*cio_write(img.tile[i].tile_parts[j].num_reso_AUX,4);*/ /* Aux_i,j : Auxiliary value */
/* fprintf(stderr,"AUX value %d\n",Aux);*/
}
/*cio_write(0,4);*/
}
/* PADDING */
while (j < num_max_tile_parts) {
opj_write_bytes(l_data_header, 0,
size_of_coding); /* start position */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
opj_write_bytes(l_data_header, 0,
size_of_coding); /* length */
opj_stream_write_data(cio, l_data_header, size_of_coding, p_manager);
if (version & 0x02) {
opj_write_bytes(l_data_header, 0, 4); /* Aux_i,j : Auxiliary value */
}
opj_stream_write_data(cio, l_data_header, 4, p_manager);
j++;
}
}
len = (OPJ_UINT32)(opj_stream_tell(cio) - lenp);
opj_stream_seek(cio, lenp, p_manager);
opj_write_bytes(l_data_header, len, 4); /* L */
opj_stream_write_data(cio, l_data_header, 4, p_manager);
opj_stream_seek(cio, lenp + len, p_manager);
return (int)len;
}
int get_num_max_tile_parts(opj_codestream_info_t cstr_info)
{
int num_max_tp = 0, i;
for (i = 0; i < cstr_info.tw * cstr_info.th; i++) {
num_max_tp = MAX(cstr_info.tile[i].num_tps, num_max_tp);
}
return num_max_tp;
}