generic-library/openjpeg
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: generic-library:v2
Branches Tags
generic-library:main generic-library:gh-pages generic-library:openjpeg-2.1 generic-library:coverity_scan generic-library:fix-bypass-restart generic-library:codingstyle generic-library:openjpeg-1.5 generic-library:openjpeg-2.0 generic-library:openjp3d generic-library:v2 generic-library:opj-v1-branch generic-library:openjpeg3d generic-library:openjpeg3d@749 generic-library:openjpeg3d@745 generic-library:avendor generic-library:j2kviewer generic-library:UCL
generic-library:v2.1.2 generic-library:v2.1.1 generic-library:wg1n6848 generic-library:version.2.1 generic-library:version.2.0.1 generic-library:version.1.5.2 generic-library:version.2.0 generic-library:version.1.5.1 generic-library:version.1.5 generic-library:version.1.3 generic-library:version.1.4 generic-library:version.1.2 generic-library:version.1.1 generic-library:version.1.0 generic-library:arelease generic-library:opj0-97 generic-library:start
..
compare: generic-library:opj0-97
Branches Tags
generic-library:gh-pages generic-library:main generic-library:openjpeg-2.1 generic-library:coverity_scan generic-library:fix-bypass-restart generic-library:codingstyle generic-library:openjpeg-1.5 generic-library:openjpeg-2.0 generic-library:openjp3d generic-library:v2 generic-library:opj-v1-branch generic-library:openjpeg3d generic-library:openjpeg3d@749 generic-library:openjpeg3d@745 generic-library:avendor generic-library:j2kviewer generic-library:UCL
generic-library:v2.1.2 generic-library:v2.1.1 generic-library:wg1n6848 generic-library:version.2.1 generic-library:version.2.0.1 generic-library:version.1.5.2 generic-library:version.2.0 generic-library:version.1.5.1 generic-library:version.1.5 generic-library:version.1.3 generic-library:version.1.4 generic-library:version.1.2 generic-library:version.1.1 generic-library:version.1.0 generic-library:arelease generic-library:opj0-97 generic-library:start

1 Commits
v2 ... opj0-97

Author SHA1 Message Date
no_author
fd3d73f678 This commit was manufactured by cvs2svn to create tag 'opj0-97'. 2005-11-09 10:20:28 +00:00
121 changed files with 21150 additions and 40735 deletions
Expand all files Collapse all files

612
CHANGES
View File

@@ -1,612 +0,0 @@
What's New for OpenJPEG
* : fixed
- : removed
! : changed
+ : added
April 13, 2011
* [antonin] fixed dllexport definition (credit to vincent torri)
April 12, 2011
- [antonin] Removed folders mj2, JavaOpenJpeg, jpwl, OPJViewer (not compliant with v2). Removed obsolete windows project files. Removed obsolete Makefiles (only build method currently supported with v2 branch: cmake). Renamed ChangeLog to CHANGES. Renamed License.txt to LICENSE. Removed obsolete README files.
* [antonin] Fixed internal function names conflict with Jasper (http://code.google.com/p/openjpeg/issues/detail?id=30)
November 25, 2010
* [antonin] Fix leak in jp2_read_header_procedure() (from even.rouault, see issue 29 on googlecode)
Jun 22, 2010
+ [MM] Import j2k_dump from trunk (much faster!)
Jun 21, 2010
* [MM] Move CMake files to CMake folder
* [MM] Remove some warnings in code
* [MM] j2k_to_image properly return error code
* [MM] increase coverage by testing all codecs
* [MM] fix installation. Place in subfolder to handle both API
* [MM] Start using cmake API for easy packaging
April 8, 2010
* [FOD] Fixed problem with Borland C++ Builder (Borland C do not have lrintf). Thanks Marek Mauder for this fix.
* [FOD] Fixed pi.c bug (issue 15 on google code). Thanks to Anton Lionel for catching this.
* [FOD] Fixed MJ2 codec bugs (issues 23-24 on google code). Thanks to Winfried for these patches.
March 26, 2010
+ [FOD] Added support for "jpc" codestreams which are equivalent to "j2c" codestreams. Thanks to Winfried for this patch
March 24, 2010
* [FOD] Code improvements using 'g++-4.4.0' to trace the code. Thanks to Winfried for this patch.
March 7, 2010
* [FOD] Fixed small compatibility issues with win32 in codec (moved include <strings.h>)
March 5,2010
! [FOD] Updated makefiles for v1.4 and v2.0
February 16, 2010
* [FOD] Fixed libopenjpeg Makefile
January 20, 2010
! [FOD] Created a new constant in openjpeg.h to differentiate the case when the colorspace is not supported by the library and when it is not specified in the codestream. Suggested by Matteo Italia.
September 10, 2009
* [antonin] fixed minor bugs which were triggering warnings at compilation (different signedness, wrong pointer type, etc)
August 21, 2008
* [antonin] found a bug in tcd.c that was preventing to find the correct threshold in tcd_rateallocate.c for high-precision images. Applied a temporary patch but a better solution should be found.
August 8, 2008
! [FOD] Modified the way raw images with more that 8bpp are read and written
August 2nd, 2008
* [Mathieu Malaterre] remove INLINE from forward decl. Fix CMakeLists.txt for UNIX platforms
August 1st, 2008
- [antonin] removed t1_generate_luts.c, useless in version 2.
! [antonin] updated XCode project file for mac users.
---------------------------
July 31, 2008
CREATION OF A OPJ V2 BRANCH
---------------------------
July 31, 2008
+ [antonin] created a branch for openjpeg version 2. Modifications that have been applied to the trunk after revision 483 should be re-applied on the branch (version 2 has been developed based on revision 483).
July 9, 2008
+ [Parvatha] Added the default lossless parameter to opj_set_default_encoder_parameters in openjpeg.c.
June 12, 2008
* [antonin] fixed a bug in dirent.h that prevented codec on Linux Alpha Systems to compile correctly. Thanks to RobinC.
May 22, 2008
* [antonin] fixed a bug in j2k.c (j2k_write_sod) that allowed to get negative rates, thanks zhong1985624 for pointing this.
May 22, 2008
* [antonin] additional test to avoid crash due to invalid image size, patch by Christopher Layne
May 20, 2008
* [antonin] memory leak fixed in openjpeg.c (opj_destroy_cstr_info()), patch by Carsten Juttner
March 12, 2008
+ [GB] help line for the -F option in j2k_to_image
March 4, 2008
! [FOD] Changed Java files copyright in JavaOpenJPEG module
February 28, 2008
* [FOD] Fixed openjpeg.c for proper initialization of codec context structures (dinfo in opj_create_compress()
and opj_create_decompress(). Bug fix suggested by Andrey V. Kiselev
* [FOD] Clean up of opj_aligned_malloc(), to just forgo the use of posix_memalign(),
as apparently memalign() is what is working better for everyone. Patch by Callum.
February 28, 2008
- [FOD] Removed the J2KViewer module, which has been replaced by OPJViewer
* [FOD] Fixed the error handling of j2k_decode in jp2.c, thanks to Robin Cornelius
February 11, 2008
* [GB] Minor style modifications to comply with c99 compiler flag; removed Microsoft-specific "union-in-struct" syntax; Re-enabled cstr_info struct creation when -W switch is specified
! [GB] Changed a number of things in opjviewer (e.g., decoding thread does not execute GUI calls anymore), to have it running under linux --> it is better than before, but still crashes
February 5, 2008
! [Parvatha] In convert.c, corrected imagetobmp() conversion for grayscale. In tcd.c, corrected Rate modification in
tcd_init_encode(). Thanks to Jeremy Furtek and Jérôme Fimes.
January 31, 2008
! [GB] In opjviewer, unification of JPEG 2000 family handlers (*.jp2, *.mj2, *.j2k) in a single file
January 22, 2008
! [FOD] In image.c, changed the opj_image_create0() memory allocation from malloc() to calloc() in order
to avoid segfaults when freeing the memory allocated for the coding of bad images.
Thanks to Christopher Layne for this improvement.
January 17, 2008
+ [antonin] Initial commit of Xcode project directory (XCode 2.5 for macosx)
available targets : libopenjpeg (stat and dyn), image_to_j2k, j2k_to_image
January 16, 2008
* [antonin] fixed opj_malloc.h for macosx (bugfix provided by janpeder, thanks)
January 11, 2008
+ [FOD] Added missing files to JavaOpenJPEG project (files from Patrick Piscaglia)
January 4, 2008
* [Parvatha] Patch by Callum Lerwick. Fixed bug during encoding using tile option in tcd.c
----------------------
December 21, 2007
VERSION 1.3.0 RELEASED
----------------------
December 21, 2007
* [FOD] Bug fixed by David Bruken. Fixed memory allocation issue in opj_malloc.h
! [FOD] Possible errors in pi_create_encode handled
December 19, 2007
* [Antonin] changed variables names alpha, beta, gamma, delta in dwt.c to avoid re-declarations on Macosx
! [Parvatha] In pi.c, removed the Recursive function pi_check_next_level() and modified the code.
* [FOD] Fixed allocation problem in pi.c
December 19, 2007
+ [FOD] In mqc.h, changed MQC_NUMCTXS from 32 to 19 as there are only 19 possible contexts
December 10, 2007
+ [FOD] First import of JAVAOpenJPEG, a Java wrapper of OpenJPEG, developed by Patrick Piscaglia of Telemis (www.telemis.com).
Thank you Patrick for this new module !
November 29, 2007
! [GB] Added index.h and index.c in VC6 projects; wrapped index.h in the C++ preprocessor; modified OPJViewer project and some files.
November 14, 2007
+ [FOD] Created the file index.c in the codec directory. This file handles the creation of index files,
at encoding and decoding.
* [FOD] Fixed bugs during the creation of the index (PCRL progression order)
* [FOD] Fixed the maximum number of resolutions a user can discard while decoding.
Added an error state in J2K_STATE (j2k.c)
November 14, 2007
! [FOD] - First Patch by Callum Lerwick. Instead of reinventing realloc, j2k_read_sod now just uses opj_realloc in j2k.c
- Second Patch by Callum Lerwick. This patch rearranges the largest memory allocations so they're allocated as
late as possible, and freed as soon as possible. This cuts memory usage by about half on two large test images.
- Third Patch by Callum Lerwick. The opj_tcd_cblk array is one of the largest allocations, because it
contains a bunch of static buffers. This also makes it a major source of cache thrashing. This patch allocates
the buffers from the heap, and dynamically sizes them in the decoder. I have not yet managed to dynamically size
them in the encoder, getting the decoder to do it was tricky enough... I also split opj_tcd_cblk_t into separate
encode and decode versions. A lot of fields were not used by both, so this cuts its size even further.
* [FOD] Avoided ABI breakage
November 13, 2007
! [FOD] Patch by Dzonatas and Callum Lerwick.
Fp/vectorization patch which basically converts most of the irreversible decode codepath to floating point,
eliminating a few rounds of int/fp conversion, resulting in a vast performance improvement,
and an increase in accuracy.
November 8, 2007
! [FOD] In t1.c, small change to avoid calling twice t1_getwmsedec()
Patches from Callum Lewick:
- Basic gcc optimization flags in cmake and makefile match.
- Fixed some spelling errors in dwt.c.
November 5, 2007
*+ [GB] Fixed a bug which prevented JPWL from working on multi-tiled images; added some more fields in the interface info structures
(keep a list of markers, save start packet number for each tile)
October 23, 2007
* [GB] Improved success for the linux build; OPJViewer shows all the COM contents
October 18, 2007
* [FOD] Changed the ROI parameter in the image_to_j2k codec to make it correspond to the documentation (i.e. -ROI c=0,U=25)
* [FOD] Patch from Callum Lewick. Memset patch.
The main idea of the patch is that currently opj_malloc clears all allocations, which unnecessarily
dirties up the cache and eats bandwidth. This patch makes it no longer do so, and I've painstakingly determined which allocations actually need
to be cleared and changed them to use opj_calloc() instead. I previously tried to just get rid of the opj_*alloc wrappers but that
idea was nixed, so this time I'm trying it with macros. I also put in a gcc pragma that helps enforce their use. Which got messy. :) It caught a
few places they weren't used but it also revealed that the mj2 tools are not very cleanly separated from the library. It includes all the
internal headers, but it wasn't using the malloc wrappers. I figured the binaries should be "external" and have minimal knowledge of the
internals of the library. I patched them to not include opj_includes.h, and include only the internal headers they actually need. However,
they're using the opj_clock() function, which is in with the malloc wrappers. So I decided to move the malloc wrappers to their own header.
But mj2.c seems to want to be "internal", so I patched it to use the wrappers. Note that this patch changes the semantics of opj_malloc, it no longer
clears the memory it allocates. If you need it to be cleared, you must use opj_calloc instead, or memset it yourself. It is also somewhat
invasive, please test it extensively. I've been pounding on it all summer with my test suite, Second Life, and valgrind, and it checks out clean.
October 12, 2007
* [FOD] Changed the way the image structure is allocated when the decoding parameters include some resolutions to discard.
This should have a significant impact for the decoding of huge images when some resolutions are discarder (-r parameter)
Warning: The output image size is now reduced when discarding resolutions !
October 10, 2007
* [FOD] Patch from Callum Lewick. Clean up of j2klib.h for the aligned malloc stuff.
It makes it work right with mingw, as _mm_malloc() isn't a macro, attempts to pave the way to using cmake
to check for this stuff and combines a patch from Dana Fagerstrom at Sun that makes it use memalign() on Solaris
convert.c: Changed some error comments for TIFF images
September 27, 2007
* [FOD] Patch from Callum Lewick. Fixed dwt.c where an alignment in buffer was problematic under x86_64.
September 25, 2007
* [Mathieu Malaterre] BUG: Fix previous patch from Callum Lerwick. I have no
clue what CMAKE_INSTALL_LIBDIR refers too. Bump up cmake 2.2 restriction to
cmake 2.4 because of previous patch (not backward compatible). Properly set the SOVERSION in a cross plateform way (yes WIN32 is a platform)
September 19, 2007
* [Parvatha] Fixed issues with generation of SOP marker.
September 18, 2007
* [Parvatha] Fixed issues with Reading and Writing TIF images in convert.c to avoid segmentation fault.
* [Parvatha] Fixed issues relating to using user specified rates for CINEMA option for multiple images.
September 17, 2007
* [FOD] Fixed issues with cstr_info when codestream has components with different number of resolutions.
! [FOD] OpenJPEG library interface modified to retain compatibility with version 1.2
September 12, 2007
* [FOD] Patch from Callum Lerwick.
Fixed the library linking so it links with the soversion properly set.
Fixes up the install targets so that it interacts properly with RPM.
Install target for MJ2. Sets some necessary and useful CFLAGS if gcc is in use.
* [FOD] Updated the MJ2 codec to be compatible with the recent changes in the OpenJPEG library
September 11, 2007
* [GB] JPWL encoding is finalized correctly into the JP2 file format; added an additional structure in opj_codestream_info, to keep a record of the written markers
September 8, 2007
* [GB] Adapted the JPWL and OPJViewer code to new interface; fixed a samll bug in JPWL which created large EPBs even when null protection was specified
September 7, 2007
+ [FOD] Indexes can now be generated when decoding J2K codestreams.
* [Mathieu Malaterre] Upon failure, properly return error code (!=0).
* [Mathieu Malaterre] CMake: Add cmake code to do testing if user has properly setup a testimages directory
September 6, 2007
+ [Mathieu Malaterre] CMake: start compiling mj2, jpwl and jp3d
+ [Mathieu Malaterre] CMake: output all executable/libs into one single directory
+ [Mathieu Malaterre] CMake: start compiling index_create
+ [Mathieu Malaterre] OpenJPEG.rc update copyright year
+ [Mathieu Malaterre] CMake: add Java j2kviewer but do not compile it using cmake since cmake has too poor support for Java. Should create a custom command running ant instead.
+ [Mathieu Malaterre] CMake: Add doxygen output
+ [GB] One more field in the codestream_info struct for recording the number of packets per tile part; JPWL now distributes the EPBs in all the tile part headers
+ [Mathieu Malaterre] CMake: Add very simple tests (simply run command line with no option)
* [Mathieu Malaterre] Fix unitialized read in img_fol (we may need a smarter initialize than memset)
September 4, 2007
+ [GB] Added some fields in the codestream_info structure: they are used to record the position of single tile parts.
Changed also the write_index function in the codec, to reflect the presence of this new information.
September 3, 2007
+ [GB] Added the knowledge of JPSEC SEC and INSEC markers (you have to compile the JPWL project). Management of these markers is limited to skipping them without crashing:
no real security function at this stage. Deprecated USE_JPSEC will be removed next
August 31, 2007
* [GB] Fixed save capabilities in OPJViewer due to recent code upgrade
August 30, 2007
* [FOD] Changed the OpenJPEG library interface to enable users to access information regarding the codestream (also called codestream index).
This index is usefull for all applications requiring to have a scalable acces to the codestream (like JPIP applications, ...)
Currently, this information is only available when encoding an image.
+ [FOD] Added the information regarding the end of packet position in the index
August 28, 2007
* [FOD] Fixed wrong destructors called in openjpeg.c
* [FOD] Fixed bug in j2k_decode_jpt_stream
August 24, 2007
* [Parvatha] The end of main header is calculated after TLM and POC marker for Dcinema.
August 21, 2007
+ [FOD] Added support for Visual Studio 2005
* [FOD] Robustified MJ2 codecs
* [Parvatha] Solved problems with codec reading from image file directory when filename had more than one "." in name
* [Callum Lerwick] Minor cleanup patch, that gets rid of a bunch of "old style declaration" warnings from Intel's compiler
* [Callum Lerwick] Aligned malloc using Intel's _mm_malloc(). Cleanup on the t1 memory allocation, getting rid of some leftover debug code
* [Callum Lerwick] Memory leaks fixed
* [Callum Lerwick] Reworks of t1_updateflags to get rid of the shift operation
* [Callum Lerwick] mqc_setcurctx moved to the header to allow it to be inlined into the t1.
* [Callum Lerwick] Consolidated some calls to mqc_setcurctx.
* [Callum Lerwick] Cleaned up t1_generate_luts to output the proper types.
* [Callum Lerwick] Replaced the large ctxno_mag lookup table with a small bit of inline-able branchless code
* [Callum Lerwick] Moved the orient flipping into the ctxno_zc table.
August 20, 2007
+ [FOD] Added support for the TGA file format in the codec
August 08, 2007
* [Parvatha] Fixed the DCinema filesize allocation. It now includes the SOT marker size
August 02, 2007
+ [GB] Added a basic saving capability to OPJViewer
July 18, 2007
! [FOD] Updated libtiff library version to 3.8.2 (for WIN32)
* [FOD] Updated BMP and PxM truncation when decoding J2K files with more than 8 bits
July 17, 2007
* [FOD] Fixed raw option for images with more than three components
July 17, 2007
+ [FOD] Added support for RAW images. This module has been developped by the University of Perugia team. Thanks to them ! [image_to_j2k.c j2k_to_image.c convert.c convert.h]
July 13, 2007
! [FOD] Modified the memory allocation for codestreams containing multiple tiles. The memory is now allocated for each tile indenpendently,
leading to an important decrease of the virtual memory needed. [j2k.c tcd.h tcd.c]
! [FOD] Modified old comments about the ability to decode mega-images and comments about the disk size necessary to do this. [image_to_j2k.c and frames_to_mj2.c]
* [FOD] Added 2000 bytes for the memory allocation in cio.c for the minimum size of headers (useful in case of very small images) [cio.c]
July 12, 2007
* [GB] fixed a bug in JPWL module, which prevented to exploit the full error correction capability of RS codes (e.g. it gave up at 5 errors,
even if 6 were correctable); defined a JPWL_MAXIMUM_EPB_ROOM for better customization of the maximum dimension of EPBs (the dimension
is pre-calculated on an hypothesis, if it goes beyond 65535 there will be problems, thus we give a little less than the max, let's say 65450)
July 8, 2007
* [ANTONIN] fixed the size of the memory allocation in cio.c (confusion between bits and bytes)
June 21, 2007
* [FOD] Output image color space set when decoding a JP2 file in jp2.c
+ [GB] Previous, home, and next frame buttons for exploring MJ2 files in OPJViewer
June 18, 2007
* [GB] Reload image doesn't crash in OPJViewer; more settings saved to registry
June 16, 2007
+ [GB] Possibility to disable parsing in OPJViewer; also, saves common settings to the registry
June 15, 2007
* [FOD] Fixed the generation of index files
----------------------
MAY 4, 2007
VERSION 1.2.0 RELEASED
----------------------
May 4, 2007
* [FOD] Bugs corrected in decoding of command line (getopt.c), in the handling of 16 bit files (t1.c and tcd.c) and the calculation of elapsed time for multiple tiles parts (tcd.c and tdc.h).
June 2, 2007
+ [GB] OPJViewer opens now BMP, PNG, GIF, PNM, TIFF (with wxWidgets internals); added an encoder settings tab, for future integration with "save file as..." in JPEG 2000 format
May 31, 2007
* [FOD] Fixed the handling of 16bit TIFF files for cinema compression. Modified "convert.c"
* [FOD] Fixed the parameters used for cinema compression (9-7 transform used instead of 5-3). Modified "image_to_j2k.c"
May 24, 2007
* [FOD] Bug fixed by Sylvain Munaut. Change in the reading of the POC marker. Since COD/COC can be anywhere in the header, the decoder cannot always know while decoding the POC marker
the value of numlayers and numresolution.
May 23, 2007
! [FOD] Patch suggested by Callum Lerwick <seg@haxxed.com>: "This makes the t1 data arrays dynamic, which greatly reduces cache thrashing. Also, some minor cleanup to prevent unnecessary casts"
May 22, 2007
! [FOD] Patch suggested by Callum Lerwick <seg@haxxed.com>: "Some formatting cleanups,
so that the long function definitions and calls fit on screen. Use of prefix increment which is theoretically faster, in practice any sane compiler can optimize a postfix
increment but its best not to count on such things. Consolidation of some redundant calculations in the inner loops, which becomes very useful in the future autovectorize patch."
! [FOD] Patch suggested by Callum Lerwick <seg@haxxed.com>: "This changes the flag code in t1 to use a flag_t type, which can then be changed to reduce RAM usage. It is now typedef to a short."
! [FOD] Patch suggested by Callum Lerwick <seg@haxxed.com>: "This patch makes the t1 LUTs static. I actually intend this as a prelude to possibly eliminating some or all of the LUTs entirely."
May 11, 2007
- [FOD] JP3D library Binaries removed from SVN.
! [FOD] MJ2 codec updated from LibOpenJPEG version 0.97 to LibOpenJPEG version 1. Hence, the MJ2 codec will now take advantage of all the improvements and optimizations done on the LibOpenJPEG library.
! [FOD] Possibility to choose to apply MCT (multiple component transform) enabled, and new decoding_limit: DECODE_ALL_BUT_PACKETS (openjpeg.h)
April 26, 2007
+ [gdcm] Add basic steps on how to use CMake for building examples (README.cmake)
April 25, 2007
+ [FOD] Modification of the openjpeg.h file to avoid and ABI break with v1.1, removed the dangerous #IFDEF JPWL and added tcp_mct in cparameters.
April 23, 2007
+ [GB] Enable/disable image decoding in OPJViewer
April 12,2007
* [Parvatha] Fixed Error in tiftoimage(). Modification in convert.c.
April 10,2007
+ [Parvatha] Accepting "j2c" as format for Encoding and Decoding. Modification in image_to_j2k.c.
* [Parvatha] Modified imagetotif() to read images with signed data. Modification in convert.c.
April 5, 2007
! [FOD] fix.h optimized. Thanks a lot to Dzonatas <dzonatas at dzonux.net> !
! [FOD] dwt.c optimized. Thanks a lot to Dzonatas <dzonatas at dzonux.net> !
! [FOD] t1.c optimized. Thanks a lot to Callum Lerwick <seg at haxxed.com> !
April 4,2007
+ [Parvatha] Digital cinema compliance for 4K chosen by "-cinema4K" option. Modification in image_to_j2k.c.
+ [Parvatha] Bit rate limitation for each color component. Modification in image_to_j2k.c, t2.c.
* [Parvatha] Modified and tested Progression order change "-POC" option. Modification in image_to_j2k.c, j2k.c, pi.c.
+ [Parvatha] Function j2k_check_poc_val() to check for possible loss of packets in case of wrong POC declaration. Modification in j2k.c.
+ [Parvatha] Structure T2_MODE. This tells if the t2_encode_packets() is called during Threshold calculation or in Final pass. Modification in j2k.h, tcd.c
March 30, 2007
* [GB] OPJViewer should now work under Linux, at least with not big j2k files. Tested under Suse 10.1 64 bit.
March 29, 2007
* [Parvatha] Enable accepting file names with `-´ symbol .Modification getopt.c
* [Parvatha] Rsiz profile name generation to be STD_RSIZ for profiles which are not DCI compliant.Modification in image_to_j2k.c
! [Parvatha] renamed convert_progression_order to j2k_convert_progression_order. Modification j2k.c
* [Parvatha] Calculation of number of tile part in each tile in j2k_calculate_tp. Modification j2k.c
! [Parvatha] j2k_setup_encoder to set bit rate limitation for digital cinema compliance with quality option. Modification in j2k.c
* [Parvatha] Equation to check multiple tile precincts. Modification pi.c
! [Parvatha] array size generation of pi->include in pi_initialise_encode().Modification in pi.c
* [Parvatha] modification in pi_create_encode for tile part generation.Modification in pi.c
+ [Parvatha] In tcd_rateallocate a variable stable_threshold which holds the valid threshold value.
This is used to avoid error in case of a wrong threshold value in the last iteration. Modification in tcd.c.
March 28, 2007
* [FOD] Fixed an historical bug in t1.c that leaded to the inclusion of useless 0xFF in the codestream. Thanks to Sylvain, Pascal and Parvatha !
March 27, 2007
+ [GB] Improved parsing in OPJViewer, as well some minor aesthetic modifications; support for image rendering with bit depths lower than 8 bits;
can display an arbitrary frame of an MJ2 file (only in B/W, though); can reload a file; better resizing capabilities
* [GB] Following to Hervé's suggestions, all the exit() calls, added by JPWL strict checking in t2.c and j2k.c,
have been substituted with (object free'ing + opj_evt_message(EVT_ERROR) + return)
+ [GB] Added linking to TIFF library in the JPWL VC6 workspaces
March 23, 2007
* [antonin] Fixed Makefile.osx and changed Readme.osx accordingly
March 21, 2007
* [Parvatha] Fixed j2k_prog_order_list[]. Modifications in j2k.c.
* [Parvatha] Fixed t1_decode_cblks. Modifications in t1.c.
March 20, 2007
+ [Parvatha] Added feature for generation of tile parts. Modifications in image_to_j2k.c, openjpeg.c, j2k.c, pi.c
+ [Parvatha] Added function j2k_write_tlm(),to generate TLM marker for a Digital cinema compliant codestream. Modifications in j2k.c.
March 14, 2007
* [FOD] Fixed linux makefile, with help from David Fries and Guido
March 7, 2007
+ [Parvatha] Added option for Digital cinema profile compliant codestream. This can be chosen by "-cinema2K" or "-cinema4K" for a 2K and 4K compliance respectively. The feature for tileparts has not been implemented in this version. Modification in image_to_j2k.c
+ [Parvatha] Added the Digital Cinema profiles (CINEMA2K and CINEMA4K) to the list of profiles recognized in the codestream SIZ marker segment. Modification in openjpeg.h,j2k.c
+ [Parvatha] Added feature for constant quality within bitrate defined in Digital cinema standards. Modification in tcd.c
! [Parvatha] Modified the method of generation of buffer length. Modification in cio.c
March 1, 2007
* [FOD] Modified codec projects (*.dsp) and makefile to include the tiff library (modified codec/image_to_j2k.dsp codec/j2k_to_image.dsp and codec/makefile)
+ [GB] Zoom capability and decoder settings dialog in OPJViewer; modified JPWL library .dsp project in order to create a library with embedded JPWL functions
February 28, 2007
+ [Parvatha] Enabled compression of TIF image format to j2k by tifftoimage() and decompression of codestream to TIF image format using imagetotif(). Modifications in image_to_j2k.c, j2k_to_image.c, convert.c, convert.h
* [antonin] fixed a bug in context numerotation that prevented the RESET switch to work correctly : mqc_reset_enc in mqc.c
* [Fod] Corrected codec Makefile by adding the compilation of "compat/getopt.c"
February 27, 2007
* [Parvatha] Made get_file_format function more robust. Modifications in image_to_j2k.c, j2k_to_image.c, getopt.c, getopt.h
February 26, 2007
+ [Parvatha] Option to read images from a Folder whose path is specified in the Input parameters by "-ImgDir" along with output decod format specified by "-OutFor" . Modifications in image_to_j2k.c, j2k_to_image.c, getopt.c, getopt.h
+ [Parvatha] Enabling use of multi character input parameters in the codec. Modifications in image_to_j2k.c, j2k_to_image.c, getopt.c, getopt.h
----------------------
February 23, 2007
VERSION 1.1.1 RELEASED
----------------------
February 23, 2007
* [GB] Fixed a copy-and-paste type assignment error (bool instead of int) in the JPWL section of decoder parameters structure in openjpeg.h; minor type-casting in jpwl_lib.c.
As a result, now OPJViewer should run correctly when built against the most current SVN trunk of LibOpenJPEG.lib
+ [GB] Linux makefile for the JPWL module; newlines at end of JPWL files
February 22, 2007
+ [FOD] Added the OPJViewer Module (/OPJViewer), developed by Giuseppe Baruffa of the university of Perugia
February 21, 2007
+ [FOD] Algorithmic optimizations in t1.c, thanks to Guido J. !
February 19, 2007
+ [FOD] Added OPJ_LIMIT_DECODING enabling us to limit the decoding to main header (modified openjpeg.c, openjpeg.h, j2k.c and j2k.h)
February 13, 2007
! [FOD] David Fries suggestions. In image_to_j2k and j2k_to_image, strncpy() functions: instead of specifying the path size macro, let the compiler read the length out of the array entry.
! [FOD] David Fries suggestions. Makefile modified. -fPIC flag used for 64-bit compilation. Move operation (rather than copy) for the dist library creation, and -p flag added.
January 31, 2007
! [FOD] Extra tokens at the end of #endif directive corrected in openjpeg.c, j2k.c and image_to_j2k.c -> no more warnings in linux compilation
! [FOD] Linux Makefile added for the codec
January 30, 2007
! [FOD] Use of OPJ_PATH_LEN (defined as 4096) to be the maximum allowed size for filenames instead of MAX_PATH which is not always defined. This caused some programs using OpenJPEG to crash. Modifications in openjpeg.h j2k_to_image.c and image_to_j2k.c
! [FOD] Correction of the syntax usage in MJ2_codec/mj2_to_frames.c
January 23, 2007
! [FOD] Modification in the context numbers, to reflect what has been specified in standard, in libopenjpeg/t1.h
December 07, 2006
+ [Giuseppe Baruffa] Antonin verified that the MacOS build suffered from a missing definition of the "min" macro; I've added this definition (properly #ifndef'ed) into both jpwl.h and rs.h
December 05, 2006
* [Giuseppe Baruffa] Better fix of the TPH EPBs bug in JPWL module
* [GB] Fixed the UEP bug in JPWL module; now, during a UEP specification, RS protection or CRC check can be switched off for selected range of packets, and consequently reswitched on without confusing the decoder
+ [GB] Added some lines in the help of JPWL_image_to_j2k, specifying that when using error protection on data packets, this must be paired with header protection, i.e. there cannot be packet protection without header protection
December 04, 2006
+ [Francois-Olivier Devaux] New tag: version1.0 (includes codec and libopenjpeg directories)
Total update of JPWL module
- [FOD] removed directories jpwl/decoder, jpwl/encoder, jpwl/decoder_02, jpwl/encoder_02
+ [FOD] added in JPWL directory crc.h, jpwl.h, rs.h, crc.c, jpwl.c, jpwl_lib.c, rs.c, JPWL_image_to_j2k.dsp, JPWL_j2k_to_image.dsp, LibOpenJPEG_JPWL.dsp, JPWL_image_to_j2k.dsw, JPWL_j2k_to_image.dsw
! [FOD] Modifications of libopenjpeg to integrate JPWL module (in libopenjpeg directory): j2k.c, j2k.h, openjpeg.c, openjpeg.h, opj_includes.g, t2.c
! [FOD] Modification of codec to integrate JPWL module (in codec directory): image_to_j2k.c, j2k_to_image.c
* [FOD] Corrected incorrect fprintf() formatting in codec/convert.c
* [FOD] Code optimization usinq vsprintf() command in libopenjpeg/event.c
* [Giuseppe Baruffa] Fixed a bug in TPH EPBs parameters: now, "last in current header" information is correctly signaled
October 31, 2006
* [Antonin] fixed a bug in the computation of the mantissa (mu)
+ [Antonin] added the ability to specify the rate as "float" (before : integer)
August 18, 2006
* [Antonin] fixed a bug in j2k_to_image.c, that prevented the -l option to work correctly.
August 4, 2006
* [Antonin] fixed a bug in pi.c, line 473, that appeared when more than 100 precincts were generated in a resolution level.
July 28, 2006
+ [Antonin Descampe] added a readme in /mj2 to warn people that it only works with opj0.97
July 21, 2006
* [Mathieu Malaterre] Install exe and lib and include correctly
* [Mathieu Malaterre] Fixed mem leaks and greyscale bmp
* [Mathieu Malaterre] Fix pgx name length + random memory access
! [Mathieu Malaterre] API is now const
March 19, 2006
* [Antonin] fixed a bug in t1.c that prevented in some cases a true lossless compression (thanks to Don Mimlitch for reporting this bug)
February 12, 2006
- [Herve Drolon] removed unneeded working variables in opj_tcd_t
February 04, 2006
* [galt] fixed a bug in codec/convert.c::imagetobmp
February 01, 2006
! [Herve Drolon] changed function definitions of INT and FIX modules to 'inline'
+ [Herve Drolon] added a VERSION resource to the DLL version of OpenJPEG
January 31, 2006
* [Mathieu Malaterre] Fix compilation using default openjpeg.dsw
* [Herve Drolon] fixed various minor warnings occuring under icc9 and bcc32
- [Mathieu Malaterre] Remove all references to OPJ_EXPORT, no declspec in header file anymore
+ [Mathieu Malaterre] Add a def.in file which is a template for Module Definition
+ [Herve Drolon] added MSVC project and compiler directives to build a 'standard' WIN32 DLL
! [Mathieu Malaterre] Update CMake to match the new shared lib system (no more def file)
January 27, 2006
* [Antonin Descampe] fixed a two initialization problems in t1.c and tcd.c
January 26, 2006
* [Herve Drolon] fixed various minor warnings occuring under gcc
* [__david__] fixed a segfault in codec/image_to_j2k.c & codec/j2k_to_image.c
* [__david__] fixed help option in codec/j2k_to_image & codec/image_to_j2k
January 25, 2006
! [Mathieu Malaterre] Sync with ITK repository, also add ref to doxygen
! [Mathieu Malaterre] Add a lot of comments on the CMake build system
! [Mathieu Malaterre] Fix MINGW32 and BORLAND compilation problems.
January 25, 2006
* [Antonin Descampe] fixed a problem in convert.c when multiple comments
+ [Antonin Descampe] added cmake files to the project
! [Antonin Descampe] fix.c : replaced "WIN32" by "_MSC_VER" for int64
+ [Antonin Descampe] added "OPJ_EXPORT" in openjpeg.h to generate shared lib with win32
! [Antonin Descampe] removed all CtrlM from files
January 24, 2006
! [Antonin Descampe] event.c : replaced "WIN32" by "_MSC_VER" for i2a
January 20, 2006
* [Antonin Descampe] fixed various minor warnings with gdcm patches
January 19, 2006
* [Herve Drolon] fixed a bug in jp2_read_ihdr (need to allocate jp2->comps)
January 18, 2006
* [Herve Drolon] changed the name of j2k_realloc to opj_realloc
* [Herve Drolon] fixed a bug in opj_cio_open when saving 48-bit images (wrong buffer size calculation)
December 8, 2005
* [Antonin Descampe] fixed a bug when specifying a rate '-r' => no distortion info was available in the index
* [Antonin Descampe] fixed a bug in t1_getwmsedec (stepsize was divided by 8192)
December 5, 2005 - 1.1.0

21
CMake/CTestCustom.cmake.in
View File

@@ -1,21 +0,0 @@
#
# For further details regarding this file,
# see http://www.vtk.org/Wiki/CMake_Testing_With_CTest#Customizing_CTest
#
SET (CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS 50)
SET (CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS 50)
SET(CTEST_CUSTOM_COVERAGE_EXCLUDE
${CTEST_CUSTOM_COVERAGE_EXCLUDE}
# Exclude files from the Testing directories
".*/Testing/.*"
)
SET(CTEST_CUSTOM_WARNING_EXCEPTION
${CTEST_CUSTOM_WARNING_EXCEPTION}
# Suppress warning caused by intentional messages about deprecation
".*warning,.* is deprecated"
)

52
CMake/FindFreeImage.cmake
View File

@@ -1,52 +0,0 @@
#
# Try to find the FreeImage library and include path.
# Once done this will define
#
# FREEIMAGE_FOUND
# FREEIMAGE_INCLUDE_PATH
# FREEIMAGE_LIBRARY
#
IF (WIN32)
FIND_PATH( FREEIMAGE_INCLUDE_PATH FreeImage.h
${OPENJPEG_SOURCE_DIR}/libs/FreeImage
DOC "The directory where FreeImage.h resides")
FIND_LIBRARY( FREEIMAGE_LIBRARY
NAMES FreeImage freeimage freeimage.s
PATHS
${OPENJPEG_SOURCE_DIR}/libs/FreeImage
DOC "The FreeImage library")
ELSE (WIN32)
FIND_PATH( FREEIMAGE_INCLUDE_PATH FreeImage.h
/usr/include
/usr/local/include
/sw/include
/opt/local/include
DOC "The directory where FreeImage.h resides")
FIND_LIBRARY( FREEIMAGE_LIBRARY
NAMES FreeImage freeimage
PATHS
/usr/lib64
/usr/lib
/usr/local/lib64
/usr/local/lib
/sw/lib
/opt/local/lib
DOC "The FreeImage library")
ENDIF (WIN32)
SET(FREEIMAGE_LIBRARIES ${FREEIMAGE_LIBRARY})
IF (FREEIMAGE_INCLUDE_PATH AND FREEIMAGE_LIBRARY)
SET( FREEIMAGE_FOUND TRUE CACHE BOOL "Set to TRUE if GLEW is found, FALSE otherwise")
ELSE (FREEIMAGE_INCLUDE_PATH AND FREEIMAGE_LIBRARY)
SET( FREEIMAGE_FOUND FALSE CACHE BOOL "Set to TRUE if GLEW is found, FALSE otherwise")
ENDIF (FREEIMAGE_INCLUDE_PATH AND FREEIMAGE_LIBRARY)
MARK_AS_ADVANCED(
FREEIMAGE_FOUND
FREEIMAGE_LIBRARY
FREEIMAGE_LIBRARIES
FREEIMAGE_INCLUDE_PATH)

3
CMake/Free_CMakeImport.cmake
View File

@@ -1,3 +0,0 @@
SET(CMAKE_MODULE_PATH "${OPENJPEG_SOURCE_DIR}/CMake")
FIND_PACKAGE(FreeImage REQUIRED)
ADD_DEFINITIONS ( -DFREEIMAGE_LIB )

49
CMake/OpenJPEGConfig.cmake.in
View File

@@ -1,49 +0,0 @@
#-----------------------------------------------------------------------------
#
# OPENJPEGConfig.cmake - CMake configuration file for external projects.
#
# This file is configured by OPENJPEG and used by the UseOPENJPEG.cmake
# module to load OPENJPEG's settings for an external project.
@OPENJPEG_CONFIG_INSTALL_ONLY@
# The OPENJPEG version number.
SET(OPENJPEG_MAJOR_VERSION "@OPENJPEG_VERSION_MAJOR@")
SET(OPENJPEG_MINOR_VERSION "@OPENJPEG_VERSION_MINOR@")
SET(OPENJPEG_BUILD_VERSION "@OPENJPEG_VERSION_BUILD@")
# The libraries.
SET(OPENJPEG_LIBRARIES "@OPENJPEG_LIBRARIES@")
# The CMake macros dir.
SET(OPENJPEG_CMAKE_DIR "@OPENJPEG_CMAKE_DIR_CONFIG@")
# The configuration options.
SET(OPENJPEG_BUILD_SHARED_LIBS "@OPENJPEG_BUILD_SHARED_LIBS@")
# The "use" file.
SET(OPENJPEG_USE_FILE "@OPENJPEG_USE_FILE_CONFIG@")
get_filename_component(SELF_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
if(EXISTS ${SELF_DIR}/OpenJPEGTargets.cmake)
# This is an install tree
include(${SELF_DIR}/OpenJPEGTargets.cmake)
get_filename_component(OPENJPEG_INCLUDE_ROOT "${SELF_DIR}/../../@OPENJPEG_INSTALL_INCLUDE_DIR@" ABSOLUTE)
set(OPENJPEG_INCLUDE_DIRS ${OPENJPEG_INCLUDE_ROOT})
set(OPENJPEG_LIBRARIES openjpeg)
else(EXISTS ${SELF_DIR}/OpenJPEGTargets.cmake)
if(EXISTS ${SELF_DIR}/OpenJPEGExports.cmake)
# This is a build tree
SET( OPENJPEG_INCLUDE_DIRS @OPENJPEG_INCLUDE_PATH@)
include(${SELF_DIR}/OpenJPEGExports.cmake)
else(EXISTS ${SELF_DIR}/OpenJPEGExports.cmake)
message(FATAL_ERROR "ooops")
endif(EXISTS ${SELF_DIR}/OpenJPEGExports.cmake)
endif(EXISTS ${SELF_DIR}/OpenJPEGTargets.cmake)
set(OPENJPEG_USE_FILE ${SELF_DIR}/UseOPENJPEG.cmake)
# Backward compatible part:
SET(OPENJPEG_FOUND TRUE)

51
CMake/mymachine_openjpeg.cmake
View File

@@ -1,51 +0,0 @@
cmake_minimum_required(VERSION 2.8)
# simply copy this file anywhere on your system and execute like this:
# ctest -S mymachine_openjpeg.cmake -V
# This will retrieve/compile/run tests/upload to cdash OpenJPEG
# results will be available at: http://my.cdash.org/index.php?project=OPENJPEG
# Begin User inputs:
set( CTEST_SITE "mymachine" ) # generally the output of hostname
set( CTEST_DASHBOARD_ROOT "/tmp" ) # writable path
set( CTEST_CMAKE_GENERATOR "Unix Makefiles" ) # What is your compilation apps ?
set( CTEST_BUILD_CONFIGURATION Debug) # What type of build do you want ?
set( ENV{CFLAGS} "-Wall" ) # just for fun...
# For testing we need to define the path to J2KP4files
# wget http://www.crc.ricoh.com/~gormish/jpeg2000conformance/j2kp4files_v1_5.zip
# unzip j2kp4files_v1_5.zip
set( CACHE_CONTENTS "
BUILD_TESTING:BOOL=TRUE
JPEG2000_CONFORMANCE_DATA_ROOT:PATH=${CTEST_SOURCE_DIRECTORY}/J2KP4files" )
# End User inputs:
# You do not need to change anything after that:
# 1. openjpeg specific:
set( CTEST_PROJECT_NAME "OPENJPEG" )
set( CTEST_SOURCE_NAME OpenJPEG)
set( CTEST_BUILD_NAME "${CMAKE_SYSTEM}-${CTEST_CMAKE_GENERATOR}-${CTEST_BUILD_CONFIGURATION}")
set( CTEST_BINARY_NAME "${CTEST_SOURCE_NAME}-${CTEST_BUILD_NAME}")
# 2. cdash/openjpeg specific:
# svn checkout http://openjpeg.googlecode.com/svn/trunk/ openjpeg-read-only
set( CTEST_SVN_URL "http://openjpeg.googlecode.com/svn/")
set( CTEST_UPDATE_COMMAND "svn")
#set( CTEST_CHECKOUT_COMMAND "${CTEST_UPDATE_COMMAND} co ${CTEST_SVN_URL}/trunk ${CTEST_SOURCE_NAME}")
set( CTEST_CHECKOUT_COMMAND "${CTEST_UPDATE_COMMAND} co ${CTEST_SVN_URL}/branches/v2 ${CTEST_SOURCE_NAME}")
# 3. cmake specific:
set( CTEST_SOURCE_DIRECTORY "${CTEST_DASHBOARD_ROOT}/${CTEST_SOURCE_NAME}")
set( CTEST_BINARY_DIRECTORY "${CTEST_DASHBOARD_ROOT}/${CTEST_BINARY_NAME}")
set( CTEST_NOTES_FILES "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
ctest_empty_binary_directory( "${CTEST_BINARY_DIRECTORY}" )
file(WRITE "${CTEST_BINARY_DIRECTORY}/CMakeCache.txt" "${CACHE_CONTENTS}")
# Perform the Nightly build
ctest_start(Nightly)
ctest_update(SOURCE "${CTEST_SOURCE_DIRECTORY}")
ctest_configure(BUILD "${CTEST_BINARY_DIRECTORY}")
ctest_build(BUILD "${CTEST_BINARY_DIRECTORY}")
ctest_test(BUILD "${CTEST_BINARY_DIRECTORY}")
ctest_submit()

204
CMakeLists.txt
View File

@@ -1,204 +0,0 @@
# Main CMakeLists.txt to build the OpenJPEG project using CMake (www.cmake.org)
# Written by Mathieu Malaterre
# 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.6)
IF(COMMAND CMAKE_POLICY)
CMAKE_POLICY(SET CMP0003 NEW)
ENDIF(COMMAND CMAKE_POLICY)
IF(NOT OPENJPEG_NAMESPACE)
SET(OPENJPEG_NAMESPACE "OPENJPEG")
SET(OPENJPEG_STANDALONE 1)
ENDIF(NOT OPENJPEG_NAMESPACE)
# In all cases:
STRING(TOLOWER ${OPENJPEG_NAMESPACE} OPENJPEG_LIBRARY_NAME)
PROJECT(${OPENJPEG_NAMESPACE} C)
# 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 0)
SET(OPENJPEG_VERSION_BUILD 0)
SET(OPENJPEG_VERSION
"${OPENJPEG_VERSION_MAJOR}.${OPENJPEG_VERSION_MINOR}.${OPENJPEG_VERSION_BUILD}")
# This setting of SOVERSION assumes that any API change
# will increment either the minor or major version number of openjpeg
SET(OPENJPEG_LIBRARY_PROPERTIES
VERSION "${OPENJPEG_VERSION_MAJOR}.${OPENJPEG_VERSION_MINOR}.${OPENJPEG_VERSION_BUILD}"
SOVERSION "${OPENJPEG_VERSION_MAJOR}.${OPENJPEG_VERSION_MINOR}"
)
# You will also need to define a value for the following variables:
# OPENJPEG_INSTALL_BIN_DIR - binary dir (executables)
# OPENJPEG_INSTALL_LIB_DIR - library dir (libs)
# OPENJPEG_INSTALL_DATA_DIR - share dir (say, examples, data, etc)
# OPENJPEG_INSTALL_INCLUDE_DIR - include dir (headers)
# --------------------------------------------------------------------------
# Install directories
STRING(TOLOWER ${PROJECT_NAME} projectname)
SET(subdir "${projectname}-${OPENJPEG_VERSION_MAJOR}.${OPENJPEG_VERSION_MINOR}")
IF(NOT OPENJPEG_INSTALL_BIN_DIR)
SET(OPENJPEG_INSTALL_BIN_DIR "bin")
ENDIF(NOT OPENJPEG_INSTALL_BIN_DIR)
IF(NOT OPENJPEG_INSTALL_LIB_DIR)
SET(OPENJPEG_INSTALL_LIB_DIR "lib")
ENDIF(NOT OPENJPEG_INSTALL_LIB_DIR)
IF(NOT OPENJPEG_INSTALL_DATA_DIR)
SET(OPENJPEG_INSTALL_DATA_DIR "share/${subdir}")
ENDIF(NOT OPENJPEG_INSTALL_DATA_DIR)
IF(NOT OPENJPEG_INSTALL_INCLUDE_DIR)
SET(OPENJPEG_INSTALL_INCLUDE_DIR "include/${subdir}")
ENDIF(NOT OPENJPEG_INSTALL_INCLUDE_DIR)
IF(NOT OPENJPEG_INSTALL_DOC_DIR)
SET(OPENJPEG_INSTALL_DOC_DIR "share/doc/${subdir}")
ENDIF(NOT OPENJPEG_INSTALL_DOC_DIR)
IF(NOT OPENJPEG_INSTALL_PACKAGE_DIR)
SET(OPENJPEG_INSTALL_PACKAGE_DIR ${OPENJPEG_INSTALL_LIB_DIR}/${subdir}
CACHE INTERNAL "")
ENDIF(NOT OPENJPEG_INSTALL_PACKAGE_DIR)
#-----------------------------------------------------------------------------
# Test for some required system information.
INCLUDE (${CMAKE_ROOT}/Modules/CMakeBackwardCompatibilityC.cmake)
#-----------------------------------------------------------------------------
# Setup file for setting custom ctest vars
CONFIGURE_FILE(
${CMAKE_CURRENT_SOURCE_DIR}/CMake/CTestCustom.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/CTestCustom.cmake
@ONLY
)
#-----------------------------------------------------------------------------
# OpenJPEG build configuration options.
OPTION(BUILD_SHARED_LIBS "Build OpenJPEG with shared libraries." OFF)
OPTION(ENABLE_PROFILING "Enable profiling for the library" OFF)
#-----------------------------------------------------------------------------
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)
#-----------------------------------------------------------------------------
# For the codec...
OPTION(BUILD_EXAMPLES "Build the Examples (codec...)." OFF)
# 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 IMMEDIATE)
ENDIF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/openjpeg_mangle.h.in)
#-----------------------------------------------------------------------------
# Configure files with settings for use by the build.
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/opj_configure.h.in
${CMAKE_CURRENT_BINARY_DIR}/opj_configure.h)
#-----------------------------------------------------------------------------
# Always build the library
INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_BINARY_DIR})
SUBDIRS(
libopenjpeg
# mj2
#j2kviewer/src
)
#IF(NOT UNIX)
#SUBDIRS(
# jpwl
# jp3d
# indexer_JPIP
# )
#ENDIF(NOT UNIX)
#-----------------------------------------------------------------------------
# Build example only if requested
IF(BUILD_EXAMPLES)
SUBDIRS(codec)
ENDIF(BUILD_EXAMPLES)
#-----------------------------------------------------------------------------
# For the documentation
OPTION(BUILD_DOCUMENTATION "Build the doxygen documentation" OFF)
IF(BUILD_DOCUMENTATION)
SUBDIRS(doc)
ENDIF(BUILD_DOCUMENTATION)
#-----------------------------------------------------------------------------
# For openjpeg team if they ever want CDash+CMake
OPTION(BUILD_TESTING "Build the tests." OFF)
IF(BUILD_TESTING)
ENABLE_TESTING()
INCLUDE(CTest)
ENDIF(BUILD_TESTING)
IF(BUILD_TESTING)
SET(CMAKE_MODULE_PATH "${OPENJPEG_SOURCE_DIR}/CMake")
FIND_PACKAGE(FreeImage)
SUBDIRS(
test_V2_tile_handling
)
if(FREEIMAGE_FOUND)
INCLUDE_DIRECTORIES( ${FREEIMAGE_INCLUDE_PATH} )
SUBDIRS(
test_Free_image_V2_tile_handling
)
endif(FREEIMAGE_FOUND)
ENDIF(BUILD_TESTING)
# Adding test with dataset from:
# http://www.crc.ricoh.com/~gormish/jpeg2000conformance/
# -> wget http://www.crc.ricoh.com/~gormish/jpeg2000conformance/j2kp4files_v1_5.zip
# http://www.jpeg.org/jpeg2000guide/testimages/testimages.html
#-----------------------------------------------------------------------------
# Adding JPEG2000_CONFORMANCE_DATA_ROOT
FIND_PATH(JPEG2000_CONFORMANCE_DATA_ROOT testimages.html
${OPENJPEG_SOURCE_DIR}/../jpeg2000testimages
$ENV{JPEG2000_CONFORMANCE_DATA_ROOT}
)
#-----------------------------------------------------------------------------
# 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(CMAKE_C_FLAGS_RELEASE "-ffast-math ${CMAKE_C_FLAGS_RELEASE}")
ENDIF(CMAKE_COMPILER_IS_GNUCC)
# install all targets referenced as OPENJPEGTargets
install(EXPORT OpenJPEGTargets DESTINATION ${OPENJPEG_INSTALL_PACKAGE_DIR})
CONFIGURE_FILE( ${OPENJPEG_SOURCE_DIR}/CMake/OpenJPEGConfig.cmake.in
${OPENJPEG_BINARY_DIR}/OpenJPEGConfig.cmake
@ONLY
)
INSTALL( FILES ${OPENJPEG_BINARY_DIR}/OpenJPEGConfig.cmake
DESTINATION ${OPENJPEG_INSTALL_PACKAGE_DIR}
)

7
CTestConfig.cmake
View File

@@ -1,7 +0,0 @@
set(CTEST_PROJECT_NAME "OPENJPEG")
set(CTEST_NIGHTLY_START_TIME "3:00:00 UTC")
set(CTEST_DROP_METHOD "http")
set(CTEST_DROP_SITE "my.cdash.org")
set(CTEST_DROP_LOCATION "/submit.php?project=OPENJPEG")
set(CTEST_DROP_SITE_CDASH TRUE)

30
LICENSE
View File

@@ -1,30 +0,0 @@
/*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* 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.
*/

109
OpenJPEG.rc
View File

@@ -1,109 +0,0 @@
//Microsoft Developer Studio generated resource script.
//
#include "resource.h"
#define APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 2 resource.
//
#include "afxres.h"
/////////////////////////////////////////////////////////////////////////////
#undef APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
// French (France) resources
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_FRA)
#ifdef _WIN32
LANGUAGE LANG_FRENCH, SUBLANG_FRENCH
#pragma code_page(1252)
#endif //_WIN32
#ifndef _MAC
/////////////////////////////////////////////////////////////////////////////
//
// Version
//
VS_VERSION_INFO VERSIONINFO
FILEVERSION 1,1,0,0
PRODUCTVERSION 1,1,0,0
FILEFLAGSMASK 0x3fL
#ifdef _DEBUG
FILEFLAGS 0x1L
#else
FILEFLAGS 0x0L
#endif
FILEOS 0x40004L
FILETYPE 0x2L
FILESUBTYPE 0x0L
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "000004b0"
BEGIN
VALUE "Comments", "The OpenJPEG library is an open-source JPEG 2000 codec. \0"
VALUE "CompanyName", "OpenJPEG\0"
VALUE "FileDescription", "OpenJPEG\0"
VALUE "FileVersion", "1, 1, 0, 0\0"
VALUE "InternalName", "OpenJPEG\0"
VALUE "LegalCopyright", "Copyright <20> 2002-2007, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium\0"
VALUE "LegalTrademarks", "See http://www.openjpeg.org for details\0"
VALUE "OriginalFilename", "OpenJPEG.dll\0"
VALUE "PrivateBuild", "\0"
VALUE "ProductName", "OpenJPEG\0"
VALUE "ProductVersion", "1, 1, 0, 0\0"
VALUE "SpecialBuild", "\0"
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x0, 1200
END
END
#endif // !_MAC
#ifdef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// TEXTINCLUDE
//
1 TEXTINCLUDE DISCARDABLE
BEGIN
"resource.h\0"
END
2 TEXTINCLUDE DISCARDABLE
BEGIN
"#include ""afxres.h""\r\n"
"\0"
END
3 TEXTINCLUDE DISCARDABLE
BEGIN
"\r\n"
"\0"
END
#endif // APSTUDIO_INVOKED
#endif // French (France) resources
/////////////////////////////////////////////////////////////////////////////
#ifndef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 3 resource.
//
/////////////////////////////////////////////////////////////////////////////
#endif // not APSTUDIO_INVOKED

9
README.cmake
View File

@@ -1,9 +0,0 @@
Basic instructions on how to build using CMake (CMake 2.4.5 or newer is required)
svn co http://www.openjpeg.org/svn/trunk
cd trunk
mkdir bin
cd bin
cmake .. -DBUILD_EXAMPLES:BOOL=ON
make
./bin/j2k_to_image

26
README.v2
View File

@@ -1,26 +0,0 @@
Preliminary notes
-----------------
The Version 2 of openjpeg has been currently added as a branch on the repository.
All the trunk has been copied and files that needed to change have been patched. In comparison with the trunk, the 'jp3d' directory has been removed because it's based on a modified version of libopenjpeg version 1 and there is no plan to make it reach the version 2 status. Idem with the 'indexer_JPIP', which is obsolete and should be rewritten from scratch.
At the time of the branch creation, the following files and directories have been updated (or added) for version 2 :
* libopenjpeg/
* codec/
* test_Free_image_V2_tile_handling/ : a test program that uses libopenjpeg v2 and libfreeimage (see libs) to implement a basic codec.
* test_V2_tile_handling/ : a test program that generates a random image and (de)compresses it with libopenjpeg v2.
* CMakeLists.txt
* Free_CMakeImport.cmake
* opj_configure.h.in
Other files and directories from the trunk (project files, jpwl/, OPJViewer/, ...) have also been copied in the branch and should be modified progressively to comply with v2. Check the Changelog for updates on this topic.
Enjoy v2 and feel free to contribute !
Instructions to compile v2
--------------------------
to be added.

6
codec/.cvsignore Normal file
View File

@@ -0,0 +1,6 @@
obj
obj.w32
bin
bin.w32
lib
lib.w32

94
codec/CMakeLists.txt
View File

@@ -1,94 +0,0 @@
# Build the demo app, small examples
# First thing define the common source:
SET(common_SRCS
convert.c
index.c
)
# Then check if getopt is present:
INCLUDE (${CMAKE_ROOT}/Modules/CheckIncludeFile.cmake)
SET(DONT_HAVE_GETOPT 1)
IF(UNIX) #I am pretty sure only *nix sys have this anyway
CHECK_INCLUDE_FILE("getopt.h" CMAKE_HAVE_GETOPT_H)
# Seems like we need the contrary:
IF(CMAKE_HAVE_GETOPT_H)
SET(DONT_HAVE_GETOPT 0)
ENDIF(CMAKE_HAVE_GETOPT_H)
ENDIF(UNIX)
# If not getopt was found then add it to the lib:
IF(DONT_HAVE_GETOPT)
ADD_DEFINITIONS(-DDONT_HAVE_GETOPT)
SET(common_SRCS
${common_SRCS}
compat/getopt.c
)
ENDIF(DONT_HAVE_GETOPT)
# Headers file are located here:
INCLUDE_DIRECTORIES(
${OPENJPEG_SOURCE_DIR}/libopenjpeg
)
# Do the proper thing when building static...if only there was configured
# headers or def files instead
IF(NOT BUILD_SHARED_LIBS)
ADD_DEFINITIONS(-DOPJ_STATIC)
ENDIF(NOT BUILD_SHARED_LIBS)
FIND_PACKAGE(TIFF REQUIRED)
FIND_PACKAGE(PNG REQUIRED)
INCLUDE_DIRECTORIES( ${PNG_INCLUDE_DIR} )
INCLUDE_DIRECTORIES( ${TIFF_INCLUDE_DIR} )
# Loop over all executables:
FOREACH(exe j2k_to_image image_to_j2k j2k_dump)
ADD_EXECUTABLE(${exe} ${exe}.c ${common_SRCS})
TARGET_LINK_LIBRARIES(${exe} ${OPJ_PREFIX}openjpeg ${TIFF_LIBRARIES} ${PNG_LIBRARIES})
ADD_TEST(${exe} ${EXECUTABLE_OUTPUT_PATH}/${exe})
# calling those exe without option will make them fail always:
SET_TESTS_PROPERTIES(${exe} PROPERTIES WILL_FAIL TRUE)
# On unix you need to link to the math library:
IF(UNIX)
TARGET_LINK_LIBRARIES(${exe} m)
ENDIF(UNIX)
# Install exe
INSTALL(TARGETS ${exe}
EXPORT OpenJPEGTargets
DESTINATION ${OPENJPEG_INSTALL_BIN_DIR} COMPONENT Applications
)
ENDFOREACH(exe)
if(BUILD_TESTING)
# Do testing here, once we know the examples are being built:
FILE(GLOB_RECURSE OPENJPEG_DATA_IMAGES_GLOB
"${JPEG2000_CONFORMANCE_DATA_ROOT}/*.j2k"
"${JPEG2000_CONFORMANCE_DATA_ROOT}/*.j2c"
"${JPEG2000_CONFORMANCE_DATA_ROOT}/*.jp2"
)
foreach(filename ${OPENJPEG_DATA_IMAGES_GLOB})
get_filename_component(filename_temp ${filename} NAME)
get_filename_component(filename_ext ${filename} EXT)
execute_process(COMMAND ${EXECUTABLE_OUTPUT_PATH}/j2k_dump -i ${filename}
OUTPUT_VARIABLE dump_success
OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/${filename_temp}.dump
ERROR_QUIET
)
if(dump_success)
file(READ ${CMAKE_CURRENT_BINARY_DIR}/${filename_temp}.dump numcomp_file)
string(REGEX REPLACE ".*numcomps=([0-9]+).*" "\\1"
numcomps "${numcomp_file}")
#message( "found:${output_variable} for ${filename_temp}" )
endif()
ADD_TEST(dump-${filename_temp} ${EXECUTABLE_OUTPUT_PATH}/j2k_dump -i ${filename})
foreach(codec_type ppm pgx bmp tif raw tga png)
ADD_TEST(j2i-${filename_temp}-${codec_type} ${EXECUTABLE_OUTPUT_PATH}/j2k_to_image -i ${filename} -o ${filename_temp}.${codec_type})
ADD_TEST(i2j-${filename_temp}-${codec_type} ${EXECUTABLE_OUTPUT_PATH}/image_to_j2k -i ${filename_temp}.${codec_type} -o ${filename_temp}.${codec_type}${filename_ext})
#if(UNIX)
# ADD_TEST(cmp-${filename_temp}-${codec_type} cmp ${filename} ${filename_temp}.${codec_type}${filename_ext})
#endif(UNIX)
endforeach(codec_type)
endforeach(filename)
endif(BUILD_TESTING)

94
codec/Makefile Normal file
View File

@@ -0,0 +1,94 @@
# $Id$
#
# makefile for OpenJPEG codec
OPENJPEG_DIR = ../libopenjpeg
ifndef DEBUG
LDFLAGS = -s -lm
else
LDFLAGS = -lm
endif
CFLAGS = -Wall -O3 -fno-strength-reduce -fomit-frame-pointer -I$(OPENJPEG_DIR)
OBJ_DIR_W32 = obj.w32
BIN_DIR_W32 = bin.w32
LIB_DIR_W32 = $(OPENJPEG_DIR)/lib.w32
ifdef MINGW32
CC = i386-mingw32-gcc
CFLAGS += -DDONT_HAVE_GETOPT
OBJ_DIR = $(OBJ_DIR_W32)
BIN_DIR = $(BIN_DIR_W32)
LIB_DIR = lib.w32
all: $(BIN_DIR) $(OBJ_DIR) $(LIB_DIR) \
$(addprefix $(BIN_DIR)/,j2k_to_image.exe image_to_j2k.exe)
else
CC = gcc
OBJ_DIR = obj
BIN_DIR = bin
LIB_DIR = lib
all: $(BIN_DIR) $(OBJ_DIR) $(LIB_DIR) \
$(addprefix $(BIN_DIR)/,j2k_to_image image_to_j2k)
endif
ifdef DYNAMIC
ifdef MINGW32
LIB_OPENJPEG = $(LIB_DIR)/libopenjpeg.dll
LDFLAGS += -L$(LIB_DIR) -lopenjpeg
else
LIB_OPENJPEG = $(OPENJPEG_DIR)/$(LIB_DIR)/libopenjpeg.so
LDFLAGS += -L$(OPENJPEG_DIR)/$(LIB_DIR) -lopenjpeg
endif
else
LIB_OPENJPEG = $(OPENJPEG_DIR)/$(LIB_DIR)/libopenjpeg.a
LDFLAGS += $(LIB_OPENJPEG)
endif
$(BIN_DIR):
mkdir $(BIN_DIR)
$(OBJ_DIR):
mkdir $(OBJ_DIR)
$(LIB_DIR):
mkdir $(LIB_DIR)
$(LIB_DIR)/libopenjpeg.dll: $(OPENJPEG_DIR)/$(LIB_DIR)/libopenjpeg.dll
ln -sf ../$< $@
$(OPENJPEG_DIR)/$(LIB_DIR)/libopenjpeg.dll:
cd $(OPENJPEG_DIR) && \
$(MAKE) $(OBJ_DIR) $(LIB_DIR) $(LIB_DIR)/libopenjpeg.dll
$(OPENJPEG_DIR)/$(LIB_DIR)/libopenjpeg.a:
cd $(OPENJPEG_DIR) && \
$(MAKE) $(OBJ_DIR) $(LIB_DIR) $(LIB_DIR)/libopenjpeg.a
$(OPENJPEG_DIR)/$(LIB_DIR)/libopenjpeg.so:
cd $(OPENJPEG_DIR) && \
$(MAKE) $(LIB_DIR) $(LIB_DIR)/libopenjpeg.so
$(OBJ_DIR)/%.o:
$(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
$(OBJ_DIR)/getopt.o: compat/getopt.c
$(OBJ_DIR)/convert.o: convert.c
$(OBJ_DIR)/j2k_to_image.o: j2k_to_image.c
$(OBJ_DIR)/image_to_j2k.o: image_to_j2k.c convert.h
J2I_OBJS = $(addprefix $(OBJ_DIR)/,j2k_to_image.o)
I2J_OBJS = $(addprefix $(OBJ_DIR)/,image_to_j2k.o convert.o)
$(BIN_DIR)/j2k_to_image: $(J2I_OBJS) $(LIB_OPENJPEG)
${CC} -o $@ $(J2I_OBJS) ${LDFLAGS}
$(BIN_DIR)/image_to_j2k: $(I2J_OBJS) $(LIB_OPENJPEG)
${CC} -o $@ $(I2J_OBJS) ${LDFLAGS}
$(BIN_DIR)/j2k_to_image.exe: $(J2I_OBJS) $(LIB_OPENJPEG)
${CC} -o $@ $(J2I_OBJS) ${LDFLAGS}
$(BIN_DIR)/image_to_j2k.exe: $(I2J_OBJS) $(LIB_OPENJPEG) $(OBJ_DIR)/getopt.o
${CC} -o $@ $(I2J_OBJS) ${LDFLAGS} $(OBJ_DIR)/getopt.o
clean:
rm -f $(BIN_DIR_W32)/* $(BIN_DIR)/* $(OBJ_DIR_W32)/* $(OBJ_DIR)/*

163
codec/compat/getopt.c
View File

@@ -45,29 +45,23 @@ int opterr = 1, /* if error message should be printed */
optind = 1, /* index into parent argv vector */ optind = 1, /* index into parent argv vector */
optopt, /* character checked for validity */ optopt, /* character checked for validity */
optreset; /* reset getopt */ optreset; /* reset getopt */
const char *optarg; /* argument associated with option */ char *optarg; /* argument associated with option */
typedef struct option
{
const char *name;
int has_arg;
int *flag;
int val;
}option_t;
#define BADCH (int)'?' #define BADCH (int)'?'
#define BADARG (int)':' #define BADARG (int)':'
#define EMSG "" #define EMSG ""
/* /*
* getopt -- * getopt --
* Parse argc/argv argument vector. * Parse argc/argv argument vector.
*/ */
int getopt(int nargc, char *const *nargv, const char *ostr) { int getopt(nargc, nargv, ostr)
int nargc;
char *const *nargv;
const char *ostr;
{
# define __progname nargv[0] # define __progname nargv[0]
static const char *place = EMSG; /* option letter processing */ static char *place = EMSG; /* option letter processing */
char *oli; /* option letter list index */ char *oli; /* option letter list index */
if (optreset || !*place) { /* update scanning pointer */ if (optreset || !*place) { /* update scanning pointer */
@@ -92,12 +86,11 @@ int getopt(int nargc, char *const *nargv, const char *ostr) {
return (-1); return (-1);
if (!*place) if (!*place)
++optind; ++optind;
if (opterr && *ostr != ':') { if (opterr && *ostr != ':')
fprintf(stderr, (void) fprintf(stderr,
"%s: illegal option -- %c\n", __progname, optopt); "%s: illegal option -- %c\n", __progname, optopt);
return (BADCH); return (BADCH);
} }
}
if (*++oli != ':') { /* don't need argument */ if (*++oli != ':') { /* don't need argument */
optarg = NULL; optarg = NULL;
if (!*place) if (!*place)
@@ -109,12 +102,11 @@ int getopt(int nargc, char *const *nargv, const char *ostr) {
place = EMSG; place = EMSG;
if (*ostr == ':') if (*ostr == ':')
return (BADARG); return (BADARG);
if (opterr) { if (opterr)
fprintf(stderr, (void) fprintf(stderr,
"%s: option requires an argument -- %c\n", "%s: option requires an argument -- %c\n",
__progname, optopt); __progname, optopt);
return (BADCH); return (BADCH);
}
} else /* white space */ } else /* white space */
optarg = nargv[optind]; optarg = nargv[optind];
place = EMSG; place = EMSG;
@@ -122,136 +114,3 @@ int getopt(int nargc, char *const *nargv, const char *ostr) {
} }
return (optopt); /* dump back option letter */ return (optopt); /* dump back option letter */
} }
int getopt_long(int argc, char * const argv[], const char *optstring,
struct option *longopts, int totlen) {
static int lastidx,lastofs;
char *tmp;
int i,len;
char param = 1;
again:
if (optind>argc || !argv[optind] || *argv[optind]!='-')
return -1;
if (argv[optind][0]=='-' && argv[optind][1]==0) {
if(optind >= (argc - 1)){ /* no more input parameters */
param = 0;
}
else{ /* more input parameters */
if(argv[optind + 1][0] == '-'){
param = 0; /* Missing parameter after '-' */
}
else{
param = 2;
}
}
}
if (param == 0) {
++optind;
return (BADCH);
}
if (argv[optind][0]=='-') { /* long option */
char* arg=argv[optind]+1;
const struct option* o;
o=longopts;
len=sizeof(longopts[0]);
if (param > 1){
arg = argv[optind+1];
optind++;
}
else
arg = argv[optind]+1;
if(strlen(arg)>1){
for (i=0;i<totlen;i=i+len,o++) {
if (!strcmp(o->name,arg)) { /* match */
if (o->has_arg == 0) {
if ((argv[optind+1])&&(!(argv[optind+1][0]=='-'))){
fprintf(stderr,"%s: option does not require an argument. Ignoring %s\n",arg,argv[optind+1]);
++optind;
}
}else{
optarg=argv[optind+1];
if(optarg){
if (optarg[0] == '-'){ /* Has read next input parameter: No arg for current parameter */
if (opterr) {
fprintf(stderr,"%s: option requires an argument\n",arg);
return (BADCH);
}
}
}
if (!optarg && o->has_arg==1) { /* no argument there */
if (opterr) {
fprintf(stderr,"%s: option requires an argument \n",arg);
return (BADCH);
}
}
++optind;
}
++optind;
if (o->flag)
*(o->flag)=o->val;
else
return o->val;
return 0;
}
}//(end for)String not found in the list
fprintf(stderr,"Invalid option %s\n",arg);
++optind;
return (BADCH);
}else{ /*Single character input parameter*/
if (*optstring==':') return ':';
if (lastidx!=optind) {
lastidx=optind; lastofs=0;
}
optopt=argv[optind][lastofs+1];
if ((tmp=strchr(optstring,optopt))) {/*Found input parameter in list*/
if (*tmp==0) { /* apparently, we looked for \0, i.e. end of argument */
++optind;
goto again;
}
if (tmp[1]==':') { /* argument expected */
if (tmp[2]==':' || argv[optind][lastofs+2]) { /* "-foo", return "oo" as optarg */
if (!*(optarg=argv[optind]+lastofs+2)) optarg=0;
goto found;
}
optarg=argv[optind+1];
if(optarg){
if (optarg[0] == '-'){ /* Has read next input parameter: No arg for current parameter */
if (opterr) {
fprintf(stderr,"%s: option requires an argument\n",arg);
return (BADCH);
}
}
}
if (!optarg) { /* missing argument */
if (opterr) {
fprintf(stderr,"%s: option requires an argument\n",arg);
return (BADCH);
}
}
++optind;
}else {/*Argument not expected*/
++lastofs;
return optopt;
}
found:
++optind;
return optopt;
} else { /* not found */
fprintf(stderr,"Invalid option %s\n",arg);
++optind;
return (BADCH);
}//end of not found
}// end of single character
}//end '-'
fprintf(stderr,"Invalid option\n");
++optind;
return (BADCH);;
}//end function

15
codec/compat/getopt.h
View File

@@ -3,18 +3,6 @@
#ifndef _GETOPT_H_ #ifndef _GETOPT_H_
#define _GETOPT_H_ #define _GETOPT_H_
typedef struct option
{
const char *name;
int has_arg;
int *flag;
int val;
}option_t;
#define NO_ARG 0
#define REQ_ARG 1
#define OPT_ARG 2
extern int opterr; extern int opterr;
extern int optind; extern int optind;
extern int optopt; extern int optopt;
@@ -22,8 +10,5 @@ extern int optreset;
extern char *optarg; extern char *optarg;
extern int getopt(int nargc, char *const *nargv, const char *ostr); extern int getopt(int nargc, char *const *nargv, const char *ostr);
extern int getopt_long(int argc, char * const argv[], const char *optstring,
const struct option *longopts, int totlen);
#endif /* _GETOPT_H_ */ #endif /* _GETOPT_H_ */

2666
codec/convert.c
View File

File diff suppressed because it is too large Load Diff

57
codec/convert.h
View File

@@ -1,10 +1,7 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens * Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren * Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -28,51 +25,15 @@
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef __J2K_CONVERT_H
#define __J2K_CONVERT_H
/**@name RAW image encoding parameters */ #include "j2k.h"
/*@{*/
typedef struct raw_cparameters {
/** width of the raw image */
int rawWidth;
/** height of the raw image */
int rawHeight;
/** components of the raw image */
int rawComp;
/** bit depth of the raw image */
int rawBitDepth;
/** signed/unsigned raw image */
bool rawSigned;
/*@}*/
} raw_cparameters_t;
/* TGA conversion */ int bmptoimage(char *filename, j2k_image_t * img, int subsampling_dx,
opj_image_t* tgatoimage(const char *filename, opj_cparameters_t *parameters); int subsampling_dy, int Dim[2]);
int imagetotga(opj_image_t * image, const char *outfile);
/* BMP conversion */ int pgxtoimage(char *filename, j2k_image_t * img, int tdy,
opj_image_t* bmptoimage(const char *filename, opj_cparameters_t *parameters); int subsampling_dx, int subsampling_dy, int Dim[2],
int imagetobmp(opj_image_t *image, const char *outfile); j2k_cp_t cp);
/* TIFF to image conversion*/
opj_image_t* tiftoimage(const char *filename, opj_cparameters_t *parameters);
int imagetotif(opj_image_t *image, const char *outfile);
/**
Load a single image component encoded in PGX file format
@param filename Name of the PGX file to load
@param parameters *List ?*
@return Returns a greyscale image if successful, returns NULL otherwise
*/
opj_image_t* pgxtoimage(const char *filename, opj_cparameters_t *parameters);
int imagetopgx(opj_image_t *image, const char *outfile);
opj_image_t* pnmtoimage(const char *filename, opj_cparameters_t *parameters);
int imagetopnm(opj_image_t *image, const char *outfile);
/* RAW conversion */
int imagetoraw(opj_image_t * image, const char *outfile);
opj_image_t* rawtoimage(const char *filename, opj_cparameters_t *parameters, raw_cparameters_t *raw_cp);
#endif /* __J2K_CONVERT_H */
int pnmtoimage(char *filename, j2k_image_t * img, int subsampling_dx,
int subsampling_dy, int Dim[2]);

677
codec/dirent.h
View File

@@ -1,677 +0,0 @@
/*
* uce-dirent.h - operating system independent dirent implementation
*
* Copyright (C) 1998-2002 Toni Ronkko
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* ``Software''), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL TONI RONKKO BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
*
* May 28 1998, Toni Ronkko <tronkko@messi.uku.fi>
*
* $Id: uce-dirent.h,v 1.7 2002/05/13 10:48:35 tr Exp $
*
* $Log: uce-dirent.h,v $
* Revision 1.7 2002/05/13 10:48:35 tr
* embedded some source code directly to the header so that no source
* modules need to be included in the MS Visual C project using the
* interface, removed all the dependencies to other headers of the `uce'
* library so that the header can be made public
*
* Revision 1.6 2002/04/12 16:22:04 tr
* Unified Compiling Environment (UCE) replaced `std' library
*
* Revision 1.5 2001/07/20 16:33:40 tr
* moved to `std' library and re-named defines accordingly
*
* Revision 1.4 2001/07/10 16:47:18 tronkko
* revised comments
*
* Revision 1.3 2001/01/11 13:16:43 tr
* using ``uce-machine.h'' for finding out defines such as `FREEBSD'
*
* Revision 1.2 2000/10/08 16:00:41 tr
* copy of FreeBSD man page
*
* Revision 1.1 2000/07/10 05:53:16 tr
* Initial revision
*
* Revision 1.2 1998/07/19 18:29:14 tr
* Added error reporting capabilities and some asserts.
*
* Revision 1.1 1998/07/04 16:27:51 tr
* Initial revision
*
*
* MSVC 1.0 scans automatic dependencies incorrectly when your project
* contains this very header. The problem is that MSVC cannot handle
* include directives inside #if..#endif block those are never entered.
* Since this header ought to compile in many different operating systems,
* there had to be several conditional blocks that are compiled only in
* operating systems for what they were designed for. MSVC 1.0 cannot
* handle inclusion of sys/dir.h in a part that is compiled only in Apollo
* operating system. To fix the problem you need to insert DIR.H into
* SYSINCL.DAT located in MSVC\BIN directory and restart visual C++.
* Consult manuals for more informaton about the problem.
*
* Since many UNIX systems have dirent.h we assume to have one also.
* However, if your UNIX system does not have dirent.h you can download one
* for example at: http://ftp.uni-mannheim.de/ftp/GNU/dirent/dirent.tar.gz.
* You can also see if you have one of dirent.h, direct.h, dir.h, ndir.h,
* sys/dir.h and sys/ndir.h somewhere. Try defining HAVE_DIRENT_H,
* HAVE_DIRECT_H, HAVE_DIR_H, HAVE_NDIR_H, HAVE_SYS_DIR_H and
* HAVE_SYS_NDIR_H according to the files found.
*/
#ifndef DIRENT_H
#define DIRENT_H
#define DIRENT_H_INCLUDED
/* find out platform */
#if defined(MSDOS) /* MS-DOS */
#elif defined(__MSDOS__) /* Turbo C/Borland */
# define MSDOS
#elif defined(__DOS__) /* Watcom */
# define MSDOS
#endif
#if defined(WIN32) /* MS-Windows */
#elif defined(__NT__) /* Watcom */
# define WIN32
#elif defined(_WIN32) /* Microsoft */
# define WIN32
#elif defined(__WIN32__) /* Borland */
# define WIN32
#endif
/*
* See what kind of dirent interface we have unless autoconf has already
* determinated that.
*/
#if !defined(HAVE_DIRENT_H) && !defined(HAVE_DIRECT_H) && !defined(HAVE_SYS_DIR_H) && !defined(HAVE_NDIR_H) && !defined(HAVE_SYS_NDIR_H) && !defined(HAVE_DIR_H)
# if defined(_MSC_VER) /* Microsoft C/C++ */
/* no dirent.h */
# elif defined(__BORLANDC__) /* Borland C/C++ */
# define HAVE_DIRENT_H
# define VOID_CLOSEDIR
# elif defined(__TURBOC__) /* Borland Turbo C */
/* no dirent.h */
# elif defined(__WATCOMC__) /* Watcom C/C++ */
# define HAVE_DIRECT_H
# elif defined(__apollo) /* Apollo */
# define HAVE_SYS_DIR_H
# elif defined(__hpux) /* HP-UX */
# define HAVE_DIRENT_H
# elif (defined(__alpha) || defined(__alpha__)) && !defined(__linux__) /* Alpha OSF1 */
# error "not implemented"
# elif defined(__sgi) /* Silicon Graphics */
# define HAVE_DIRENT_H
# elif defined(sun) || defined(_sun) /* Sun Solaris */
# define HAVE_DIRENT_H
# elif defined(__FreeBSD__) /* FreeBSD */
# define HAVE_DIRENT_H
# elif defined(__linux__) /* Linux */
# define HAVE_DIRENT_H
# elif defined(__GNUC__) /* GNU C/C++ */
# define HAVE_DIRENT_H
# else
# error "not implemented"
# endif
#endif
/* include proper interface headers */
#if defined(HAVE_DIRENT_H)
# include <dirent.h>
# ifdef FREEBSD
# define NAMLEN(dp) ((int)((dp)->d_namlen))
# else
# define NAMLEN(dp) ((int)(strlen((dp)->d_name)))
# endif
#elif defined(HAVE_NDIR_H)
# include <ndir.h>
# define NAMLEN(dp) ((int)((dp)->d_namlen))
#elif defined(HAVE_SYS_NDIR_H)
# include <sys/ndir.h>
# define NAMLEN(dp) ((int)((dp)->d_namlen))
#elif defined(HAVE_DIRECT_H)
# include <direct.h>
# define NAMLEN(dp) ((int)((dp)->d_namlen))
#elif defined(HAVE_DIR_H)
# include <dir.h>
# define NAMLEN(dp) ((int)((dp)->d_namlen))
#elif defined(HAVE_SYS_DIR_H)
# include <sys/types.h>
# include <sys/dir.h>
# ifndef dirent
# define dirent direct
# endif
# define NAMLEN(dp) ((int)((dp)->d_namlen))
#elif defined(MSDOS) || defined(WIN32)
/* figure out type of underlaying directory interface to be used */
# if defined(WIN32)
# define DIRENT_WIN32_INTERFACE
# elif defined(MSDOS)
# define DIRENT_MSDOS_INTERFACE
# else
# error "missing native dirent interface"
# endif
/*** WIN32 specifics ***/
# if defined(DIRENT_WIN32_INTERFACE)
# include <windows.h>
# if !defined(DIRENT_MAXNAMLEN)
# define DIRENT_MAXNAMLEN (MAX_PATH)
# endif
/*** MS-DOS specifics ***/
# elif defined(DIRENT_MSDOS_INTERFACE)
# include <dos.h>
/* Borland defines file length macros in dir.h */
# if defined(__BORLANDC__)
# include <dir.h>
# if !defined(DIRENT_MAXNAMLEN)
# define DIRENT_MAXNAMLEN ((MAXFILE)+(MAXEXT))
# endif
# if !defined(_find_t)
# define _find_t find_t
# endif
/* Turbo C defines ffblk structure in dir.h */
# elif defined(__TURBOC__)
# include <dir.h>
# if !defined(DIRENT_MAXNAMLEN)
# define DIRENT_MAXNAMLEN ((MAXFILE)+(MAXEXT))
# endif
# define DIRENT_USE_FFBLK
/* MSVC */
# elif defined(_MSC_VER)
# if !defined(DIRENT_MAXNAMLEN)
# define DIRENT_MAXNAMLEN (12)
# endif
/* Watcom */
# elif defined(__WATCOMC__)
# if !defined(DIRENT_MAXNAMLEN)
# if defined(__OS2__) || defined(__NT__)
# define DIRENT_MAXNAMLEN (255)
# else
# define DIRENT_MAXNAMLEN (12)
# endif
# endif
# endif
# endif
/*** generic MS-DOS and MS-Windows stuff ***/
# if !defined(NAME_MAX) && defined(DIRENT_MAXNAMLEN)
# define NAME_MAX DIRENT_MAXNAMLEN
# endif
# if NAME_MAX < DIRENT_MAXNAMLEN
# error "assertion failed: NAME_MAX >= DIRENT_MAXNAMLEN"
# endif
/*
* Substitute for real dirent structure. Note that `d_name' field is a
* true character array although we have it copied in the implementation
* dependent data. We could save some memory if we had declared `d_name'
* as a pointer refering the name within implementation dependent data.
* We have not done that since some code may rely on sizeof(d_name) to be
* something other than four. Besides, directory entries are typically so
* small that it takes virtually no time to copy them from place to place.
*/
typedef struct dirent {
char d_name[NAME_MAX + 1];
/*** Operating system specific part ***/
# if defined(DIRENT_WIN32_INTERFACE) /*WIN32*/
WIN32_FIND_DATA data;
# elif defined(DIRENT_MSDOS_INTERFACE) /*MSDOS*/
# if defined(DIRENT_USE_FFBLK)
struct ffblk data;
# else
struct _find_t data;
# endif
# endif
} dirent;
/* DIR substitute structure containing directory name. The name is
* essential for the operation of ``rewinndir'' function. */
typedef struct DIR {
char *dirname; /* directory being scanned */
dirent current; /* current entry */
int dirent_filled; /* is current un-processed? */
/*** Operating system specific part ***/
# if defined(DIRENT_WIN32_INTERFACE)
HANDLE search_handle;
# elif defined(DIRENT_MSDOS_INTERFACE)
# endif
} DIR;
# ifdef __cplusplus
extern "C" {
# endif
/* supply prototypes for dirent functions */
static DIR *opendir (const char *dirname);
static struct dirent *readdir (DIR *dirp);
static int closedir (DIR *dirp);
static void rewinddir (DIR *dirp);
/*
* Implement dirent interface as static functions so that the user does not
* need to change his project in any way to use dirent function. With this
* it is sufficient to include this very header from source modules using
* dirent functions and the functions will be pulled in automatically.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
/* use ffblk instead of _find_t if requested */
#if defined(DIRENT_USE_FFBLK)
# define _A_ARCH (FA_ARCH)
# define _A_HIDDEN (FA_HIDDEN)
# define _A_NORMAL (0)
# define _A_RDONLY (FA_RDONLY)
# define _A_SUBDIR (FA_DIREC)
# define _A_SYSTEM (FA_SYSTEM)
# define _A_VOLID (FA_LABEL)
# define _dos_findnext(dest) findnext(dest)
# define _dos_findfirst(name,flags,dest) findfirst(name,dest,flags)
#endif
static int _initdir (DIR *p);
static const char *_getdirname (const struct dirent *dp);
static void _setdirname (struct DIR *dirp);
/*
* <function name="opendir">
* <intro>open directory stream for reading
* <syntax>DIR *opendir (const char *dirname);
*
* <desc>Open named directory stream for read and return pointer to the
* internal working area that is used for retrieving individual directory
* entries. The internal working area has no fields of your interest.
*
* <ret>Returns a pointer to the internal working area or NULL in case the
* directory stream could not be opened. Global `errno' variable will set
* in case of error as follows:
*
* <table>
* [EACESS |Permission denied.
* [EMFILE |Too many open files used by the process.
* [ENFILE |Too many open files in system.
* [ENOENT |Directory does not exist.
* [ENOMEM |Insufficient memory.
* [ENOTDIR |dirname does not refer to directory. This value is not
* reliable on MS-DOS and MS-Windows platforms. Many
* implementations return ENOENT even when the name refers to a
* file.]
* </table>
* </function>
*/
static DIR *opendir(const char *dirname)
{
DIR *dirp;
assert (dirname != NULL);
dirp = (DIR*)malloc (sizeof (struct DIR));
if (dirp != NULL) {
char *p;
/* allocate room for directory name */
dirp->dirname = (char*) malloc (strlen (dirname) + 1 + strlen ("\\*.*"));
if (dirp->dirname == NULL) {
/* failed to duplicate directory name. errno set by malloc() */
free (dirp);
return NULL;
}
/* Copy directory name while appending directory separator and "*.*".
* Directory separator is not appended if the name already ends with
* drive or directory separator. Directory separator is assumed to be
* '/' or '\' and drive separator is assumed to be ':'. */
strcpy (dirp->dirname, dirname);
p = strchr (dirp->dirname, '\0');
if (dirp->dirname < p &&
*(p - 1) != '\\' && *(p - 1) != '/' && *(p - 1) != ':')
{
strcpy (p++, "\\");
}
# ifdef DIRENT_WIN32_INTERFACE
strcpy (p, "*"); /*scan files with and without extension in win32*/
# else
strcpy (p, "*.*"); /*scan files with and without extension in DOS*/
# endif
/* open stream */
if (_initdir (dirp) == 0) {
/* initialization failed */
free (dirp->dirname);
free (dirp);
return NULL;
}
}
return dirp;
}
/*
* <function name="readdir">
* <intro>read a directory entry
* <syntax>struct dirent *readdir (DIR *dirp);
*
* <desc>Read individual directory entry and return pointer to a structure
* containing the name of the entry. Individual directory entries returned
* include normal files, sub-directories, pseudo-directories "." and ".."
* and also volume labels, hidden files and system files in MS-DOS and
* MS-Windows. You might want to use stat(2) function to determinate which
* one are you dealing with. Many dirent implementations already contain
* equivalent information in dirent structure but you cannot depend on
* this.
*
* The dirent structure contains several system dependent fields that
* generally have no interest to you. The only interesting one is char
* d_name[] that is also portable across different systems. The d_name
* field contains the name of the directory entry without leading path.
* While d_name is portable across different systems the actual storage
* capacity of d_name varies from system to system and there is no portable
* way to find out it at compile time as different systems define the
* capacity of d_name with different macros and some systems do not define
* capacity at all (besides actual declaration of the field). If you really
* need to find out storage capacity of d_name then you might want to try
* NAME_MAX macro. The NAME_MAX is defined in POSIX standard althought
* there are many MS-DOS and MS-Windows implementations those do not define
* it. There are also systems that declare d_name as "char d_name[1]" and
* then allocate suitable amount of memory at run-time. Thanks to Alain
* Decamps (Alain.Decamps@advalvas.be) for pointing it out to me.
*
* This all leads to the fact that it is difficult to allocate space
* for the directory names when the very same program is being compiled on
* number of operating systems. Therefore I suggest that you always
* allocate space for directory names dynamically.
*
* <ret>
* Returns a pointer to a structure containing name of the directory entry
* in `d_name' field or NULL if there was an error. In case of an error the
* global `errno' variable will set as follows:
*
* <table>
* [EBADF |dir parameter refers to an invalid directory stream. This value
* is not set reliably on all implementations.]
* </table>
* </function>
*/
static struct dirent *
readdir (DIR *dirp)
{
assert(dirp != NULL);
if (dirp == NULL) {
errno = EBADF;
return NULL;
}
#if defined(DIRENT_WIN32_INTERFACE)
if (dirp->search_handle == INVALID_HANDLE_VALUE) {
/* directory stream was opened/rewound incorrectly or it ended normally */
errno = EBADF;
return NULL;
}
#endif
if (dirp->dirent_filled != 0) {
/*
* Directory entry has already been retrieved and there is no need to
* retrieve a new one. Directory entry will be retrieved in advance
* when the user calls readdir function for the first time. This is so
* because real dirent has separate functions for opening and reading
* the stream whereas Win32 and DOS dirents open the stream
* automatically when we retrieve the first file. Therefore, we have to
* save the first file when opening the stream and later we have to
* return the saved entry when the user tries to read the first entry.
*/
dirp->dirent_filled = 0;
} else {
/* fill in entry and return that */
#if defined(DIRENT_WIN32_INTERFACE)
if (FindNextFile (dirp->search_handle, &dirp->current.data) == FALSE) {
/* Last file has been processed or an error occured */
FindClose (dirp->search_handle);
dirp->search_handle = INVALID_HANDLE_VALUE;
errno = ENOENT;
return NULL;
}
# elif defined(DIRENT_MSDOS_INTERFACE)
if (_dos_findnext (&dirp->current.data) != 0) {
/* _dos_findnext and findnext will set errno to ENOENT when no
* more entries could be retrieved. */
return NULL;
}
# endif
_setdirname (dirp);
assert (dirp->dirent_filled == 0);
}
return &dirp->current;
}
/*
* <function name="closedir">
* <intro>close directory stream.
* <syntax>int closedir (DIR *dirp);
*
* <desc>Close directory stream opened by the `opendir' function. Close of
* directory stream invalidates the DIR structure as well as previously read
* dirent entry.
*
* <ret>The function typically returns 0 on success and -1 on failure but
* the function may be declared to return void on same systems. At least
* Borland C/C++ and some UNIX implementations use void as a return type.
* The dirent wrapper tries to define VOID_CLOSEDIR whenever closedir is
* known to return nothing. The very same definition is made by the GNU
* autoconf if you happen to use it.
*
* The global `errno' variable will set to EBADF in case of error.
* </function>
*/
static int
closedir (DIR *dirp)
{
int retcode = 0;
/* make sure that dirp points to legal structure */
assert (dirp != NULL);
if (dirp == NULL) {
errno = EBADF;
return -1;
}
/* free directory name and search handles */
if (dirp->dirname != NULL) free (dirp->dirname);
#if defined(DIRENT_WIN32_INTERFACE)
if (dirp->search_handle != INVALID_HANDLE_VALUE) {
if (FindClose (dirp->search_handle) == FALSE) {
/* Unknown error */
retcode = -1;
errno = EBADF;
}
}
#endif
/* clear dirp structure to make sure that it cannot be used anymore*/
memset (dirp, 0, sizeof (*dirp));
# if defined(DIRENT_WIN32_INTERFACE)
dirp->search_handle = INVALID_HANDLE_VALUE;
# endif
free (dirp);
return retcode;
}
/*
* <function name="rewinddir">
* <intro>rewind directory stream to the beginning
* <syntax>void rewinddir (DIR *dirp);
*
* <desc>Rewind directory stream to the beginning so that the next call of
* readdir() returns the very first directory entry again. However, note
* that next call of readdir() may not return the same directory entry as it
* did in first time. The directory stream may have been affected by newly
* created files.
*
* Almost every dirent implementation ensure that rewinddir will update
* the directory stream to reflect any changes made to the directory entries
* since the previous ``opendir'' or ``rewinddir'' call. Keep an eye on
* this if your program depends on the feature. I know at least one dirent
* implementation where you are required to close and re-open the stream to
* see the changes.
*
* <ret>Returns nothing. If something went wrong while rewinding, you will
* notice it later when you try to retrieve the first directory entry.
*/
static void
rewinddir (DIR *dirp)
{
/* make sure that dirp is legal */
assert (dirp != NULL);
if (dirp == NULL) {
errno = EBADF;
return;
}
assert (dirp->dirname != NULL);
/* close previous stream */
#if defined(DIRENT_WIN32_INTERFACE)
if (dirp->search_handle != INVALID_HANDLE_VALUE) {
if (FindClose (dirp->search_handle) == FALSE) {
/* Unknown error */
errno = EBADF;
}
}
#endif
/* re-open previous stream */
if (_initdir (dirp) == 0) {
/* initialization failed but we cannot deal with error. User will notice
* error later when she tries to retrieve first directory enty. */
/*EMPTY*/;
}
}
/*
* Open native directory stream object and retrieve first file.
* Be sure to close previous stream before opening new one.
*/
static int
_initdir (DIR *dirp)
{
assert (dirp != NULL);
assert (dirp->dirname != NULL);
dirp->dirent_filled = 0;
# if defined(DIRENT_WIN32_INTERFACE)
/* Open stream and retrieve first file */
dirp->search_handle = FindFirstFile (dirp->dirname, &dirp->current.data);
if (dirp->search_handle == INVALID_HANDLE_VALUE) {
/* something went wrong but we don't know what. GetLastError() could
* give us more information about the error, but then we should map
* the error code into errno. */
errno = ENOENT;
return 0;
}
# elif defined(DIRENT_MSDOS_INTERFACE)
if (_dos_findfirst (dirp->dirname,
_A_SUBDIR | _A_RDONLY | _A_ARCH | _A_SYSTEM | _A_HIDDEN,
&dirp->current.data) != 0)
{
/* _dos_findfirst and findfirst will set errno to ENOENT when no
* more entries could be retrieved. */
return 0;
}
# endif
/* initialize DIR and it's first entry */
_setdirname (dirp);
dirp->dirent_filled = 1;
return 1;
}
/*
* Return implementation dependent name of the current directory entry.
*/
static const char *
_getdirname (const struct dirent *dp)
{
#if defined(DIRENT_WIN32_INTERFACE)
return dp->data.cFileName;
#elif defined(DIRENT_USE_FFBLK)
return dp->data.ff_name;
#else
return dp->data.name;
#endif
}
/*
* Copy name of implementation dependent directory entry to the d_name field.
*/
static void
_setdirname (struct DIR *dirp) {
/* make sure that d_name is long enough */
assert (strlen (_getdirname (&dirp->current)) <= NAME_MAX);
strncpy (dirp->current.d_name,
_getdirname (&dirp->current),
NAME_MAX);
dirp->current.d_name[NAME_MAX] = '\0'; /*char d_name[NAME_MAX+1]*/
}
# ifdef __cplusplus
}
# endif
# define NAMLEN(dp) ((int)(strlen((dp)->d_name)))
#else
# error "missing dirent interface"
#endif
#endif /*DIRENT_H*/

2117
codec/image_to_j2k.c
View File

File diff suppressed because it is too large Load Diff

249
codec/image_to_j2k.dsp Normal file
View File

@@ -0,0 +1,249 @@
# Microsoft Developer Studio Project File - Name="image_to_j2k" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=image_to_j2k - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "image_to_j2k.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "image_to_j2k.mak" CFG="image_to_j2k - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "image_to_j2k - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "image_to_j2k - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "image_to_j2k - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /W3 /GX /O2 /I "../libopenjpeg" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "DONT_HAVE_GETOPT" /YX /FD /c
# ADD BASE RSC /l 0x80c /d "NDEBUG"
# ADD RSC /l 0x80c /i "../libopenjpeg" /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "image_to_j2k - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../libopenjpeg" /D "_DEBUG" /D "DONT_HAVE_GETOPT" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /FR /YX /FD /GZ /c
# ADD BASE RSC /l 0x80c /d "_DEBUG"
# ADD RSC /l 0x80c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "image_to_j2k - Win32 Release"
# Name "image_to_j2k - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\libopenjpeg\bio.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\cio.c
# End Source File
# Begin Source File
SOURCE=.\convert.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\dwt.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\fix.c
# End Source File
# Begin Source File
SOURCE=.\compat\getopt.c
# End Source File
# Begin Source File
SOURCE=.\image_to_j2k.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\int.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\j2k.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jp2.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jpt.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\mct.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\mqc.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\pi.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\raw.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\t1.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\t2.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\tcd.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\tgt.c
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=..\libopenjpeg\bio.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\cio.h
# End Source File
# Begin Source File
SOURCE=.\convert.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\dwt.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\fix.h
# End Source File
# Begin Source File
SOURCE=.\compat\getopt.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\int.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\j2k.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jp2.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jpt.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\mct.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\mqc.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\openjpeg.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\pi.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\raw.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\t1.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\t2.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\tcd.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\tgt.h
# End Source File
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

391
codec/index.c
View File

@@ -1,391 +0,0 @@
/*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2003-2007, Francois-Olivier Devaux
* 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 <stdio.h>
#include <math.h>
#include <string.h>
#include "openjpeg.h"
#include "index.h"
/* ------------------------------------------------------------------------------------ */
/**
Write a structured index to a file
@param cstr_info Codestream information
@param index Index filename
@return Returns 0 if successful, returns 1 otherwise
*/
int write_index_file(opj_codestream_info_t *cstr_info, char *index) {
int tileno, compno, layno, resno, precno, pack_nb, x, y;
FILE *stream = NULL;
double total_disto = 0;
/* UniPG>> */
int tilepartno;
char disto_on, numpix_on;
#ifdef USE_JPWL
if (!strcmp(index, JPWL_PRIVATEINDEX_NAME))
return 0;
#endif /* USE_JPWL */
/* <<UniPG */
if (!cstr_info)
return 1;
stream = fopen(index, "w");
if (!stream) {
fprintf(stderr, "failed to open index file [%s] for writing\n", index);
return 1;
}
if (cstr_info->tile[0].distotile)
disto_on = 1;
else
disto_on = 0;
if (cstr_info->tile[0].numpix)
numpix_on = 1;
else
numpix_on = 0;
fprintf(stream, "%d %d\n", cstr_info->image_w, cstr_info->image_h);
fprintf(stream, "%d\n", cstr_info->prog);
fprintf(stream, "%d %d\n", cstr_info->tile_x, cstr_info->tile_y);
fprintf(stream, "%d %d\n", cstr_info->tw, cstr_info->th);
fprintf(stream, "%d\n", cstr_info->numcomps);
fprintf(stream, "%d\n", cstr_info->numlayers);
fprintf(stream, "%d\n", cstr_info->numdecompos[0]); /* based on component 0 */
for (resno = cstr_info->numdecompos[0]; resno >= 0; resno--) {
fprintf(stream, "[%d,%d] ",
(1 << cstr_info->tile[0].pdx[resno]), (1 << cstr_info->tile[0].pdx[resno])); /* based on tile 0 and component 0 */
}
fprintf(stream, "\n");
/* UniPG>> */
fprintf(stream, "%d\n", cstr_info->main_head_start);
/* <<UniPG */
fprintf(stream, "%d\n", cstr_info->main_head_end);
fprintf(stream, "%d\n", cstr_info->codestream_size);
fprintf(stream, "\nINFO ON TILES\n");
fprintf(stream, "tileno start_pos end_hd end_tile nbparts");
if (disto_on)
fprintf(stream," disto");
if (numpix_on)
fprintf(stream," nbpix");
if (disto_on && numpix_on)
fprintf(stream," disto/nbpix");
fprintf(stream, "\n");
for (tileno = 0; tileno < cstr_info->tw * cstr_info->th; tileno++) {
fprintf(stream, "%4d %9d %9d %9d %9d",
cstr_info->tile[tileno].tileno,
cstr_info->tile[tileno].start_pos,
cstr_info->tile[tileno].end_header,
cstr_info->tile[tileno].end_pos,
cstr_info->tile[tileno].num_tps);
if (disto_on)
fprintf(stream," %9e", cstr_info->tile[tileno].distotile);
if (numpix_on)
fprintf(stream," %9d", cstr_info->tile[tileno].numpix);
if (disto_on && numpix_on)
fprintf(stream," %9e", cstr_info->tile[tileno].distotile / cstr_info->tile[tileno].numpix);
fprintf(stream, "\n");
}
for (tileno = 0; tileno < cstr_info->tw * cstr_info->th; tileno++) {
int start_pos, end_ph_pos, end_pos;
double disto = 0;
int max_numdecompos = 0;
pack_nb = 0;
for (compno = 0; compno < cstr_info->numcomps; compno++) {
if (max_numdecompos < cstr_info->numdecompos[compno])
max_numdecompos = cstr_info->numdecompos[compno];
}
fprintf(stream, "\nTILE %d DETAILS\n", tileno);
fprintf(stream, "part_nb tileno start_pack num_packs start_pos end_tph_pos end_pos\n");
for (tilepartno = 0; tilepartno < cstr_info->tile[tileno].num_tps; tilepartno++)
fprintf(stream, "%4d %9d %9d %9d %9d %11d %9d\n",
tilepartno, tileno,
cstr_info->tile[tileno].tp[tilepartno].tp_start_pack,
cstr_info->tile[tileno].tp[tilepartno].tp_numpacks,
cstr_info->tile[tileno].tp[tilepartno].tp_start_pos,
cstr_info->tile[tileno].tp[tilepartno].tp_end_header,
cstr_info->tile[tileno].tp[tilepartno].tp_end_pos
);
if (cstr_info->prog == LRCP) { /* LRCP */
fprintf(stream, "LRCP\npack_nb tileno layno resno compno precno start_pos end_ph_pos end_pos");
if (disto_on)
fprintf(stream, " disto");
fprintf(stream,"\n");
for (layno = 0; layno < cstr_info->numlayers; layno++) {
for (resno = 0; resno < max_numdecompos + 1; resno++) {
for (compno = 0; compno < cstr_info->numcomps; compno++) {
int prec_max;
if (resno > cstr_info->numdecompos[compno])
break;
prec_max = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];
for (precno = 0; precno < prec_max; precno++) {
start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;
end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;
end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;
disto = cstr_info->tile[tileno].packet[pack_nb].disto;
fprintf(stream, "%4d %6d %7d %5d %6d %6d %6d %6d %7d",
pack_nb, tileno, layno, resno, compno, precno, start_pos, end_ph_pos, end_pos);
if (disto_on)
fprintf(stream, " %8e", disto);
fprintf(stream, "\n");
total_disto += disto;
pack_nb++;
}
}
}
}
} /* LRCP */
else if (cstr_info->prog == RLCP) { /* RLCP */
fprintf(stream, "RLCP\npack_nb tileno resno layno compno precno start_pos end_ph_pos end_pos\n");
if (disto_on)
fprintf(stream, " disto");
fprintf(stream,"\n");
for (resno = 0; resno < max_numdecompos + 1; resno++) {
for (layno = 0; layno < cstr_info->numlayers; layno++) {
for (compno = 0; compno < cstr_info->numcomps; compno++) {
int prec_max;
if (resno > cstr_info->numdecompos[compno])
break;
prec_max = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];
for (precno = 0; precno < prec_max; precno++) {
start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;
end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;
end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;
disto = cstr_info->tile[tileno].packet[pack_nb].disto;
fprintf(stream, "%4d %6d %5d %7d %6d %6d %9d %9d %7d",
pack_nb, tileno, resno, layno, compno, precno, start_pos, end_ph_pos, end_pos);
if (disto_on)
fprintf(stream, " %8e", disto);
fprintf(stream, "\n");
total_disto += disto;
pack_nb++;
}
}
}
}
} /* RLCP */
else if (cstr_info->prog == RPCL) { /* RPCL */
fprintf(stream, "RPCL\npack_nb tileno resno precno compno layno start_pos end_ph_pos end_pos");
if (disto_on)
fprintf(stream, " disto");
fprintf(stream,"\n");
for (resno = 0; resno < max_numdecompos + 1; resno++) {
int numprec = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];
for (precno = 0; precno < numprec; precno++) {
/* I suppose components have same XRsiz, YRsiz */
int x0 = cstr_info->tile_Ox + tileno - (int)floor((float)tileno/(float)cstr_info->tw ) * cstr_info->tw * cstr_info->tile_x;
int y0 = cstr_info->tile_Ox + (int)floor( (float)tileno/(float)cstr_info->tw ) * cstr_info->tile_y;
int x1 = x0 + cstr_info->tile_x;
int y1 = y0 + cstr_info->tile_y;
for (compno = 0; compno < cstr_info->numcomps; compno++) {
int pcnx = cstr_info->tile[tileno].pw[resno];
int pcx = (int) pow( 2, cstr_info->tile[tileno].pdx[resno] + cstr_info->numdecompos[compno] - resno );
int pcy = (int) pow( 2, cstr_info->tile[tileno].pdy[resno] + cstr_info->numdecompos[compno] - resno );
int precno_x = precno - (int) floor( (float)precno/(float)pcnx ) * pcnx;
int precno_y = (int) floor( (float)precno/(float)pcnx );
if (resno > cstr_info->numdecompos[compno])
break;
for(y = y0; y < y1; y++) {
if (precno_y*pcy == y ) {
for (x = x0; x < x1; x++) {
if (precno_x*pcx == x ) {
for (layno = 0; layno < cstr_info->numlayers; layno++) {
start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;
end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;
end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;
disto = cstr_info->tile[tileno].packet[pack_nb].disto;
fprintf(stream, "%4d %6d %5d %6d %6d %7d %9d %9d %7d",
pack_nb, tileno, resno, precno, compno, layno, start_pos, end_ph_pos, end_pos);
if (disto_on)
fprintf(stream, " %8e", disto);
fprintf(stream, "\n");
total_disto += disto;
pack_nb++;
}
}
}/* x = x0..x1 */
}
} /* y = y0..y1 */
} /* precno */
} /* compno */
} /* resno */
} /* RPCL */
else if (cstr_info->prog == PCRL) { /* PCRL */
/* I suppose components have same XRsiz, YRsiz */
int x0 = cstr_info->tile_Ox + tileno - (int)floor( (float)tileno/(float)cstr_info->tw ) * cstr_info->tw * cstr_info->tile_x;
int y0 = cstr_info->tile_Ox + (int)floor( (float)tileno/(float)cstr_info->tw ) * cstr_info->tile_y;
int x1 = x0 + cstr_info->tile_x;
int y1 = y0 + cstr_info->tile_y;
// Count the maximum number of precincts
int max_numprec = 0;
for (resno = 0; resno < max_numdecompos + 1; resno++) {
int numprec = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];
if (numprec > max_numprec)
max_numprec = numprec;
}
fprintf(stream, "PCRL\npack_nb tileno precno compno resno layno start_pos end_ph_pos end_pos");
if (disto_on)
fprintf(stream, " disto");
fprintf(stream,"\n");
for (precno = 0; precno < max_numprec; precno++) {
for (compno = 0; compno < cstr_info->numcomps; compno++) {
for (resno = 0; resno < cstr_info->numdecompos[compno] + 1; resno++) {
int numprec = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];
int pcnx = cstr_info->tile[tileno].pw[resno];
int pcx = (int) pow( 2, cstr_info->tile[tileno].pdx[resno] + cstr_info->numdecompos[compno] - resno );
int pcy = (int) pow( 2, cstr_info->tile[tileno].pdy[resno] + cstr_info->numdecompos[compno] - resno );
int precno_x = precno - (int) floor( (float)precno/(float)pcnx ) * pcnx;
int precno_y = (int) floor( (float)precno/(float)pcnx );
if (precno >= numprec)
continue;
for(y = y0; y < y1; y++) {
if (precno_y*pcy == y ) {
for (x = x0; x < x1; x++) {
if (precno_x*pcx == x ) {
for (layno = 0; layno < cstr_info->numlayers; layno++) {
start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;
end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;
end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;
disto = cstr_info->tile[tileno].packet[pack_nb].disto;
fprintf(stream, "%4d %6d %6d %6d %5d %7d %9d %9d %7d",
pack_nb, tileno, precno, compno, resno, layno, start_pos, end_ph_pos, end_pos);
if (disto_on)
fprintf(stream, " %8e", disto);
fprintf(stream, "\n");
total_disto += disto;
pack_nb++;
}
}
}/* x = x0..x1 */
}
} /* y = y0..y1 */
} /* resno */
} /* compno */
} /* precno */
} /* PCRL */
else { /* CPRL */
// Count the maximum number of precincts
int max_numprec = 0;
for (resno = 0; resno < max_numdecompos + 1; resno++) {
int numprec = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];
if (numprec > max_numprec)
max_numprec = numprec;
}
fprintf(stream, "CPRL\npack_nb tileno compno precno resno layno start_pos end_ph_pos end_pos");
if (disto_on)
fprintf(stream, " disto");
fprintf(stream,"\n");
for (compno = 0; compno < cstr_info->numcomps; compno++) {
/* I suppose components have same XRsiz, YRsiz */
int x0 = cstr_info->tile_Ox + tileno - (int)floor( (float)tileno/(float)cstr_info->tw ) * cstr_info->tw * cstr_info->tile_x;
int y0 = cstr_info->tile_Ox + (int)floor( (float)tileno/(float)cstr_info->tw ) * cstr_info->tile_y;
int x1 = x0 + cstr_info->tile_x;
int y1 = y0 + cstr_info->tile_y;
for (precno = 0; precno < max_numprec; precno++) {
for (resno = 0; resno < cstr_info->numdecompos[compno] + 1; resno++) {
int numprec = cstr_info->tile[tileno].pw[resno] * cstr_info->tile[tileno].ph[resno];
int pcnx = cstr_info->tile[tileno].pw[resno];
int pcx = (int) pow( 2, cstr_info->tile[tileno].pdx[resno] + cstr_info->numdecompos[compno] - resno );
int pcy = (int) pow( 2, cstr_info->tile[tileno].pdy[resno] + cstr_info->numdecompos[compno] - resno );
int precno_x = precno - (int) floor( (float)precno/(float)pcnx ) * pcnx;
int precno_y = (int) floor( (float)precno/(float)pcnx );
if (precno >= numprec)
continue;
for(y = y0; y < y1; y++) {
if (precno_y*pcy == y ) {
for (x = x0; x < x1; x++) {
if (precno_x*pcx == x ) {
for (layno = 0; layno < cstr_info->numlayers; layno++) {
start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;
end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;
end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;
disto = cstr_info->tile[tileno].packet[pack_nb].disto;
fprintf(stream, "%4d %6d %6d %6d %5d %7d %9d %9d %7d",
pack_nb, tileno, compno, precno, resno, layno, start_pos, end_ph_pos, end_pos);
if (disto_on)
fprintf(stream, " %8e", disto);
fprintf(stream, "\n");
total_disto += disto;
pack_nb++;
}
}
}/* x = x0..x1 */
}
} /* y = y0..y1 */
} /* resno */
} /* precno */
} /* compno */
} /* CPRL */
} /* tileno */
if (disto_on) {
fprintf(stream, "%8e\n", cstr_info->D_max); /* SE max */
fprintf(stream, "%.8e\n", total_disto); /* SE totale */
}
/* UniPG>> */
/* print the markers' list */
if (cstr_info->marknum) {
fprintf(stream, "\nMARKER LIST\n");
fprintf(stream, "%d\n", cstr_info->marknum);
fprintf(stream, "type\tstart_pos length\n");
for (x = 0; x < cstr_info->marknum; x++)
fprintf(stream, "%X\t%9d %9d\n", cstr_info->marker[x].type, cstr_info->marker[x].pos, cstr_info->marker[x].len);
}
/* <<UniPG */
fclose(stream);
fprintf(stderr,"Generated index file %s\n", index);
return 0;
}

49
codec/index.h
View File

@@ -1,49 +0,0 @@
/*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2003-2007, Francois-Olivier Devaux
* 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.
*/
#ifndef __J2K_INDEX_H
#define __J2K_INDEX_H
#ifdef __cplusplus
extern "C" {
#endif
/**
Write a structured index to a file
@param cstr_info Codestream information
@param index Index filename
@return Returns 0 if successful, returns 1 otherwise
*/
int write_index_file(opj_codestream_info_t *cstr_info, char *index);
#ifdef __cplusplus
}
#endif
#endif /* __J2K_INDEX_H */

495
codec/j2k_dump.c
View File

@@ -1,495 +0,0 @@
/*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2006-2007, Parvatha Elangovan
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* 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 <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#define USE_OPJ_DEPRECATED
#include "openjpeg.h"
#include "j2k.h"
#include "jp2.h"
#include "compat/getopt.h"
#include "convert.h"
#include "dirent.h"
#include "index.h"
#ifndef WIN32
#include <strings.h>
#define _stricmp strcasecmp
#define _strnicmp strncasecmp
#endif
/* ----------------------------------------------------------------------- */
#define J2K_CFMT 0
#define JP2_CFMT 1
#define JPT_CFMT 2
#define PXM_DFMT 10
#define PGX_DFMT 11
#define BMP_DFMT 12
#define YUV_DFMT 13
#define TIF_DFMT 14
#define RAW_DFMT 15
#define TGA_DFMT 16
/* ----------------------------------------------------------------------- */
typedef struct dircnt{
/** Buffer for holding images read from Directory*/
char *filename_buf;
/** Pointer to the buffer*/
char **filename;
}dircnt_t;
typedef struct img_folder{
/** The directory path of the folder containing input images*/
char *imgdirpath;
/** Output format*/
const char *out_format;
/** Enable option*/
char set_imgdir;
/** Enable Cod Format for output*/
char set_out_format;
}img_fol_t;
void decode_help_display() {
fprintf(stdout,"HELP\n----\n\n");
fprintf(stdout,"- the -h option displays this help information on screen\n\n");
/* UniPG>> */
fprintf(stdout,"List of parameters for the JPEG 2000 "
#ifdef USE_JPWL
"+ JPWL "
#endif /* USE_JPWL */
"decoder:\n");
/* <<UniPG */
fprintf(stdout,"\n");
fprintf(stdout,"\n");
fprintf(stdout," -ImgDir \n");
fprintf(stdout," Image file Directory path \n");
fprintf(stdout," -i <compressed file>\n");
fprintf(stdout," REQUIRED only if an Input image directory not specified\n");
fprintf(stdout," Currently accepts J2K-files, JP2-files and JPT-files. The file type\n");
fprintf(stdout," is identified based on its suffix.\n");
fprintf(stdout,"\n");
}
/* -------------------------------------------------------------------------- */
int get_num_images(char *imgdirpath){
DIR *dir;
struct dirent* content;
int num_images = 0;
/*Reading the input images from given input directory*/
dir= opendir(imgdirpath);
if(!dir){
fprintf(stderr,"Could not open Folder %s\n",imgdirpath);
return 0;
}
while((content=readdir(dir))!=NULL){
if(strcmp(".",content->d_name)==0 || strcmp("..",content->d_name)==0 )
continue;
num_images++;
}
return num_images;
}
int load_images(dircnt_t *dirptr, char *imgdirpath){
DIR *dir;
struct dirent* content;
int i = 0;
/*Reading the input images from given input directory*/
dir= opendir(imgdirpath);
if(!dir){
fprintf(stderr,"Could not open Folder %s\n",imgdirpath);
return 1;
}else {
fprintf(stderr,"Folder opened successfully\n");
}
while((content=readdir(dir))!=NULL){
if(strcmp(".",content->d_name)==0 || strcmp("..",content->d_name)==0 )
continue;
strcpy(dirptr->filename[i],content->d_name);
i++;
}
return 0;
}
int get_file_format(char *filename) {
unsigned int i;
static const char *extension[] = {"pgx", "pnm", "pgm", "ppm", "bmp","tif", "raw", "tga", "j2k", "jp2", "jpt", "j2c", "jpc" };
static const int format[] = { PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT, TIF_DFMT, RAW_DFMT, TGA_DFMT, J2K_CFMT, JP2_CFMT, JPT_CFMT, J2K_CFMT, J2K_CFMT };
char * ext = strrchr(filename, '.');
if (ext == NULL)
return -1;
ext++;
if(ext) {
for(i = 0; i < sizeof(format)/sizeof(*format); i++) {
if(_strnicmp(ext, extension[i], 3) == 0) {
return format[i];
}
}
}
return -1;
}
char get_next_file(int imageno,dircnt_t *dirptr,img_fol_t *img_fol, opj_dparameters_t *parameters){
char image_filename[OPJ_PATH_LEN], infilename[OPJ_PATH_LEN],outfilename[OPJ_PATH_LEN],temp_ofname[OPJ_PATH_LEN];
char *temp_p, temp1[OPJ_PATH_LEN]="";
strcpy(image_filename,dirptr->filename[imageno]);
fprintf(stderr,"File Number %d \"%s\"\n",imageno,image_filename);
parameters->decod_format = get_file_format(image_filename);
if (parameters->decod_format == -1)
return 1;
sprintf(infilename,"%s/%s",img_fol->imgdirpath,image_filename);
strncpy(parameters->infile, infilename, sizeof(infilename));
//Set output file
strcpy(temp_ofname,strtok(image_filename,"."));
while((temp_p = strtok(NULL,".")) != NULL){
strcat(temp_ofname,temp1);
sprintf(temp1,".%s",temp_p);
}
if(img_fol->set_out_format==1){
sprintf(outfilename,"%s/%s.%s",img_fol->imgdirpath,temp_ofname,img_fol->out_format);
strncpy(parameters->outfile, outfilename, sizeof(outfilename));
}
return 0;
}
/* -------------------------------------------------------------------------- */
int parse_cmdline_decoder(int argc, char **argv, opj_dparameters_t *parameters,img_fol_t *img_fol, char *indexfilename) {
/* parse the command line */
int totlen;
option_t long_option[]={
{"ImgDir",REQ_ARG, NULL ,'y'},
};
const char optlist[] = "i:h";
totlen=sizeof(long_option);
img_fol->set_out_format = 0;
while (1) {
int c = getopt_long(argc, argv,optlist,long_option,totlen);
if (c == -1)
break;
switch (c) {
case 'i': /* input file */
{
char *infile = optarg;
parameters->decod_format = get_file_format(infile);
switch(parameters->decod_format) {
case J2K_CFMT:
case JP2_CFMT:
case JPT_CFMT:
break;
default:
fprintf(stderr,
"!! Unrecognized format for infile : %s [accept only *.j2k, *.jp2, *.jpc or *.jpt] !!\n\n",
infile);
return 1;
}
strncpy(parameters->infile, infile, sizeof(parameters->infile)-1);
}
break;
/* ----------------------------------------------------- */
case 'h': /* display an help description */
decode_help_display();
return 1;
/* ------------------------------------------------------ */
case 'y': /* Image Directory path */
{
img_fol->imgdirpath = (char*)malloc(strlen(optarg) + 1);
strcpy(img_fol->imgdirpath,optarg);
img_fol->set_imgdir=1;
}
break;
/* ----------------------------------------------------- */
default:
fprintf(stderr,"WARNING -> this option is not valid \"-%c %s\"\n",c, optarg);
break;
}
}
/* check for possible errors */
if(img_fol->set_imgdir==1){
if(!(parameters->infile[0]==0)){
fprintf(stderr, "Error: options -ImgDir and -i cannot be used together !!\n");
return 1;
}
if(img_fol->set_out_format == 0){
fprintf(stderr, "Error: When -ImgDir is used, -OutFor <FORMAT> must be used !!\n");
fprintf(stderr, "Only one format allowed! Valid format PGM, PPM, PNM, PGX, BMP, TIF, RAW and TGA!!\n");
return 1;
}
if(!((parameters->outfile[0] == 0))){
fprintf(stderr, "Error: options -ImgDir and -o cannot be used together !!\n");
return 1;
}
}else{
if((parameters->infile[0] == 0) ) {
fprintf(stderr, "Error: One of the options -i or -ImgDir must be specified\n");
fprintf(stderr, "usage: image_to_j2k -i *.j2k/jp2/j2c (+ options)\n");
return 1;
}
}
return 0;
}
/* -------------------------------------------------------------------------- */
/**
sample error callback expecting a FILE* client object
*/
void error_callback(const char *msg, void *client_data) {
FILE *stream = (FILE*)client_data;
fprintf(stream, "[ERROR] %s", msg);
}
/**
sample warning callback expecting a FILE* client object
*/
void warning_callback(const char *msg, void *client_data) {
FILE *stream = (FILE*)client_data;
fprintf(stream, "[WARNING] %s", msg);
}
/**
sample debug callback expecting no client object
*/
void info_callback(const char *msg, void *client_data) {
(void)client_data;
fprintf(stdout, "[INFO] %s", msg);
}
/* -------------------------------------------------------------------------- */
int main(int argc, char *argv[])
{
int ret;
opj_dparameters_t parameters; /* decompression parameters */
img_fol_t img_fol;
opj_image_t *image = NULL;
FILE *fsrc = NULL;
bool bResult;
int num_images;
int i,imageno;
dircnt_t *dirptr;
opj_codec_t* dinfo = NULL; /* handle to a decompressor */
opj_stream_t *cio = NULL;
opj_codestream_info_t cstr_info; /* Codestream information structure */
char indexfilename[OPJ_PATH_LEN]; /* index file name */
OPJ_INT32 l_tile_x0,l_tile_y0;
OPJ_UINT32 l_tile_width,l_tile_height,l_nb_tiles_x,l_nb_tiles_y;
/* configure the event callbacks (not required) */
/* set decoding parameters to default values */
opj_set_default_decoder_parameters(&parameters);
/* Initialize indexfilename and img_fol */
*indexfilename = 0;
memset(&img_fol,0,sizeof(img_fol_t));
/* parse input and get user encoding parameters */
if(parse_cmdline_decoder(argc, argv, &parameters,&img_fol, indexfilename) == 1) {
return EXIT_FAILURE;
}
/* Initialize reading of directory */
if(img_fol.set_imgdir==1){
num_images=get_num_images(img_fol.imgdirpath);
dirptr=(dircnt_t*)malloc(sizeof(dircnt_t));
if(dirptr){
dirptr->filename_buf = (char*)malloc(num_images*OPJ_PATH_LEN*sizeof(char)); // Stores at max 10 image file names
dirptr->filename = (char**) malloc(num_images*sizeof(char*));
if(!dirptr->filename_buf){
return EXIT_FAILURE;
}
for(i=0;i<num_images;i++){
dirptr->filename[i] = dirptr->filename_buf + i*OPJ_PATH_LEN;
}
}
if(load_images(dirptr,img_fol.imgdirpath)==1){
return EXIT_FAILURE;
}
if (num_images==0){
fprintf(stdout,"Folder is empty\n");
return EXIT_FAILURE;
}
}else{
num_images=1;
}
/*Encoding image one by one*/
for(imageno = 0; imageno < num_images ; imageno++)
{
image = NULL;
fprintf(stderr,"\n");
if(img_fol.set_imgdir==1){
if (get_next_file(imageno, dirptr,&img_fol, &parameters)) {
fprintf(stderr,"skipping file...\n");
continue;
}
}
/* read the input file and put it in memory */
/* ---------------------------------------- */
fsrc = fopen(parameters.infile, "rb");
if (!fsrc) {
fprintf(stderr, "ERROR -> failed to open %s for reading\n", parameters.infile);
return EXIT_FAILURE;
}
cio = opj_stream_create_default_file_stream(fsrc,true);
/* decode the code-stream */
/* ---------------------- */
switch (parameters.decod_format)
{
case J2K_CFMT:
{
/* JPEG-2000 codestream */
/* get a decoder handle */
dinfo = opj_create_decompress(CODEC_J2K);
break;
}
case JP2_CFMT:
{
/* JPEG 2000 compressed image data */
/* get a decoder handle */
dinfo = opj_create_decompress(CODEC_JP2);
break;
}
case JPT_CFMT:
{
/* JPEG 2000, JPIP */
/* get a decoder handle */
dinfo = opj_create_decompress(CODEC_JPT);
break;
}
default:
fprintf(stderr, "skipping file..\n");
opj_stream_destroy(cio);
continue;
}
/* catch events using our callbacks and give a local context */
/* setup the decoder decoding parameters using user parameters */
opj_setup_decoder(dinfo, &parameters);
/* decode the stream and fill the image structure */
/* if (*indexfilename) // If need to extract codestream information
image = opj_decode_with_info(dinfo, cio, &cstr_info);
else
*/
bResult = opj_read_header(
dinfo,
&image,
&l_tile_x0,
&l_tile_y0,
&l_tile_width,
&l_tile_height,
&l_nb_tiles_x,
&l_nb_tiles_y,
cio);
//image = opj_decode(dinfo, cio);
//bResult = bResult && (image != 00);
//bResult = bResult && opj_end_decompress(dinfo,cio);
//if
// (!image)
//{
// fprintf(stderr, "ERROR -> j2k_to_image: failed to decode image!\n");
// opj_destroy_codec(dinfo);
// opj_stream_destroy(cio);
// fclose(fsrc);
// return EXIT_FAILURE;
//}
/* dump image */
if(!image)
{
fprintf(stderr, "ERROR -> j2k_to_image: failed to read header\n");
return EXIT_FAILURE;
}
j2k_dump_image(stdout, image);
/* dump cp */
//j2k_dump_cp(stdout, image, dinfo->m_codec);
/* close the byte stream */
opj_stream_destroy(cio);
fclose(fsrc);
/* Write the index to disk */
if (*indexfilename) {
char bSuccess;
bSuccess = write_index_file(&cstr_info, indexfilename);
if (bSuccess) {
fprintf(stderr, "Failed to output index file\n");
ret = EXIT_FAILURE;
}
}
/* free remaining structures */
if (dinfo) {
opj_destroy_codec(dinfo);
}
/* free codestream information structure */
if (*indexfilename)
opj_destroy_cstr_info(&cstr_info);
/* free image data structure */
opj_image_destroy(image);
}
return ret;
}
//end main

1311
codec/j2k_to_image.c
View File

File diff suppressed because it is too large Load Diff

240
codec/j2k_to_image.dsp Normal file
View File

@@ -0,0 +1,240 @@
# Microsoft Developer Studio Project File - Name="j2k_to_image" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=j2k_to_image - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "j2k_to_image.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "j2k_to_image.mak" CFG="j2k_to_image - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "j2k_to_image - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "j2k_to_image - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "j2k_to_image - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /W3 /GX /O2 /I "../libopenjpeg" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "DONT_HAVE_GETOPT" /YX /FD /c
# ADD BASE RSC /l 0x80c /d "NDEBUG"
# ADD RSC /l 0x80c /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "j2k_to_image - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "j2k_to_image___Win32_Debug"
# PROP BASE Intermediate_Dir "j2k_to_image___Win32_Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "j2k_to_image___Win32_Debug"
# PROP Intermediate_Dir "j2k_to_image___Win32_Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../libopenjpeg" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "DONT_HAVE_GETOPT" /YX /FD /GZ /c
# ADD BASE RSC /l 0x80c /d "_DEBUG"
# ADD RSC /l 0x80c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "j2k_to_image - Win32 Release"
# Name "j2k_to_image - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\libopenjpeg\bio.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\cio.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\dwt.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\fix.c
# End Source File
# Begin Source File
SOURCE=.\compat\getopt.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\int.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\j2k.c
# End Source File
# Begin Source File
SOURCE=.\j2k_to_image.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jp2.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jpt.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\mct.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\mqc.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\pi.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\raw.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\t1.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\t2.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\tcd.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\tgt.c
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=..\libopenjpeg\bio.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\cio.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\dwt.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\fix.h
# End Source File
# Begin Source File
SOURCE=.\compat\getopt.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\int.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\j2k.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jp2.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jpt.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\mct.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\mqc.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\openjpeg.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\pi.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\raw.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\t1.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\t2.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\tcd.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\tgt.h
# End Source File
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

105
codec/readme.txt Normal file
View File

@@ -0,0 +1,105 @@
List of parameters for the coder JPEG 2000 :
Date : June the 25th, 2003
Author : Yannick Verschueren
Contact : verschueren@tele.ucl.ac.be
- the option -help displays the readme.txt file on screen
- The markers COD and QCD are writed both of two in the main_header and never appear in the tile_header. The markers in the main header are : SOC SIZ COD QCD COM.
- This coder can encode mega image, a test was made on a 24000x24000 pixels color image. You need enough disk space memory (twice the original) to encode the image. (i.e. for a 1.5 Gb image you need a minimum of 3Gb of disk memory)
REMARKS :
---------
* the value of rate enter in the code line is the compression factor !
exemple :
-r 20,10,1 means quality 1 : compress 20x, quality 2 : compress 10x and quality 3 : compress 1x = lossless
* The number of resolution can be modified by the program in view to respect profile-0 conditions (Taubman, Marcelin (2002), "JPEG2000, image compression fundamentals, standards and practice", p700)
By default :
------------
* lossless
* 1 tile
* size of precinct 2^15 x 2^15 (means 1 precinct)
* size of code-block 64 x 64
* Number of resolution : 6
* No SOP marker in the codestream
* No EPH marker in the codestream
* No sub-sampling in x and y direction
* No mode switch activated
* progression order : LRCP
* No index file
* No ROI upshifted
* No offset of the origin of the image
* No offset of the origin of the tiles
* Reversible DWT 5-3
Parameters :
------------
-i : source file (-i source.pnm also *.pgm, *.ppm) "required"
-o : destination file (-o dest.j2k) "required"
-r : different rates (-r 20,10,5) "optional"
-n : Number of resolution (-n 3) "optional"
-b : size of code block (-b 32,32) "optional"
-c : size of precinct (-c 128,128) "optional"
-t : size of tile (-t 512,512) "optional"
-p : progression order (-p LRCP) [LRCP, RLCP, RPCL, PCRL, CPRL] "optional"
-s : subsampling factor (-s 2,2) [-s X,Y] "optional"
-SOP : write SOP marker before each packet "optional"
-EPH : write EPH marker after each header packet "optional"
-M : mode switch (-M 3) [1= BYPASS(LAZY) 2=RESET 4=RESTART(TERMALL) 8=VSC 16=ERTERM(SEGTERM) 32=SEGMARK(SEGSYM)] "optional"
for several mode switch you have to add the value of each mode you want
ex : RESTART(4) + RESET(2) + SEGMARK(32) = -M 38
-x : Create an index file *.Idx (-x index_name.Idx) "optional"
-ROI:c=%d,U=%d : quantization indices upshifted for component c=%d [%d = 0,1,2]
with a value of U=%d [0 <= %d <= 37] (i.e. -ROI:c=0,U=25) "optional"
-d : offset of the origin of the image (-d 150,300) "optional"
-T : offset of the origin of the tiles (-T 100,75) "optional"
-I : Use the irreversible DWT 9-7 (-I) "optional"
IMPORTANT :
-----------
* subsampling bigger than 2 can produce error
The index file respect the structure below :
---------------------------------------------
Image_height Image_width
progression order
Tiles_size_X Tiles_size_Y
Components_nb
Layers_nb
decomposition_levels
Precincts_size_X Precincts_size_Y
Main_header_end_position
Codestream_size
Tile0 start_pos end_Theader end_pos
Tile1 " " "
...
TileN " " "
Tpacket_0 Tile layer res. comp. prec. start_pos end_pos
...
Tpacket_M " " " " " " "

12
doc/CMakeLists.txt
View File

@@ -1,12 +0,0 @@
FIND_PACKAGE(Doxygen REQUIRED)
# The Doxyfile.dox is poorly defined and produce output
# in the source dir
ADD_CUSTOM_TARGET(doxygen
# By default doxygen target is added to the 'all' target. Project is small
# thus running doxygen is not too time consuming
ALL
${DOXYGEN}
${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.dox
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)

234
doc/Doxyfile.dox
View File

@@ -1,234 +0,0 @@
# Doxyfile 1.4.2
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
PROJECT_NAME = OpenJPEG
PROJECT_NUMBER =
OUTPUT_DIRECTORY = ../
CREATE_SUBDIRS = NO
OUTPUT_LANGUAGE = English
USE_WINDOWS_ENCODING = YES
BRIEF_MEMBER_DESC = YES
REPEAT_BRIEF = YES
ABBREVIATE_BRIEF = "The $name class" \
"The $name widget" \
"The $name file" \
is \
provides \
specifies \
contains \
represents \
a \
an \
the
ALWAYS_DETAILED_SEC = NO
INLINE_INHERITED_MEMB = NO
FULL_PATH_NAMES = NO
STRIP_FROM_PATH = C://
STRIP_FROM_INC_PATH =
SHORT_NAMES = NO
JAVADOC_AUTOBRIEF = YES
MULTILINE_CPP_IS_BRIEF = NO
DETAILS_AT_TOP = YES
INHERIT_DOCS = YES
DISTRIBUTE_GROUP_DOC = NO
SEPARATE_MEMBER_PAGES = NO
TAB_SIZE = 8
ALIASES =
OPTIMIZE_OUTPUT_FOR_C = YES
OPTIMIZE_OUTPUT_JAVA = NO
SUBGROUPING = YES
#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------
EXTRACT_ALL = YES
EXTRACT_PRIVATE = YES
EXTRACT_STATIC = YES
EXTRACT_LOCAL_CLASSES = YES
EXTRACT_LOCAL_METHODS = NO
HIDE_UNDOC_MEMBERS = NO
HIDE_UNDOC_CLASSES = NO
HIDE_FRIEND_COMPOUNDS = NO
HIDE_IN_BODY_DOCS = NO
INTERNAL_DOCS = NO
CASE_SENSE_NAMES = NO
HIDE_SCOPE_NAMES = NO
SHOW_INCLUDE_FILES = YES
INLINE_INFO = YES
SORT_MEMBER_DOCS = YES
SORT_BRIEF_DOCS = NO
SORT_BY_SCOPE_NAME = NO
GENERATE_TODOLIST = YES
GENERATE_TESTLIST = YES
GENERATE_BUGLIST = YES
GENERATE_DEPRECATEDLIST= YES
ENABLED_SECTIONS =
MAX_INITIALIZER_LINES = 30
SHOW_USED_FILES = YES
SHOW_DIRECTORIES = NO
FILE_VERSION_FILTER =
#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------
QUIET = NO
WARNINGS = YES
WARN_IF_UNDOCUMENTED = YES
WARN_IF_DOC_ERROR = YES
WARN_NO_PARAMDOC = NO
WARN_FORMAT = "$file:$line: $text"
WARN_LOGFILE =
#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------
INPUT = ../libopenjpeg \
../jpwl
FILE_PATTERNS = *.h \
*.c
RECURSIVE = NO
EXCLUDE =
EXCLUDE_SYMLINKS = NO
EXCLUDE_PATTERNS =
EXAMPLE_PATH =
EXAMPLE_PATTERNS = *
EXAMPLE_RECURSIVE = NO
IMAGE_PATH =
INPUT_FILTER =
FILTER_PATTERNS =
FILTER_SOURCE_FILES = NO
#---------------------------------------------------------------------------
# configuration options related to source browsing
#---------------------------------------------------------------------------
SOURCE_BROWSER = NO
INLINE_SOURCES = NO
STRIP_CODE_COMMENTS = YES
REFERENCED_BY_RELATION = YES
REFERENCES_RELATION = YES
VERBATIM_HEADERS = YES
#---------------------------------------------------------------------------
# configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
ALPHABETICAL_INDEX = NO
COLS_IN_ALPHA_INDEX = 5
IGNORE_PREFIX =
#---------------------------------------------------------------------------
# configuration options related to the HTML output
#---------------------------------------------------------------------------
GENERATE_HTML = YES
HTML_OUTPUT = ./html
HTML_FILE_EXTENSION = .html
HTML_HEADER =
HTML_FOOTER =
HTML_STYLESHEET =
HTML_ALIGN_MEMBERS = YES
GENERATE_HTMLHELP = NO
CHM_FILE =
HHC_LOCATION =
GENERATE_CHI = NO
BINARY_TOC = NO
TOC_EXPAND = NO
DISABLE_INDEX = NO
ENUM_VALUES_PER_LINE = 4
GENERATE_TREEVIEW = NO
TREEVIEW_WIDTH = 250
#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------
GENERATE_LATEX = NO
LATEX_OUTPUT = latex
LATEX_CMD_NAME = latex
MAKEINDEX_CMD_NAME = makeindex
COMPACT_LATEX = NO
PAPER_TYPE = a4wide
EXTRA_PACKAGES =
LATEX_HEADER =
PDF_HYPERLINKS = NO
USE_PDFLATEX = NO
LATEX_BATCHMODE = NO
LATEX_HIDE_INDICES = NO
#---------------------------------------------------------------------------
# configuration options related to the RTF output
#---------------------------------------------------------------------------
GENERATE_RTF = NO
RTF_OUTPUT = rtf
COMPACT_RTF = NO
RTF_HYPERLINKS = NO
RTF_STYLESHEET_FILE =
RTF_EXTENSIONS_FILE =
#---------------------------------------------------------------------------
# configuration options related to the man page output
#---------------------------------------------------------------------------
GENERATE_MAN = NO
MAN_OUTPUT = man
MAN_EXTENSION = .3
MAN_LINKS = NO
#---------------------------------------------------------------------------
# configuration options related to the XML output
#---------------------------------------------------------------------------
GENERATE_XML = NO
XML_OUTPUT = xml
XML_SCHEMA =
XML_DTD =
XML_PROGRAMLISTING = YES
#---------------------------------------------------------------------------
# configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------
GENERATE_AUTOGEN_DEF = NO
#---------------------------------------------------------------------------
# configuration options related to the Perl module output
#---------------------------------------------------------------------------
GENERATE_PERLMOD = NO
PERLMOD_LATEX = NO
PERLMOD_PRETTY = YES
PERLMOD_MAKEVAR_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = NO
EXPAND_ONLY_PREDEF = NO
SEARCH_INCLUDES = YES
INCLUDE_PATH =
INCLUDE_FILE_PATTERNS =
PREDEFINED = USE_JPWL \
USE_JPSEC
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
# Configuration::additions related to external references
#---------------------------------------------------------------------------
TAGFILES =
GENERATE_TAGFILE =
ALLEXTERNALS = NO
EXTERNAL_GROUPS = YES
PERL_PATH = /usr/bin/perl
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
CLASS_DIAGRAMS = YES
HIDE_UNDOC_RELATIONS = YES
HAVE_DOT = NO
CLASS_GRAPH = YES
COLLABORATION_GRAPH = YES
GROUP_GRAPHS = YES
UML_LOOK = NO
TEMPLATE_RELATIONS = NO
INCLUDE_GRAPH = YES
INCLUDED_BY_GRAPH = YES
CALL_GRAPH = NO
GRAPHICAL_HIERARCHY = YES
DIRECTORY_GRAPH = YES
DOT_IMAGE_FORMAT = png
DOT_PATH =
DOTFILE_DIRS =
MAX_DOT_GRAPH_WIDTH = 1024
MAX_DOT_GRAPH_HEIGHT = 1024
MAX_DOT_GRAPH_DEPTH = 1000
DOT_TRANSPARENT = NO
DOT_MULTI_TARGETS = NO
GENERATE_LEGEND = YES
DOT_CLEANUP = YES
#---------------------------------------------------------------------------
# Configuration::additions related to the search engine
#---------------------------------------------------------------------------
SEARCHENGINE = NO

6
libopenjpeg/.cvsignore Normal file
View File

@@ -0,0 +1,6 @@
obj
obj.w32
bin
bin.w32
lib
lib.w32

80
libopenjpeg/CMakeLists.txt
View File

@@ -1,80 +0,0 @@
INCLUDE_REGULAR_EXPRESSION("^.*$")
# Defines the source code for the library
SET(OPENJPEG_SRCS
tcd.c
bio.c
cio.c
dwt.c
event.c
image.c
j2k.c
j2k_lib.c
jp2.c
jpt.c
mct.c
mqc.c
openjpeg.c
pi.c
raw.c
t1.c
tgt.c
profile.c
invert.c
function_list.c
t2.c
bio.h
cio.h
dwt.h
event.h
image.h
j2k.h
j2k_lib.h
jp2.h
jpt.h
mct.h
mqc.h
openjpeg.h
pi.h
int.h
raw.h
t1.h
t2.h
tcd.h
tgt.h
profile.h
invert.h
function_list.h
)
# Pass proper definition to preprocessor to generate shared lib
IF(WIN32)
IF(BUILD_SHARED_LIBS)
ADD_DEFINITIONS(-DOPJ_EXPORTS)
ELSE(BUILD_SHARED_LIBS)
ADD_DEFINITIONS(-DOPJ_STATIC)
ENDIF(BUILD_SHARED_LIBS)
ENDIF(WIN32)
IF(ENABLE_PROFILING)
ADD_DEFINITIONS(-D_PROFILE)
ENDIF(ENABLE_PROFILING)
# Create the library
ADD_LIBRARY(${OPENJPEG_LIBRARY_NAME} ${OPENJPEG_SRCS})
SET_TARGET_PROPERTIES(${OPENJPEG_LIBRARY_NAME} PROPERTIES
${OPENJPEG_LIBRARY_PROPERTIES})
IF(UNIX)
TARGET_LINK_LIBRARIES(${OPENJPEG_LIBRARY_NAME} m)
ENDIF(UNIX)
# Install library
INSTALL(TARGETS ${OPENJPEG_LIBRARY_NAME}
EXPORT OpenJPEGTargets
DESTINATION ${OPENJPEG_INSTALL_LIB_DIR} COMPONENT Libraries
)
# Install includes files
INSTALL(FILES openjpeg.h
DESTINATION ${OPENJPEG_INSTALL_INCLUDE_DIR} COMPONENT Headers
)

78
libopenjpeg/Makefile Normal file
View File

@@ -0,0 +1,78 @@
# $Id$
#
# makefile for OpenJPEG library
CFLAGS = -Wall -O3 -fno-strength-reduce -fomit-frame-pointer
ifndef DEBUG
LDFLAGS = -s -lm
else
LDFLAGS = -lm
endif
OBJ_DIR_W32 = obj.w32
LIB_DIR_W32 = lib.w32
ifdef MINGW32
CC = i386-mingw32-gcc
AR = i386-mingw32-ar
OBJ_DIR = $(OBJ_DIR_W32)
LIB_DIR = $(LIB_DIR_W32)
all: $(OBJ_DIR) $(LIB_DIR) \
$(LIB_DIR)/libopenjpeg.a $(LIB_DIR)/libopenjpeg.dll
else
CC = gcc
AR = ar
OBJ_DIR = obj
LIB_DIR = lib
all: $(OBJ_DIR) $(LIB_DIR) \
$(LIB_DIR)/libopenjpeg.a $(LIB_DIR)/libopenjpeg.so
endif
$(OBJ_DIR):
mkdir $(OBJ_DIR)
$(LIB_DIR):
mkdir $(LIB_DIR)
$(OBJ_DIR)/%.o:
$(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
$(OBJ_DIR)/bio.o: bio.c bio.h
$(OBJ_DIR)/cio.o: cio.c cio.h
$(OBJ_DIR)/dwt.o: dwt.c dwt.h int.h fix.h tcd.h
$(OBJ_DIR)/fix.o: fix.c fix.h
$(OBJ_DIR)/int.o: int.c
$(OBJ_DIR)/j2k.o: j2k.c j2k.h cio.h tcd.h dwt.h int.h
$(OBJ_DIR)/mct.o: mct.c mct.h fix.h
$(OBJ_DIR)/mqc.o: mqc.c mqc.h
$(OBJ_DIR)/pi.o: pi.c pi.h int.h
$(OBJ_DIR)/raw.o: raw.c raw.h
$(OBJ_DIR)/t1.o: t1.c t1.h j2k.h mqc.h raw.h int.h mct.h dwt.h fix.h
$(OBJ_DIR)/t2.o: t2.c t2.h tcd.h bio.h j2k.h pi.h tgt.h int.h cio.h
$(OBJ_DIR)/tcd.o: tcd.c tcd.h int.h t1.h t2.h dwt.h mct.h
$(OBJ_DIR)/tgt.o: tgt.c tgt.h bio.h
$(OBJ_DIR)/jpt.o: jpt.c jpt.h cio.h
$(OBJ_DIR)/jp2.o: jp2.c jp2.h
COM_OBJS = $(addprefix $(OBJ_DIR)/, j2k.o bio.o cio.o dwt.o fix.o int.o mct.o \
mqc.o pi.o t1.o t2.o tgt.o tcd.o raw.o jpt.o jp2.o)
$(LIB_DIR)/libopenjpeg.a: ${COM_OBJS}
$(AR) -sr $@ $^
$(LIB_DIR)/libopenjpeg.dll: ${COM_OBJS}
${CC} -s -shared -Wl,-soname,libopenjpeg.dll -o $@ $^
$(LIB_DIR)/libopenjpeg.so.1.0: ${COM_OBJS}
${CC} -s -shared -Wl,-soname,libopenjpeg.so.1 -o $@ $^
$(LIB_DIR)/libopenjpeg.so.1: $(LIB_DIR)/libopenjpeg.so.1.0
ln -s libopenjpeg.so.1.0 $(LIB_DIR)/libopenjpeg.so.1
$(LIB_DIR)/libopenjpeg.so: $(LIB_DIR)/libopenjpeg.so.1
ln -s libopenjpeg.so.1 $(LIB_DIR)/libopenjpeg.so
clean:
rm -f $(OBJ_DIR_W32)/* $(OBJ_DIR)/* $(LIB_DIR_W32)/* $(LIB_DIR)/*

285
libopenjpeg/bio.c
View File

@@ -1,11 +1,8 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq * Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2001-2003, David Janssens * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* Copyright (c) 2002-2003, Yannick Verschueren *
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -28,162 +25,170 @@
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * 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 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ ***/
#include "bio.h" #include "bio.h"
#include "opj_malloc.h" #include <stdio.h>
#include <setjmp.h>
/** @defgroup BIO BIO - Individual bit input-output stream */ static unsigned char *bio_start; /* pointer to the start of the buffer */
/*@{*/ static unsigned char *bio_end; /* pointer to the end of the buffer */
static unsigned char *bio_bp; /* pointer to the present position in the buffer */
static unsigned int bio_buf; /* temporary place where each byte is read or written */
static int bio_ct; /* coder : number of bits free to write // decoder : number of bits read */
/** @name Local static functions */ extern jmp_buf j2k_error;
/*@{*/
/**
Write a bit
@param bio BIO handle
@param b Bit to write (0 or 1)
*/
static void bio_putbit(opj_bio_t *bio, OPJ_UINT32 b);
/**
Read a bit
@param bio BIO handle
@return Returns the read bit
*/
static OPJ_UINT32 bio_getbit(opj_bio_t *bio);
/**
Write a byte
@param bio BIO handle
@return Returns 0 if successful, returns 1 otherwise
*/
static bool bio_byteout(opj_bio_t *bio);
/**
Read a byte
@param bio BIO handle
@return Returns 0 if successful, returns 1 otherwise
*/
static bool bio_bytein(opj_bio_t *bio);
/*@}*/
/*@}*/
/* /*
========================================================== * Number of bytes written.
local functions
==========================================================
*/ */
int bio_numbytes()
static bool bio_byteout(opj_bio_t *bio) { {
bio->buf = (bio->buf << 8) & 0xffff; return bio_bp - bio_start;
bio->ct = bio->buf == 0xff00 ? 7 : 8;
if (bio->bp >= bio->end) {
return true;
}
*bio->bp++ = bio->buf >> 8;
return false;
}
static bool bio_bytein(opj_bio_t *bio) {
bio->buf = (bio->buf << 8) & 0xffff;
bio->ct = bio->buf == 0xff00 ? 7 : 8;
if (bio->bp >= bio->end) {
return true;
}
bio->buf |= *bio->bp++;
return false;
}
static void bio_putbit(opj_bio_t *bio, OPJ_UINT32 b) {
if (bio->ct == 0) {
bio_byteout(bio);
}
bio->ct--;
bio->buf |= b << bio->ct;
}
static OPJ_UINT32 bio_getbit(opj_bio_t *bio) {
if (bio->ct == 0) {
bio_bytein(bio);
}
bio->ct--;
return (bio->buf >> bio->ct) & 1;
} }
/* /*
========================================================== * Init encoder.
Bit Input/Output interface *
========================================================== * bp : Output buffer
* len : Output buffer length
*/ */
void bio_init_enc(unsigned char *bp, int len)
opj_bio_t* bio_create(void) { {
opj_bio_t *bio = (opj_bio_t*)opj_malloc(sizeof(opj_bio_t)); bio_start = bp;
return bio; bio_end = bp + len;
bio_bp = bp;
bio_buf = 0;
bio_ct = 8;
} }
void bio_destroy(opj_bio_t *bio) { /*
if(bio) { * Init decoder.
opj_free(bio); *
* bp : Input buffer
* len : Input buffer length
*/
void bio_init_dec(unsigned char *bp, int len)
{
bio_start = bp;
bio_end = bp + len;
bio_bp = bp;
bio_buf = 0;
bio_ct = 0;
}
/*
* Write byte. --> function modified to eliminate longjmp !!!
*
*/
int bio_byteout()
{
bio_buf = (bio_buf << 8) & 0xffff;
bio_ct = bio_buf == 0xff00 ? 7 : 8;
if (bio_bp >= bio_end)
return 1;
*bio_bp++ = bio_buf >> 8;
return 0;
}
/*
* Read byte. --> function modified to eliminate longjmp !!
*
*/
int bio_bytein()
{
bio_buf = (bio_buf << 8) & 0xffff;
bio_ct = bio_buf == 0xff00 ? 7 : 8;
if (bio_bp >= bio_end)
return 1;
bio_buf |= *bio_bp++;
return 0;
}
/*
* Write bit.
*
* b : Bit to write (0 or 1)
*/
void bio_putbit(int b)
{
if (bio_ct == 0) {
bio_byteout();
}
bio_ct--;
bio_buf |= b << bio_ct;
}
/*
* Read bit.
*
*/
int bio_getbit()
{
if (bio_ct == 0) {
bio_bytein();
}
bio_ct--;
return (bio_buf >> bio_ct) & 1;
}
/*
* Write bits.
*
* v : Value of bits
* n : Number of bits to write
*/
void bio_write(int v, int n)
{
int i;
for (i = n - 1; i >= 0; i--) {
bio_putbit((v >> i) & 1);
} }
} }
OPJ_UINT32 bio_numbytes(opj_bio_t *bio) { /*
return (bio->bp - bio->start); * Read bits.
} *
* n : Number of bits to read
void bio_init_enc(opj_bio_t *bio, OPJ_BYTE *bp, OPJ_UINT32 len) { */
bio->start = bp; int bio_read(int n)
bio->end = bp + len; {
bio->bp = bp; int i, v;
bio->buf = 0;
bio->ct = 8;
}
void bio_init_dec(opj_bio_t *bio, OPJ_BYTE *bp, OPJ_UINT32 len) {
bio->start = bp;
bio->end = bp + len;
bio->bp = bp;
bio->buf = 0;
bio->ct = 0;
}
void bio_write(opj_bio_t *bio, OPJ_UINT32 v, OPJ_UINT32 n) {
OPJ_UINT32 i;
for (i = n - 1; i != -1 ; --i) {
bio_putbit(bio, (v >> i) & 1);
}
}
OPJ_UINT32 bio_read(opj_bio_t *bio, OPJ_UINT32 n) {
OPJ_UINT32 i, v;
v = 0; v = 0;
for (i = n - 1; i != -1 ; --i) { for (i = n - 1; i >= 0; i--) {
v += bio_getbit(bio) << i; v += bio_getbit() << i;
} }
return v; return v;
} }
bool bio_flush(opj_bio_t *bio) { /*
bio->ct = 0; * Flush bits. Modified to eliminate longjmp !!
if (bio_byteout(bio)) { *
return true; */
int bio_flush()
{
bio_ct = 0;
if (bio_byteout())
return 1;
if (bio_ct == 7) {
bio_ct = 0;
if (bio_byteout())
return 1;
} }
if (bio->ct == 7) { return 0;
bio->ct = 0;
if (bio_byteout(bio)) {
return true;
}
}
return false;
} }
bool bio_inalign(opj_bio_t *bio) { /*
bio->ct = 0; * Passes the ending bits (coming from flushing)
if ((bio->buf & 0xff) == 0xff) { */
if (bio_bytein(bio)) { int bio_inalign()
return true; {
bio_ct = 0;
if ((bio_buf & 0xff) == 0xff) {
if (bio_bytein())
return 1;
bio_ct = 0;
} }
bio->ct = 0; return 0;
}
return false;
} }

129
libopenjpeg/bio.h
View File

@@ -1,11 +1,7 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq * Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2001-2003, David Janssens * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -32,95 +28,48 @@
#ifndef __BIO_H #ifndef __BIO_H
#define __BIO_H #define __BIO_H
/**
@file bio.h
@brief Implementation of an individual bit input-output (BIO)
The functions in BIO.C have for goal to realize an individual bit input - output. /*
* Number of bytes written.
*/ */
#include "openjpeg.h" int bio_numbytes();
/** @defgroup BIO BIO - Individual bit input-output stream */
/*@{*/
/** /*
Individual bit input-output stream (BIO) * Init encoder.
*
* bp : Output buffer
* len : Output buffer length
*/ */
typedef struct opj_bio { void bio_init_enc(unsigned char *bp, int len);
/** pointer to the start of the buffer */
OPJ_BYTE *start;
/** pointer to the end of the buffer */
OPJ_BYTE *end;
/** pointer to the present position in the buffer */
OPJ_BYTE *bp;
/** temporary place where each byte is read or written */
OPJ_UINT32 buf;
/** coder : number of bits free to write. decoder : number of bits read */
OPJ_UINT32 ct;
} opj_bio_t;
/** @name Exported functions */ /*
/*@{*/ * Init decoder.
/* ----------------------------------------------------------------------- */ *
/** * bp : Input buffer
Create a new BIO handle * len : Input buffer length
@return Returns a new BIO handle if successful, returns NULL otherwise
*/ */
opj_bio_t* bio_create(void); void bio_init_dec(unsigned char *bp, int len);
/**
Destroy a previously created BIO handle
@param bio BIO handle to destroy
*/
void bio_destroy(opj_bio_t *bio);
/**
Number of bytes written.
@param bio BIO handle
@return Returns the number of bytes written
*/
OPJ_UINT32 bio_numbytes(opj_bio_t *bio);
/**
Init encoder
@param bio BIO handle
@param bp Output buffer
@param len Output buffer length
*/
void bio_init_enc(opj_bio_t *bio, OPJ_BYTE *bp, OPJ_UINT32 len);
/**
Init decoder
@param bio BIO handle
@param bp Input buffer
@param len Input buffer length
*/
void bio_init_dec(opj_bio_t *bio, OPJ_BYTE *bp, OPJ_UINT32 len);
/**
Write bits
@param bio BIO handle
@param v Value of bits
@param n Number of bits to write
*/
void bio_write(opj_bio_t *bio, OPJ_UINT32 v, OPJ_UINT32 n);
/**
Read bits
@param bio BIO handle
@param n Number of bits to read
@return Returns the corresponding read number
*/
OPJ_UINT32 bio_read(opj_bio_t *bio, OPJ_UINT32 n);
/**
Flush bits
@param bio BIO handle
@return Returns 1 if successful, returns 0 otherwise
*/
bool bio_flush(opj_bio_t *bio);
/**
Passes the ending bits (coming from flushing)
@param bio BIO handle
@return Returns 1 if successful, returns 0 otherwise
*/
bool bio_inalign(opj_bio_t *bio);
/* ----------------------------------------------------------------------- */
/*@}*/
/*@}*/ /*
* Write bits.
*
* v : Value of bits
* n : Number of bits to write
*/
void bio_write(int v, int n);
#endif /* __BIO_H */ /*
* Read bits.
*
* n : Number of bits to read
*/
int bio_read(int n);
/*
* Flush bits. Modified to eliminate longjmp !!
*/
int bio_flush();
int bio_inalign(); /* modified to eliminated longjmp !! */
#endif

871
libopenjpeg/cio.c
View File

@@ -1,11 +1,5 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -31,798 +25,155 @@
*/ */
#include "cio.h" #include "cio.h"
#include "opj_includes.h" #include <setjmp.h>
#include "opj_malloc.h" #include <memory.h>
#include "event.h"
/* ----------------------------------------------------------------------- */ static unsigned char *cio_start; /* pointer to the start of the stream */
static unsigned char *cio_end; /* pointer to the end of the stream */
static unsigned char *cio_bp; /* pointer to the present position */
extern jmp_buf j2k_error;
/** /*
* Write some bytes to the given data buffer, this function is used in Big Endian cpus. * Number of bytes written.
* @param p_buffer pointer the data buffer to write data to.
* @param p_value the value to write
* @param p_nb_bytes the number of bytes to write
*/ */
void opj_write_bytes_BE (OPJ_BYTE * p_buffer, OPJ_UINT32 p_value, OPJ_UINT32 p_nb_bytes) int cio_numbytes()
{ {
const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + p_nb_bytes; return cio_bp - cio_start;
assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
memcpy(p_buffer,l_data_ptr,p_nb_bytes);
} }
/** /*
* Write some bytes to the given data buffer, this function is used in Little Endian cpus. * Get position in byte stream.
* @param p_buffer pointer the data buffer to write data to.
* @param p_value the value to write
* @param p_nb_bytes the number of bytes to write
* @return the number of bytes written or -1 if an error occured
*/ */
void opj_write_bytes_LE (OPJ_BYTE * p_buffer, OPJ_UINT32 p_value, OPJ_UINT32 p_nb_bytes) int cio_tell()
{ {
const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + p_nb_bytes - 1; return cio_bp - cio_start;
OPJ_UINT32 i;
assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
for
(i=0;i<p_nb_bytes;++i)
{
*(p_buffer++) = *(l_data_ptr--);
}
} }
/** /*
* Reads some bytes from the given data buffer, this function is used in Big Endian cpus. * Set position in byte stream.
* @param p_buffer pointer the data buffer to read data from.
* @param p_value pointer to the value that will store the data.
* @param p_nb_bytes the nb bytes to read.
* @return the number of bytes read or -1 if an error occured.
*/
void opj_read_bytes_BE(const OPJ_BYTE * p_buffer, OPJ_UINT32 * p_value, OPJ_UINT32 p_nb_bytes)
{
OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
*p_value = 0;
memcpy(l_data_ptr+4-p_nb_bytes,p_buffer,p_nb_bytes);
}
/**
* Reads some bytes from the given data buffer, this function is used in Little Endian cpus.
* @param p_buffer pointer the data buffer to read data from.
* @param p_value pointer to the value that will store the data.
* @param p_nb_bytes the nb bytes to read.
* @return the number of bytes read or -1 if an error occured.
*/
void opj_read_bytes_LE(const OPJ_BYTE * p_buffer, OPJ_UINT32 * p_value, OPJ_UINT32 p_nb_bytes)
{
OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + p_nb_bytes-1;
OPJ_UINT32 i;
assert(p_nb_bytes > 0 && p_nb_bytes <= sizeof(OPJ_UINT32));
*p_value = 0;
for
(i=0;i<p_nb_bytes;++i)
{
*(l_data_ptr--) = *(p_buffer++);
}
}
/**
* Write some bytes to the given data buffer, this function is used in Big Endian cpus.
* @param p_buffer pointer the data buffer to write data to.
* @param p_value the value to write
* @return the number of bytes written or -1 if an error occured
*/
void opj_write_double_BE(OPJ_BYTE * p_buffer, OPJ_FLOAT64 p_value)
{
const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value);
memcpy(p_buffer,l_data_ptr,sizeof(OPJ_FLOAT64));
}
/**
* Write some bytes to the given data buffer, this function is used in Little Endian cpus.
* @param p_buffer pointer the data buffer to write data to.
* @param p_value the value to write
*/
void opj_write_double_LE(OPJ_BYTE * p_buffer, OPJ_FLOAT64 p_value)
{
const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + sizeof(OPJ_FLOAT64) - 1;
OPJ_UINT32 i;
for
(i=0;i<sizeof(OPJ_FLOAT64);++i)
{
*(p_buffer++) = *(l_data_ptr--);
}
}
/**
* Reads some bytes from the given data buffer, this function is used in Big Endian cpus.
* @param p_buffer pointer the data buffer to read data from.
* @param p_value pointer to the value that will store the data.
*/
void opj_read_double_BE(const OPJ_BYTE * p_buffer, OPJ_FLOAT64 * p_value)
{
OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
memcpy(l_data_ptr,p_buffer,sizeof(OPJ_FLOAT64));
}
/**
* Reads some bytes from the given data buffer, this function is used in Little Endian cpus.
* @param p_buffer pointer the data buffer to read data from.
* @param p_value pointer to the value that will store the data.
*/
void opj_read_double_LE(const OPJ_BYTE * p_buffer, OPJ_FLOAT64 * p_value)
{
OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + sizeof(OPJ_FLOAT64)-1;
OPJ_UINT32 i;
for
(i=0;i<sizeof(OPJ_FLOAT64);++i)
{
*(l_data_ptr--) = *(p_buffer++);
}
}
/**
* Write some bytes to the given data buffer, this function is used in Big Endian cpus.
* @param p_buffer pointer the data buffer to write data to.
* @param p_value the value to write
* @return the number of bytes written or -1 if an error occured
*/
void opj_write_float_BE(OPJ_BYTE * p_buffer, OPJ_FLOAT32 p_value)
{
const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value);
memcpy(p_buffer,l_data_ptr,sizeof(OPJ_FLOAT32));
}
/**
* Write some bytes to the given data buffer, this function is used in Little Endian cpus.
* @param p_buffer pointer the data buffer to write data to.
* @param p_value the value to write
*/
void opj_write_float_LE(OPJ_BYTE * p_buffer, OPJ_FLOAT32 p_value)
{
const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + sizeof(OPJ_FLOAT32) - 1;
OPJ_UINT32 i;
for
(i=0;i<sizeof(OPJ_FLOAT32);++i)
{
*(p_buffer++) = *(l_data_ptr--);
}
}
/**
* Reads some bytes from the given data buffer, this function is used in Big Endian cpus.
* @param p_buffer pointer the data buffer to read data from.
* @param p_value pointer to the value that will store the data.
*/
void opj_read_float_BE(const OPJ_BYTE * p_buffer, OPJ_FLOAT32 * p_value)
{
OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value);
memcpy(l_data_ptr,p_buffer,sizeof(OPJ_FLOAT32));
}
/**
* Reads some bytes from the given data buffer, this function is used in Little Endian cpus.
* @param p_buffer pointer the data buffer to read data from.
* @param p_value pointer to the value that will store the data.
*/
void opj_read_float_LE(const OPJ_BYTE * p_buffer, OPJ_FLOAT32 * p_value)
{
OPJ_BYTE * l_data_ptr = ((OPJ_BYTE *) p_value) + sizeof(OPJ_FLOAT32)-1;
OPJ_UINT32 i;
for
(i=0;i<sizeof(OPJ_FLOAT32);++i)
{
*(l_data_ptr--) = *(p_buffer++);
}
}
/**
* Creates an abstract stream. This function does nothing except allocating memory and initializing the abstract stream.
* @return a stream object.
*/
opj_stream_t* OPJ_CALLCONV opj_stream_create(OPJ_UINT32 p_size,bool l_is_input)
{
opj_stream_private_t * l_stream = 00;
l_stream = (opj_stream_private_t*) opj_malloc(sizeof(opj_stream_private_t));
if
(! l_stream)
{
return 00;
}
memset(l_stream,0,sizeof(opj_stream_private_t));
l_stream->m_buffer_size = p_size;
l_stream->m_stored_data = (OPJ_BYTE *) opj_malloc(p_size);
if
(! l_stream->m_stored_data)
{
opj_free(l_stream);
return 00;
}
l_stream->m_current_data = l_stream->m_stored_data;
if
(l_is_input)
{
l_stream->m_status |= opj_stream_e_input;
l_stream->m_opj_skip = opj_stream_read_skip;
l_stream->m_opj_seek = opj_stream_read_seek;
}
else
{
l_stream->m_status |= opj_stream_e_output;
l_stream->m_opj_skip = opj_stream_write_skip;
l_stream->m_opj_seek = opj_stream_write_seek;
}
l_stream->m_read_fn = opj_stream_default_read;
l_stream->m_write_fn = opj_stream_default_write;
l_stream->m_skip_fn = opj_stream_default_skip;
l_stream->m_seek_fn = opj_stream_default_seek;
return (opj_stream_t *) l_stream;
}
/**
* Creates an abstract stream. This function does nothing except allocating memory and initializing the abstract stream.
* @return a stream object.
*/
opj_stream_t* OPJ_CALLCONV opj_stream_default_create(bool l_is_input)
{
return opj_stream_create(J2K_STREAM_CHUNK_SIZE,l_is_input);
}
/**
* Destroys a stream created by opj_create_stream. This function does NOT close the abstract stream. If needed the user must
* close its own implementation of the stream.
*/
OPJ_API void OPJ_CALLCONV opj_stream_destroy(opj_stream_t* p_stream)
{
opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
if
(l_stream)
{
opj_free(l_stream->m_stored_data);
l_stream->m_stored_data = 00;
opj_free(l_stream);
}
}
/**
* Sets the given function to be used as a read function.
* @param p_stream the stream to modify
* @param p_function the function to use a read function.
*/
OPJ_API void OPJ_CALLCONV opj_stream_set_read_function(opj_stream_t* p_stream, opj_stream_read_fn p_function)
{
opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
if
((!l_stream) || (! (l_stream->m_status & opj_stream_e_input)))
{
return;
}
l_stream->m_read_fn = p_function;
}
OPJ_API void OPJ_CALLCONV opj_stream_set_seek_function(opj_stream_t* p_stream, opj_stream_seek_fn p_function)
{
opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
if
(!l_stream)
{
return;
}
l_stream->m_seek_fn = p_function;
}
/**
* Sets the given function to be used as a write function.
* @param p_stream the stream to modify
* @param p_function the function to use a write function.
*/
OPJ_API void OPJ_CALLCONV opj_stream_set_write_function(opj_stream_t* p_stream, opj_stream_write_fn p_function)
{
opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
if
((!l_stream )|| (! (l_stream->m_status & opj_stream_e_output)))
{
return;
}
l_stream->m_write_fn = p_function;
}
/**
* Sets the given function to be used as a skip function.
* @param p_stream the stream to modify
* @param p_function the function to use a skip function.
*/
OPJ_API void OPJ_CALLCONV opj_stream_set_skip_function(opj_stream_t* p_stream, opj_stream_skip_fn p_function)
{
opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
if
(! l_stream)
{
return;
}
l_stream->m_skip_fn = p_function;
}
/**
* Sets the given data to be used as a user data for the stream.
* @param p_stream the stream to modify
* @param p_data the data to set.
*/
OPJ_API void OPJ_CALLCONV opj_stream_set_user_data(opj_stream_t* p_stream, void * p_data)
{
opj_stream_private_t* l_stream = (opj_stream_private_t*) p_stream;
l_stream->m_user_data = p_data;
}
/**
* Reads some bytes from the stream.
* @param p_stream the stream to read data from.
* @param p_buffer pointer to the data buffer that will receive the data.
* @param p_size number of bytes to read.
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes read, or -1 if an error occured or if the stream is at the end.
*/
OPJ_UINT32 opj_stream_read_data (opj_stream_private_t * p_stream,OPJ_BYTE * p_buffer, OPJ_UINT32 p_size, opj_event_mgr_t * p_event_mgr)
{
OPJ_UINT32 l_read_nb_bytes = 0;
if
(p_stream->m_bytes_in_buffer >= p_size)
{
memcpy(p_buffer,p_stream->m_current_data,p_size);
p_stream->m_current_data += p_size;
p_stream->m_bytes_in_buffer -= p_size;
l_read_nb_bytes += p_size;
p_stream->m_byte_offset += p_size;
return l_read_nb_bytes;
}
// we are now in the case when the remaining data if not sufficient
if
(p_stream->m_status & opj_stream_e_end)
{
l_read_nb_bytes += p_stream->m_bytes_in_buffer;
memcpy(p_buffer,p_stream->m_current_data,p_stream->m_bytes_in_buffer);
p_stream->m_current_data += p_stream->m_bytes_in_buffer;
p_stream->m_byte_offset += p_stream->m_bytes_in_buffer;
p_stream->m_bytes_in_buffer = 0;
return l_read_nb_bytes ? l_read_nb_bytes : -1;
}
// the flag is not set, we copy data and then do an actual read on the stream
if
(p_stream->m_bytes_in_buffer)
{
l_read_nb_bytes += p_stream->m_bytes_in_buffer;
memcpy(p_buffer,p_stream->m_current_data,p_stream->m_bytes_in_buffer);
p_stream->m_current_data = p_stream->m_stored_data;
p_buffer += p_stream->m_bytes_in_buffer;
p_size -= p_stream->m_bytes_in_buffer;
p_stream->m_byte_offset += p_stream->m_bytes_in_buffer;
p_stream->m_bytes_in_buffer = 0;
}
else
{
/* case where we are already at the end of the buffer
so reset the m_current_data to point to the start of the
stored buffer to get ready to read from disk*/
p_stream->m_current_data = p_stream->m_stored_data;
}
while
(true)
{
// we should read less than a chunk -> read a chunk
if
(p_size < p_stream->m_buffer_size)
{
// we should do an actual read on the media
p_stream->m_bytes_in_buffer = p_stream->m_read_fn(p_stream->m_stored_data,p_stream->m_buffer_size,p_stream->m_user_data);
if
(p_stream->m_bytes_in_buffer == -1)
{
// end of stream
opj_event_msg(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
p_stream->m_bytes_in_buffer = 0;
p_stream->m_status |= opj_stream_e_end;
// end of stream
return l_read_nb_bytes ? l_read_nb_bytes : -1;
}
else if
(p_stream->m_bytes_in_buffer < p_size)
{
// not enough data
l_read_nb_bytes += p_stream->m_bytes_in_buffer;
memcpy(p_buffer,p_stream->m_current_data,p_stream->m_bytes_in_buffer);
p_stream->m_current_data = p_stream->m_stored_data;
p_buffer += p_stream->m_bytes_in_buffer;
p_size -= p_stream->m_bytes_in_buffer;
p_stream->m_byte_offset += p_stream->m_bytes_in_buffer;
p_stream->m_bytes_in_buffer = 0;
}
else
{
l_read_nb_bytes += p_size;
memcpy(p_buffer,p_stream->m_current_data,p_size);
p_stream->m_current_data += p_size;
p_stream->m_bytes_in_buffer -= p_size;
p_stream->m_byte_offset += p_size;
return l_read_nb_bytes;
}
}
else
{
// direct read on the dest buffer
p_stream->m_bytes_in_buffer = p_stream->m_read_fn(p_buffer,p_size,p_stream->m_user_data);
if
(p_stream->m_bytes_in_buffer == -1)
{
// end of stream
opj_event_msg(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
p_stream->m_bytes_in_buffer = 0;
p_stream->m_status |= opj_stream_e_end;
// end of stream
return l_read_nb_bytes ? l_read_nb_bytes : -1;
}
else if
(p_stream->m_bytes_in_buffer < p_size)
{
// not enough data
l_read_nb_bytes += p_stream->m_bytes_in_buffer;
p_stream->m_current_data = p_stream->m_stored_data;
p_buffer += p_stream->m_bytes_in_buffer;
p_size -= p_stream->m_bytes_in_buffer;
p_stream->m_byte_offset += p_stream->m_bytes_in_buffer;
p_stream->m_bytes_in_buffer = 0;
}
else
{
// we have read the exact size
l_read_nb_bytes += p_stream->m_bytes_in_buffer;
p_stream->m_byte_offset += p_stream->m_bytes_in_buffer;
p_stream->m_current_data = p_stream->m_stored_data;
p_stream->m_bytes_in_buffer = 0;
return l_read_nb_bytes;
}
}
}
}
/**
* Writes some bytes from the stream.
* @param p_stream the stream to write data to.
* @param p_buffer pointer to the data buffer holds the data to be writtent.
* @param p_size number of bytes to write.
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes writtent, or -1 if an error occured.
*/
OPJ_UINT32 opj_stream_write_data (opj_stream_private_t * p_stream,const OPJ_BYTE * p_buffer,OPJ_UINT32 p_size, opj_event_mgr_t * p_event_mgr)
{
OPJ_UINT32 l_remaining_bytes = 0;
OPJ_UINT32 l_write_nb_bytes = 0;
if
(p_stream->m_status & opj_stream_e_error)
{
return -1;
}
while
(true)
{
l_remaining_bytes = p_stream->m_buffer_size - p_stream->m_bytes_in_buffer;
// we have more memory than required
if
(l_remaining_bytes >= p_size)
{
memcpy(p_stream->m_current_data,p_buffer,p_size);
p_stream->m_current_data += p_size;
p_stream->m_bytes_in_buffer += p_size;
l_write_nb_bytes += p_size;
p_stream->m_byte_offset += p_size;
return l_write_nb_bytes;
}
// we copy data and then do an actual read on the stream
if
(l_remaining_bytes)
{
l_write_nb_bytes += l_remaining_bytes;
memcpy(p_stream->m_current_data,p_buffer,l_remaining_bytes);
p_stream->m_current_data = p_stream->m_stored_data;
p_buffer += l_remaining_bytes;
p_size -= l_remaining_bytes;
p_stream->m_bytes_in_buffer += l_remaining_bytes;
p_stream->m_byte_offset += l_remaining_bytes;
}
if
(! opj_stream_flush(p_stream, p_event_mgr))
{
return -1;
}
}
}
/**
* Writes the content of the stream buffer to the stream.
* @param p_stream the stream to write data to.
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes written, or -1 if an error occured.
*/
bool opj_stream_flush (opj_stream_private_t * p_stream, opj_event_mgr_t * p_event_mgr)
{
// the number of bytes written on the media.
OPJ_UINT32 l_current_write_nb_bytes = 0;
p_stream->m_current_data = p_stream->m_stored_data;
while
(p_stream->m_bytes_in_buffer)
{
// we should do an actual write on the media
l_current_write_nb_bytes = p_stream->m_write_fn(p_stream->m_current_data,p_stream->m_bytes_in_buffer,p_stream->m_user_data);
if
(l_current_write_nb_bytes == -1)
{
p_stream->m_status |= opj_stream_e_error;
opj_event_msg(p_event_mgr, EVT_INFO, "Error on writting stream!\n");
return false;
}
p_stream->m_current_data += l_current_write_nb_bytes;
p_stream->m_bytes_in_buffer -= l_current_write_nb_bytes;
}
p_stream->m_current_data = p_stream->m_stored_data;
return true;
}
/**
* Skips a number of bytes from the stream.
* @param p_stream the stream to skip data from.
* @param p_size the number of bytes to skip.
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes skipped, or -1 if an error occured.
*/
OPJ_SIZE_T opj_stream_read_skip (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, opj_event_mgr_t * p_event_mgr)
{
OPJ_SIZE_T l_skip_nb_bytes = 0;
OPJ_SIZE_T l_current_skip_nb_bytes = 0;
if
(p_stream->m_bytes_in_buffer >= p_size)
{
p_stream->m_current_data += p_size;
p_stream->m_bytes_in_buffer -= p_size;
l_skip_nb_bytes += p_size;
p_stream->m_byte_offset += l_skip_nb_bytes;
return l_skip_nb_bytes;
}
// we are now in the case when the remaining data if not sufficient
if
(p_stream->m_status & opj_stream_e_end)
{
l_skip_nb_bytes += p_stream->m_bytes_in_buffer;
p_stream->m_current_data += p_stream->m_bytes_in_buffer;
p_stream->m_bytes_in_buffer = 0;
p_stream->m_byte_offset += l_skip_nb_bytes;
return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_SIZE_T) -1;
}
// the flag is not set, we copy data and then do an actual skip on the stream
if
(p_stream->m_bytes_in_buffer)
{
l_skip_nb_bytes += p_stream->m_bytes_in_buffer;
p_stream->m_current_data = p_stream->m_stored_data;
p_size -= p_stream->m_bytes_in_buffer;
p_stream->m_bytes_in_buffer = 0;
}
while
(p_size > 0)
{
// we should do an actual skip on the media
l_current_skip_nb_bytes = p_stream->m_skip_fn(p_size, p_stream->m_user_data);
if
(l_current_skip_nb_bytes == (OPJ_SIZE_T) -1)
{
opj_event_msg(p_event_mgr, EVT_INFO, "Stream reached its end !\n");
p_stream->m_status |= opj_stream_e_end;
p_stream->m_byte_offset += l_skip_nb_bytes;
// end if stream
return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_SIZE_T) -1;
}
p_size -= l_current_skip_nb_bytes;
l_skip_nb_bytes += l_current_skip_nb_bytes;
}
p_stream->m_byte_offset += l_skip_nb_bytes;
return l_skip_nb_bytes;
}
/**
* Skips a number of bytes from the stream.
* @param p_stream the stream to skip data from.
* @param p_size the number of bytes to skip.
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes skipped, or -1 if an error occured.
*/
OPJ_SIZE_T opj_stream_write_skip (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, opj_event_mgr_t * p_event_mgr)
{
bool l_is_written = 0;
OPJ_SIZE_T l_current_skip_nb_bytes = 0;
OPJ_SIZE_T l_skip_nb_bytes = 0;
if
(p_stream->m_status & opj_stream_e_error)
{
return (OPJ_SIZE_T) -1;
}
// we should flush data
l_is_written = opj_stream_flush (p_stream, p_event_mgr);
if
(! l_is_written)
{
p_stream->m_status |= opj_stream_e_error;
p_stream->m_bytes_in_buffer = 0;
p_stream->m_current_data = p_stream->m_current_data;
return (OPJ_SIZE_T) -1;
}
// then skip
while
(p_size > 0)
{
// we should do an actual skip on the media
l_current_skip_nb_bytes = p_stream->m_skip_fn(p_size, p_stream->m_user_data);
if
(l_current_skip_nb_bytes == (OPJ_SIZE_T)-1)
{
opj_event_msg(p_event_mgr, EVT_INFO, "Stream error!\n");
p_stream->m_status |= opj_stream_e_error;
p_stream->m_byte_offset += l_skip_nb_bytes;
// end if stream
return l_skip_nb_bytes ? l_skip_nb_bytes : (OPJ_SIZE_T)-1;
}
p_size -= l_current_skip_nb_bytes;
l_skip_nb_bytes += l_current_skip_nb_bytes;
}
p_stream->m_byte_offset += l_skip_nb_bytes;
return l_skip_nb_bytes;
}
/**
* Tells the byte offset on the stream (similar to ftell).
* *
* @param p_stream the stream to get the information from. * pos : position, in number of bytes, from the beginning of the stream
*/
void cio_seek(int pos)
{
cio_bp = cio_start + pos;
}
/*
* Number of bytes left before the end of the stream.
*/
int cio_numbytesleft()
{
return cio_end - cio_bp;
}
/*
* Get pointer to the current position in the stream.
*/
unsigned char *cio_getbp()
{
return cio_bp;
}
/*
* Initialize byte IO
* *
* @return the current position o fthe stream. * bp : destination/source stream
* len : length of the stream
*/ */
OPJ_SIZE_T opj_stream_tell (const opj_stream_private_t * p_stream) void cio_init(unsigned char *bp, int len)
{ {
return p_stream->m_byte_offset; cio_start = bp;
cio_end = bp + len;
cio_bp = bp;
} }
/** /*
* Skips a number of bytes from the stream. * Write a byte.
* @param p_stream the stream to skip data from.
* @param p_size the number of bytes to skip.
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes skipped, or -1 if an error occured.
*/ */
OPJ_SIZE_T opj_stream_skip (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, opj_event_mgr_t * p_event_mgr) void cio_byteout(unsigned char v)
{ {
return p_stream->m_opj_skip(p_stream,p_size,p_event_mgr); if (cio_bp >= cio_end)
longjmp(j2k_error, 1);
*cio_bp++ = v;
} }
/*
/** * Read a byte.
* Skips a number of bytes from the stream.
* @param p_stream the stream to skip data from.
* @param p_size the number of bytes to skip.
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes skipped, or -1 if an error occured.
*/ */
bool opj_stream_read_seek (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, opj_event_mgr_t * p_event_mgr) unsigned char cio_bytein()
{ {
p_stream->m_current_data = p_stream->m_stored_data; if (cio_bp >= cio_end)
p_stream->m_bytes_in_buffer = 0; longjmp(j2k_error, 1);
if return *cio_bp++;
(! p_stream->m_seek_fn(p_size,p_stream->m_user_data))
{
p_stream->m_status |= opj_stream_e_end;
return false;
}
else
{
// reset stream status
p_stream->m_status &= (~opj_stream_e_end);
p_stream->m_byte_offset = p_size;
}
return true;
} }
/** /*
* Skips a number of bytes from the stream. * Write some bytes.
* @param p_stream the stream to skip data from. *
* @param p_size the number of bytes to skip. * v : value to write
* @param p_event_mgr the user event manager to be notified of special events. * n : number of bytes to write
* @return the number of bytes skipped, or -1 if an error occured.
*/ */
bool opj_stream_write_seek (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, opj_event_mgr_t * p_event_mgr) void cio_write(unsigned int v, int n)
{ {
if int i;
(! opj_stream_flush(p_stream,p_event_mgr)) for (i = n - 1; i >= 0; i--) {
{ cio_byteout((unsigned char) ((v >> (i << 3)) & 0xff));
p_stream->m_status |= opj_stream_e_error; }
return false;
} }
p_stream->m_current_data = p_stream->m_stored_data; /*
p_stream->m_bytes_in_buffer = 0; * Read some bytes.
*
if * n : number of bytes to read
(! p_stream->m_seek_fn(p_size,p_stream->m_user_data)) *
{ * return : value of the n bytes read
p_stream->m_status |= opj_stream_e_error;
return false;
}
else
{
p_stream->m_byte_offset = p_size;
}
return true;
}
/**
* Seeks a number of bytes from the stream.
* @param p_stream the stream to skip data from.
* @param p_size the number of bytes to skip.
* @param p_event_mgr the user event manager to be notified of special events.
* @return true if the stream is seekable.
*/ */
bool opj_stream_seek (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, struct opj_event_mgr * p_event_mgr) unsigned int cio_read(int n)
{ {
return p_stream->m_opj_seek(p_stream,p_size,p_event_mgr); int i;
unsigned int v;
v = 0;
for (i = n - 1; i >= 0; i--) {
v += cio_bytein() << (i << 3);
}
return v;
} }
/** /*
* Tells if the given stream is seekable. * Skip some bytes.
*
* n : number of bytes to skip
*/ */
bool opj_stream_has_seek (const opj_stream_private_t * p_stream) void cio_skip(int n)
{ {
return p_stream->m_seek_fn != opj_stream_default_seek; cio_bp += n;
} }
/*
* Read n bytes, copy to buffer
*
* n : number of bytes to transfer
OPJ_UINT32 opj_stream_default_read (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data) */
void cio_read_to_buf(unsigned char* src_buf, int n)/* Glenn adds */
{ {
return (OPJ_UINT32) -1; if (cio_bp + n > cio_end)
} longjmp(j2k_error, 1);
OPJ_UINT32 opj_stream_default_write (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data) memcpy(cio_bp, src_buf, n);
{ cio_bp += n;
return (OPJ_UINT32) -1;
}
OPJ_SIZE_T opj_stream_default_skip (OPJ_SIZE_T p_nb_bytes, void * p_user_data)
{
return (OPJ_SIZE_T) -1;
} }
bool opj_stream_default_seek (OPJ_SIZE_T p_nb_bytes, void * p_user_data) /*
* Write n bytes, copy from buffer
*
* n : number of bytes to transfer
*/
void cio_write_from_buf(unsigned char* dest_buf, int n)/* Glenn adds */
{ {
return false; if (cio_bp + n > cio_end)
longjmp(j2k_error, 1);
memcpy(dest_buf, cio_bp, n);
cio_bp += n;
} }

372
libopenjpeg/cio.h
View File

@@ -1,11 +1,5 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -32,328 +26,82 @@
#ifndef __CIO_H #ifndef __CIO_H
#define __CIO_H #define __CIO_H
/**
@file cio.h
@brief Implementation of a byte input-output process (CIO)
The functions in CIO.C have for goal to realize a byte input / output process. /*
*/ * Number of bytes written.
/** @defgroup CIO CIO - byte input-output stream */
/*@{*/
#include "openjpeg.h"
#include "opj_configure.h"
struct opj_event_mgr;
/** @name Exported functions (see also openjpeg.h) */
/*@{*/
/* ----------------------------------------------------------------------- */
#if defined(OPJ_BIG_ENDIAN)
#if !defined(OPJ_LITTLE_ENDIAN)
#define opj_write_bytes opj_write_bytes_BE
#define opj_read_bytes opj_read_bytes_BE
#define opj_write_double opj_write_double_BE
#define opj_read_double opj_read_double_BE
#define opj_write_float opj_write_float_BE
#define opj_read_float opj_read_float_BE
#else
#error "Either BIG_ENDIAN or LITTLE_ENDIAN must be #defined, but not both."
#endif
#else
#if defined(OPJ_LITTLE_ENDIAN)
#define opj_write_bytes opj_write_bytes_LE
#define opj_read_bytes opj_read_bytes_LE
#define opj_write_double opj_write_double_LE
#define opj_read_double opj_read_double_LE
#define opj_write_float opj_write_float_LE
#define opj_read_float opj_read_float_LE
#else
#error "Either BIG_ENDIAN or LITTLE_ENDIAN must be #defined, but not none."
#endif
#endif
typedef enum
{
opj_stream_e_output = 0x1,
opj_stream_e_input = 0x2,
opj_stream_e_end = 0x4,
opj_stream_e_error = 0x8
}
opj_stream_flag ;
/**
Byte input-output stream.
*/
typedef struct opj_stream_private
{
/**
* User data, be it files, ... The actual data depends on the type of the stream.
*/
void * m_user_data;
/**
* Pointer to actual read function (NULL at the initialization of the cio.
*/
opj_stream_read_fn m_read_fn;
/**
* Pointer to actual write function (NULL at the initialization of the cio.
*/
opj_stream_write_fn m_write_fn;
/**
* Pointer to actual skip function (NULL at the initialization of the cio.
* There is no seek function to prevent from back and forth slow procedures.
*/
opj_stream_skip_fn m_skip_fn;
/**
* Pointer to actual seek function (if available).
*/
opj_stream_seek_fn m_seek_fn;
/**
* Actual data stored into the stream if readed from. Data is read by chunk of fixed size.
* you should never access this data directly.
*/
OPJ_BYTE * m_stored_data;
/**
* Pointer to the current read data.
*/
OPJ_BYTE * m_current_data;
OPJ_SIZE_T (* m_opj_skip)(struct opj_stream_private * ,OPJ_SIZE_T , struct opj_event_mgr *);
bool (* m_opj_seek) (struct opj_stream_private * , OPJ_SIZE_T , struct opj_event_mgr *);
/**
* number of bytes containing in the buffer.
*/
OPJ_UINT32 m_bytes_in_buffer;
/**
* The number of bytes read/written.
*/
OPJ_SIZE_T m_byte_offset;
/**
* The size of the buffer.
*/
OPJ_UINT32 m_buffer_size;
/**
* Flags to tell the status of the stream.
*/
OPJ_UINT32 m_status;
}
opj_stream_private_t;
/**
* Write some bytes to the given data buffer, this function is used in Big Endian cpus.
* @param p_buffer pointer the data buffer to write data to.
* @param p_value the value to write
* @param p_nb_bytes the number of bytes to write
*/
void opj_write_bytes_BE (OPJ_BYTE * p_buffer, OPJ_UINT32 p_value, OPJ_UINT32 p_nb_bytes);
/**
* Reads some bytes from the given data buffer, this function is used in Big Endian cpus.
* @param p_buffer pointer the data buffer to read data from.
* @param p_value pointer to the value that will store the data.
* @param p_nb_bytes the nb bytes to read.
* @return the number of bytes read or -1 if an error occured.
*/
void opj_read_bytes_BE(const OPJ_BYTE * p_buffer, OPJ_UINT32 * p_value, OPJ_UINT32 p_nb_bytes);
/**
* Write some bytes to the given data buffer, this function is used in Little Endian cpus.
* @param p_buffer pointer the data buffer to write data to.
* @param p_value the value to write
* @param p_nb_bytes the number of bytes to write
* @return the number of bytes written or -1 if an error occured
*/
void opj_write_bytes_LE (OPJ_BYTE * p_buffer, OPJ_UINT32 p_value, OPJ_UINT32 p_nb_bytes);
/**
* Reads some bytes from the given data buffer, this function is used in Little Endian cpus.
* @param p_buffer pointer the data buffer to read data from.
* @param p_value pointer to the value that will store the data.
* @param p_nb_bytes the nb bytes to read.
* @return the number of bytes read or -1 if an error occured.
*/
void opj_read_bytes_LE(const OPJ_BYTE * p_buffer, OPJ_UINT32 * p_value, OPJ_UINT32 p_nb_bytes);
/**
* Write some bytes to the given data buffer, this function is used in Little Endian cpus.
* @param p_buffer pointer the data buffer to write data to.
* @param p_value the value to write
*/
void opj_write_double_LE(OPJ_BYTE * p_buffer, OPJ_FLOAT64 p_value);
/***
* Write some bytes to the given data buffer, this function is used in Big Endian cpus.
* @param p_buffer pointer the data buffer to write data to.
* @param p_value the value to write
*/
void opj_write_double_BE(OPJ_BYTE * p_buffer, OPJ_FLOAT64 p_value);
/**
* Reads some bytes from the given data buffer, this function is used in Little Endian cpus.
* @param p_buffer pointer the data buffer to read data from.
* @param p_value pointer to the value that will store the data.
*/
void opj_read_double_LE(const OPJ_BYTE * p_buffer, OPJ_FLOAT64 * p_value);
/**
* Reads some bytes from the given data buffer, this function is used in Big Endian cpus.
* @param p_buffer pointer the data buffer to read data from.
* @param p_value pointer to the value that will store the data.
*/
void opj_read_double_BE(const OPJ_BYTE * p_buffer, OPJ_FLOAT64 * p_value);
/**
* Reads some bytes from the given data buffer, this function is used in Little Endian cpus.
* @param p_buffer pointer the data buffer to read data from.
* @param p_value pointer to the value that will store the data.
*/
void opj_read_float_LE(const OPJ_BYTE * p_buffer, OPJ_FLOAT32 * p_value);
/**
* Reads some bytes from the given data buffer, this function is used in Big Endian cpus.
* @param p_buffer pointer the data buffer to read data from.
* @param p_value pointer to the value that will store the data.
*/
void opj_read_float_BE(const OPJ_BYTE * p_buffer, OPJ_FLOAT32 * p_value);
/**
* Write some bytes to the given data buffer, this function is used in Little Endian cpus.
* @param p_buffer pointer the data buffer to write data to.
* @param p_value the value to write
*/
void opj_write_float_LE(OPJ_BYTE * p_buffer, OPJ_FLOAT32 p_value);
/***
* Write some bytes to the given data buffer, this function is used in Big Endian cpus.
* @param p_buffer pointer the data buffer to write data to.
* @param p_value the value to write
*/
void opj_write_float_BE(OPJ_BYTE * p_buffer, OPJ_FLOAT32 p_value);
/**
* Reads some bytes from the stream.
* @param p_stream the stream to read data from.
* @param p_buffer pointer to the data buffer that will receive the data.
* @param p_size number of bytes to read.
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes read, or -1 if an error occured or if the stream is at the end.
*/
OPJ_UINT32 opj_stream_read_data (opj_stream_private_t * p_stream,OPJ_BYTE * p_buffer, OPJ_UINT32 p_size, struct opj_event_mgr * p_event_mgr);
/**
* Writes some bytes to the stream.
* @param p_stream the stream to write data to.
* @param p_buffer pointer to the data buffer holds the data to be writtent.
* @param p_size number of bytes to write.
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes writtent, or -1 if an error occured.
*/
OPJ_UINT32 opj_stream_write_data (opj_stream_private_t * p_stream,const OPJ_BYTE * p_buffer, OPJ_UINT32 p_size, struct opj_event_mgr * p_event_mgr);
/**
* Writes the content of the stream buffer to the stream.
* @param p_stream the stream to write data to.
* @param p_event_mgr the user event manager to be notified of special events.
* @return true if the data could be flushed, false else.
*/
bool opj_stream_flush (opj_stream_private_t * p_stream, struct opj_event_mgr * p_event_mgr);
/**
* Skips a number of bytes from the stream.
* @param p_stream the stream to skip data from.
* @param p_size the number of bytes to skip.
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes skipped, or -1 if an error occured.
*/
OPJ_SIZE_T opj_stream_skip (opj_stream_private_t * p_stream,OPJ_SIZE_T p_size, struct opj_event_mgr * p_event_mgr);
/**
* Tells the byte offset on the stream (similar to ftell).
* *
* @param p_stream the stream to get the information from. * returns number of bytes written
*/
int cio_numbytes();
/*
* Get position in byte stream.
* *
* @return the current position o fthe stream. * return position in bytes
*/ */
OPJ_SIZE_T opj_stream_tell (const opj_stream_private_t * p_stream); int cio_tell();
/** /*
* Skips a number of bytes from the stream. * Set position in byte stream.
* @param p_stream the stream to skip data from. *
* @param p_size the number of bytes to skip. * pos : position, in number of bytes, from the beginning of the stream
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes skipped, or -1 if an error occured.
*/ */
OPJ_SIZE_T opj_stream_write_skip (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, struct opj_event_mgr * p_event_mgr); void cio_seek(int pos);
/** /*
* Skips a number of bytes from the stream. * Number of bytes left before the end of the stream.
* @param p_stream the stream to skip data from. *
* @param p_size the number of bytes to skip. * Returns the number of bytes before the end of the stream
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes skipped, or -1 if an error occured.
*/ */
OPJ_SIZE_T opj_stream_read_skip (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, struct opj_event_mgr * p_event_mgr); int cio_numbytesleft();
/** /*
* Skips a number of bytes from the stream. * Get pointer to the current position in the stream.
* @param p_stream the stream to skip data from. *
* @param p_size the number of bytes to skip. * return : pointer to the position
* @param p_event_mgr the user event manager to be notified of special events.
* @return the number of bytes skipped, or -1 if an error occured.
*/ */
bool opj_stream_read_seek (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, struct opj_event_mgr * p_event_mgr); unsigned char *cio_getbp();
/** /*
* Skips a number of bytes from the stream. * Initialize byte IO
* @param p_stream the stream to skip data from. *
* @param p_size the number of bytes to skip. * bp : destination/source stream
* @param p_event_mgr the user event manager to be notified of special events. * len : length of the stream
* @return the number of bytes skipped, or -1 if an error occured.
*/ */
bool opj_stream_write_seek (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, struct opj_event_mgr * p_event_mgr); void cio_init(unsigned char *bp, int len);
/** /*
* Seeks a number of bytes from the stream. * Write some bytes.
* @param p_stream the stream to skip data from. *
* @param p_size the number of bytes to skip. * v : value to write
* @param p_event_mgr the user event manager to be notified of special events. * n : number of bytes to write
* @return true if the stream is seekable.
*/ */
bool opj_stream_seek (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, struct opj_event_mgr * p_event_mgr); void cio_write(unsigned int v, int n);
/** /*
* Tells if the given stream is seekable. * Read some bytes.
*
* n : number of bytes to read
*
* return : value of the n bytes read
*/ */
bool opj_stream_has_seek (const opj_stream_private_t * p_stream); unsigned int cio_read(int n);
OPJ_UINT32 opj_stream_default_read (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data); /*
OPJ_UINT32 opj_stream_default_write (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data); * Skip some bytes.
OPJ_SIZE_T opj_stream_default_skip (OPJ_SIZE_T p_nb_bytes, void * p_user_data); *
bool opj_stream_default_seek (OPJ_SIZE_T p_nb_bytes, void * p_user_data); * n : number of bytes to skip
*/
void cio_skip(int n);
/* ----------------------------------------------------------------------- */ /*
/*@}*/ * Read n bytes, copy to buffer
*/
void cio_read_to_buf(unsigned char* src_buf, int n);/* Glenn Pearson adds */
/*@}*/ /*
* Write n bytes, copy from buffer
#endif /* __CIO_H */ */
void cio_write_from_buf(unsigned char* dest_buf, int n);/* Glenn Pearson adds */
#endif

1044
libopenjpeg/dwt.c
View File

File diff suppressed because it is too large Load Diff

123
libopenjpeg/dwt.h
View File

@@ -1,11 +1,7 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren * Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -30,89 +26,56 @@
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "tcd.h"
#ifndef __DWT_H #ifndef __DWT_H
#define __DWT_H #define __DWT_H
/**
@file dwt.h
@brief Implementation of a discrete wavelet transform (DWT)
The functions in DWT.C have for goal to realize forward and inverse discret wavelet /*
transform with filter 5-3 (reversible) and filter 9-7 (irreversible). The functions in * Apply a reversible DWT transform to a component of an image
DWT.C are used by some function in TCD.C. * tilec : tile component information (present tile)
*/ */
#include "openjpeg.h" /* void dwt_encode(int* a, int w, int h, int l); */
void dwt_encode(tcd_tilecomp_t * tilec);
/*
* Apply a reversible inverse DWT transform to a component of an image
* tilec : tile component information (present tile)
*/
void dwt_decode(tcd_tilecomp_t * tilec, int stop);
struct opj_tcd_tilecomp; /*
struct opj_tccp; * Get the gain of a subband for the reversible DWT
* orient: number that identifies the subband (0->LL, 1->HL, 2->LH, 3->HH)
*/
int dwt_getgain(int orient);
/** @defgroup DWT DWT - Implementation of a discrete wavelet transform */ /*
/*@{*/ * Get the norm of a wavelet function of a subband at a specified level for the reversible DWT
* level: level of the wavelet function
* orient: band of the wavelet function
*/
double dwt_getnorm(int level, int orient);
/*
* Apply an irreversible DWT transform to a component of an image
*/
void dwt_encode_real(tcd_tilecomp_t * tilec);
/** @name Exported functions */ /*
/*@{*/ * Apply an irreversible inverse DWT transform to a component of an image
/* ----------------------------------------------------------------------- */
/**
Forward 5-3 wavelet tranform in 2-D.
Apply a reversible DWT transform to a component of an image.
@param tilec Tile component information (current tile)
*/ */
bool dwt_encode(struct opj_tcd_tilecomp * tilec); void dwt_decode_real(tcd_tilecomp_t * tilec, int stop);
/** /*
Inverse 5-3 wavelet tranform in 2-D. * Get the gain of a subband for the irreversible DWT
Apply a reversible inverse DWT transform to a component of an image. * orient: number that identifies the subband (0->LL, 1->HL, 2->LH, 3->HH)
@param tilec Tile component information (current tile)
@param numres Number of resolution levels to decode
*/ */
bool dwt_decode(struct opj_tcd_tilecomp* tilec, OPJ_UINT32 numres); int dwt_getgain_real(int orient);
/**
Get the gain of a subband for the reversible 5-3 DWT.
@param orient Number that identifies the subband (0->LL, 1->HL, 2->LH, 3->HH)
@return Returns 0 if orient = 0, returns 1 if orient = 1 or 2, returns 2 otherwise
*/
OPJ_UINT32 dwt_getgain(OPJ_UINT32 orient);
/**
Get the norm of a wavelet function of a subband at a specified level for the reversible 5-3 DWT.
@param level Level of the wavelet function
@param orient Band of the wavelet function
@return Returns the norm of the wavelet function
*/
OPJ_FLOAT64 dwt_getnorm(OPJ_UINT32 level, OPJ_UINT32 orient);
/**
Forward 9-7 wavelet transform in 2-D.
Apply an irreversible DWT transform to a component of an image.
@param tilec Tile component information (current tile)
*/
bool dwt_encode_real(struct opj_tcd_tilecomp * tilec);
/**
Inverse 9-7 wavelet transform in 2-D.
Apply an irreversible inverse DWT transform to a component of an image.
@param tilec Tile component information (current tile)
@param numres Number of resolution levels to decode
*/
bool dwt_decode_real(struct opj_tcd_tilecomp* tilec, OPJ_UINT32 numres);
/**
Get the gain of a subband for the irreversible 9-7 DWT.
@param orient Number that identifies the subband (0->LL, 1->HL, 2->LH, 3->HH)
@return Returns the gain of the 9-7 wavelet transform
*/
OPJ_UINT32 dwt_getgain_real(OPJ_UINT32 orient);
/**
Get the norm of a wavelet function of a subband at a specified level for the irreversible 9-7 DWT
@param level Level of the wavelet function
@param orient Band of the wavelet function
@return Returns the norm of the 9-7 wavelet
*/
OPJ_FLOAT64 dwt_getnorm_real(OPJ_UINT32 level, OPJ_UINT32 orient);
/**
Explicit calculation of the Quantization Stepsizes
@param tccp Tile-component coding parameters
@param prec Precint analyzed
*/
void dwt_calc_explicit_stepsizes(struct opj_tccp * tccp, OPJ_UINT32 prec);
/* ----------------------------------------------------------------------- */
/*@}*/
/*@}*/ /*
* Get the norm of a wavelet function of a subband at a specified level for the irreversible DWT
* level: level of the wavelet function
* orient: band of the wavelet function
*/
double dwt_getnorm_real(int level, int orient);
#endif /* __DWT_H */ #endif

96
libopenjpeg/event.c
View File

@@ -1,96 +0,0 @@
/*
* Copyright (c) 2005, Herv<72> Drolon, FreeImage Team
* 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 "event.h"
#include "openjpeg.h"
#include "opj_includes.h"
/* ==========================================================
Utility functions
==========================================================*/
#if !defined(_MSC_VER) && !defined(__MINGW32__)
static OPJ_CHAR*
i2a(OPJ_UINT32 i, OPJ_CHAR *a, OPJ_UINT32 r) {
if (i/r > 0) a = i2a(i/r,a,r);
*a = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[i%r];
return a+1;
}
#endif
/* ----------------------------------------------------------------------- */
bool opj_event_msg(opj_event_mgr_t * p_event_mgr, OPJ_INT32 event_type, const OPJ_CHAR *fmt, ...) {
#define MSG_SIZE 512 /* 512 bytes should be more than enough for a short message */
opj_msg_callback msg_handler = 00;
void * l_data = 00;
if(p_event_mgr != 00) {
switch(event_type) {
case EVT_ERROR:
msg_handler = p_event_mgr->error_handler;
l_data = p_event_mgr->m_error_data;
break;
case EVT_WARNING:
msg_handler = p_event_mgr->warning_handler;
l_data = p_event_mgr->m_warning_data;
break;
case EVT_INFO:
msg_handler = p_event_mgr->info_handler;
l_data = p_event_mgr->m_info_data;
break;
default:
break;
}
if(msg_handler == 00) {
return false;
}
} else {
return false;
}
if ((fmt != 00) && (p_event_mgr != 00)) {
va_list arg;
OPJ_INT32 str_length/*, i, j*/; /* UniPG */
OPJ_CHAR message[MSG_SIZE];
memset(message, 0, MSG_SIZE);
/* initialize the optional parameter list */
va_start(arg, fmt);
/* check the length of the format string */
str_length = (strlen(fmt) > MSG_SIZE) ? MSG_SIZE : strlen(fmt);
/* parse the format string and put the result in 'message' */
vsprintf(message, fmt, arg); /* UniPG */
/* deinitialize the optional parameter list */
va_end(arg);
/* output the message to the user program */
msg_handler(message, l_data);
}
return true;
}

86
libopenjpeg/event.h
View File

@@ -1,86 +0,0 @@
/*
* Copyright (c) 2005, Herv<72> Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* 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.
*/
#ifndef __EVENT_H
#define __EVENT_H
#include "openjpeg.h"
/**
@file event.h
@brief Implementation of a event callback system
The functions in EVENT.C have for goal to send output messages (errors, warnings, debug) to the user.
*/
/**
Message handler object
used for
<ul>
<li>Error messages
<li>Warning messages
<li>Debugging messages
</ul>
*/
typedef struct opj_event_mgr
{
/** Data to call the event manager upon */
void * m_error_data;
/** Data to call the event manager upon */
void * m_warning_data;
/** Data to call the event manager upon */
void * m_info_data;
/** Error message callback if available, NULL otherwise */
opj_msg_callback error_handler;
/** Warning message callback if available, NULL otherwise */
opj_msg_callback warning_handler;
/** Debug message callback if available, NULL otherwise */
opj_msg_callback info_handler;
} opj_event_mgr_t;
#define EVT_ERROR 1 /**< Error event type */
#define EVT_WARNING 2 /**< Warning event type */
#define EVT_INFO 4 /**< Debug event type */
/** @defgroup EVENT EVENT - Implementation of a event callback system */
/*@{*/
/** @name Exported functions (see also openjpeg.h) */
/*@{*/
/* ----------------------------------------------------------------------- */
/**
* Writes formatted data to a string and send the string to a user callback.
* @param p_event_mgr the event manager to display messages.
* @param event_type Event type of the message
* @param fmt Format-control string (plus optionnal arguments)
* @return Returns true if successful, returns false otherwise
*/
bool opj_event_msg(struct opj_event_mgr * p_event_mgr, OPJ_INT32 event_type, const OPJ_CHAR *fmt, ...);
/* ----------------------------------------------------------------------- */
/*@}*/
/*@}*/
#endif /* __EVENT_H */

55
libopenjpeg/j2k_lib.h → libopenjpeg/fix.c
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2005, Hervé Drolon, FreeImage Team * Copyright (c) 2001-2002, David Janssens
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -23,32 +23,41 @@
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef __J2K_LIB_H
#define __J2K_LIB_H
/**
@file j2k_lib.h
@brief Internal functions
The functions in J2K_LIB.C are internal utilities mainly used for timing. #include "fix.h"
#include <math.h> /*Add Antonin : multbug1*/
#ifdef WIN32
#define int64 __int64
#else
#define int64 long long
#endif
/*
* Multiply two fixed-precision rational numbers.
*/ */
#include "openjpeg.h"
/** @defgroup MISC MISC - Miscellaneous internal functions */
/*@{*/
/** @name Exported functions */ /*int fix_mul(int a, int b)
/*@{*/ {
/* ----------------------------------------------------------------------- */ return (int) ((int64) a * (int64) b >> 13);
}*/
/**
Difference in successive opj_clock() calls tells you the elapsed time /*Mod Antonin : multbug1*/
@return Returns time in seconds /*
int fix_mul(int a, int b)
{
double tmp= (double) ((int64) a * (int64) b);
int64 v = (int64) ((fabs(tmp/8192.0)>=floor(fabs(tmp/8192.0))+0.5)?fabs(tmp/8192.0)+1.0:fabs(tmp/8192.0));
v = (tmp<0)?-v:v;
return (int) v;
}
*/ */
OPJ_FLOAT64 opj_clock(void); /*doM*/
/* ----------------------------------------------------------------------- */ int fix_mul(int a, int b) /* Luke Lee optimized : 11/16/2004*/
/*@}*/ {
int64 temp = (int64) a * (int64) b >> 12;
/*@}*/ return (int) ((temp >> 1) + (temp & 1)) ;
}
#endif /* __J2K_LIB_H */

37
libopenjpeg/fix.h
View File

@@ -1,10 +1,5 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -28,33 +23,11 @@
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef __FIX_H #ifndef __FIX_H
#define __FIX_H #define __FIX_H
#include "openjpeg.h" int fix_mul(int a, int b);
#include "opj_includes.h"
/** #endif
@file fix.h
@brief Implementation of operations of specific multiplication (FIX)
The functions in FIX.H have for goal to realize specific multiplication.
*/
/** @defgroup FIX FIX - Implementation of operations of specific multiplication */
/*@{*/
/**
Multiply two fixed-precision rational numbers.
@param a
@param b
@return Returns a * b
*/
static INLINE int fix_mul(int a, int b) {
OPJ_INT64 temp = (OPJ_INT64) a * (OPJ_INT64) b ;
temp += temp & 4096;
return (int) (temp >> 13) ;
}
/*@}*/
#endif /* __FIX_H */

149
libopenjpeg/function_list.c
View File

@@ -1,149 +0,0 @@
/*
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* 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 "function_list.h"
#include "opj_includes.h"
#include "opj_malloc.h"
/**
* Default size of the validation list, if not sufficient, data will be reallocated with a double size.
*/
#define OPJ_VALIDATION_SIZE 10
/**
* Creates a validation list.
*
* @return the newly created validation list.
*/
opj_procedure_list_t * opj_procedure_list_create()
{
/* memory allocation */
opj_procedure_list_t * l_validation = (opj_procedure_list_t *) opj_malloc(sizeof(opj_procedure_list_t));
if
(! l_validation)
{
return 00;
}
/* initialization */
memset(l_validation,0,sizeof(opj_procedure_list_t));
l_validation->m_nb_max_procedures = OPJ_VALIDATION_SIZE;
l_validation->m_procedures = (void**)opj_malloc(
OPJ_VALIDATION_SIZE * sizeof(opj_procedure));
if
(! l_validation->m_procedures)
{
opj_free(l_validation);
return 00;
}
memset(l_validation->m_procedures,0,OPJ_VALIDATION_SIZE * sizeof(opj_procedure));
return l_validation;
}
/**
* Destroys a validation list.
*
* @param p_list the list to destroy.
*/
void opj_procedure_list_destroy(opj_procedure_list_t * p_list)
{
if
(! p_list)
{
return;
}
/* initialization */
if
(p_list->m_procedures)
{
opj_free(p_list->m_procedures);
}
opj_free(p_list);
}
/**
* Adds a new validation procedure.
*
* @param p_validation_list the list of procedure to modify.
* @param p_procedure the procedure to add.
*/
bool opj_procedure_list_add_procedure (opj_procedure_list_t * p_validation_list, opj_procedure p_procedure)
{
if
(p_validation_list->m_nb_max_procedures == p_validation_list->m_nb_procedures)
{
p_validation_list->m_nb_max_procedures += OPJ_VALIDATION_SIZE;
p_validation_list->m_procedures = (void**)opj_realloc(
p_validation_list->m_procedures,p_validation_list->m_nb_max_procedures * sizeof(opj_procedure));
if
(! p_validation_list->m_procedures)
{
p_validation_list->m_nb_max_procedures = 0;
p_validation_list->m_nb_procedures = 0;
return false;
}
}
p_validation_list->m_procedures[p_validation_list->m_nb_procedures] = p_procedure;
++p_validation_list->m_nb_procedures;
return true;
}
/**
* Gets the number of validation procedures.
*
* @param p_validation_list the list of procedure to modify.
*
* @return the number of validation procedures.
*/
OPJ_UINT32 opj_procedure_list_get_nb_procedures (opj_procedure_list_t * p_validation_list)
{
return p_validation_list->m_nb_procedures;
}
/**
* Gets the pointer on the first validation procedure. This function is similar to the C++
* iterator class to iterate through all the procedures inside the validation list.
* the caller does not take ownership of the pointer.
*
* @param p_validation_list the list of procedure to get the first procedure from.
*
* @return a pointer to the first procedure.
*/
opj_procedure* opj_procedure_list_get_first_procedure (opj_procedure_list_t * p_validation_list)
{
return p_validation_list->m_procedures;
}
/**
* Clears the list of validation procedures.
*
* @param p_validation_list the list of procedure to clear.
*
*/
void opj_procedure_list_clear (opj_procedure_list_t * p_validation_list)
{
p_validation_list->m_nb_procedures = 0;
}

131
libopenjpeg/function_list.h
View File

@@ -1,131 +0,0 @@
/*
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* 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.
*/
#ifndef __FUNCTION_LIST_H
#define __FUNCTION_LIST_H
/**
* @file function_list.h
* @brief Implementation of a list of procedures.
* The functions in validation.c aims to have access to a list of procedures.
*/
/** @defgroup validation validation procedure*/
/*@{*/
#include "openjpeg.h"
/**************************************************************************************************
***************************************** FORWARD DECLARATION ************************************
**************************************************************************************************/
struct opj_jp2;
/**
* ARGGGG, when will the template be added to the C language ???
* in order not to have to duplicate the code in a vast number of times, use void * and downcast
* it after => UGLY but faster and easier
* TODO : make the class template in C++, use STL vector or duplicate code for each procedure type.
*/
typedef void * opj_procedure;
/**
* A list of procedures.
*/
typedef struct opj_procedure_list
{
/**
* The number of validation procedures.
*/
OPJ_UINT32 m_nb_procedures;
/**
* The number of the array of validation procedures.
*/
OPJ_UINT32 m_nb_max_procedures;
/**
* The array of procedures.
*/
opj_procedure * m_procedures;
} opj_procedure_list_t;
/* ----------------------------------------------------------------------- */
/**
* Creates a validation list.
*
* @return the newly created validation list.
*/
opj_procedure_list_t * opj_procedure_list_create();
/**
* Destroys a validation list.
*
* @param p_list the list to destroy.
*/
void opj_procedure_list_destroy(opj_procedure_list_t * p_list);
/**
* Adds a new validation procedure.
*
* @param p_validation_list the list of procedure to modify.
* @param p_procedure the procedure to add.
*
* @return true if the procedure could ne added.
*/
bool opj_procedure_list_add_procedure (opj_procedure_list_t * p_validation_list, opj_procedure p_procedure);
/**
* Gets the number of validation procedures.
*
* @param p_validation_list the list of procedure to modify.
*
* @return the number of validation procedures.
*/
OPJ_UINT32 opj_procedure_list_get_nb_procedures (opj_procedure_list_t * p_validation_list);
/**
* Gets the pointer on the first validation procedure. This function is similar to the C++
* iterator class to iterate through all the procedures inside the validation list.
* the caller does not take ownership of the pointer.
*
* @param p_validation_list the list of procedure to get the first procedure from.
*
* @return a pointer to the first procedure.
*/
opj_procedure* opj_procedure_list_get_first_procedure (opj_procedure_list_t * p_validation_list);
/**
* Clears the list of validation procedures.
*
* @param p_validation_list the list of procedure to clear.
*
*/
void opj_procedure_list_clear (opj_procedure_list_t * p_validation_list);
#endif /* __FUNCTION_LIST_H */

175
libopenjpeg/image.c
View File

@@ -1,175 +0,0 @@
/*
* Copyright (c) 2005, Herv<72> Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* 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 "image.h"
#include "openjpeg.h"
#include "opj_malloc.h"
#include "j2k.h"
#include "int.h"
opj_image_t* opj_image_create0(void) {
opj_image_t *image = (opj_image_t*)opj_malloc(sizeof(opj_image_t));
memset(image,0,sizeof(opj_image_t));
return image;
}
opj_image_t* OPJ_CALLCONV opj_image_create(OPJ_UINT32 numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc) {
OPJ_UINT32 compno;
opj_image_t *image = 00;
image = (opj_image_t*) opj_malloc(sizeof(opj_image_t));
if
(image)
{
memset(image,0,sizeof(opj_image_t));
image->color_space = clrspc;
image->numcomps = numcmpts;
/* allocate memory for the per-component information */
image->comps = (opj_image_comp_t*)opj_malloc(image->numcomps * sizeof(opj_image_comp_t));
if
(!image->comps)
{
opj_image_destroy(image);
return 00;
}
memset(image->comps,0,image->numcomps * sizeof(opj_image_comp_t));
/* create the individual image components */
for(compno = 0; compno < numcmpts; compno++) {
opj_image_comp_t *comp = &image->comps[compno];
comp->dx = cmptparms[compno].dx;
comp->dy = cmptparms[compno].dy;
comp->w = cmptparms[compno].w;
comp->h = cmptparms[compno].h;
comp->x0 = cmptparms[compno].x0;
comp->y0 = cmptparms[compno].y0;
comp->prec = cmptparms[compno].prec;
comp->sgnd = cmptparms[compno].sgnd;
comp->data = (OPJ_INT32*) opj_calloc(comp->w * comp->h, sizeof(OPJ_INT32));
if
(!comp->data)
{
opj_image_destroy(image);
return 00;
}
}
}
return image;
}
opj_image_t* OPJ_CALLCONV opj_image_tile_create(OPJ_UINT32 numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc) {
OPJ_UINT32 compno;
opj_image_t *image = 00;
image = (opj_image_t*) opj_malloc(sizeof(opj_image_t));
if
(image)
{
memset(image,0,sizeof(opj_image_t));
image->color_space = clrspc;
image->numcomps = numcmpts;
/* allocate memory for the per-component information */
image->comps = (opj_image_comp_t*)opj_malloc(image->numcomps * sizeof(opj_image_comp_t));
if
(!image->comps)
{
opj_image_destroy(image);
return 00;
}
memset(image->comps,0,image->numcomps * sizeof(opj_image_comp_t));
/* create the individual image components */
for(compno = 0; compno < numcmpts; compno++) {
opj_image_comp_t *comp = &image->comps[compno];
comp->dx = cmptparms[compno].dx;
comp->dy = cmptparms[compno].dy;
comp->w = cmptparms[compno].w;
comp->h = cmptparms[compno].h;
comp->x0 = cmptparms[compno].x0;
comp->y0 = cmptparms[compno].y0;
comp->prec = cmptparms[compno].prec;
comp->sgnd = cmptparms[compno].sgnd;
comp->data = 0;
}
}
return image;
}
void OPJ_CALLCONV opj_image_destroy(opj_image_t *image) {
OPJ_UINT32 i;
if
(image)
{
if
(image->comps)
{
/* image components */
for(i = 0; i < image->numcomps; i++) {
opj_image_comp_t *image_comp = &image->comps[i];
if(image_comp->data) {
opj_free(image_comp->data);
}
}
opj_free(image->comps);
}
opj_free(image);
}
}
/**
* Updates the components of the image from the coding parameters.
*
* @param p_image the image to update.
* @param p_cp the coding parameters from which to update the image.
*/
void opj_image_comp_update(opj_image_t * p_image,const opj_cp_t * p_cp)
{
OPJ_UINT32 i, l_width, l_height;
OPJ_INT32 l_x0,l_y0,l_x1,l_y1;
OPJ_INT32 l_comp_x0,l_comp_y0,l_comp_x1,l_comp_y1;
opj_image_comp_t * l_img_comp = 00;
l_x0 = int_max(p_cp->tx0 , p_image->x0);
l_y0 = int_max(p_cp->ty0 , p_image->y0);
l_x1 = int_min(p_cp->tx0 + p_cp->tw * p_cp->tdx, p_image->x1);
l_y1 = int_min(p_cp->ty0 + p_cp->th * p_cp->tdy, p_image->y1);
l_img_comp = p_image->comps;
for
(i = 0; i < p_image->numcomps; ++i)
{
l_comp_x0 = int_ceildiv(l_x0, l_img_comp->dx);
l_comp_y0 = int_ceildiv(l_y0, l_img_comp->dy);
l_comp_x1 = int_ceildiv(l_x1, l_img_comp->dx);
l_comp_y1 = int_ceildiv(l_y1, l_img_comp->dy);
l_width = int_ceildivpow2(l_comp_x1 - l_comp_x0, l_img_comp->factor);
l_height = int_ceildivpow2(l_comp_y1 - l_comp_y0, l_img_comp->factor);
l_img_comp->w = l_width;
l_img_comp->h = l_height;
l_img_comp->x0 = l_x0;
l_img_comp->y0 = l_y0;
++l_img_comp;
}
}

111
libopenjpeg/image.h → libopenjpeg/int.c
View File

@@ -1,6 +1,5 @@
/* /*
* Copyright (c) 2005, Hervé Drolon, FreeImage Team * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -24,35 +23,93 @@
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef __IMAGE_H
#define __IMAGE_H
/**
@file image.h
@brief Implementation of operations on images (IMAGE)
The functions in IMAGE.C have for goal to realize operations on images. #include "int.h"
*/
struct opj_image;
struct opj_cp;
/** @defgroup IMAGE IMAGE - Implementation of operations on images */
/*@{*/
/** /*
Create an empty image * Get the minimum of two integers.
@todo this function should be removed
@return returns an empty image if successful, returns NULL otherwise
*/
struct opj_image* opj_image_create0(void);
/**
* Updates the components of the image from the coding parameters.
* *
* @param p_image the image to update. * returns a if a < b else b
* @param p_cp the coding parameters from which to update the image.
*/ */
void opj_image_comp_update(struct opj_image * p_image,const struct opj_cp * p_cp); int int_min(int a, int b)
{
return a < b ? a : b;
}
/*@}*/ /*
* Get the maximum of two integers.
*
* returns a if a > b else b
*/
int int_max(int a, int b)
{
return a > b ? a : b;
}
#endif /* __IMAGE_H */ /*
* Clamp an integer inside an interval.
*
* return a if (min < a < max)
* return max if (a > max)
* return min if (a < min)
*/
int int_clamp(int a, int min, int max)
{
if (a < min)
return min;
if (a > max)
return max;
return a;
}
/*
* Get absolute value of integer.
*/
int int_abs(int a)
{
return a < 0 ? -a : a;
}
/*
* Divide an integer and round upwards.
*
* a divided by b
*/
int int_ceildiv(int a, int b)
{
return (a + b - 1) / b;
}
/*
* Divide an integer by a power of 2 and round upwards.
*
* a divided by 2^b
*/
int int_ceildivpow2(int a, int b)
{
return (a + (1 << b) - 1) >> b;
}
/*
* Divide an integer by a power of 2 and round downwards.
*
* a divided by 2^b
*/
int int_floordivpow2(int a, int b)
{
return a >> b;
}
/*
* Get logarithm of an integer and round downwards.
*
* log2(a)
*/
int int_floorlog2(int a)
{
int l;
for (l = 0; a > 1; l++) {
a >>= 1;
}
return l;
}

161
libopenjpeg/int.h
View File

@@ -1,11 +1,5 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -29,131 +23,66 @@
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "j2k.h"
#ifndef __INT_H #ifndef __INT_H
#define __INT_H #define __INT_H
/**
@file int.h
@brief Implementation of operations on integers (INT)
The functions in INT.H have for goal to realize operations on integers. /*
* Get the minimum of two integers.
*
* returns a if a < b else b
*/ */
#include "openjpeg.h" int int_min(int a, int b);
#include "opj_includes.h"
/** @defgroup INT INT - Implementation of operations on integers */
/*@{*/
/** @name Exported functions (see also openjpeg.h) */ /*
/*@{*/ * Get the maximum of two integers.
/* ----------------------------------------------------------------------- */ *
/** * returns a if a > b else b
Get the minimum of two integers
@return Returns a if a < b else b
*/ */
static INLINE OPJ_INT32 int_min(OPJ_INT32 a, OPJ_INT32 b) { int int_max(int a, int b);
return a < b ? a : b;
}
/** /*
Get the minimum of two integers * Clamp an integer inside an interval.
@return Returns a if a < b else b *
* return a if (min < a < max)
* return max if (a > max)
* return min if (a < min)
*/ */
static INLINE OPJ_UINT32 uint_min(OPJ_UINT32 a, OPJ_UINT32 b) { int int_clamp(int a, int min, int max);
return a < b ? a : b;
}
/** /*
Get the maximum of two integers * Get absolute value of integer.
@return Returns a if a > b else b
*/ */
static INLINE OPJ_INT32 int_max(OPJ_INT32 a, OPJ_INT32 b) { int int_abs(int a);
return (a > b) ? a : b;
}
/** /*
Get the maximum of two integers * Divide an integer and round upwards.
@return Returns a if a > b else b *
* a divided by b
*/ */
static INLINE OPJ_UINT32 uint_max(OPJ_UINT32 a, OPJ_UINT32 b) { int int_ceildiv(int a, int b);
return (a > b) ? a : b;
}
/**
Clamp an integer inside an interval
@return
<ul>
<li>Returns a if (min < a < max)
<li>Returns max if (a > max)
<li>Returns min if (a < min)
</ul>
*/
static INLINE OPJ_INT32 int_clamp(OPJ_INT32 a, OPJ_INT32 min, OPJ_INT32 max) {
if (a < min)
return min;
if (a > max)
return max;
return a;
}
/**
@return Get absolute value of integer
*/
static INLINE OPJ_INT32 int_abs(OPJ_INT32 a) {
return a < 0 ? -a : a;
}
/**
Divide an integer and round upwards
@return Returns a divided by b
*/
static INLINE OPJ_INT32 int_ceildiv(OPJ_INT32 a, OPJ_INT32 b) {
return (a + b - 1) / b;
}
/** /*
Divide an integer and round upwards * Divide an integer by a power of 2 and round upwards.
@return Returns a divided by b *
* a divided by 2^b
*/ */
static INLINE OPJ_UINT32 uint_ceildiv(OPJ_UINT32 a, OPJ_UINT32 b) { LIBJ2K_API int int_ceildivpow2(int a, int b);
return (a + b - 1) / b;
}
/**
Divide an integer by a power of 2 and round upwards
@return Returns a divided by 2^b
*/
static INLINE OPJ_INT32 int_ceildivpow2(OPJ_INT32 a, OPJ_INT32 b) {
return (a + (1 << b) - 1) >> b;
}
/**
Divide an integer by a power of 2 and round downwards
@return Returns a divided by 2^b
*/
static INLINE OPJ_INT32 int_floordivpow2(OPJ_INT32 a, OPJ_INT32 b) {
return a >> b;
}
/**
Get logarithm of an integer and round downwards
@return Returns log2(a)
*/
static INLINE OPJ_INT32 int_floorlog2(OPJ_INT32 a) {
OPJ_INT32 l;
for (l = 0; a > 1; l++) {
a >>= 1;
}
return l;
}
/** /*
Get logarithm of an integer and round downwards * Divide an integer by a power of 2 and round downwards.
@return Returns log2(a) *
* a divided by 2^b
*/ */
static INLINE OPJ_UINT32 uint_floorlog2(OPJ_UINT32 a) { LIBJ2K_API int int_floordivpow2(int a, int b);
OPJ_UINT32 l;
for (l = 0; a > 1; ++l)
{
a >>= 1;
}
return l;
}
/* ----------------------------------------------------------------------- */
/*@}*/
/*@}*/ /*
* Get logarithm of an integer and round downwards.
*
* log2(a)
*/
int int_floorlog2(int a);
#endif #endif

291
libopenjpeg/invert.c
View File

@@ -1,291 +0,0 @@
/*
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* 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 "invert.h"
#include "opj_malloc.h"
bool opj_lupDecompose(OPJ_FLOAT32 * matrix,OPJ_UINT32 * permutations, OPJ_FLOAT32 * p_swap_area,OPJ_UINT32 n);
void opj_lupSolve(OPJ_FLOAT32 * pResult, OPJ_FLOAT32* pMatrix, OPJ_FLOAT32* pVector, OPJ_UINT32* pPermutations, OPJ_UINT32 n,OPJ_FLOAT32 * p_intermediate_data);
void opj_lupInvert (OPJ_FLOAT32 * pSrcMatrix,
OPJ_FLOAT32 * pDestMatrix,
OPJ_UINT32 n,
OPJ_UINT32 * pPermutations,
OPJ_FLOAT32 * p_src_temp,
OPJ_FLOAT32 * p_dest_temp,
OPJ_FLOAT32 * p_swap_area);
/**
* Matrix inversion.
*/
bool opj_matrix_inversion_f(OPJ_FLOAT32 * pSrcMatrix,OPJ_FLOAT32 * pDestMatrix, OPJ_UINT32 n)
{
OPJ_BYTE * l_data = 00;
OPJ_UINT32 l_permutation_size = n * sizeof(OPJ_UINT32);
OPJ_UINT32 l_swap_size = n * sizeof(OPJ_FLOAT32);
OPJ_UINT32 l_total_size = l_permutation_size + 3 * l_swap_size;
OPJ_UINT32 * lPermutations = 00;
OPJ_FLOAT32 * l_double_data = 00;
l_data = (OPJ_BYTE *) opj_malloc(l_total_size);
if
(l_data == 0)
{
return false;
}
lPermutations = (OPJ_UINT32 *) l_data;
l_double_data = (OPJ_FLOAT32 *) (l_data + l_permutation_size);
memset(lPermutations,0,l_permutation_size);
if
(! opj_lupDecompose(pSrcMatrix,lPermutations,l_double_data,n))
{
opj_free(l_data);
return false;
}
opj_lupInvert(pSrcMatrix,pDestMatrix,n,lPermutations,l_double_data,l_double_data + n,l_double_data + 2*n);
opj_free(l_data);
return true;
}
/**
* LUP decomposition
*/
bool opj_lupDecompose(OPJ_FLOAT32 * matrix,OPJ_UINT32 * permutations, OPJ_FLOAT32 * p_swap_area,OPJ_UINT32 n)
{
OPJ_UINT32 * tmpPermutations = permutations;
OPJ_UINT32 * dstPermutations;
OPJ_UINT32 k2=0,t;
OPJ_FLOAT32 temp;
OPJ_UINT32 i,j,k;
OPJ_FLOAT32 p;
OPJ_UINT32 lLastColum = n - 1;
OPJ_UINT32 lSwapSize = n * sizeof(OPJ_FLOAT32);
OPJ_FLOAT32 * lTmpMatrix = matrix;
OPJ_FLOAT32 * lColumnMatrix,* lDestMatrix;
OPJ_UINT32 offset = 1;
OPJ_UINT32 lStride = n-1;
//initialize permutations
for
(i = 0; i < n; ++i)
{
*tmpPermutations++ = i;
}
// now make a pivot with colum switch
tmpPermutations = permutations;
for
(k = 0; k < lLastColum; ++k)
{
p = 0.0;
// take the middle element
lColumnMatrix = lTmpMatrix + k;
// make permutation with the biggest value in the column
for
(i = k; i < n; ++i)
{
temp = ((*lColumnMatrix > 0) ? *lColumnMatrix : -(*lColumnMatrix));
if
(temp > p)
{
p = temp;
k2 = i;
}
// next line
lColumnMatrix += n;
}
// a whole rest of 0 -> non singular
if
(p == 0.0)
{
return false;
}
// should we permute ?
if
(k2 != k)
{
//exchange of line
// k2 > k
dstPermutations = tmpPermutations + k2 - k;
// swap indices
t = *tmpPermutations;
*tmpPermutations = *dstPermutations;
*dstPermutations = t;
// and swap entire line.
lColumnMatrix = lTmpMatrix + (k2 - k) * n;
memcpy(p_swap_area,lColumnMatrix,lSwapSize);
memcpy(lColumnMatrix,lTmpMatrix,lSwapSize);
memcpy(lTmpMatrix,p_swap_area,lSwapSize);
}
// now update data in the rest of the line and line after
lDestMatrix = lTmpMatrix + k;
lColumnMatrix = lDestMatrix + n;
// take the middle element
temp = *(lDestMatrix++);
// now compute up data (i.e. coeff up of the diagonal).
for (i = offset; i < n; ++i)
{
//lColumnMatrix;
// divide the lower column elements by the diagonal value
// matrix[i][k] /= matrix[k][k];
// p = matrix[i][k]
p = *lColumnMatrix / temp;
*(lColumnMatrix++) = p;
for
(j = /* k + 1 */ offset; j < n; ++j)
{
// matrix[i][j] -= matrix[i][k] * matrix[k][j];
*(lColumnMatrix++) -= p * (*(lDestMatrix++));
}
// come back to the k+1th element
lDestMatrix -= lStride;
// go to kth element of the next line
lColumnMatrix += k;
}
// offset is now k+2
++offset;
// 1 element less for stride
--lStride;
// next line
lTmpMatrix+=n;
// next permutation element
++tmpPermutations;
}
return true;
}
/**
* LUP solving
*/
void opj_lupSolve (OPJ_FLOAT32 * pResult, OPJ_FLOAT32 * pMatrix, OPJ_FLOAT32 * pVector, OPJ_UINT32* pPermutations, OPJ_UINT32 n,OPJ_FLOAT32 * p_intermediate_data)
{
OPJ_UINT32 i,j;
OPJ_FLOAT32 sum;
OPJ_FLOAT32 u;
OPJ_UINT32 lStride = n+1;
OPJ_FLOAT32 * lCurrentPtr;
OPJ_FLOAT32 * lIntermediatePtr;
OPJ_FLOAT32 * lDestPtr;
OPJ_FLOAT32 * lTmpMatrix;
OPJ_FLOAT32 * lLineMatrix = pMatrix;
OPJ_FLOAT32 * lBeginPtr = pResult + n - 1;
OPJ_FLOAT32 * lGeneratedData;
OPJ_UINT32 * lCurrentPermutationPtr = pPermutations;
lIntermediatePtr = p_intermediate_data;
lGeneratedData = p_intermediate_data + n - 1;
for
(i = 0; i < n; ++i)
{
sum = 0.0;
lCurrentPtr = p_intermediate_data;
lTmpMatrix = lLineMatrix;
for
(j = 1; j <= i; ++j)
{
// sum += matrix[i][j-1] * y[j-1];
sum += (*(lTmpMatrix++)) * (*(lCurrentPtr++));
}
//y[i] = pVector[pPermutations[i]] - sum;
*(lIntermediatePtr++) = pVector[*(lCurrentPermutationPtr++)] - sum;
lLineMatrix += n;
}
// we take the last point of the matrix
lLineMatrix = pMatrix + n*n - 1;
// and we take after the last point of the destination vector
lDestPtr = pResult + n;
for
(i = n - 1; i != -1 ; --i)
{
sum = 0.0;
lTmpMatrix = lLineMatrix;
u = *(lTmpMatrix++);
lCurrentPtr = lDestPtr--;
for
(j = i + 1; j < n; ++j)
{
// sum += matrix[i][j] * x[j]
sum += (*(lTmpMatrix++)) * (*(lCurrentPtr++));
}
//x[i] = (y[i] - sum) / u;
*(lBeginPtr--) = (*(lGeneratedData--) - sum) / u;
lLineMatrix -= lStride;
}
}
/** LUP inversion (call with the result of lupDecompose)
*/
void opj_lupInvert (
OPJ_FLOAT32 * pSrcMatrix,
OPJ_FLOAT32 * pDestMatrix,
OPJ_UINT32 n,
OPJ_UINT32 * pPermutations,
OPJ_FLOAT32 * p_src_temp,
OPJ_FLOAT32 * p_dest_temp,
OPJ_FLOAT32 * p_swap_area
)
{
OPJ_UINT32 j,i;
OPJ_FLOAT32 * lCurrentPtr;
OPJ_FLOAT32 * lLineMatrix = pDestMatrix;
OPJ_UINT32 lSwapSize = n * sizeof(OPJ_FLOAT32);
for
(j = 0; j < n; ++j)
{
lCurrentPtr = lLineMatrix++;
memset(p_src_temp,0,lSwapSize);
p_src_temp[j] = 1.0;
opj_lupSolve(p_dest_temp,pSrcMatrix,p_src_temp, pPermutations, n , p_swap_area);
for
(i = 0; i < n; ++i)
{
*(lCurrentPtr) = p_dest_temp[i];
lCurrentPtr+=n;
}
}
}

40
libopenjpeg/invert.h
View File

@@ -1,40 +0,0 @@
/*
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* 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.
*/
#ifndef __INVERT_H
#define __INVERT_H
#include "openjpeg.h"
/**
* Calculates a n x n double matrix inversion with a LUP method. Data is aligned, rows after rows (or columns after columns).
* The function does not take ownership of any memory block, data must be fred by the user.
*
* @param pSrcMatrix the matrix to invert.
* @param pDestMatrix data to store the inverted matrix.
* @return 1 if the inversion is successful, 0 if the matrix is singular.
*/
bool opj_matrix_inversion_f(OPJ_FLOAT32 * pSrcMatrix,OPJ_FLOAT32 * pDestMatrix, OPJ_UINT32 n);
#endif

10374
libopenjpeg/j2k.c
View File

File diff suppressed because it is too large Load Diff

862
libopenjpeg/j2k.h
View File

@@ -1,12 +1,7 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren * Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2006-2007, Parvatha Elangovan
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -30,22 +25,37 @@
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#define VERSION "0.0.8"
#if defined(_WIN32) && defined (OPENJPEGDLL)
#ifdef gdcmopenjpeg_EXPORTS /*LIBJ2K_EXPORTS*/
#define LIBJ2K_API __declspec(dllexport)
#else
#define LIBJ2K_API __declspec(dllimport)
#endif
#else
#ifdef OPENJPEGSTATIC
#define LIBJ2K_API extern
#else
#define LIBJ2K_API
#endif
#endif
#ifndef __J2K_H #ifndef __J2K_H
#define __J2K_H #define __J2K_H
/**
@file j2k.h
@brief The JPEG-2000 Codestream Reader/Writer (J2K)
The functions in J2K.C have for goal to read/write the several parts of the codestream: markers and data. #define J2K_MAXRLVLS 33 /* Number of maximum resolution level authorized */
*/ #define J2K_MAXBANDS (3*J2K_MAXRLVLS-2) /* Number of maximum sub-band linked to number of resolution level */
#define J2K_CFMT 0
#include "openjpeg.h" #define JP2_CFMT 1
#define JPT_CFMT 2
struct opj_dparameters; #define MJ2_CFMT 3
struct opj_stream_private; #define PXM_DFMT 0
struct opj_event_mgr; #define PGX_DFMT 1
/** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */ #define BMP_DFMT 2
/*@{*/ #define YUV_DFMT 3
#define J2K_CP_CSTY_PRT 0x01 #define J2K_CP_CSTY_PRT 0x01
#define J2K_CP_CSTY_SOP 0x02 #define J2K_CP_CSTY_SOP 0x02
@@ -61,677 +71,171 @@ struct opj_event_mgr;
#define J2K_CCP_QNTSTY_SIQNT 1 #define J2K_CCP_QNTSTY_SIQNT 1
#define J2K_CCP_QNTSTY_SEQNT 2 #define J2K_CCP_QNTSTY_SEQNT 2
/* ----------------------------------------------------------------------- */ typedef struct {
int dx, dy; /* XRsiz, YRsiz */
int w, h; /* width and height of data */
int x0, y0; /* offset of the component compare to the whole image */
int prec; /* precision */
int bpp; /* deapth of image in bits */
int sgnd; /* signed */
int resno_decoded; /* number of decoded resolution */
int factor; /* number of division by 2 of the out image compare to the original size of image */
int *data; /* image-component data */
} j2k_comp_t;
#define J2K_MS_SOC 0xff4f /**< SOC marker value */ typedef struct {
#define J2K_MS_SOT 0xff90 /**< SOT marker value */ int x0, y0; /* XOsiz, YOsiz */
#define J2K_MS_SOD 0xff93 /**< SOD marker value */ int x1, y1; /* Xsiz, Ysiz */
#define J2K_MS_EOC 0xffd9 /**< EOC marker value */ int numcomps; /* number of components */
#define J2K_MS_SIZ 0xff51 /**< SIZ marker value */ int color_space; /* sRGB, Greyscale or YUV */
#define J2K_MS_COD 0xff52 /**< COD marker value */ j2k_comp_t *comps; /* image-components */
#define J2K_MS_COC 0xff53 /**< COC marker value */ } j2k_image_t;
#define J2K_MS_RGN 0xff5e /**< RGN marker value */
#define J2K_MS_QCD 0xff5c /**< QCD marker value */
#define J2K_MS_QCC 0xff5d /**< QCC marker value */
#define J2K_MS_POC 0xff5f /**< POC marker value */
#define J2K_MS_TLM 0xff55 /**< TLM marker value */
#define J2K_MS_PLM 0xff57 /**< PLM marker value */
#define J2K_MS_PLT 0xff58 /**< PLT marker value */
#define J2K_MS_PPM 0xff60 /**< PPM marker value */
#define J2K_MS_PPT 0xff61 /**< PPT marker value */
#define J2K_MS_SOP 0xff91 /**< SOP marker value */
#define J2K_MS_EPH 0xff92 /**< EPH marker value */
#define J2K_MS_CRG 0xff63 /**< CRG marker value */
#define J2K_MS_COM 0xff64 /**< COM marker value */
#define J2K_MS_CBD 0xff78 /**< CBD marker value */
#define J2K_MS_MCC 0xff75 /**< MCC marker value */
#define J2K_MS_MCT 0xff74 /**< MCT marker value */
#define J2K_MS_MCO 0xff77 /**< MCO marker value */
/* UniPG>> */ typedef struct {
#ifdef USE_JPWL int expn; /* exponent */
#define J2K_MS_EPC 0xff68 /**< EPC marker value (Part 11: JPEG 2000 for Wireless) */ int mant; /* mantissa */
#define J2K_MS_EPB 0xff66 /**< EPB marker value (Part 11: JPEG 2000 for Wireless) */ } j2k_stepsize_t;
#define J2K_MS_ESD 0xff67 /**< ESD marker value (Part 11: JPEG 2000 for Wireless) */
#define J2K_MS_RED 0xff69 /**< RED marker value (Part 11: JPEG 2000 for Wireless) */
#endif /* USE_JPWL */
#ifdef USE_JPSEC
#define J2K_MS_SEC 0xff65 /**< SEC marker value (Part 8: Secure JPEG 2000) */
#define J2K_MS_INSEC 0xff94 /**< INSEC marker value (Part 8: Secure JPEG 2000) */
#endif /* USE_JPSEC */
/* <<UniPG */
typedef struct {
int csty; /* coding style */
int numresolutions; /* number of resolutions */
int cblkw; /* width of code-blocks */
int cblkh; /* height of code-blocks */
int cblksty; /* code-block coding style */
int qmfbid; /* discrete wavelet transform identifier */
int qntsty; /* quantisation style */
j2k_stepsize_t stepsizes[J2K_MAXBANDS]; /* stepsizes used for quantization */
int numgbits; /* number of guard bits */
int roishift; /* Region Of Interest shift */
int prcw[J2K_MAXRLVLS]; /* Precinct width */
int prch[J2K_MAXRLVLS]; /* Precinct height */
} j2k_tccp_t;
/* ----------------------------------------------------------------------- */ typedef struct {
int resno0, compno0;
int layno1, resno1, compno1;
int prg;
int tile;
char progorder[4];
} j2k_poc_t;
/** typedef struct {
Values that specify the status of the decoding process when decoding the main header. int first; /* 1 : first part-tile of a tile */
These values may be combined with a | operator. int csty; /* coding style */
int prg; /* progression order */
int numlayers; /* number of layers */
int mct; /* multi-component transform identifier */
int rates[100]; /* rates of layers */
int numpocs; /* number of progression order changes */
int POC; /* Precise if a POC marker has been used O:NO, 1:YES */
j2k_poc_t pocs[32]; /* progression order changes */
unsigned char *ppt_data; /* packet header store there for futur use in t2_decode_packet */
unsigned char *ppt_data_first; /* pointer remaining on the first byte of the first header if ppt is used */
int ppt; /* If ppt == 1 --> there was a PPT marker for the present tile */
int ppt_store; /* Use in case of multiple marker PPT (number of info already store) */
int ppt_len; /* ppmbug1 */
float distoratio[100]; /* add fixed_quality */
j2k_tccp_t *tccps; /* tile-component coding parameters */
} j2k_tcp_t;
typedef struct {
int intermed_file; /* 1: Store each encoded tile one by one in the output file (for mega-Images)*/
int decod_format; /* 0: PGX, 1: PxM, 2: BMP */
int cod_format; /* 0: J2K, 1: JP2, 2: JPT */
int disto_alloc; /* Allocation by rate/distortion */
int fixed_alloc; /* Allocation by fixed layer */
int fixed_quality; /* add fixed_quality */
int reduce; /* if != 0, then original dimension divided by 2^(reduce); if == 0 or not used, image is decoded to the full resolution */
int layer; /* if != 0, then only the first "layer" layers are decoded; if == 0 or not used, all the quality layers are decoded */
int index_on; /* 0 = no index || 1 = index */
int tx0, ty0; /* XTOsiz, YTOsiz */
int tdx, tdy; /* XTsiz, YTsiz */
char *comment; /* comment for coding */
int tw, th; /* number of tiles in width and heigth */
int *tileno; /* ID number of the tiles present in the codestream */
int tileno_size; /* size of the vector tileno */
unsigned char *ppm_data; /* packet header store there for futur use in t2_decode_packet */
unsigned char *ppm_data_first; /* pointer remaining on the first byte of the first header if ppm is used */
int ppm; /* If ppm == 1 --> there was a PPM marker for the present tile */
int ppm_store; /* Use in case of multiple marker PPM (number of info already store) */
int ppm_previous; /* Use in case of multiple marker PPM (case on non-finished previous info) */
int ppm_len; /* ppmbug1 */
j2k_tcp_t *tcps; /* tile coding parameters */
int *matrice; /* Fixed layer */
} j2k_cp_t;
typedef struct {
int start_pos, end_pos; /* start and end position */
double disto; /* ADD for Marcela */
} info_packet; /* Index struct */
typedef struct {
double *thresh; /* value of thresh for each layer by tile cfr. Marcela */
int num_tile; /* Number of Tile */
int start_pos; /* Start position */
int end_header; /* End position of the header */
int end_pos; /* End position */
int pw[33], ph[33]; /* precinct number for each resolution level */
int pdx[33], pdy[33]; /* precinct size (in power of 2), in X and Y for each resolution level */
info_packet *packet; /* information concerning packets inside tile */
int nbpix; /* add fixed_quality */
double distotile; /* add fixed_quality */
} info_tile; /* index struct */
typedef struct {
int index_on;
double D_max; /* ADD for Marcela */
int num; /* numero of packet */
int index_write; /* writing the packet inthe index with t2_encode_packets */
int Im_w, Im_h; /* Image width and Height */
int Prog; /* progression order */
int Tile_x, Tile_y; /* Tile size in x and y */
int Tile_Ox, Tile_Oy;
int tw, th; /* Number of Tile in X and Y */
int Comp; /* Component numbers */
int Layer; /* number of layer */
int Decomposition; /* number of decomposition */
int Main_head_end; /* Main header position */
int codestream_size; /* codestream's size */
info_tile *tile; /* information concerning tiles inside image */
} info_image; /* index struct */
/*
* Encode an image into a JPEG-2000 codestream
* i: image to encode
* cp: coding parameters
* output: destination buffer or name of the output file when cp->intermed_file==1
* len: length of destination buffer
* index : index file name
*/ */
typedef enum LIBJ2K_API int j2k_encode(j2k_image_t * i, j2k_cp_t * cp, char *output,
{ int len, char *index);
J2K_DEC_STATE_NONE = 0x0000, /**< a SOC marker is expected */
J2K_DEC_STATE_MHSOC = 0x0001, /**< a SOC marker is expected */
J2K_DEC_STATE_MHSIZ = 0x0002, /**< a SIZ marker is expected */
J2K_DEC_STATE_MH = 0x0004, /**< the decoding process is in the main header */
J2K_DEC_STATE_TPHSOT = 0x0008, /**< the decoding process is in a tile part header and expects a SOT marker */
J2K_DEC_STATE_TPH = 0x0010, /**< the decoding process is in a tile part header */
J2K_DEC_STATE_MT = 0x0020, /**< the EOC marker has just been read */
J2K_DEC_STATE_NEOC = 0x0040, /**< the decoding process must not expect a EOC marker because the codestream is truncated */
J2K_DEC_STATE_DATA = 0x0080, /**< the decoding process must not expect a EOC marker because the codestream is truncated */
J2K_DEC_STATE_ERR = 0x8000, /**< the decoding process has encountered an error */
J2K_DEC_STATE_EOC = 0x0100
}
J2K_DECODING_STATUS;
/** /* LIBJ2K_API int j2k_encode(j2k_image_t *i, j2k_cp_t *cp,unsigned char *dest, int len); */
Values that specify the status of the decoding process when decoding the main header. /*
These values may be combined with a | operator. * Decode an image from a JPEG-2000 codestream
* src: source buffer
* len: length of source buffer
* i: decode image
* cp: coding parameters that were used to encode the image
*/ */
typedef enum
{
J2K_ENC_STATE_NONE = 0x0000, /**< a SOC marker is expected */
J2K_ENC_STATE_ENCODE = 0x0001, /**< a SOC marker is expected */
}
J2K_ENCODING_STATUS;
/** LIBJ2K_API int j2k_decode(unsigned char *src, int len, j2k_image_t * img,
* Type of data for storing the MCT data j2k_cp_t * cp);
*/
typedef enum MCT_ELEMENT_TYPE
{
MCT_TYPE_INT16 = 0, /** MCT data is stored as signed shorts*/
MCT_TYPE_INT32 = 1, /** MCT data is stored as signed integers*/
MCT_TYPE_FLOAT = 2, /** MCT data is stored as floats*/
MCT_TYPE_DOUBLE = 3 /** MCT data is stored as doubles*/
} J2K_MCT_ELEMENT_TYPE;
/**
* Type of data for storing the MCT data
*/
typedef enum MCT_ARRAY_TYPE
{
MCT_TYPE_DEPENDENCY = 0,
MCT_TYPE_DECORRELATION = 1,
MCT_TYPE_OFFSET = 2
} J2K_MCT_ARRAY_TYPE;
/* ----------------------------------------------------------------------- */ /*
* Decode an image form a JPT-stream (JPEG 2000, JPIP)
* src: source buffer
* len: length of source buffer
/** * i: decode image
Quantization stepsize * cp: coding parameters that were used to encode the image
*/
typedef struct opj_stepsize
{
/** exponent */
OPJ_UINT32 expn;
/** mantissa */
OPJ_UINT32 mant;
}
opj_stepsize_t;
typedef struct opj_mct_data
{
J2K_MCT_ELEMENT_TYPE m_element_type;
J2K_MCT_ARRAY_TYPE m_array_type;
OPJ_UINT32 m_index;
OPJ_BYTE * m_data;
OPJ_UINT32 m_data_size;
}
opj_mct_data_t;
typedef struct opj_simple_mcc_decorrelation_data
{
OPJ_UINT32 m_index;
OPJ_UINT32 m_nb_comps;
opj_mct_data_t * m_decorrelation_array;
opj_mct_data_t * m_offset_array;
OPJ_UINT32 m_is_irreversible : 1;
}
opj_simple_mcc_decorrelation_data_t;
/**
Tile-component coding parameters
*/
typedef struct opj_tccp
{
/** coding style */
OPJ_UINT32 csty;
/** number of resolutions */
OPJ_UINT32 numresolutions;
/** code-blocks width */
OPJ_UINT32 cblkw;
/** code-blocks height */
OPJ_UINT32 cblkh;
/** code-block coding style */
OPJ_UINT32 cblksty;
/** discrete wavelet transform identifier */
OPJ_UINT32 qmfbid;
/** quantisation style */
OPJ_UINT32 qntsty;
/** stepsizes used for quantization */
opj_stepsize_t stepsizes[J2K_MAXBANDS];
/** number of guard bits */
OPJ_UINT32 numgbits;
/** Region Of Interest shift */
OPJ_INT32 roishift;
/** precinct width */
OPJ_UINT32 prcw[J2K_MAXRLVLS];
/** precinct height */
OPJ_UINT32 prch[J2K_MAXRLVLS];
/** the dc_level_shift **/
OPJ_INT32 m_dc_level_shift;
}
opj_tccp_t;
/**
Tile coding parameters :
this structure is used to store coding/decoding parameters common to all
tiles (information like COD, COC in main header)
*/
typedef struct opj_tcp
{
/** coding style */
OPJ_UINT32 csty;
/** progression order */
OPJ_PROG_ORDER prg;
/** number of layers */
OPJ_UINT32 numlayers;
OPJ_UINT32 num_layers_to_decode;
/** multi-component transform identifier */
OPJ_UINT32 mct;
/** rates of layers */
OPJ_FLOAT32 rates[100];
/** number of progression order changes */
OPJ_UINT32 numpocs;
/** progression order changes */
opj_poc_t pocs[32];
/** packet header store there for futur use in t2_decode_packet */
OPJ_BYTE *ppt_data;
/** used to keep a track of the allocated memory */
OPJ_BYTE *ppt_buffer;
/** Number of bytes stored inside ppt_data*/
OPJ_UINT32 ppt_data_size;
/** size of ppt_data*/
OPJ_UINT32 ppt_len;
/** add fixed_quality */
OPJ_FLOAT32 distoratio[100];
/** tile-component coding parameters */
opj_tccp_t *tccps;
/** number of tile parts for the tile. */
OPJ_UINT32 m_nb_tile_parts;
/** data for the tile */
OPJ_BYTE * m_data;
/** size of data */
OPJ_UINT32 m_data_size;
/** encoding norms */
OPJ_FLOAT64 * mct_norms;
/** the mct decoding matrix */
OPJ_FLOAT32 * m_mct_decoding_matrix;
/** the mct coding matrix */
OPJ_FLOAT32 * m_mct_coding_matrix;
/** mct records */
opj_mct_data_t * m_mct_records;
/** the number of mct records. */
OPJ_UINT32 m_nb_mct_records;
/** the max number of mct records. */
OPJ_UINT32 m_nb_max_mct_records;
/** mcc records */
opj_simple_mcc_decorrelation_data_t * m_mcc_records;
/** the number of mct records. */
OPJ_UINT32 m_nb_mcc_records;
/** the max number of mct records. */
OPJ_UINT32 m_nb_max_mcc_records;
/***** FLAGS *******/
/** If ppt == 1 --> there was a PPT marker for the present tile */
OPJ_UINT32 ppt : 1;
/** indicates if a POC marker has been used O:NO, 1:YES */
OPJ_UINT32 POC : 1;
} opj_tcp_t;
typedef struct opj_encoding_param
{
/** Digital cinema profile*/
OPJ_CINEMA_MODE m_cinema;
/** Maximum rate for each component. If == 0, component size limitation is not considered */
OPJ_UINT32 m_max_comp_size;
/** Position of tile part flag in progression order*/
OPJ_INT32 m_tp_pos;
/** fixed layer */
OPJ_INT32 *m_matrice;
/** Flag determining tile part generation*/
OPJ_BYTE m_tp_flag;
/** allocation by rate/distortion */
OPJ_UINT32 m_disto_alloc : 1;
/** allocation by fixed layer */
OPJ_UINT32 m_fixed_alloc : 1;
/** add fixed_quality */
OPJ_UINT32 m_fixed_quality : 1;
/** Enabling Tile part generation*/
OPJ_UINT32 m_tp_on : 1;
}
opj_encoding_param_t;
typedef struct opj_decoding_param
{
/** if != 0, then original dimension divided by 2^(reduce); if == 0 or not used, image is decoded to the full resolution */
OPJ_UINT32 m_reduce;
/** if != 0, then only the first "layer" layers are decoded; if == 0 or not used, all the quality layers are decoded */
OPJ_UINT32 m_layer;
}
opj_decoding_param_t;
/**
Coding parameters
*/
typedef struct opj_cp
{
/** Size of the image in bits*/
/*int img_size;*/
/** Rsiz*/
OPJ_RSIZ_CAPABILITIES rsiz;
/** XTOsiz */
OPJ_INT32 tx0;
/** YTOsiz */
OPJ_INT32 ty0;
/** XTsiz */
OPJ_UINT32 tdx;
/** YTsiz */
OPJ_UINT32 tdy;
/** comment */
OPJ_CHAR *comment;
/** number of tiles in width */
OPJ_UINT32 tw;
/** number of tiles in heigth */
OPJ_UINT32 th;
/** packet header storage original buffer */
OPJ_BYTE *ppm_buffer;
/** packet header store there for futur use in t2_decode_packet */
OPJ_BYTE *ppm_data;
/** size of the ppm_data*/
OPJ_UINT32 ppm_len;
/** Number of bytes actually stored inside the ppm_data */
OPJ_UINT32 ppm_data_size;
/** tile coding parameters */
opj_tcp_t *tcps;
union
{
opj_decoding_param_t m_dec;
opj_encoding_param_t m_enc;
}
m_specific_param;
/* UniPG>> */
#ifdef USE_JPWL
/** enables writing of EPC in MH, thus activating JPWL */
bool epc_on;
/** enables writing of EPB, in case of activated JPWL */
bool epb_on;
/** enables writing of ESD, in case of activated JPWL */
bool esd_on;
/** enables writing of informative techniques of ESD, in case of activated JPWL */
bool info_on;
/** enables writing of RED, in case of activated JPWL */
bool red_on;
/** error protection method for MH (0,1,16,32,37-128) */
int hprot_MH;
/** tile number of header protection specification (>=0) */
int hprot_TPH_tileno[JPWL_MAX_NO_TILESPECS];
/** error protection methods for TPHs (0,1,16,32,37-128) */
int hprot_TPH[JPWL_MAX_NO_TILESPECS];
/** tile number of packet protection specification (>=0) */
int pprot_tileno[JPWL_MAX_NO_PACKSPECS];
/** packet number of packet protection specification (>=0) */
int pprot_packno[JPWL_MAX_NO_PACKSPECS];
/** error protection methods for packets (0,1,16,32,37-128) */
int pprot[JPWL_MAX_NO_PACKSPECS];
/** enables writing of ESD, (0/2/4 bytes) */
int sens_size;
/** sensitivity addressing size (0=auto/2/4 bytes) */
int sens_addr;
/** sensitivity range (0-3) */
int sens_range;
/** sensitivity method for MH (-1,0-7) */
int sens_MH;
/** tile number of sensitivity specification (>=0) */
int sens_TPH_tileno[JPWL_MAX_NO_TILESPECS];
/** sensitivity methods for TPHs (-1,0-7) */
int sens_TPH[JPWL_MAX_NO_TILESPECS];
/** enables JPWL correction at the decoder */
bool correct;
/** expected number of components at the decoder */
int exp_comps;
/** maximum number of tiles at the decoder */
int max_tiles;
#endif /* USE_JPWL */
/******** FLAGS *********/
/** if ppm == 1 --> there was a PPM marker*/
OPJ_UINT32 ppm : 1;
/** tells if the parameter is a coding or decoding one */
OPJ_UINT32 m_is_decoder : 1;
/* <<UniPG */
} opj_cp_t;
typedef struct opj_j2k_dec
{
/** locate in which part of the codestream the decoder is (main header, tile header, end) */
OPJ_UINT32 m_state;
/**
* store decoding parameters common to all tiles (information like COD, COC in main header)
*/
opj_tcp_t *m_default_tcp;
OPJ_BYTE *m_header_data;
OPJ_UINT32 m_header_data_size;
/** to tell the tile part length */
OPJ_UINT32 m_sot_length;
/** Only tiles index in the correct range will be decoded.*/
OPJ_UINT32 m_start_tile_x;
OPJ_UINT32 m_start_tile_y;
OPJ_UINT32 m_end_tile_x;
OPJ_UINT32 m_end_tile_y;
/** to tell that a tile can be decoded. */
OPJ_UINT32 m_can_decode : 1;
OPJ_UINT32 m_discard_tiles : 1;
OPJ_UINT32 m_skip_data : 1;
} opj_j2k_dec_t;
typedef struct opj_j2k_enc
{
/** Tile part number, regardless of poc, for each new poc, tp is reset to 1*/
OPJ_UINT32 m_current_poc_tile_part_number; // tp_num
/** 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
/**
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.
*/
OPJ_SIZE_T m_tlm_start;
/**
* Stores the sizes of the tlm.
*/
OPJ_BYTE * m_tlm_sot_offsets_buffer;
/**
* The current offset of the tlm buffer.
*/
OPJ_BYTE * m_tlm_sot_offsets_current;
/** Total num of tile parts in whole image = num tiles* num tileparts in each tile*/
/** used in TLMmarker*/
OPJ_UINT32 m_total_tile_parts; // totnum_tp
/* encoded data for a tile */
OPJ_BYTE * m_encoded_tile_data;
/* size of the encoded_data */
OPJ_UINT32 m_encoded_tile_size;
/* encoded data for a tile */
OPJ_BYTE * m_header_tile_data;
/* size of the encoded_data */
OPJ_UINT32 m_header_tile_data_size;
} opj_j2k_enc_t;
/**
JPEG-2000 codestream reader/writer
*/
typedef struct opj_j2k
{
union
{
opj_j2k_dec_t m_decoder;
opj_j2k_enc_t m_encoder;
}
m_specific_param;
/** number of the tile curently concern by coding/decoding */
OPJ_UINT32 m_current_tile_number;
/** pointer to the encoded / decoded image */
opj_image_t *m_image;
/** Coding parameters */
opj_cp_t m_cp;
/** the list of procedures to exec **/
struct opj_procedure_list * m_procedure_list;
/** the list of validation procedures to follow to make sure the code is valid **/
struct opj_procedure_list * m_validation_list;
/** helper used to write the index file */
opj_codestream_info_t *cstr_info;
/** the current tile coder/decoder **/
struct opj_tcd * m_tcd;
OPJ_UINT32 m_is_decoder : 1;
}
opj_j2k_t;
/** @name Exported functions */
/*@{*/
/* ----------------------------------------------------------------------- */
/**
* Creates a J2K decompression structure.
* *
* @return a handle to a J2K decompressor if successful, NULL otherwise.
*/ */
opj_j2k_t* j2k_create_decompress(); int j2k_decode_jpt_stream(unsigned char *src, int len, j2k_image_t * img,
j2k_cp_t * cp);
/** LIBJ2K_API void j2k_dec_release();/*antonin*/
* Destroys a jpeg2000 codec.
*
* @param p_j2k the jpeg20000 structure to destroy.
*/
void j2k_destroy (opj_j2k_t *p_j2k);
/** #endif
* Starts a compression scheme, i.e. validates the codec parameters, writes the header.
*
* @param p_j2k the jpeg2000 codec.
* @param cio the stream object.
* @param p_manager the user event manager.
*
* @return true if the codec is valid.
*/
bool j2k_start_compress(
opj_j2k_t *p_j2k,
struct opj_stream_private *cio,
struct opj_image * p_image,
struct opj_event_mgr * p_manager
);
/**
* Ends the compression procedures and possibiliy add data to be read after the
* codestream.
*/
bool j2k_end_compress(opj_j2k_t *p_j2k, struct opj_stream_private *cio, struct opj_event_mgr * p_manager);
/**
* Sets up the decoder decoding parameters using user parameters.
* Decoding parameters are stored in j2k->cp.
*
* @param p_j2k J2K codec
* @param p_parameters decompression parameters
* @deprecated
*/
void j2k_setup_decoder(
opj_j2k_t *p_j2k,
struct opj_dparameters *p_parameters
);
/**
* Reads a jpeg2000 codestream header structure.
*
* @param cio the stream to read data from.
* @param p_j2k the jpeg2000 codec.
* @param p_manager the user event manager.
*
* @return true if the box is valid.
*/
bool j2k_read_header(
opj_j2k_t *p_j2k,
struct opj_image ** p_image,
OPJ_INT32 * p_tile_x0,
OPJ_INT32 * p_tile_y0,
OPJ_UINT32 * p_tile_width,
OPJ_UINT32 * p_tile_height,
OPJ_UINT32 * p_nb_tiles_x,
OPJ_UINT32 * p_nb_tiles_y,
struct opj_stream_private *cio,
struct opj_event_mgr * p_manager
);
/**
Decode an image from a JPEG-2000 codestream
@param j2k J2K decompressor handle
@param cio Input buffer stream
@param cstr_info Codestream information structure if required, NULL otherwise
@return Returns a decoded image if successful, returns NULL otherwise
*/
opj_image_t* j2k_decode(opj_j2k_t *j2k, struct opj_stream_private *cio, struct opj_event_mgr * p_manager);
/**
* Ends the decompression procedures and possibiliy add data to be read after the
* codestream.
*/
bool j2k_end_decompress(opj_j2k_t *j2k, struct opj_stream_private *cio, struct opj_event_mgr * p_manager);
/**
Decode an image form a JPT-stream (JPEG 2000, JPIP)
@param j2k J2K decompressor handle
@param cio Input buffer stream
@param cstr_info Codestream information structure if required, NULL otherwise
@return Returns a decoded image if successful, returns NULL otherwise
*/
opj_image_t* j2k_decode_jpt_stream(opj_j2k_t *j2k, struct opj_stream_private *cio, struct opj_codestream_info *cstr_info);
/**
Creates a J2K compression structure
@param cinfo Codec context info
@return Returns a handle to a J2K compressor if successful, returns NULL otherwise
*/
opj_j2k_t* j2k_create_compress();
/**
Setup the encoder parameters using the current image and using user parameters.
Coding parameters are returned in j2k->cp.
@param j2k J2K compressor handle
@param parameters compression parameters
@param image input filled image
*/
void j2k_setup_encoder(opj_j2k_t *j2k, opj_cparameters_t *parameters, opj_image_t *image, struct opj_event_mgr * p_manager);
/**
* Writes a tile.
* @param p_j2k the jpeg2000 codec.
* @param p_stream the stream to write data to.
* @param p_manager the user event manager.
*/
bool j2k_write_tile (
opj_j2k_t * p_j2k,
OPJ_UINT32 p_tile_index,
OPJ_BYTE * p_data,
OPJ_UINT32 p_data_size,
struct opj_stream_private *p_stream,
struct opj_event_mgr * p_manager
);
/**
* Converts an enum type progression order to string type.
*
* @param prg_order the progression order to get.
*
* @return the string representation of the gicen progression order.
*/
const char * j2k_convert_progression_order(OPJ_PROG_ORDER prg_order);
/**
* Encodes an image into a JPEG-2000 codestream
*/
bool j2k_encode(
opj_j2k_t * p_j2k,
struct opj_stream_private *cio,
struct opj_event_mgr * p_manager
);
bool j2k_setup_mct_encoding (opj_tcp_t * p_tcp,opj_image_t * p_image);
/**
* Decode tile data.
* @param p_j2k the jpeg2000 codec.
* @param p_stream the stream to write data to.
* @param p_manager the user event manager.
*/
bool j2k_decode_tile (
opj_j2k_t * p_j2k,
OPJ_UINT32 p_tile_index,
OPJ_BYTE * p_data,
OPJ_UINT32 p_data_size,
struct opj_stream_private *p_stream,
struct opj_event_mgr * p_manager
);
/**
* Reads a tile header.
* @param p_j2k the jpeg2000 codec.
* @param p_stream the stream to write data to.
* @param p_manager the user event manager.
*/
bool j2k_read_tile_header (
opj_j2k_t * p_j2k,
OPJ_UINT32 * p_tile_index,
OPJ_UINT32 * p_data_size,
OPJ_INT32 * p_tile_x0,
OPJ_INT32 * p_tile_y0,
OPJ_INT32 * p_tile_x1,
OPJ_INT32 * p_tile_y1,
OPJ_UINT32 * p_nb_comps,
bool * p_go_on,
struct opj_stream_private *p_stream,
struct opj_event_mgr * p_manager
);
/**
* Sets the given area to be decoded. This function should be called right after opj_read_header and before any tile header reading.
*
* @param p_j2k the jpeg2000 codec.
* @param p_start_x the left position of the rectangle to decode (in image coordinates).
* @param p_end_x the right position of the rectangle to decode (in image coordinates).
* @param p_start_y the up position of the rectangle to decode (in image coordinates).
* @param p_end_y the bottom position of the rectangle to decode (in image coordinates).
* @param p_manager the user event manager
*
* @return true if the area could be set.
*/
bool j2k_set_decode_area(
opj_j2k_t *p_j2k,
OPJ_INT32 p_start_x,
OPJ_INT32 p_start_y,
OPJ_INT32 p_end_x,
OPJ_INT32 p_end_y,
struct opj_event_mgr * p_manager
);
void j2k_dump_image(FILE *fd, opj_image_t * img);
/* ----------------------------------------------------------------------- */
/*@}*/
/*@}*/
#endif /* __J2K_H */

65
libopenjpeg/j2k_lib.c
View File

@@ -1,65 +0,0 @@
/*
* Copyright (c) 2005, Herv<72> Drolon, FreeImage Team
* 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.
*/
#ifdef WIN32
#include <windows.h>
#else
/*#include <sys/time.h>
#include <sys/resource.h>
#include <sys/times.h>
*/
#endif /* WIN32 */
#include "j2k_lib.h"
OPJ_FLOAT64 opj_clock(void) {
#if 0
#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 ( t.QuadPart /(double) freq.QuadPart ) ;
#else
/* Unix or Linux: use resource usage */
struct rusage t;
double 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 = t.ru_utime.tv_sec + t.ru_stime.tv_sec;
/* (2b) More precisely! Get the microseconds part ! */
return ( procTime + (t.ru_utime.tv_usec + t.ru_stime.tv_usec) * 1e-6 ) ;
#endif
#endif
return 0;
}

2492
libopenjpeg/jp2.c
View File

File diff suppressed because it is too large Load Diff

336
libopenjpeg/jp2.h
View File

@@ -1,9 +1,6 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2002-2007, Professor Benoit Macq * Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -29,92 +26,18 @@
*/ */
#ifndef __JP2_H #ifndef __JP2_H
#define __JP2_H #define __JP2_H
/**
@file jp2.h
@brief The JPEG-2000 file format Reader/Writer (JP2)
*/ #include "j2k.h"
#include "openjpeg.h"
typedef struct {
int depth;
/**********************************************************************************
********************************* FORWARD DECLARATIONS ***************************
**********************************************************************************/
struct opj_j2k;
struct opj_procedure_list;
struct opj_event_mgr;
struct opj_stream_private;
struct opj_dparameters;
struct opj_cparameters;
/** @defgroup JP2 JP2 - JPEG-2000 file format reader/writer */
/*@{*/
#define JPIP_JPIP 0x6a706970
#define JP2_JP 0x6a502020 /**< JPEG 2000 signature box */
#define JP2_FTYP 0x66747970 /**< File type box */
#define JP2_JP2H 0x6a703268 /**< JP2 header box */
#define JP2_IHDR 0x69686472 /**< Image header box */
#define JP2_COLR 0x636f6c72 /**< Colour specification box */
#define JP2_JP2C 0x6a703263 /**< Contiguous codestream box */
#define JP2_URL 0x75726c20 /**< URL box */
#define JP2_DBTL 0x6474626c /**< ??? */
#define JP2_BPCC 0x62706363 /**< Bits per component box */
#define JP2_JP2 0x6a703220 /**< File type fields */
/* ----------------------------------------------------------------------- */
typedef enum
{
JP2_STATE_NONE = 0x0,
JP2_STATE_SIGNATURE = 0x1,
JP2_STATE_FILE_TYPE = 0x2,
JP2_STATE_HEADER = 0x4,
JP2_STATE_CODESTREAM = 0x8,
JP2_STATE_END_CODESTREAM = 0x10,
JP2_STATE_UNKNOWN = 0x80000000
}
JP2_STATE;
typedef enum
{
JP2_IMG_STATE_NONE = 0x0,
JP2_IMG_STATE_UNKNOWN = 0x80000000
}
JP2_IMG_STATE;
/**
JP2 component
*/
typedef struct opj_jp2_comps
{
unsigned int depth;
int sgnd; int sgnd;
unsigned int bpcc; int bpcc;
} } jp2_comps_t;
opj_jp2_comps_t;
/** typedef struct {
JPEG-2000 file format reader/writer
*/
typedef struct opj_jp2
{
/** handle to the J2K codec */
struct opj_j2k *j2k;
/** list of validation procedures */
struct opj_procedure_list * m_validation_list;
/** list of execution procedures */
struct opj_procedure_list * m_procedure_list;
/* width of image */
unsigned int w; unsigned int w;
/* height of image */
unsigned int h; unsigned int h;
/* number of components in the image */
unsigned int numcomps; unsigned int numcomps;
unsigned int bpc; unsigned int bpc;
unsigned int C; unsigned int C;
@@ -128,215 +51,68 @@ typedef struct opj_jp2
unsigned int minversion; unsigned int minversion;
unsigned int numcl; unsigned int numcl;
unsigned int *cl; unsigned int *cl;
opj_jp2_comps_t *comps; jp2_comps_t *comps;
j2k_image_t *image;
unsigned int j2k_codestream_offset; unsigned int j2k_codestream_offset;
unsigned int jp2_state; unsigned int j2k_codestream_len;
unsigned int jp2_img_state; } jp2_struct_t;
} typedef struct {
opj_jp2_t; int length;
int type;
int init_pos;
} jp2_box_t;
/** /* int jp2_init_stdjp2(jp2_struct_t * jp2_struct, j2k_image_t * img);
JP2 Box
*/
typedef struct opj_jp2_box
{
unsigned int length;
unsigned int type;
}
opj_jp2_box_t;
typedef struct opj_jp2_header_handler
{
/* marker value */
int id;
/* action linked to the marker */
bool (*handler) (opj_jp2_t *jp2,unsigned char * p_header_data, unsigned int p_header_size,struct opj_event_mgr * p_manager);
}
opj_jp2_header_handler_t;
typedef struct opj_jp2_img_header_writer_handler
{
/* action to perform */
unsigned char* (*handler) (opj_jp2_t *jp2, unsigned int * p_data_size);
/* result of the action : data */
unsigned char * m_data;
/* size of data */
unsigned int m_size;
}
opj_jp2_img_header_writer_handler_t;
/** @name Exported functions */
/*@{*/
/* ----------------------------------------------------------------------- */
/**
* Creates a jpeg2000 file decompressor.
* *
* @return an empty jpeg2000 file codec. * Create a standard jp2_structure
* jp2_struct: the structure you are creating
* img: a j2k_image_t wich will help you to create the jp2_structure
*/ */
opj_jp2_t* jp2_create (bool p_is_decoder); int jp2_init_stdjp2(jp2_struct_t * jp2_struct);
/** /* int jp2_write_jp2c(int j2k_len, int *j2k_codestream_offset, char *j2k_codestream)
Destroy a JP2 decompressor handle
@param jp2 JP2 decompressor handle to destroy
*/
void jp2_destroy(opj_jp2_t *jp2);
/**
Setup the decoder decoding parameters using user parameters.
Decoding parameters are returned in jp2->j2k->cp.
@param jp2 JP2 decompressor handle
@param parameters decompression parameters
*/
void jp2_setup_decoder(opj_jp2_t *jp2, struct opj_dparameters *parameters);
/**
* Decode an image from a JPEG-2000 file stream
* @param jp2 JP2 decompressor handle
* @param cio Input buffer stream
* @param cstr_info Codestream information structure if required, NULL otherwise
* @return Returns a decoded image if successful, returns NULL otherwise
*/
struct opj_image* opj_jp2_decode(opj_jp2_t *jp2, struct opj_stream_private *cio, struct opj_event_mgr * p_manager);
/**
Setup the encoder parameters using the current image and using user parameters.
Coding parameters are returned in jp2->j2k->cp.
@param jp2 JP2 compressor handle
@param parameters compression parameters
@param image input filled image
*/
void jp2_setup_encoder(opj_jp2_t *jp2, struct opj_cparameters *parameters, struct opj_image *image,struct opj_event_mgr * p_manager);
/**
* Starts a compression scheme, i.e. validates the codec parameters, writes the header.
* *
* @param jp2 the jpeg2000 file codec. * Write the jp2c codestream box
* @param cio the stream object. * j2k_len: the j2k codestream length
* j2k_codestream_offset: the function will return the j2k codestream offset
* j2k_codestream: the j2k codestream to include in jp2 file
*/
int jp2_write_jp2c(int j2k_len, int *j2k_codestream_offset, char *j2k_codestream);
/* int jp2_write_jp2h(jp2_struct_t * jp2_struct);
* *
* @return true if the codec is valid. * Write the jp2h header box
* jp2_struct: the jp2 structure you are working with
*/ */
bool jp2_start_compress(opj_jp2_t *jp2, struct opj_stream_private *cio,struct opj_image * p_image,struct opj_event_mgr * p_manager); void jp2_write_jp2h(jp2_struct_t * jp2_struct);
/** /* int jp2_read_jp2h(jp2_struct_t * jp2_struct);
* Ends the compression procedures and possibiliy add data to be read after the
* codestream.
*/
bool jp2_end_compress(opj_jp2_t *jp2, struct opj_stream_private *cio, struct opj_event_mgr * p_manager);
/**
Encode an image into a JPEG-2000 file stream
@param jp2 JP2 compressor handle
@param cio Output buffer stream
@param image Image to encode
@param cstr_info Codestream information structure if required, NULL otherwise
@return Returns true if successful, returns false otherwise
*/
bool opj_jp2_encode(opj_jp2_t *jp2, struct opj_stream_private *cio, struct opj_event_mgr * p_manager);
/**
* Reads a jpeg2000 file header structure.
* *
* @param cio the stream to read data from. * Read the jp2h header box
* @param jp2 the jpeg2000 file header structure. * jp2_struct: the jp2 structure you are working with
* @param p_manager the user event manager. */
int jp2_read_jp2h(jp2_struct_t * jp2_struct);
/* int jp2_wrap_j2k(jp2_struct_t * jp2_struct, char *j2k_codestream,
int j2k_len, char *output)
* *
* @return true if the box is valid. * Wrap a J2K codestream in a JP2 file
* jp2_struct: the jp2 structure used to create jp2 boxes
* j2k_codestream: the j2k codestream to include in jp2 file
* output: pointer to jp2 codestream that will be created
*/ */
bool jp2_read_header( int jp2_wrap_j2k(jp2_struct_t * jp2_struct, char *j2k_codestream,
opj_jp2_t *jp2, char *output);
struct opj_image ** p_image,
OPJ_INT32 * p_tile_x0,
OPJ_INT32 * p_tile_y0,
OPJ_UINT32 * p_tile_width,
OPJ_UINT32 * p_tile_height,
OPJ_UINT32 * p_nb_tiles_x,
OPJ_UINT32 * p_nb_tiles_y,
struct opj_stream_private *cio,
struct opj_event_mgr * p_manager
);
/**
* Ends the decompression procedures and possibiliy add data to be read after the
* codestream.
*/
bool jp2_end_decompress(opj_jp2_t *jp2, struct opj_stream_private *cio, struct opj_event_mgr * p_manager);
/**
* Writes a tile. /* int jp2_read_struct(unsigned char *src, jp2_struct_t * jp2_struct);
* @param p_j2k the jpeg2000 codec.
* @param p_stream the stream to write data to.
* @param p_manager the user event manager.
*/
bool jp2_write_tile (
opj_jp2_t *p_jp2,
OPJ_UINT32 p_tile_index,
OPJ_BYTE * p_data,
OPJ_UINT32 p_data_size,
struct opj_stream_private *p_stream,
struct opj_event_mgr * p_manager
);
/**
* Decode tile data.
* @param p_j2k the jpeg2000 codec.
* @param p_stream the stream to write data to.
* @param p_manager the user event manager.
*/
bool opj_jp2_decode_tile (
opj_jp2_t * p_jp2,
OPJ_UINT32 p_tile_index,
OPJ_BYTE * p_data,
OPJ_UINT32 p_data_size,
struct opj_stream_private *p_stream,
struct opj_event_mgr * p_manager
);
/**
* Reads a tile header.
* @param p_j2k the jpeg2000 codec.
* @param p_stream the stream to write data to.
* @param p_manager the user event manager.
*/
bool jp2_read_tile_header (
opj_jp2_t * p_j2k,
OPJ_UINT32 * p_tile_index,
OPJ_UINT32 * p_data_size,
OPJ_INT32 * p_tile_x0,
OPJ_INT32 * p_tile_y0,
OPJ_INT32 * p_tile_x1,
OPJ_INT32 * p_tile_y1,
OPJ_UINT32 * p_nb_comps,
bool * p_go_on,
struct opj_stream_private *p_stream,
struct opj_event_mgr * p_manager
);
/**
* Sets the given area to be decoded. This function should be called right after opj_read_header and before any tile header reading.
* *
* @param p_jp2 the jpeg2000 codec. * Decode the structure of a JP2 file
* @param p_end_x the right position of the rectangle to decode (in image coordinates). * src: pointer to memory where compressed data is stored
* @param p_start_y the up position of the rectangle to decode (in image coordinates). * jp2_struct: the jp2 structure that will be created
* @param p_end_y the bottom position of the rectangle to decode (in image coordinates). * len: length of jp2 codestream
* @param p_manager the user event manager
*
* @return true if the area could be set.
*/ */
bool jp2_set_decode_area( int jp2_read_struct(unsigned char *src, jp2_struct_t * jp2_struct, int len);
opj_jp2_t *p_jp2,
OPJ_INT32 p_start_x,
OPJ_INT32 p_start_y,
OPJ_INT32 p_end_x,
OPJ_INT32 p_end_y,
struct opj_event_mgr * p_manager
);
/* ----------------------------------------------------------------------- */
/*@}*/
/*@}*/
#endif /* __JP2_H */
#endif

162
libopenjpeg/jpt.c
View File

@@ -1,9 +1,6 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2004, Yannick Verschueren
* Copyright (c) 2002-2007, Professor Benoit Macq * Copyright (c) 2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -28,60 +25,40 @@
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <stdio.h>
#include <stdlib.h>
#include "jpt.h" #include "jpt.h"
#include "openjpeg.h" #include "j2k.h"
#include "cio.h" #include "cio.h"
#include "event.h"
/* /*
* Read the information contains in VBAS [JPP/JPT stream message header] * Read the information contains in VBAS [JPP/JPT stream message header]
* Store information (7 bits) in value * Store information (7 bits) in value
* @param p_cio the stream to read from. *
* @param p_value the data to update
* @return the nb of bytes read or -1 if an io error occurred.
*/ */
bool jpt_read_VBAS_info(opj_stream_private_t * p_cio, OPJ_UINT32 * p_nb_bytes_read, OPJ_UINT32 * p_value, opj_event_mgr_t * p_manager) unsigned int jpt_read_VBAS_info(unsigned int value)
{ {
OPJ_BYTE l_elmt; unsigned char elmt;
OPJ_UINT32 l_nb_bytes_read = 0;
// read data till the MSB of the current byte is 1. elmt = cio_read(1);
// concatenate 7 bits of data, last bit is finish flag while ((elmt >> 7) == 1) {
value = (value << 7);
// read data from the stream value |= (elmt & 0x7f);
elmt = cio_read(1);
if
(opj_stream_read_data(p_cio,&l_elmt,1,p_manager) != 1)
{
opj_event_msg(p_manager, EVT_ERROR, "Error trying to read a byte of data.\n");
return false;
} }
++l_nb_bytes_read; value = (value << 7);
value |= (elmt & 0x7f);
// is the MSB equal to 1 ? return value;
while
(l_elmt & 0x80)
{
// concatenate 7 bits of data, last bit is finish flag
*p_value = (*p_value << 7) | (l_elmt & 0x7f);
if
(opj_stream_read_data(p_cio,&l_elmt,1,p_manager) != 1)
{
opj_event_msg(p_manager, EVT_ERROR, "Error trying to read a byte of data.\n");
return false;
}
++l_nb_bytes_read;
}
// concatenate 7 bits of data, last bit is finish flag
*p_value = (*p_value << 7) | (l_elmt & 0x7f);
* p_nb_bytes_read = l_nb_bytes_read;
return true;
} }
/* /*
* Initialize the value of the message header structure * Initialize the value of the message header structure
* *
*/ */
void jpt_init_msg_header(opj_jpt_msg_header_t * header) void jpt_init_Msg_Header(jpt_msg_header_struct_t * header)
{ {
header->Id = 0; /* In-class Identifier */ header->Id = 0; /* In-class Identifier */
header->last_byte = 0; /* Last byte information */ header->last_byte = 0; /* Last byte information */
@@ -98,7 +75,7 @@ void jpt_init_msg_header(opj_jpt_msg_header_t * header)
* Only parameters always present in message header * Only parameters always present in message header
* *
*/ */
void jpt_reinit_msg_header(opj_jpt_msg_header_t * header) void jpt_reinit_Msg_Header(jpt_msg_header_struct_t * header)
{ {
header->Id = 0; /* In-class Identifier */ header->Id = 0; /* In-class Identifier */
header->last_byte = 0; /* Last byte information */ header->last_byte = 0; /* Last byte information */
@@ -110,31 +87,20 @@ void jpt_reinit_msg_header(opj_jpt_msg_header_t * header)
* Read the message header for a JPP/JPT - stream * Read the message header for a JPP/JPT - stream
* *
*/ */
bool jpt_read_msg_header(opj_stream_private_t *cio, opj_jpt_msg_header_t *header, OPJ_UINT32 * p_nb_bytes_read, opj_event_mgr_t * p_manager) void jpt_read_Msg_Header(jpt_msg_header_struct_t * header)
{ {
OPJ_BYTE elmt, Class = 0, CSn = 0; unsigned char elmt, Class = 0, CSn = 0;
OPJ_UINT32 l_nb_bytes_read = 0; jpt_reinit_Msg_Header(header);
OPJ_UINT32 l_last_nb_bytes_read;
jpt_reinit_msg_header(header);
/* ------------- */ /* ------------- */
/* VBAS : Bin-ID */ /* VBAS : Bin-ID */
/* ------------- */ /* ------------- */
if elmt = cio_read(1);
(opj_stream_read_data(cio,&elmt,1,p_manager) != 1)
{
opj_event_msg(p_manager, EVT_ERROR, "Forbidden value encounter in message header !!\n");
return false;
}
++l_nb_bytes_read;
/* See for Class and CSn */ /* See for Class and CSn */
switch ((elmt >> 5) & 0x03) switch ((elmt >> 5) & 0x03) {
{
case 0: case 0:
opj_event_msg(p_manager, EVT_ERROR, "Error trying to read a byte of data!!!\n"); fprintf(stderr, "Forbidden value encounter in message header !!\n");
break; break;
case 1: case 1:
Class = 0; Class = 0;
@@ -153,97 +119,45 @@ bool jpt_read_msg_header(opj_stream_private_t *cio, opj_jpt_msg_header_t *header
} }
/* see information on bits 'c' [p 10 : A.2.1 general, ISO/IEC FCD 15444-9] */ /* see information on bits 'c' [p 10 : A.2.1 general, ISO/IEC FCD 15444-9] */
if if (((elmt >> 4) & 0x01) == 1)
(((elmt >> 4) & 0x01) == 1)
{
header->last_byte = 1; header->last_byte = 1;
}
/* In-class identifier */ /* In-class identifier */
header->Id |= (elmt & 0x0f); header->Id |= (elmt & 0x0f);
if if ((elmt >> 7) == 1)
((elmt >> 7) == 1) header->Id = jpt_read_VBAS_info(header->Id);
{
l_last_nb_bytes_read = 0;
if
(! jpt_read_VBAS_info(cio, &l_last_nb_bytes_read, &(header->Id), p_manager))
{
opj_event_msg(p_manager, EVT_ERROR, "Error trying to read a byte of data!!!\n");
return false;
}
l_nb_bytes_read += l_last_nb_bytes_read;
}
/* ------------ */ /* ------------ */
/* VBAS : Class */ /* VBAS : Class */
/* ------------ */ /* ------------ */
if (Class == 1) if (Class == 1) {
{
header->Class_Id = 0; header->Class_Id = 0;
l_last_nb_bytes_read = 0; header->Class_Id = jpt_read_VBAS_info(header->Class_Id);
if
(! jpt_read_VBAS_info(cio, &l_last_nb_bytes_read, &(header->Class_Id), p_manager))
{
opj_event_msg(p_manager, EVT_ERROR, "Error trying to read a byte of data!!!\n");
return false;
}
l_nb_bytes_read += l_last_nb_bytes_read;
} }
/* ---------- */ /* ---------- */
/* VBAS : CSn */ /* VBAS : CSn */
/* ---------- */ /* ---------- */
if (CSn == 1) if (CSn == 1) {
{
header->CSn_Id = 0; header->CSn_Id = 0;
l_last_nb_bytes_read = 0; header->CSn_Id = jpt_read_VBAS_info(header->CSn_Id);
if
(! jpt_read_VBAS_info(cio, &l_last_nb_bytes_read, &(header->CSn_Id), p_manager))
{
opj_event_msg(p_manager, EVT_ERROR, "Error trying to read a byte of data!!!\n");
return false;
}
l_nb_bytes_read += l_last_nb_bytes_read;
} }
/* ----------------- */ /* ----------------- */
/* VBAS : Msg_offset */ /* VBAS : Msg_offset */
/* ----------------- */ /* ----------------- */
l_last_nb_bytes_read = 0; header->Msg_offset = jpt_read_VBAS_info(header->Msg_offset);
if
(! jpt_read_VBAS_info(cio, &l_last_nb_bytes_read, &(header->Msg_offset), p_manager))
{
opj_event_msg(p_manager, EVT_ERROR, "Error trying to read a byte of data!!!\n");
return false;
}
l_nb_bytes_read += l_last_nb_bytes_read;
/* ----------------- */ /* ----------------- */
/* VBAS : Msg_length */ /* VBAS : Msg_length */
/* ----------------- */ /* ----------------- */
l_last_nb_bytes_read = 0; header->Msg_length = jpt_read_VBAS_info(header->Msg_length);
if
(! jpt_read_VBAS_info(cio, &l_last_nb_bytes_read, &(header->Msg_length), p_manager))
{
opj_event_msg(p_manager, EVT_ERROR, "Error trying to read a byte of data!!!\n");
return false;
}
l_nb_bytes_read += l_last_nb_bytes_read;
/* ---------- */ /* ---------- */
/* VBAS : Aux */ /* VBAS : Aux */
/* ---------- */ /* ---------- */
if ((header->Class_Id & 0x01) == 1) if ((header->Class_Id & 0x01) == 1) {
{
header->Layer_nb = 0; header->Layer_nb = 0;
if header->Layer_nb = jpt_read_VBAS_info(header->Layer_nb);
(! jpt_read_VBAS_info(cio, &l_last_nb_bytes_read, &(header->Layer_nb), p_manager))
{
opj_event_msg(p_manager, EVT_ERROR, "Error trying to read a byte of data!!!\n");
return false;
} }
l_nb_bytes_read += l_last_nb_bytes_read;
}
* p_nb_bytes_read = l_nb_bytes_read;
return true;
} }

79
libopenjpeg/jpt.h
View File

@@ -1,9 +1,6 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2004, Yannick Verschueren
* Copyright (c) 2002-2007, Professor Benoit Macq * Copyright (c) 2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -28,56 +25,32 @@
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef __JPT_H /*
#define __JPT_H * Message Header JPT_stream Structure
/** *
@file jpt.h
@brief JPT-stream reader (JPEG 2000, JPIP)
JPT-stream functions are implemented in J2K.C.
*/ */
#include "openjpeg.h" typedef struct {
struct opj_stream_private; unsigned int Id; /* In-class Identifier */
struct opj_event_mgr; unsigned int last_byte; /* Last byte information */
/** unsigned int Class_Id; /* Class Identifier */
Message Header JPT stream structure unsigned int CSn_Id; /* CSn : index identifier */
unsigned int Msg_offset; /* Message offset */
unsigned int Msg_length; /* Message length */
unsigned int Layer_nb; /* Auxiliary for JPP case */
} jpt_msg_header_struct_t;
/*
* Initialize the value of the message header structure
*
* header : Message header structure
*
*/ */
typedef struct opj_jpt_msg_header void jpt_init_Msg_Header(jpt_msg_header_struct_t * header);
{
/** In-class Identifier */
OPJ_UINT32 Id;
/** Last byte information */
OPJ_UINT32 last_byte;
/** Class Identifier */
OPJ_UINT32 Class_Id;
/** CSn : index identifier */
OPJ_UINT32 CSn_Id;
/** Message offset */
OPJ_UINT32 Msg_offset;
/** Message length */
OPJ_UINT32 Msg_length;
/** Auxiliary for JPP case */
OPJ_UINT32 Layer_nb;
} opj_jpt_msg_header_t;
/* ----------------------------------------------------------------------- */ /*
/**
Initialize the value of the message header structure
@param header Message header structure
*/
void jpt_init_msg_header(opj_jpt_msg_header_t * header);
/**
* Read the message header for a JPP/JPT - stream * Read the message header for a JPP/JPT - stream
* @param p_cio stream handle *
* @param header JPT Message header structure * header : Message header structure
* @param p_manager user event manager to display nice messages. *
*/ */
bool jpt_read_msg_header( void jpt_read_Msg_Header(jpt_msg_header_struct_t * header);
struct opj_stream_private * p_cio,
opj_jpt_msg_header_t * p_header,
OPJ_UINT32 * p_nb_bytes_read,
struct opj_event_mgr * p_manager);
#endif

264
libopenjpeg/mct.c
View File

@@ -1,11 +1,5 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -32,49 +26,31 @@
#include "mct.h" #include "mct.h"
#include "fix.h" #include "fix.h"
#include "opj_malloc.h"
/* <summary> */ /* <summary> */
/* This table contains the norms of the basis function of the reversible MCT. */ /* This table contains the norms of the basis function of the reversible MCT. */
/* </summary> */ /* </summary> */
static const OPJ_FLOAT64 mct_norms[3] = { 1.732, .8292, .8292 }; double mct_norms[3] = { 1.732, .8292, .8292 };
/* <summary> */ /* <summary> */
/* This table contains the norms of the basis function of the irreversible MCT. */ /* This table contains the norms of the basis function of the irreversible MCT. */
/* </summary> */ /* </summary> */
static const OPJ_FLOAT64 mct_norms_real[3] = { 1.732, 1.805, 1.573 }; double mct_norms_real[3] = { 1.732, 1.805, 1.573 };
const OPJ_FLOAT64 * get_mct_norms ()
{
return mct_norms;
}
const OPJ_FLOAT64 * get_mct_norms_real ()
{
return mct_norms_real;
}
/* <summary> */ /* <summary> */
/* Foward reversible MCT. */ /* Foward reversible MCT. */
/* </summary> */ /* </summary> */
void mct_encode( void mct_encode(int *c0, int *c1, int *c2, int n)
OPJ_INT32* restrict c0,
OPJ_INT32* restrict c1,
OPJ_INT32* restrict c2,
OPJ_UINT32 n)
{ {
OPJ_UINT32 i; int i;
for(i = 0; i < n; ++i) { for (i = 0; i < n; i++) {
OPJ_INT32 r = c0[i]; int r, g, b, y, u, v;
OPJ_INT32 g = c1[i]; r = c0[i];
OPJ_INT32 b = c2[i]; g = c1[i];
OPJ_INT32 y = (r + (g * 2) + b) >> 2; b = c2[i];
OPJ_INT32 u = b - g; y = (r + (g << 1) + b) >> 2;
OPJ_INT32 v = r - g; u = b - g;
v = r - g;
c0[i] = y; c0[i] = y;
c1[i] = u; c1[i] = u;
c2[i] = v; c2[i] = v;
@@ -84,20 +60,17 @@ void mct_encode(
/* <summary> */ /* <summary> */
/* Inverse reversible MCT. */ /* Inverse reversible MCT. */
/* </summary> */ /* </summary> */
void mct_decode( void mct_decode(int *c0, int *c1, int *c2, int n)
OPJ_INT32* restrict c0,
OPJ_INT32* restrict c1,
OPJ_INT32* restrict c2,
OPJ_UINT32 n)
{ {
OPJ_UINT32 i; int i;
for (i = 0; i < n; ++i) { for (i = 0; i < n; i++) {
OPJ_INT32 y = c0[i]; int y, u, v, r, g, b;
OPJ_INT32 u = c1[i]; y = c0[i];
OPJ_INT32 v = c2[i]; u = c1[i];
OPJ_INT32 g = y - ((u + v) >> 2); v = c2[i];
OPJ_INT32 r = v + g; g = y - ((u + v) >> 2);
OPJ_INT32 b = u + g; r = v + g;
b = u + g;
c0[i] = r; c0[i] = r;
c1[i] = g; c1[i] = g;
c2[i] = b; c2[i] = b;
@@ -107,27 +80,25 @@ void mct_decode(
/* <summary> */ /* <summary> */
/* Get norm of basis function of reversible MCT. */ /* Get norm of basis function of reversible MCT. */
/* </summary> */ /* </summary> */
OPJ_FLOAT64 mct_getnorm(OPJ_UINT32 compno) { double mct_getnorm(int compno)
{
return mct_norms[compno]; return mct_norms[compno];
} }
/* <summary> */ /* <summary> */
/* Foward irreversible MCT. */ /* Foward irreversible MCT. */
/* </summary> */ /* </summary> */
void mct_encode_real( void mct_encode_real(int *c0, int *c1, int *c2, int n)
OPJ_INT32* restrict c0,
OPJ_INT32* restrict c1,
OPJ_INT32* restrict c2,
OPJ_UINT32 n)
{ {
OPJ_UINT32 i; int i;
for(i = 0; i < n; ++i) { for (i = 0; i < n; i++) {
OPJ_INT32 r = c0[i]; int r, g, b, y, u, v;
OPJ_INT32 g = c1[i]; r = c0[i];
OPJ_INT32 b = c2[i]; g = c1[i];
OPJ_INT32 y = fix_mul(r, 2449) + fix_mul(g, 4809) + fix_mul(b, 934); b = c2[i];
OPJ_INT32 u = -fix_mul(r, 1382) - fix_mul(g, 2714) + fix_mul(b, 4096); y = fix_mul(r, 2449) + fix_mul(g, 4809) + fix_mul(b, 934);
OPJ_INT32 v = fix_mul(r, 4096) - fix_mul(g, 3430) - fix_mul(b, 666); u = -fix_mul(r, 1382) - fix_mul(g, 2714) + fix_mul(b, 4096);
v = fix_mul(r, 4096) - fix_mul(g, 3430) - fix_mul(b, 666);
c0[i] = y; c0[i] = y;
c1[i] = u; c1[i] = u;
c2[i] = v; c2[i] = v;
@@ -137,20 +108,17 @@ void mct_encode_real(
/* <summary> */ /* <summary> */
/* Inverse irreversible MCT. */ /* Inverse irreversible MCT. */
/* </summary> */ /* </summary> */
void mct_decode_real( void mct_decode_real(int *c0, int *c1, int *c2, int n)
OPJ_FLOAT32* restrict c0,
OPJ_FLOAT32* restrict c1,
OPJ_FLOAT32* restrict c2,
OPJ_UINT32 n)
{ {
OPJ_UINT32 i; int i;
for(i = 0; i < n; ++i) { for (i = 0; i < n; i++) {
OPJ_FLOAT32 y = c0[i]; int y, u, v, r, g, b;
OPJ_FLOAT32 u = c1[i]; y = c0[i];
OPJ_FLOAT32 v = c2[i]; u = c1[i];
OPJ_FLOAT32 r = y + (v * 1.402f); v = c2[i];
OPJ_FLOAT32 g = y - (u * 0.34413f) - (v * (0.71414f)); r = y + fix_mul(v, 11485);
OPJ_FLOAT32 b = y + (u * 1.772f); g = y - fix_mul(u, 2819) - fix_mul(v, 5850);
b = y + fix_mul(u, 14516);
c0[i] = r; c0[i] = r;
c1[i] = g; c1[i] = g;
c2[i] = b; c2[i] = b;
@@ -160,145 +128,7 @@ void mct_decode_real(
/* <summary> */ /* <summary> */
/* Get norm of basis function of irreversible MCT. */ /* Get norm of basis function of irreversible MCT. */
/* </summary> */ /* </summary> */
OPJ_FLOAT64 mct_getnorm_real(OPJ_UINT32 compno) { double mct_getnorm_real(int compno)
{
return mct_norms_real[compno]; return mct_norms_real[compno];
} }
bool mct_encode_custom(
// MCT data
OPJ_BYTE * pCodingdata,
// size of components
OPJ_UINT32 n,
// components
OPJ_BYTE ** pData,
// nb of components (i.e. size of pData)
OPJ_UINT32 pNbComp,
// tells if the data is signed
OPJ_UINT32 isSigned)
{
OPJ_FLOAT32 * lMct = (OPJ_FLOAT32 *) pCodingdata;
OPJ_UINT32 i;
OPJ_UINT32 j;
OPJ_UINT32 k;
OPJ_UINT32 lNbMatCoeff = pNbComp * pNbComp;
OPJ_INT32 * lCurrentData = 00;
OPJ_INT32 * lCurrentMatrix = 00;
OPJ_INT32 ** lData = (OPJ_INT32 **) pData;
OPJ_UINT32 lMultiplicator = 1 << 13;
OPJ_INT32 * lMctPtr;
lCurrentData = (OPJ_INT32 *) opj_malloc((pNbComp + lNbMatCoeff) * sizeof(OPJ_INT32));
if
(! lCurrentData)
{
return false;
}
lCurrentMatrix = lCurrentData + pNbComp;
for
(i =0;i<lNbMatCoeff;++i)
{
lCurrentMatrix[i] = (OPJ_INT32) (*(lMct++) * lMultiplicator);
}
for
(i = 0; i < n; ++i)
{
lMctPtr = lCurrentMatrix;
for
(j=0;j<pNbComp;++j)
{
lCurrentData[j] = (*(lData[j]));
}
for
(j=0;j<pNbComp;++j)
{
*(lData[j]) = 0;
for
(k=0;k<pNbComp;++k)
{
*(lData[j]) += fix_mul(*lMctPtr, lCurrentData[k]);
++lMctPtr;
}
++lData[j];
}
}
opj_free(lCurrentData);
return true;
}
bool mct_decode_custom(
// MCT data
OPJ_BYTE * pDecodingData,
// size of components
OPJ_UINT32 n,
// components
OPJ_BYTE ** pData,
// nb of components (i.e. size of pData)
OPJ_UINT32 pNbComp,
// tells if the data is signed
OPJ_UINT32 isSigned)
{
OPJ_FLOAT32 * lMct;
OPJ_UINT32 i;
OPJ_UINT32 j;
OPJ_UINT32 k;
OPJ_FLOAT32 * lCurrentData = 00;
OPJ_FLOAT32 * lCurrentResult = 00;
OPJ_FLOAT32 ** lData = (OPJ_FLOAT32 **) pData;
lCurrentData = (OPJ_FLOAT32 *) opj_malloc (2 * pNbComp * sizeof(OPJ_FLOAT32));
if
(! lCurrentData)
{
return false;
}
lCurrentResult = lCurrentData + pNbComp;
for
(i = 0; i < n; ++i)
{
lMct = (OPJ_FLOAT32 *) pDecodingData;
for
(j=0;j<pNbComp;++j)
{
lCurrentData[j] = (OPJ_FLOAT32) (*(lData[j]));
}
for
(j=0;j<pNbComp;++j)
{
lCurrentResult[j] = 0;
for
(k=0;k<pNbComp;++k)
{
lCurrentResult[j] += *(lMct++) * lCurrentData[k];
}
*(lData[j]++) = (OPJ_FLOAT32) (lCurrentResult[j]);
}
}
opj_free(lCurrentData);
return true;
}
void opj_calculate_norms(OPJ_FLOAT64 * pNorms,OPJ_UINT32 pNbComps,OPJ_FLOAT32 * pMatrix)
{
OPJ_UINT32 i,j,lIndex;
OPJ_FLOAT32 lCurrentValue;
OPJ_FLOAT64 * lNorms = (OPJ_FLOAT64 *) pNorms;
OPJ_FLOAT32 * lMatrix = (OPJ_FLOAT32 *) pMatrix;
for
(i=0;i<pNbComps;++i)
{
lNorms[i] = 0;
lIndex = i;
for
(j=0;j<pNbComps;++j)
{
lCurrentValue = lMatrix[lIndex];
lIndex += pNbComps;
lNorms[i] += lCurrentValue * lCurrentValue;
}
lNorms[i] = sqrt(lNorms[i]);
}
}

134
libopenjpeg/mct.h
View File

@@ -1,11 +1,5 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -32,99 +26,49 @@
#ifndef __MCT_H #ifndef __MCT_H
#define __MCT_H #define __MCT_H
/**
@file mct.h
@brief Implementation of a multi-component transforms (MCT)
The functions in MCT.C have for goal to realize reversible and irreversible multicomponent /*
transform. The functions in MCT.C are used by some function in TCD.C. * Apply a reversible multi-component transform to an image
* R: samples for red component
* G: samples for green component
* B: samples blue component
* n: number of samples for each component
*/ */
#include "openjpeg.h" void mct_encode(int *R, int *G, int *B, int n);
/** @defgroup MCT MCT - Implementation of a multi-component transform */ /*
/*@{*/ * Apply a reversible multi-component inverse transform to an image
* Y: samples for luminance component
/** @name Exported functions */ * U: samples for red chrominance component
/*@{*/ * V: samples for blue chrominance component
/* ----------------------------------------------------------------------- */ * n: number of samples for each component
/**
Apply a reversible multi-component transform to an image
@param c0 Samples for red component
@param c1 Samples for green component
@param c2 Samples blue component
@param n Number of samples for each component
*/ */
void mct_encode(OPJ_INT32 *c0, OPJ_INT32 *c1, OPJ_INT32 *c2, OPJ_UINT32 n); void mct_decode(int *V, int *U, int *Y, int n);
/** /*
Apply a reversible multi-component inverse transform to an image * Get norm of the basis function used for the reversible multi-component transform
@param c0 Samples for luminance component * compno: number of the component (0->Y, 1->U, 2->V)
@param c1 Samples for red chrominance component
@param c2 Samples for blue chrominance component
@param n Number of samples for each component
*/ */
void mct_decode(OPJ_INT32 *c0, OPJ_INT32 *c1, OPJ_INT32 *c2, OPJ_UINT32 n); double mct_getnorm(int compno);
/**
Get norm of the basis function used for the reversible multi-component transform /*
@param compno Number of the component (0->Y, 1->U, 2->V) * Apply an irreversible multi-component transform to an image
@return * R: samples for red component
* G: samples for green component
* B: samples blue component
* n: number of samples for each component
*/ */
OPJ_FLOAT64 mct_getnorm(OPJ_UINT32 compno); void mct_encode_real(int *c0, int *c1, int *c2, int n);
/*
/** * Apply an irreversible multi-component inverse transform to an image
Apply an irreversible multi-component transform to an image * Y: samples for luminance component
@param c0 Samples for red component * U: samples for red chrominance component
@param c1 Samples for green component * V: samples for blue chrominance component
@param c2 Samples blue component * n: number of samples for each component
@param n Number of samples for each component
*/ */
void mct_encode_real(OPJ_INT32 *c0, OPJ_INT32 *c1, OPJ_INT32 *c2, OPJ_UINT32 n); void mct_decode_real(int *c0, int *c1, int *c2, int n);
/** /*
Apply an irreversible multi-component inverse transform to an image * Get norm of the basis function used for the irreversible multi-component transform
@param c0 Samples for luminance component * compno: number of the component (0->Y, 1->U, 2->V)
@param c1 Samples for red chrominance component
@param c2 Samples for blue chrominance component
@param n Number of samples for each component
*/ */
void mct_decode_real(OPJ_FLOAT32* c0, OPJ_FLOAT32* c1, OPJ_FLOAT32* c2, OPJ_UINT32 n); double mct_getnorm_real(int compno);
/**
Get norm of the basis function used for the irreversible multi-component transform
@param compno Number of the component (0->Y, 1->U, 2->V)
@return
*/
OPJ_FLOAT64 mct_getnorm_real(OPJ_UINT32 compno);
bool mct_encode_custom( #endif
// MCT data
OPJ_BYTE * p_coding_data,
// size of components
OPJ_UINT32 n,
// components
OPJ_BYTE ** p_data,
// nb of components (i.e. size of p_data)
OPJ_UINT32 p_nb_comp,
// tells if the data is signed
OPJ_UINT32 is_signed);
bool mct_decode_custom(
// MCT data
OPJ_BYTE * pDecodingData,
// size of components
OPJ_UINT32 n,
// components
OPJ_BYTE ** pData,
// nb of components (i.e. size of pData)
OPJ_UINT32 pNbComp,
// tells if the data is signed
OPJ_UINT32 isSigned);
void opj_calculate_norms(OPJ_FLOAT64 * pNorms,OPJ_UINT32 p_nb_comps,OPJ_FLOAT32 * pMatrix);
const OPJ_FLOAT64 * get_mct_norms ();
const OPJ_FLOAT64 * get_mct_norms_real ();
/* ----------------------------------------------------------------------- */
/*@}*/
/*@}*/
#endif /* __MCT_H */

743
libopenjpeg/mqc.c
View File

@@ -1,11 +1,7 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren * Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -31,72 +27,22 @@
*/ */
#include "mqc.h" #include "mqc.h"
#include "t1.h" #include <stdio.h>
#include "opj_malloc.h"
/** @defgroup MQC MQC - Implementation of an MQ-Coder */ /* <summary> */
/*@{*/ /* This struct defines the state of a context. */
/* </summary> */
/** @name Local static functions */ typedef struct mqc_state_s {
/*@{*/ unsigned int qeval; /* the probability of the Least Probable Symbol (0.75->0x8000, 1.5->0xffff) */
int mps; /* the Most Probable Symbol (0 or 1) */
/** struct mqc_state_s *nmps; /* next state if the next encoded symbol is the MPS */
Output a byte, doing bit-stuffing if necessary. struct mqc_state_s *nlps; /* next state if the next encoded symbol is the LPS */
After a 0xff byte, the next byte must be smaller than 0x90. } mqc_state_t;
@param mqc MQC handle
*/
static void mqc_byteout(opj_mqc_t *mqc);
/**
Renormalize mqc->a and mqc->c while encoding, so that mqc->a stays between 0x8000 and 0x10000
@param mqc MQC handle
*/
static void mqc_renorme(opj_mqc_t *mqc);
/**
Encode the most probable symbol
@param mqc MQC handle
*/
static void mqc_codemps(opj_mqc_t *mqc);
/**
Encode the most least symbol
@param mqc MQC handle
*/
static void mqc_codelps(opj_mqc_t *mqc);
/**
Fill mqc->c with 1's for flushing
@param mqc MQC handle
*/
static void mqc_setbits(opj_mqc_t *mqc);
/**
FIXME: documentation ???
@param mqc MQC handle
@return
*/
static OPJ_INT32 mqc_mpsexchange(opj_mqc_t *mqc);
/**
FIXME: documentation ???
@param mqc MQC handle
@return
*/
static OPJ_INT32 mqc_lpsexchange(opj_mqc_t *mqc);
/**
Input a byte
@param mqc MQC handle
*/
static void mqc_bytein(opj_mqc_t *mqc);
/**
Renormalize mqc->a and mqc->c while decoding
@param mqc MQC handle
*/
static void mqc_renormd(opj_mqc_t *mqc);
/*@}*/
/*@}*/
/* <summary> */ /* <summary> */
/* This array defines all the possible states for a context. */ /* This array defines all the possible states for a context. */
/* </summary> */ /* </summary> */
static opj_mqc_state_t mqc_states[47 * 2] = { mqc_state_t mqc_states[47 * 2] = {
{0x5601, 0, &mqc_states[2], &mqc_states[3]}, {0x5601, 0, &mqc_states[2], &mqc_states[3]},
{0x5601, 1, &mqc_states[3], &mqc_states[2]}, {0x5601, 1, &mqc_states[3], &mqc_states[2]},
{0x3401, 0, &mqc_states[4], &mqc_states[12]}, {0x3401, 0, &mqc_states[4], &mqc_states[12]},
@@ -193,352 +139,453 @@ static opj_mqc_state_t mqc_states[47 * 2] = {
{0x5601, 1, &mqc_states[93], &mqc_states[93]}, {0x5601, 1, &mqc_states[93], &mqc_states[93]},
}; };
/* #define MQC_NUMCTXS 32
==========================================================
local functions
==========================================================
*/
static void mqc_byteout(opj_mqc_t *mqc) { unsigned int mqc_c;
if (*mqc->bp == 0xff) { unsigned int mqc_a;
mqc->bp++; unsigned int mqc_ct;
*mqc->bp = mqc->c >> 20; unsigned char *mqc_bp;
mqc->c &= 0xfffff; unsigned char *mqc_start;
mqc->ct = 7; unsigned char *mqc_end;
} else { mqc_state_t *mqc_ctxs[MQC_NUMCTXS];
if ((mqc->c & 0x8000000) == 0) { /* ((mqc->c&0x8000000)==0) CHANGE */ mqc_state_t **mqc_curctx;
mqc->bp++;
*mqc->bp = mqc->c >> 19;
mqc->c &= 0x7ffff;
mqc->ct = 8;
} else {
(*mqc->bp)++;
if (*mqc->bp == 0xff) {
mqc->c &= 0x7ffffff;
mqc->bp++;
*mqc->bp = mqc->c >> 20;
mqc->c &= 0xfffff;
mqc->ct = 7;
} else {
mqc->bp++;
*mqc->bp = mqc->c >> 19;
mqc->c &= 0x7ffff;
mqc->ct = 8;
}
}
}
}
static void mqc_renorme(opj_mqc_t *mqc) { /* <summary> */
do { /* Return the number of bytes already encoded. */
mqc->a <<= 1; /* </summary> */
mqc->c <<= 1; int mqc_numbytes()
mqc->ct--;
if (mqc->ct == 0) {
mqc_byteout(mqc);
}
} while ((mqc->a & 0x8000) == 0);
}
static void mqc_codemps(opj_mqc_t *mqc) {
mqc->a -= (*mqc->curctx)->qeval;
if ((mqc->a & 0x8000) == 0) {
if (mqc->a < (*mqc->curctx)->qeval) {
mqc->a = (*mqc->curctx)->qeval;
} else {
mqc->c += (*mqc->curctx)->qeval;
}
*mqc->curctx = (*mqc->curctx)->nmps;
mqc_renorme(mqc);
} else {
mqc->c += (*mqc->curctx)->qeval;
}
}
static void mqc_codelps(opj_mqc_t *mqc) {
mqc->a -= (*mqc->curctx)->qeval;
if (mqc->a < (*mqc->curctx)->qeval) {
mqc->c += (*mqc->curctx)->qeval;
} else {
mqc->a = (*mqc->curctx)->qeval;
}
*mqc->curctx = (*mqc->curctx)->nlps;
mqc_renorme(mqc);
}
static void mqc_setbits(opj_mqc_t *mqc) {
OPJ_UINT32 tempc = mqc->c + mqc->a;
mqc->c |= 0xffff;
if (mqc->c >= tempc) {
mqc->c -= 0x8000;
}
}
static OPJ_INT32 mqc_mpsexchange(opj_mqc_t *mqc) {
OPJ_INT32 d;
if (mqc->a < (*mqc->curctx)->qeval) {
d = 1 - (*mqc->curctx)->mps;
*mqc->curctx = (*mqc->curctx)->nlps;
} else {
d = (*mqc->curctx)->mps;
*mqc->curctx = (*mqc->curctx)->nmps;
}
return d;
}
static OPJ_INT32 mqc_lpsexchange(opj_mqc_t *mqc) {
OPJ_INT32 d;
if (mqc->a < (*mqc->curctx)->qeval) {
mqc->a = (*mqc->curctx)->qeval;
d = (*mqc->curctx)->mps;
*mqc->curctx = (*mqc->curctx)->nmps;
} else {
mqc->a = (*mqc->curctx)->qeval;
d = 1 - (*mqc->curctx)->mps;
*mqc->curctx = (*mqc->curctx)->nlps;
}
return d;
}
static void mqc_bytein(opj_mqc_t *mqc) {
if (mqc->bp != mqc->end) {
OPJ_UINT32 c;
if (mqc->bp + 1 != mqc->end) {
c = *(mqc->bp + 1);
} else {
c = 0xff;
}
if (*mqc->bp == 0xff) {
if (c > 0x8f) {
mqc->c += 0xff00;
mqc->ct = 8;
} else {
mqc->bp++;
mqc->c += c << 9;
mqc->ct = 7;
}
} else {
mqc->bp++;
mqc->c += c << 8;
mqc->ct = 8;
}
} else {
mqc->c += 0xff00;
mqc->ct = 8;
}
}
static void mqc_renormd(opj_mqc_t *mqc) {
do {
if (mqc->ct == 0) {
mqc_bytein(mqc);
}
mqc->a <<= 1;
mqc->c <<= 1;
mqc->ct--;
} while (mqc->a < 0x8000);
}
/*
==========================================================
MQ-Coder interface
==========================================================
*/
opj_mqc_t* mqc_create(void) {
opj_mqc_t *mqc = (opj_mqc_t*)opj_malloc(sizeof(opj_mqc_t));
return mqc;
}
void mqc_destroy(opj_mqc_t *mqc) {
if
(mqc)
{ {
opj_free(mqc); return mqc_bp - mqc_start;
}
} }
OPJ_UINT32 mqc_numbytes(opj_mqc_t *mqc) { /* <summary> */
return mqc->bp - mqc->start; /* Output a byte, doing bit-stuffing if necessary. */
} /* After a 0xff byte, the next byte must be smaller than 0x90 */
/* </summary> */
void mqc_init_enc(opj_mqc_t *mqc, OPJ_BYTE *bp) { void mqc_byteout()
mqc_setcurctx(mqc, 0); {
mqc->a = 0x8000; if (*mqc_bp == 0xff) {
mqc->c = 0; mqc_bp++;
mqc->bp = bp - 1; *mqc_bp = mqc_c >> 20;
*(mqc->bp) = 0; mqc_c &= 0xfffff;
mqc->ct = 12; mqc_ct = 7;
/*if (*mqc->bp == 0xff) {
mqc->ct = 13;
}*/
mqc->start = bp;
}
void mqc_encode(opj_mqc_t *mqc, OPJ_UINT32 d) {
if ((*mqc->curctx)->mps == d) {
mqc_codemps(mqc);
} else { } else {
mqc_codelps(mqc); if ((mqc_c & 0x8000000) == 0) { /* ((mqc_c&0x8000000)==0) CHANGE */
mqc_bp++;
*mqc_bp = mqc_c >> 19;
mqc_c &= 0x7ffff;
mqc_ct = 8;
} else {
(*mqc_bp)++;
if (*mqc_bp == 0xff) {
mqc_c &= 0x7ffffff;
mqc_bp++;
*mqc_bp = mqc_c >> 20;
mqc_c &= 0xfffff;
mqc_ct = 7;
} else {
mqc_bp++;
*mqc_bp = mqc_c >> 19;
mqc_c &= 0x7ffff;
mqc_ct = 8;
}
}
} }
} }
void mqc_flush(opj_mqc_t *mqc) { /* <summary> */
mqc_setbits(mqc); /* Renormalize mqc_a and mqc_c while encoding, so that mqc_a stays between 0x8000 and 0x10000 */
mqc->c <<= mqc->ct; /* </summary> */
mqc_byteout(mqc); void mqc_renorme()
mqc->c <<= mqc->ct; {
mqc_byteout(mqc); do {
mqc_a <<= 1;
mqc_c <<= 1;
mqc_ct--;
if (mqc_ct == 0) {
mqc_byteout();
}
} while ((mqc_a & 0x8000) == 0);
}
if (*mqc->bp != 0xff) { /* <summary> */
mqc->bp++; /* Encode the most probable symbol. */
/* </summary> */
void mqc_codemps()
{
mqc_a -= (*mqc_curctx)->qeval;
if ((mqc_a & 0x8000) == 0) {
if (mqc_a < (*mqc_curctx)->qeval) {
mqc_a = (*mqc_curctx)->qeval;
} else {
mqc_c += (*mqc_curctx)->qeval;
}
*mqc_curctx = (*mqc_curctx)->nmps;
mqc_renorme();
} else {
mqc_c += (*mqc_curctx)->qeval;
} }
} }
void mqc_bypass_init_enc(opj_mqc_t *mqc) { /* <summary> */
mqc->c = 0; /* Encode the most least symbol. */
mqc->ct = 8; /* </summary> */
/*if (*mqc->bp == 0xff) { void mqc_codelps()
mqc->ct = 7; {
mqc_a -= (*mqc_curctx)->qeval;
if (mqc_a < (*mqc_curctx)->qeval) {
mqc_c += (*mqc_curctx)->qeval;
} else {
mqc_a = (*mqc_curctx)->qeval;
}
*mqc_curctx = (*mqc_curctx)->nlps;
mqc_renorme();
}
/* <summary> */
/* Initialize encoder. */
/* </summary> */
/* <param name="bp">Output buffer.</param> */
void mqc_init_enc(unsigned char *bp)
{
mqc_setcurctx(0);
mqc_a = 0x8000;
mqc_c = 0;
mqc_bp = bp - 1;
mqc_ct = 12;
if (*mqc_bp == 0xff) {
mqc_ct = 13;
}
mqc_start = bp;
}
/* <summary> */
/* Set current context. */
/* </summary> */
/* <param name="ctxno">Context number.</param> */
void mqc_setcurctx(int ctxno)
{
mqc_curctx = &mqc_ctxs[ctxno];
}
/* <summary> */
/* Encode a symbol using the MQ-coder. */
/* </summary> */
/* <param name="d"> The symbol to be encoded (0 or 1).</param> */
void mqc_encode(int d)
{
if ((*mqc_curctx)->mps == d) {
mqc_codemps();
} else {
mqc_codelps();
}
}
/* <summary> */
/* Fill mqc_c with 1's for flushing */
/* </summary> */
void mqc_setbits()
{
unsigned int tempc = mqc_c + mqc_a;
mqc_c |= 0xffff;
if (mqc_c >= tempc) {
mqc_c -= 0x8000;
}
}
/* <summary> */
/* Flush encoded data. */
/* </summary> */
void mqc_flush()
{
mqc_setbits();
mqc_c <<= mqc_ct;
mqc_byteout();
mqc_c <<= mqc_ct;
mqc_byteout();
if (*mqc_bp != 0xff) {
mqc_bp++;
}
}
/* <summary> */
/* not fully implemented and tested !! */
/* BYPASS mode switch, initialization operation */
/* JPEG 2000 p 505 */
/* </summary> */
void mqc_bypass_init_enc()
{
mqc_c = 0;
mqc_ct = 8;
/*if (*mqc_bp == 0xff) {
mqc_ct = 7;
} */ } */
} }
void mqc_bypass_enc(opj_mqc_t *mqc, OPJ_UINT32 d) { /* <summary> */
mqc->ct--; /* not fully implemented and tested !! */
mqc->c = mqc->c + (d << mqc->ct); /* BYPASS mode switch, coding operation */
if (mqc->ct == 0) { /* JPEG 2000 p 505 */
mqc->bp++; /* </summary> */
*mqc->bp = mqc->c; void mqc_bypass_enc(int d)
mqc->ct = 8; {
if (*mqc->bp == 0xff) { mqc_ct--;
mqc->ct = 7; mqc_c = mqc_c + (d << mqc_ct);
if (mqc_ct == 0) {
mqc_bp++;
*mqc_bp = mqc_c;
mqc_ct = 8;
if (*mqc_bp == 0xff) {
mqc_ct = 7;
} }
mqc->c = 0; mqc_c = 0;
} }
} }
OPJ_UINT32 mqc_bypass_flush_enc(opj_mqc_t *mqc) { /* <summary> */
OPJ_BYTE bit_padding; /* not fully implemented and tested !! */
/* BYPASS mode switch, flush operation */
/* </summary> */
int mqc_bypass_flush_enc()
{
unsigned char bit_padding;
bit_padding = 0; bit_padding = 0;
if (mqc->ct != 0) { if (mqc_ct != 0) {
while (mqc->ct > 0) { while (mqc_ct > 0) {
mqc->ct--; mqc_ct--;
mqc->c += bit_padding << mqc->ct; mqc_c += bit_padding << mqc_ct;
bit_padding = (bit_padding + 1) & 0x01; bit_padding = (bit_padding + 1) & 0x01;
} }
mqc->bp++; mqc_bp++;
*mqc->bp = mqc->c; *mqc_bp = mqc_c;
mqc->ct = 8; mqc_ct = 8;
mqc->c = 0; mqc_c = 0;
} }
return 1; return 1;
} }
void mqc_reset_enc(opj_mqc_t *mqc) { /* <summary> */
mqc_resetstates(mqc); /* RESET mode switch */
mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46); /* </summary> */
mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3); void mqc_reset_enc()
mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4); {
mqc_resetstates();
mqc_setstate(18, 0, 46);
mqc_setstate(0, 0, 3);
mqc_setstate(1, 0, 4);
} }
OPJ_UINT32 mqc_restart_enc(opj_mqc_t *mqc) { /* <summary> */
OPJ_UINT32 correction = 1; /* mode switch RESTART (TERMALL) */
/* </summary> */
int mqc_restart_enc()
{
int correction = 1;
/* <flush part> */ /* <flush part> */
OPJ_INT32 n = 27 - 15 - mqc->ct; int n = 27 - 15 - mqc_ct;
mqc->c <<= mqc->ct; mqc_c <<= mqc_ct;
while (n > 0) { while (n > 0) {
mqc_byteout(mqc); mqc_byteout();
n -= mqc->ct; n -= mqc_ct;
mqc->c <<= mqc->ct; mqc_c <<= mqc_ct;
} }
mqc_byteout(mqc); mqc_byteout();
return correction; return correction;
} }
void mqc_restart_init_enc(opj_mqc_t *mqc) { /* <summary> */
/* mode switch RESTART (TERMALL) reinitialisation */
/* </summary> */
void mqc_restart_init_enc()
{
/* <Re-init part> */ /* <Re-init part> */
mqc_setcurctx(mqc, 0); mqc_setcurctx(0);
mqc->a = 0x8000; mqc_a = 0x8000;
mqc->c = 0; mqc_c = 0;
mqc->ct = 12; mqc_ct = 12;
mqc->bp--; mqc_bp--;
if (*mqc->bp == 0xff) { if (*mqc_bp == 0xff) {
mqc->ct = 13; mqc_ct = 13;
} }
} }
void mqc_erterm_enc(opj_mqc_t *mqc) {
OPJ_INT32 k = 11 - mqc->ct + 1; /* <summary> */
/* ERTERM mode switch */
/* </summary> */
void mqc_erterm_enc()
{
int k = 11 - mqc_ct + 1;
while (k > 0) { while (k > 0) {
mqc->c <<= mqc->ct; mqc_c <<= mqc_ct;
mqc->ct = 0; mqc_ct = 0;
mqc_byteout(mqc); mqc_byteout();
k -= mqc->ct; k -= mqc_ct;
} }
if (*mqc->bp != 0xff) { if (*mqc_bp != 0xff) {
mqc_byteout(mqc); mqc_byteout();
} }
} }
void mqc_segmark_enc(opj_mqc_t *mqc) { /* <summary> */
OPJ_UINT32 i; /* SEGMARK mode switch (SEGSYM) */
mqc_setcurctx(mqc, 18); /* </summary> */
void mqc_segmark_enc()
{
int i;
mqc_setcurctx(18);
for (i = 1; i < 5; i++) { for (i = 1; i < 5; i++) {
mqc_encode(mqc, i % 2); mqc_encode(i % 2);
} }
} }
void mqc_init_dec(opj_mqc_t *mqc, OPJ_BYTE *bp, OPJ_UINT32 len) { /* <summary> */
mqc_setcurctx(mqc, 0); /* </summary> */
mqc->start = bp; int mqc_mpsexchange()
mqc->end = bp + len; {
mqc->bp = bp; int d;
if (len==0) mqc->c = 0xff << 16; if (mqc_a < (*mqc_curctx)->qeval) {
else mqc->c = *mqc->bp << 16; d = 1 - (*mqc_curctx)->mps;
mqc_bytein(mqc); *mqc_curctx = (*mqc_curctx)->nlps;
mqc->c <<= 7;
mqc->ct -= 7;
mqc->a = 0x8000;
}
OPJ_UINT32 mqc_decode(opj_mqc_t *mqc) {
OPJ_INT32 d;
mqc->a -= (*mqc->curctx)->qeval;
if ((mqc->c >> 16) < (*mqc->curctx)->qeval) {
d = mqc_lpsexchange(mqc);
mqc_renormd(mqc);
} else { } else {
mqc->c -= (*mqc->curctx)->qeval << 16; d = (*mqc_curctx)->mps;
if ((mqc->a & 0x8000) == 0) { *mqc_curctx = (*mqc_curctx)->nmps;
d = mqc_mpsexchange(mqc); }
mqc_renormd(mqc); return d;
}
/* <summary> */
/* </summary> */
int mqc_lpsexchange()
{
int d;
if (mqc_a < (*mqc_curctx)->qeval) {
mqc_a = (*mqc_curctx)->qeval;
d = (*mqc_curctx)->mps;
*mqc_curctx = (*mqc_curctx)->nmps;
} else { } else {
d = (*mqc->curctx)->mps; mqc_a = (*mqc_curctx)->qeval;
d = 1 - (*mqc_curctx)->mps;
*mqc_curctx = (*mqc_curctx)->nlps;
}
return d;
}
/* <summary> */
/* Input a byte. */
/* </summary> */
void mqc_bytein()
{
if (mqc_bp != mqc_end) {
unsigned int c;
if (mqc_bp + 1 != mqc_end) {
c = *(mqc_bp + 1);
} else {
c = 0xff;
}
if (*mqc_bp == 0xff) {
if (c > 0x8f) {
mqc_c += 0xff00;
mqc_ct = 8;
} else {
mqc_bp++;
mqc_c += c << 9;
mqc_ct = 7;
}
} else {
mqc_bp++;
mqc_c += c << 8;
mqc_ct = 8;
}
} else {
mqc_c += 0xff00;
mqc_ct = 8;
} }
} }
return (OPJ_UINT32)d; /* <summary> */
/* Renormalize mqc_a and mqc_c while decoding. */
/* </summary> */
void mqc_renormd()
{
do {
if (mqc_ct == 0) {
mqc_bytein();
}
mqc_a <<= 1;
mqc_c <<= 1;
mqc_ct--;
} while (mqc_a < 0x8000);
} }
void mqc_resetstates(opj_mqc_t *mqc) { /* <summary> */
OPJ_UINT32 i; /* Initialize decoder. */
/* </summary> */
void mqc_init_dec(unsigned char *bp, int len)
{
mqc_setcurctx(0);
mqc_start = bp;
mqc_end = bp + len;
mqc_bp = bp;
/*add antonin initbug1*/
if (len==0) mqc_c = 0xff << 16;
else mqc_c = *mqc_bp << 16;
/*dda*/
mqc_bytein();
mqc_c <<= 7;
mqc_ct -= 7;
mqc_a = 0x8000;
}
/* <summary> */
/* Decode a symbol. */
/* </summary> */
int mqc_decode()
{
int d;
mqc_a -= (*mqc_curctx)->qeval;
if ((mqc_c >> 16) < (*mqc_curctx)->qeval) {
d = mqc_lpsexchange();
mqc_renormd();
} else {
mqc_c -= (*mqc_curctx)->qeval << 16;
if ((mqc_a & 0x8000) == 0) {
d = mqc_mpsexchange();
mqc_renormd();
} else {
d = (*mqc_curctx)->mps;
}
}
return d;
}
/* <summary> */
/* Reset states of all contexts. */
/* </summary> */
void mqc_resetstates()
{
int i;
for (i = 0; i < MQC_NUMCTXS; i++) { for (i = 0; i < MQC_NUMCTXS; i++) {
mqc->ctxs[i] = mqc_states; mqc_ctxs[i] = mqc_states;
} }
} }
void mqc_setstate(opj_mqc_t *mqc, OPJ_UINT32 ctxno, OPJ_UINT32 msb, OPJ_INT32 prob) { /* <summary> */
mqc->ctxs[ctxno] = &mqc_states[msb + (prob << 1)]; /* Set the state for a context. */
/* </summary> */
/* <param name="ctxno">Context number</param> */
/* <param name="msb">Most significant bit</param> */
/* <param name="prob">Index to the probability of symbols</param> */
void mqc_setstate(int ctxno, int msb, int prob)
{
mqc_ctxs[ctxno] = &mqc_states[msb + (prob << 1)];
} }

247
libopenjpeg/mqc.h
View File

@@ -1,11 +1,7 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren * Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -32,167 +28,100 @@
#ifndef __MQC_H #ifndef __MQC_H
#define __MQC_H #define __MQC_H
/**
@file mqc.h
@brief Implementation of an MQ-Coder (MQC)
The functions in MQC.C have for goal to realize the MQ-coder operations. The functions /*
in MQC.C are used by some function in T1.C. * Return the number of bytes written/read since initialisation
*/ */
#include "openjpeg.h" int mqc_numbytes();
/** @defgroup MQC MQC - Implementation of an MQ-Coder */
/*@{*/
/** /*
This struct defines the state of a context. * Reset the states of all the context of the coder/decoder
* (each context is set to a state where 0 and 1 are more or less equiprobable)
*/ */
typedef struct opj_mqc_state { void mqc_resetstates();
/** the probability of the Least Probable Symbol (0.75->0x8000, 1.5->0xffff) */
OPJ_UINT32 qeval;
/** the Most Probable Symbol (0 or 1) */
OPJ_INT32 mps;
/** next state if the next encoded symbol is the MPS */
struct opj_mqc_state *nmps;
/** next state if the next encoded symbol is the LPS */
struct opj_mqc_state *nlps;
} opj_mqc_state_t;
#define MQC_NUMCTXS 32 /*
* Set the state of a particular context
* ctxno: number that identifies the context
* msb: the MSB of the new state of the context
* prob: number that identifies the probability of the symbols for the new state of the context
*/
void mqc_setstate(int ctxno, int msb, int prob);
/** /*
MQ coder * Initialize the encoder
* bp: pointer to the start of the buffer where the bytes will be written
*/ */
typedef struct opj_mqc { void mqc_init_enc(unsigned char *bp);
OPJ_UINT32 c;
OPJ_UINT32 a;
OPJ_UINT32 ct;
OPJ_BYTE *bp;
OPJ_BYTE *start;
OPJ_BYTE *end;
opj_mqc_state_t *ctxs[MQC_NUMCTXS];
opj_mqc_state_t **curctx;
} opj_mqc_t;
/** @name Exported functions */ /*
/*@{*/ * Set the current context used for coding/decoding
/* ----------------------------------------------------------------------- */ * ctxno: number that identifies the context
/**
Create a new MQC handle
@return Returns a new MQC handle if successful, returns NULL otherwise
*/ */
opj_mqc_t* mqc_create(void); void mqc_setcurctx(int ctxno);
/**
Destroy a previously created MQC handle
@param mqc MQC handle to destroy
*/
void mqc_destroy(opj_mqc_t *mqc);
/**
Return the number of bytes written/read since initialisation
@param mqc MQC handle
@return Returns the number of bytes already encoded
*/
OPJ_UINT32 mqc_numbytes(opj_mqc_t *mqc);
/**
Reset the states of all the context of the coder/decoder
(each context is set to a state where 0 and 1 are more or less equiprobable)
@param mqc MQC handle
*/
void mqc_resetstates(opj_mqc_t *mqc);
/**
Set the state of a particular context
@param mqc MQC handle
@param ctxno Number that identifies the context
@param msb The MSB of the new state of the context
@param prob Number that identifies the probability of the symbols for the new state of the context
*/
void mqc_setstate(opj_mqc_t *mqc, OPJ_UINT32 ctxno, OPJ_UINT32 msb, OPJ_INT32 prob);
/**
Initialize the encoder
@param mqc MQC handle
@param bp Pointer to the start of the buffer where the bytes will be written
*/
void mqc_init_enc(opj_mqc_t *mqc, OPJ_BYTE *bp);
/**
Set the current context used for coding/decoding
@param mqc MQC handle
@param ctxno Number that identifies the context
*/
#define mqc_setcurctx(mqc, ctxno) (mqc)->curctx = &(mqc)->ctxs[(OPJ_UINT32)(ctxno)]
/**
Encode a symbol using the MQ-coder
@param mqc MQC handle
@param d The symbol to be encoded (0 or 1)
*/
void mqc_encode(opj_mqc_t *mqc, OPJ_UINT32 d);
/**
Flush the encoder, so that all remaining data is written
@param mqc MQC handle
*/
void mqc_flush(opj_mqc_t *mqc);
/**
BYPASS mode switch, initialization operation.
JPEG 2000 p 505.
<h2>Not fully implemented and tested !!</h2>
@param mqc MQC handle
*/
void mqc_bypass_init_enc(opj_mqc_t *mqc);
/**
BYPASS mode switch, coding operation.
JPEG 2000 p 505.
<h2>Not fully implemented and tested !!</h2>
@param mqc MQC handle
@param d The symbol to be encoded (0 or 1)
*/
void mqc_bypass_enc(opj_mqc_t *mqc, OPJ_UINT32 d);
/**
BYPASS mode switch, flush operation
<h2>Not fully implemented and tested !!</h2>
@param mqc MQC handle
@return Returns 1 (always)
*/
OPJ_UINT32 mqc_bypass_flush_enc(opj_mqc_t *mqc);
/**
RESET mode switch
@param mqc MQC handle
*/
void mqc_reset_enc(opj_mqc_t *mqc);
/**
RESTART mode switch (TERMALL)
@param mqc MQC handle
@return Returns 1 (always)
*/
OPJ_UINT32 mqc_restart_enc(opj_mqc_t *mqc);
/**
RESTART mode switch (TERMALL) reinitialisation
@param mqc MQC handle
*/
void mqc_restart_init_enc(opj_mqc_t *mqc);
/**
ERTERM mode switch (PTERM)
@param mqc MQC handle
*/
void mqc_erterm_enc(opj_mqc_t *mqc);
/**
SEGMARK mode switch (SEGSYM)
@param mqc MQC handle
*/
void mqc_segmark_enc(opj_mqc_t *mqc);
/**
Initialize the decoder
@param mqc MQC handle
@param bp Pointer to the start of the buffer from which the bytes will be read
@param len Length of the input buffer
*/
void mqc_init_dec(opj_mqc_t *mqc, OPJ_BYTE *bp, OPJ_UINT32 len);
/**
Decode a symbol
@param mqc MQC handle
@return Returns the decoded symbol (0 or 1)
*/
OPJ_UINT32 mqc_decode(opj_mqc_t *mqc);
/* ----------------------------------------------------------------------- */
/*@}*/
/*@}*/ /*
* Encode a bit
* d: bit to encode (0 or 1)
*/
void mqc_encode(int d);
#endif /* __MQC_H */ /*
* Flush the encoder, so that all remaining data is written
*/
void mqc_flush();
/*
* BYPASS mode switch
*/
void mqc_bypass_init_enc();
/*
* BYPASS mode switch
*/
void mqc_bypass_enc(int d);
/*
* BYPASS mode switch
*/
int mqc_bypass_flush_enc();
/*
* RESET mode switch
*/
void mqc_reset_enc();
/*
* RESTART mode switch (TERMALL)
*/
int mqc_restart_enc();
/*
* RESTART mode switch (TERMALL)
*/
void mqc_restart_init_enc();
/*
* ERTERM mode switch (PTERM)
*/
void mqc_erterm_enc();
/*
* SEGMARK mode switch (SEGSYM)
*/
void mqc_segmark_enc();
/*
* Initialize the decoder
* bp: pointer to the start of the buffer from which the bytes will be read
* len: length of the input buffer
*/
void mqc_init_dec(unsigned char *bp, int len);
/*
* Decode a bit (returns 0 or 1)
*/
int mqc_decode();
#endif

908
libopenjpeg/openjpeg.c
View File

@@ -1,908 +0,0 @@
/*
* Copyright (c) 2005, Herv<72> Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* 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.
*/
#ifdef WIN32
#include <windows.h>
#endif /* WIN32 */
#include "openjpeg.h"
#include "opj_malloc.h"
#include "j2k.h"
#include "jp2.h"
#include "event.h"
#include "cio.h"
typedef struct opj_decompression
{
bool (* opj_read_header) (
void *p_codec,
opj_image_t **,
OPJ_INT32 * p_tile_x0,
OPJ_INT32 * p_tile_y0,
OPJ_UINT32 * p_tile_width,
OPJ_UINT32 * p_tile_height,
OPJ_UINT32 * p_nb_tiles_x,
OPJ_UINT32 * p_nb_tiles_y,
struct opj_stream_private *cio,
struct opj_event_mgr * p_manager);
opj_image_t* (* opj_decode) (void * p_codec, struct opj_stream_private *p_cio, struct opj_event_mgr * p_manager);
bool (*opj_read_tile_header)(
void * p_codec,
OPJ_UINT32 * p_tile_index,
OPJ_UINT32* p_data_size,
OPJ_INT32 * p_tile_x0,
OPJ_INT32 * p_tile_y0,
OPJ_INT32 * p_tile_x1,
OPJ_INT32 * p_tile_y1,
OPJ_UINT32 * p_nb_comps,
bool * p_should_go_on,
struct opj_stream_private *p_cio,
struct opj_event_mgr * p_manager);
bool (*opj_decode_tile_data)(void * p_codec,OPJ_UINT32 p_tile_index,OPJ_BYTE * p_data,OPJ_UINT32 p_data_size,struct opj_stream_private *p_cio,struct opj_event_mgr * p_manager);
bool (* opj_end_decompress) (void *p_codec,struct opj_stream_private *cio,struct opj_event_mgr * p_manager);
void (* opj_destroy) (void * p_codec);
void (*opj_setup_decoder) (void * p_codec,opj_dparameters_t * p_param);
bool (*opj_set_decode_area) (void * p_codec,OPJ_INT32 p_start_x,OPJ_INT32 p_end_x,OPJ_INT32 p_start_y,OPJ_INT32 p_end_y,struct opj_event_mgr * p_manager);
}opj_decompression_t;
typedef struct opj_compression
{
bool (* opj_start_compress) (void *p_codec,struct opj_stream_private *cio,struct opj_image * p_image, struct opj_event_mgr * p_manager);
bool (* opj_encode) (void * p_codec, struct opj_stream_private *p_cio, struct opj_event_mgr * p_manager);
bool (* opj_write_tile) (void * p_codec,OPJ_UINT32 p_tile_index,OPJ_BYTE * p_data,OPJ_UINT32 p_data_size,struct opj_stream_private * p_cio,struct opj_event_mgr * p_manager);
bool (* opj_end_compress) (void * p_codec, struct opj_stream_private *p_cio, struct opj_event_mgr * p_manager);
void (* opj_destroy) (void * p_codec);
void (*opj_setup_encoder) (void * p_codec,opj_cparameters_t * p_param,struct opj_image * p_image, struct opj_event_mgr * p_manager);
}opj_compression_t;
typedef struct opj_codec_private
{
union
{ /* code-blocks informations */
opj_decompression_t m_decompression;
opj_compression_t m_compression;
} m_codec_data;
void * m_codec;
opj_event_mgr_t m_event_mgr;
unsigned is_decompressor : 1;
}
opj_codec_private_t;
/**
* Default callback function.
* Do nothing.
*/
void opj_default_callback (const char *msg, void *client_data)
{
}
void set_default_event_handler(opj_event_mgr_t * p_manager)
{
p_manager->m_error_data = 00;
p_manager->m_warning_data = 00;
p_manager->m_info_data = 00;
p_manager->error_handler = opj_default_callback;
p_manager->info_handler = opj_default_callback;
p_manager->warning_handler = opj_default_callback;
}
OPJ_UINT32 opj_read_from_file (void * p_buffer, OPJ_UINT32 p_nb_bytes, FILE * p_file)
{
OPJ_UINT32 l_nb_read = fread(p_buffer,1,p_nb_bytes,p_file);
return l_nb_read ? l_nb_read : -1;
}
OPJ_UINT32 opj_write_from_file (void * p_buffer, OPJ_UINT32 p_nb_bytes, FILE * p_file)
{
return fwrite(p_buffer,1,p_nb_bytes,p_file);
}
OPJ_SIZE_T opj_skip_from_file (OPJ_SIZE_T p_nb_bytes, FILE * p_user_data)
{
if
(fseek(p_user_data,p_nb_bytes,SEEK_CUR))
{
return -1;
}
return p_nb_bytes;
}
bool opj_seek_from_file (OPJ_SIZE_T p_nb_bytes, FILE * p_user_data)
{
if
(fseek(p_user_data,p_nb_bytes,SEEK_SET))
{
return false;
}
return true;
}
/* ---------------------------------------------------------------------- */
#ifdef WIN32
#ifndef OPJ_STATIC
BOOL APIENTRY
DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
switch (ul_reason_for_call) {
case DLL_PROCESS_ATTACH :
break;
case DLL_PROCESS_DETACH :
break;
case DLL_THREAD_ATTACH :
case DLL_THREAD_DETACH :
break;
}
return TRUE;
}
#endif /* OPJ_STATIC */
#endif /* WIN32 */
/* ---------------------------------------------------------------------- */
const char* OPJ_CALLCONV opj_version(void) {
return OPENJPEG_VERSION;
}
opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT p_format)
{
opj_codec_private_t *l_info = 00;
l_info = (opj_codec_private_t*) opj_calloc(1, sizeof(opj_codec_private_t));
if
(!l_info)
{
return 00;
}
memset(l_info, 0, sizeof(opj_codec_private_t));
l_info->is_decompressor = 1;
switch
(p_format)
{
case CODEC_J2K:
l_info->m_codec_data.m_decompression.opj_decode = (opj_image_t* (*) (void *, struct opj_stream_private *, struct opj_event_mgr * ))j2k_decode;
l_info->m_codec_data.m_decompression.opj_end_decompress = (bool (*) (void *,struct opj_stream_private *,struct opj_event_mgr *))j2k_end_decompress;
l_info->m_codec_data.m_decompression.opj_read_header = (bool (*) (
void *,
opj_image_t **,
OPJ_INT32 * ,
OPJ_INT32 * ,
OPJ_UINT32 * ,
OPJ_UINT32 * ,
OPJ_UINT32 * ,
OPJ_UINT32 * ,
struct opj_stream_private *,
struct opj_event_mgr * )) j2k_read_header;
l_info->m_codec_data.m_decompression.opj_destroy = (void (*) (void *))j2k_destroy;
l_info->m_codec_data.m_decompression.opj_setup_decoder = (void (*) (void * ,opj_dparameters_t * )) j2k_setup_decoder;
l_info->m_codec_data.m_decompression.opj_read_tile_header = (bool (*) (
void *,
OPJ_UINT32*,
OPJ_UINT32*,
OPJ_INT32 * ,
OPJ_INT32 * ,
OPJ_INT32 * ,
OPJ_INT32 * ,
OPJ_UINT32 * ,
bool *,
struct opj_stream_private *,
struct opj_event_mgr * )) j2k_read_tile_header;
l_info->m_codec_data.m_decompression.opj_decode_tile_data = (bool (*) (void *,OPJ_UINT32,OPJ_BYTE*,OPJ_UINT32,struct opj_stream_private *, struct opj_event_mgr * )) j2k_decode_tile;
l_info->m_codec_data.m_decompression.opj_set_decode_area = (bool (*) (void *,OPJ_INT32,OPJ_INT32,OPJ_INT32,OPJ_INT32, struct opj_event_mgr * )) j2k_set_decode_area;
l_info->m_codec = j2k_create_decompress();
if
(! l_info->m_codec)
{
opj_free(l_info);
return 00;
}
break;
case CODEC_JP2:
/* get a JP2 decoder handle */
l_info->m_codec_data.m_decompression.opj_decode = (opj_image_t* (*) (void *, struct opj_stream_private *, struct opj_event_mgr * ))opj_jp2_decode;
l_info->m_codec_data.m_decompression.opj_end_decompress = (bool (*) (void *,struct opj_stream_private *,struct opj_event_mgr *)) jp2_end_decompress;
l_info->m_codec_data.m_decompression.opj_read_header = (bool (*) (
void *,
opj_image_t **,
OPJ_INT32 * ,
OPJ_INT32 * ,
OPJ_UINT32 * ,
OPJ_UINT32 * ,
OPJ_UINT32 * ,
OPJ_UINT32 * ,
struct opj_stream_private *,
struct opj_event_mgr * )) jp2_read_header;
l_info->m_codec_data.m_decompression.opj_read_tile_header = (
bool (*) (
void *,
OPJ_UINT32*,
OPJ_UINT32*,
OPJ_INT32*,
OPJ_INT32*,
OPJ_INT32 * ,
OPJ_INT32 * ,
OPJ_UINT32 * ,
bool *,
struct opj_stream_private *,
struct opj_event_mgr * )) jp2_read_tile_header;
l_info->m_codec_data.m_decompression.opj_decode_tile_data = (bool (*) (void *,OPJ_UINT32,OPJ_BYTE*,OPJ_UINT32,struct opj_stream_private *, struct opj_event_mgr * )) opj_jp2_decode_tile;
l_info->m_codec_data.m_decompression.opj_destroy = (void (*) (void *))jp2_destroy;
l_info->m_codec_data.m_decompression.opj_setup_decoder = (void (*) (void * ,opj_dparameters_t * )) jp2_setup_decoder;
l_info->m_codec_data.m_decompression.opj_set_decode_area = (bool (*) (void *,OPJ_INT32,OPJ_INT32,OPJ_INT32,OPJ_INT32, struct opj_event_mgr * )) jp2_set_decode_area;
l_info->m_codec = jp2_create(true);
if
(! l_info->m_codec)
{
opj_free(l_info);
return 00;
}
break;
case CODEC_UNKNOWN:
case CODEC_JPT:
default:
opj_free(l_info);
return 00;
}
set_default_event_handler(&(l_info->m_event_mgr));
return (opj_codec_t*) l_info;
}
void OPJ_CALLCONV opj_destroy_codec(opj_codec_t *p_info)
{
if
(p_info)
{
opj_codec_private_t * l_info = (opj_codec_private_t *) p_info;
if
(l_info->is_decompressor)
{
l_info->m_codec_data.m_decompression.opj_destroy(l_info->m_codec);
}
else
{
l_info->m_codec_data.m_compression.opj_destroy(l_info->m_codec);
}
l_info->m_codec = 00;
opj_free(l_info);
}
}
void OPJ_CALLCONV opj_set_default_decoder_parameters(opj_dparameters_t *parameters) {
if(parameters) {
memset(parameters, 0, sizeof(opj_dparameters_t));
/* default decoding parameters */
parameters->cp_layer = 0;
parameters->cp_reduce = 0;
parameters->decod_format = -1;
parameters->cod_format = -1;
/* UniPG>> */
#ifdef USE_JPWL
parameters->jpwl_correct = false;
parameters->jpwl_exp_comps = JPWL_EXPECTED_COMPONENTS;
parameters->jpwl_max_tiles = JPWL_MAXIMUM_TILES;
#endif /* USE_JPWL */
/* <<UniPG */
}
}
bool OPJ_CALLCONV opj_setup_decoder(opj_codec_t *p_info, opj_dparameters_t *parameters) {
if
(p_info && parameters)
{
opj_codec_private_t * l_info = (opj_codec_private_t *) p_info;
if
(! l_info->is_decompressor)
{
return false;
}
l_info->m_codec_data.m_decompression.opj_setup_decoder(l_info->m_codec,parameters);
return true;
}
return false;
}
opj_image_t* OPJ_CALLCONV opj_decode(opj_codec_t *p_info, opj_stream_t *cio)
{
if
(p_info && cio)
{
opj_codec_private_t * l_info = (opj_codec_private_t *) p_info;
opj_stream_private_t * l_cio = (opj_stream_private_t *) cio;
if
(! l_info->is_decompressor)
{
return 00;
}
return l_info->m_codec_data.m_decompression.opj_decode(l_info->m_codec,l_cio,&(l_info->m_event_mgr));
}
return 00;
}
/**
* Writes a tile with the given data.
*
* @param p_compressor the jpeg2000 codec.
* @param p_tile_index the index of the tile to write. At the moment, the tiles must be written from 0 to n-1 in sequence.
* @param p_data pointer to the data to write. Data is arranged in sequence, data_comp0, then data_comp1, then ... NO INTERLEAVING should be set.
* @param p_data_size this value os used to make sure the data being written is correct. The size must be equal to the sum for each component of tile_width * tile_height * component_size. component_size can be 1,2 or 4 bytes,
* depending on the precision of the given component.
* @param p_stream the stream to write data to.
*/
bool OPJ_CALLCONV opj_write_tile (
opj_codec_t *p_codec,
OPJ_UINT32 p_tile_index,
OPJ_BYTE * p_data,
OPJ_UINT32 p_data_size,
opj_stream_t *p_stream
)
{
if
(p_codec && p_stream && p_data)
{
opj_codec_private_t * l_info = (opj_codec_private_t *) p_codec;
opj_stream_private_t * l_cio = (opj_stream_private_t *) p_stream;
if
(l_info->is_decompressor)
{
return false;
}
return l_info->m_codec_data.m_compression.opj_write_tile(l_info->m_codec,p_tile_index,p_data,p_data_size,l_cio,&(l_info->m_event_mgr));
}
return false;
}
/**
* Reads a tile header. This function is compulsory and allows one to know the size of the tile thta will be decoded.
* The user may need to refer to the image got by opj_read_header to understand the size being taken by the tile.
*
* @param p_codec the jpeg2000 codec.
* @param p_tile_index pointer to a value that will hold the index of the tile being decoded, in case of success.
* @param p_data_size pointer to a value that will hold the maximum size of the decoded data, in case of success. In case
* of truncated codestreams, the actual number of bytes decoded may be lower. The computation of the size is the same
* as depicted in opj_write_tile.
* @param p_tile_x0 pointer to a value that will hold the x0 pos of the tile (in the image).
* @param p_tile_y0 pointer to a value that will hold the y0 pos of the tile (in the image).
* @param p_tile_x1 pointer to a value that will hold the x1 pos of the tile (in the image).
* @param p_tile_y1 pointer to a value that will hold the y1 pos of the tile (in the image).
* @param p_nb_comps pointer to a value that will hold the number of components in the tile.
* @param p_should_go_on pointer to a boolean that will hold the fact that the decoding should go on. In case the
* codestream is over at the time of the call, the value will be set to false. The user should then stop
* the decoding.
* @param p_stream the stream to decode.
* @return true if the tile header could be decoded. In case the decoding should end, the returned value is still true.
* returning false may be the result of a shortage of memory or an internal error.
*/
bool OPJ_CALLCONV opj_read_tile_header(
opj_codec_t *p_codec,
OPJ_UINT32 * p_tile_index,
OPJ_UINT32 * p_data_size,
OPJ_INT32 * p_tile_x0,
OPJ_INT32 * p_tile_y0,
OPJ_INT32 * p_tile_x1,
OPJ_INT32 * p_tile_y1,
OPJ_UINT32 * p_nb_comps,
bool * p_should_go_on,
opj_stream_t * p_stream)
{
if
(p_codec && p_stream && p_data_size && p_tile_index)
{
opj_codec_private_t * l_info = (opj_codec_private_t *) p_codec;
opj_stream_private_t * l_cio = (opj_stream_private_t *) p_stream;
if
(! l_info->is_decompressor)
{
return false;
}
return l_info->m_codec_data.m_decompression.opj_read_tile_header(
l_info->m_codec,
p_tile_index,
p_data_size,
p_tile_x0,
p_tile_y0,
p_tile_x1,
p_tile_y1,
p_nb_comps,
p_should_go_on,
l_cio,&(l_info->m_event_mgr));
}
return false;
}
/**
* Reads a tile data. This function is compulsory and allows one to decode tile data. opj_read_tile_header should be called before.
* The user may need to refer to the image got by opj_read_header to understand the size being taken by the tile.
*
* @param p_codec the jpeg2000 codec.
* @param p_tile_index the index of the tile being decoded, this should be the value set by opj_read_tile_header.
* @param p_data pointer to a memory block that will hold the decoded data.
* @param p_data_size size of p_data. p_data_size should be bigger or equal to the value set by opj_read_tile_header.
* @param p_stream the stream to decode.
*
* @return true if the data could be decoded.
*/
bool OPJ_CALLCONV opj_decode_tile_data(
opj_codec_t *p_codec,
OPJ_UINT32 p_tile_index,
OPJ_BYTE * p_data,
OPJ_UINT32 p_data_size,
opj_stream_t *p_stream
)
{
if
(p_codec && p_data && p_stream)
{
opj_codec_private_t * l_info = (opj_codec_private_t *) p_codec;
opj_stream_private_t * l_cio = (opj_stream_private_t *) p_stream;
if
(! l_info->is_decompressor)
{
return false;
}
return l_info->m_codec_data.m_decompression.opj_decode_tile_data(l_info->m_codec,p_tile_index,p_data,p_data_size,l_cio,&(l_info->m_event_mgr));
}
return false;
}
bool OPJ_CALLCONV opj_read_header (
opj_codec_t *p_codec,
opj_image_t ** p_image,
OPJ_INT32 * p_tile_x0,
OPJ_INT32 * p_tile_y0,
OPJ_UINT32 * p_tile_width,
OPJ_UINT32 * p_tile_height,
OPJ_UINT32 * p_nb_tiles_x,
OPJ_UINT32 * p_nb_tiles_y,
opj_stream_t *p_cio)
{
if
(p_codec && p_cio)
{
opj_codec_private_t * l_info = (opj_codec_private_t *) p_codec;
opj_stream_private_t * l_cio = (opj_stream_private_t *) p_cio;
if
(! l_info->is_decompressor)
{
return false;
}
return l_info->m_codec_data.m_decompression.opj_read_header(
l_info->m_codec,
p_image,
p_tile_x0,
p_tile_y0,
p_tile_width,
p_tile_height,
p_nb_tiles_x,
p_nb_tiles_y,
l_cio,
&(l_info->m_event_mgr));
}
return false;
}
/**
* Sets the given area to be decoded. This function should be called right after opj_read_header and before any tile header reading.
*
* @param p_codec the jpeg2000 codec.
* @param p_start_x the left position of the rectangle to decode (in image coordinates).
* @param p_end_x the right position of the rectangle to decode (in image coordinates).
* @param p_start_y the up position of the rectangle to decode (in image coordinates).
* @param p_end_y the bottom position of the rectangle to decode (in image coordinates).
*
* @return true if the area could be set.
*/
bool OPJ_CALLCONV opj_set_decode_area(
opj_codec_t *p_codec,
OPJ_INT32 p_start_x,
OPJ_INT32 p_start_y,
OPJ_INT32 p_end_x,
OPJ_INT32 p_end_y
)
{
if
(p_codec)
{
opj_codec_private_t * l_info = (opj_codec_private_t *) p_codec;
if
(! l_info->is_decompressor)
{
return false;
}
return l_info->m_codec_data.m_decompression.opj_set_decode_area(
l_info->m_codec,
p_start_x,
p_start_y,
p_end_x,
p_end_y,
&(l_info->m_event_mgr));
}
return false;
}
bool OPJ_CALLCONV opj_end_decompress (opj_codec_t *p_codec,opj_stream_t *p_cio)
{
if
(p_codec && p_cio)
{
opj_codec_private_t * l_info = (opj_codec_private_t *) p_codec;
opj_stream_private_t * l_cio = (opj_stream_private_t *) p_cio;
if
(! l_info->is_decompressor)
{
return false;
}
return l_info->m_codec_data.m_decompression.opj_end_decompress(l_info->m_codec,l_cio,&(l_info->m_event_mgr));
}
return false;
}
opj_codec_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT p_format)
{
opj_codec_private_t *l_info = 00;
l_info = (opj_codec_private_t*)opj_calloc(1, sizeof(opj_codec_private_t));
if
(!l_info)
{
return 00;
}
memset(l_info, 0, sizeof(opj_codec_private_t));
l_info->is_decompressor = 0;
switch
(p_format)
{
case CODEC_J2K:
l_info->m_codec_data.m_compression.opj_encode = (bool (*) (void *, struct opj_stream_private *, struct opj_event_mgr * )) j2k_encode;
l_info->m_codec_data.m_compression.opj_end_compress = (bool (*) (void *, struct opj_stream_private *, struct opj_event_mgr *)) j2k_end_compress;
l_info->m_codec_data.m_compression.opj_start_compress = (bool (*) (void *,struct opj_stream_private *,struct opj_image * , struct opj_event_mgr *)) j2k_start_compress;
l_info->m_codec_data.m_compression.opj_write_tile = (bool (*) (void *,OPJ_UINT32,OPJ_BYTE*,OPJ_UINT32,struct opj_stream_private *, struct opj_event_mgr *)) j2k_write_tile;
l_info->m_codec_data.m_compression.opj_destroy = (void (*) (void *)) j2k_destroy;
l_info->m_codec_data.m_compression.opj_setup_encoder = (void (*) (void *,opj_cparameters_t *,struct opj_image *, struct opj_event_mgr * )) j2k_setup_encoder;
l_info->m_codec = j2k_create_compress();
if
(! l_info->m_codec)
{
opj_free(l_info);
return 00;
}
break;
case CODEC_JP2:
/* get a JP2 decoder handle */
l_info->m_codec_data.m_compression.opj_encode = (bool (*) (void *, struct opj_stream_private *, struct opj_event_mgr * )) opj_jp2_encode;
l_info->m_codec_data.m_compression.opj_end_compress = (bool (*) (void *, struct opj_stream_private *, struct opj_event_mgr *)) jp2_end_compress;
l_info->m_codec_data.m_compression.opj_start_compress = (bool (*) (void *,struct opj_stream_private *,struct opj_image * , struct opj_event_mgr *)) jp2_start_compress;
l_info->m_codec_data.m_compression.opj_write_tile = (bool (*) (void *,OPJ_UINT32,OPJ_BYTE*,OPJ_UINT32,struct opj_stream_private *, struct opj_event_mgr *)) jp2_write_tile;
l_info->m_codec_data.m_compression.opj_destroy = (void (*) (void *)) jp2_destroy;
l_info->m_codec_data.m_compression.opj_setup_encoder = (void (*) (void *,opj_cparameters_t *,struct opj_image *, struct opj_event_mgr * )) jp2_setup_encoder;
l_info->m_codec = jp2_create(false);
if
(! l_info->m_codec)
{
opj_free(l_info);
return 00;
}
break;
case CODEC_UNKNOWN:
case CODEC_JPT:
default:
opj_free(l_info);
return 00;
}
set_default_event_handler(&(l_info->m_event_mgr));
return (opj_codec_t*) l_info;
}
void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters) {
if(parameters) {
memset(parameters, 0, sizeof(opj_cparameters_t));
/* default coding parameters */
parameters->cp_cinema = OFF;
parameters->max_comp_size = 0;
parameters->numresolution = 6;
parameters->cp_rsiz = STD_RSIZ;
parameters->cblockw_init = 64;
parameters->cblockh_init = 64;
parameters->prog_order = LRCP;
parameters->roi_compno = -1; /* no ROI */
parameters->subsampling_dx = 1;
parameters->subsampling_dy = 1;
parameters->tp_on = 0;
parameters->decod_format = -1;
parameters->cod_format = -1;
parameters->tcp_rates[0] = 0;
parameters->tcp_numlayers = 0;
parameters->cp_disto_alloc = 0;
parameters->cp_fixed_alloc = 0;
parameters->cp_fixed_quality = 0;
/* UniPG>> */
#ifdef USE_JPWL
parameters->jpwl_epc_on = false;
parameters->jpwl_hprot_MH = -1; /* -1 means unassigned */
{
int i;
for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
parameters->jpwl_hprot_TPH_tileno[i] = -1; /* unassigned */
parameters->jpwl_hprot_TPH[i] = 0; /* absent */
}
};
{
int i;
for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
parameters->jpwl_pprot_tileno[i] = -1; /* unassigned */
parameters->jpwl_pprot_packno[i] = -1; /* unassigned */
parameters->jpwl_pprot[i] = 0; /* absent */
}
};
parameters->jpwl_sens_size = 0; /* 0 means no ESD */
parameters->jpwl_sens_addr = 0; /* 0 means auto */
parameters->jpwl_sens_range = 0; /* 0 means packet */
parameters->jpwl_sens_MH = -1; /* -1 means unassigned */
{
int i;
for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
parameters->jpwl_sens_TPH_tileno[i] = -1; /* unassigned */
parameters->jpwl_sens_TPH[i] = -1; /* absent */
}
};
#endif /* USE_JPWL */
/* <<UniPG */
}
}
/**
* Helper function.
* Sets the stream to be a file stream. The FILE must have been open previously.
* @param p_stream the stream to modify
* @param p_file handler to an already open file.
*/
opj_stream_t* OPJ_CALLCONV opj_stream_create_default_file_stream (FILE * p_file,bool p_is_read_stream)
{
return opj_stream_create_file_stream(p_file,J2K_STREAM_CHUNK_SIZE,p_is_read_stream);
}
opj_stream_t* OPJ_CALLCONV opj_stream_create_file_stream (FILE * p_file,OPJ_UINT32 p_size,bool p_is_read_stream)
{
opj_stream_t* l_stream = 00;
if
(! p_file)
{
return 00;
}
l_stream = opj_stream_create(p_size,p_is_read_stream);
if
(! l_stream)
{
return 00;
}
opj_stream_set_user_data(l_stream,p_file);
opj_stream_set_read_function(l_stream,(opj_stream_read_fn) 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);
return l_stream;
}
bool OPJ_CALLCONV opj_setup_encoder(opj_codec_t *p_info, opj_cparameters_t *parameters, opj_image_t *image)
{
if
(p_info && parameters && image)
{
opj_codec_private_t * l_codec = ((opj_codec_private_t *) p_info);
if
(! l_codec->is_decompressor)
{
l_codec->m_codec_data.m_compression.opj_setup_encoder(l_codec->m_codec,parameters,image,&(l_codec->m_event_mgr));
return true;
}
}
return false;
}
bool OPJ_CALLCONV opj_encode(opj_codec_t *p_info, opj_stream_t *cio)
{
if
(p_info && cio)
{
opj_codec_private_t * l_codec = (opj_codec_private_t *) p_info;
opj_stream_private_t * l_cio = (opj_stream_private_t *) cio;
if
(! l_codec->is_decompressor)
{
l_codec->m_codec_data.m_compression.opj_encode(l_codec->m_codec,l_cio,&(l_codec->m_event_mgr));
return true;
}
}
return false;
}
bool OPJ_CALLCONV opj_start_compress (opj_codec_t *p_codec,opj_image_t * p_image,opj_stream_t *p_cio)
{
if
(p_codec && p_cio)
{
opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
opj_stream_private_t * l_cio = (opj_stream_private_t *) p_cio;
if
(! l_codec->is_decompressor)
{
return l_codec->m_codec_data.m_compression.opj_start_compress(l_codec->m_codec,l_cio,p_image,&(l_codec->m_event_mgr));
}
}
return false;
}
bool OPJ_CALLCONV opj_end_compress (opj_codec_t *p_codec,opj_stream_t *p_cio)
{
if
(p_codec && p_cio)
{
opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
opj_stream_private_t * l_cio = (opj_stream_private_t *) p_cio;
if
(! l_codec->is_decompressor)
{
return l_codec->m_codec_data.m_compression.opj_end_compress(l_codec->m_codec,l_cio,&(l_codec->m_event_mgr));
}
}
return false;
}
bool OPJ_CALLCONV opj_set_info_handler(opj_codec_t * p_codec, opj_msg_callback p_callback,void * p_user_data)
{
opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
if
(! l_codec)
{
return false;
}
l_codec->m_event_mgr.info_handler = p_callback;
l_codec->m_event_mgr.m_info_data = p_user_data;
return true;
}
bool OPJ_CALLCONV opj_set_warning_handler(opj_codec_t * p_codec, opj_msg_callback p_callback,void * p_user_data)
{
opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
if
(! l_codec)
{
return false;
}
l_codec->m_event_mgr.warning_handler = p_callback;
l_codec->m_event_mgr.m_warning_data = p_user_data;
return true;
}
bool OPJ_CALLCONV opj_set_error_handler(opj_codec_t * p_codec, opj_msg_callback p_callback,void * p_user_data)
{
opj_codec_private_t * l_codec = (opj_codec_private_t *) p_codec;
if
(! l_codec)
{
return false;
}
l_codec->m_event_mgr.error_handler = p_callback;
l_codec->m_event_mgr.m_error_data = p_user_data;
return true;
}
/*bool OPJ_CALLCONV opj_encode_with_info(opj_cinfo_t *cinfo, opj_stream_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info) {
if(cinfo && cio && image) {
switch(cinfo->codec_format) {
case CODEC_J2K:
return j2k_encode((opj_j2k_t*)cinfo->j2k_handle, (opj_stream_private_t *) cio, image, cstr_info);
case CODEC_JP2:
return opj_jp2_encode((opj_jp2_t*)cinfo->jp2_handle, (opj_stream_private_t *) cio, image, cstr_info);
case CODEC_JPT:
case CODEC_UNKNOWN:
default:
break;
}
}
return false;
}*/
void OPJ_CALLCONV opj_destroy_cstr_info(opj_codestream_info_t *cstr_info) {
if
(cstr_info)
{
int tileno;
for (tileno = 0; tileno < cstr_info->tw * cstr_info->th; tileno++) {
opj_tile_info_t *tile_info = &cstr_info->tile[tileno];
opj_free(tile_info->thresh);
opj_free(tile_info->packet);
opj_free(tile_info->tp);
}
opj_free(cstr_info->tile);
opj_free(cstr_info->marker);
}
}
bool OPJ_CALLCONV opj_set_MCT(opj_cparameters_t *parameters,OPJ_FLOAT32 * pEncodingMatrix,OPJ_INT32 * p_dc_shift,OPJ_UINT32 pNbComp)
{
OPJ_UINT32 l_matrix_size = pNbComp * pNbComp * sizeof(OPJ_FLOAT32);
OPJ_UINT32 l_dc_shift_size = pNbComp * sizeof(OPJ_INT32);
OPJ_UINT32 l_mct_total_size = l_matrix_size + l_dc_shift_size;
// add MCT capability
int rsiz = (int)parameters->cp_rsiz | (int)MCT;
parameters->cp_rsiz = (OPJ_RSIZ_CAPABILITIES)rsiz;
parameters->irreversible = 1;
// use array based MCT
parameters->tcp_mct = 2;
parameters->mct_data = opj_malloc(l_mct_total_size);
if
(! parameters->mct_data)
{
return false;
}
memcpy(parameters->mct_data,pEncodingMatrix,l_matrix_size);
memcpy(((OPJ_BYTE *) parameters->mct_data) + l_matrix_size,p_dc_shift,l_dc_shift_size);
return true;
}
/**
* Restricts the decoding to the given image area.
*
* @param parameters the parameters to update.
* @param p_start_x the starting x position of the area to decode.
* @param p_start_y the starting y position of the area to decode.
* @param p_end_x the x end position of the area to decode.
* @param p_end_x the y end position of the area to decode.
*/
OPJ_API bool OPJ_CALLCONV opj_restrict_decoding (opj_dparameters_t *parameters,OPJ_INT32 p_start_x,OPJ_INT32 p_start_y,OPJ_INT32 p_end_x,OPJ_INT32 p_end_y)
{
parameters->m_use_restrict_decode = 1;
parameters->m_decode_start_x = p_start_x;
parameters->m_decode_start_y = p_start_y;
parameters->m_decode_end_x = p_end_x;
parameters->m_decode_end_y = p_end_y;
return true;
}

1075
libopenjpeg/openjpeg.h
View File

File diff suppressed because it is too large Load Diff

16
libopenjpeg/opj_configure.h
View File

@@ -1,16 +0,0 @@
/*
* here is where system comupted values get stored these values should only
* change when the target compile platform changes
*/
/* what byte order */
#ifndef __OPJ_CONFIGURE_H
#define __OPJ_CONFIGURE_H
/* #undef CMAKE_WORDS_BIGENDIAN */
#ifdef CMAKE_WORDS_BIGENDIAN
#define OPJ_BIG_ENDIAN
#else
#define OPJ_LITTLE_ENDIAN
#endif
#endif /* __OPJ_CONFIGURE_H */

124
libopenjpeg/opj_includes.h
View File

@@ -1,124 +0,0 @@
/*
* Copyright (c) 2005, Herv<72> Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* 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.
*/
#ifndef OPJ_INCLUDES_H
#define OPJ_INCLUDES_H
/*
==========================================================
Standard includes used by the library
==========================================================
*/
#include <memory.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <float.h>
#include <time.h>
#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
#include <assert.h>
/*
==========================================================
OpenJPEG interface
==========================================================
*/
/*
==========================================================
OpenJPEG modules
==========================================================
*/
/* Ignore GCC attributes if this is not GCC */
#ifndef __GNUC__
#define __attribute__(x) /* __attribute__(x) */
#endif
/*
The inline keyword is supported by C99 but not by C90.
Most compilers implement their own version of this keyword ...
*/
#ifndef INLINE
#if defined(_MSC_VER)
#define INLINE __inline
#elif defined(__GNUC__)
#define INLINE __inline__
#elif defined(__MWERKS__)
#define INLINE inline
#else
/* add other compilers here ... */
#define INLINE
#endif /* defined(<Compiler>) */
#endif /* INLINE */
/* Are restricted pointers available? (C99) */
#if (__STDC_VERSION__ != 199901L)
/* Not a C99 compiler */
#ifdef __GNUC__
#define restrict __restrict__
#else
#define restrict /* restrict */
#endif
#endif
/* MSVC and Borland C do not have lrintf */
#if defined(_MSC_VER) || defined(__BORLANDC__)
/* MSVC 64bits doesn't support _asm */
#if !defined(_WIN64)
static INLINE long lrintf(float f){
int i;
_asm{
fld f
fistp i
};
return i;
}
#else
static INLINE long lrintf(float x){
long r;
if (x>=0.f)
{
x+=0.5f;
}
else
{
x-=0.5f;
}
r = (long)(x);
if ( x != (float)(r) ) return r;
return 2*(r/2);
}
#endif
#endif
#endif /* OPJ_INCLUDES_H */

145
libopenjpeg/opj_malloc.h
View File

@@ -1,145 +0,0 @@
/*
* Copyright (c) 2005, Hervé Drolon, FreeImage Team
* Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* 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.
*/
#ifndef __OPJ_MALLOC_H
#define __OPJ_MALLOC_H
/**
@file opj_malloc.h
@brief Internal functions
The functions in opj_malloc.h are internal utilities used for memory management.
*/
#include "openjpeg.h"
#include "opj_includes.h"
/** @defgroup MISC MISC - Miscellaneous internal functions */
/*@{*/
/** @name Exported functions */
/*@{*/
/* ----------------------------------------------------------------------- */
/**
Allocate an uninitialized memory block
@param size Bytes to allocate
@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
*/
#define opj_malloc(size) malloc(size)
#define my_opj_malloc(size) malloc(size)
/**
Allocate a memory block with elements initialized to 0
@param num Blocks to allocate
@param size Bytes per block to allocate
@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
*/
#define opj_calloc(num, size) calloc(num, size)
/**
Allocate memory aligned to a 16 byte boundry
@param size Bytes to allocate
@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
*/
/* FIXME: These should be set with cmake tests, but we're currently not requiring use of cmake */
#ifdef WIN32
/* Someone should tell the mingw people that their malloc.h ought to provide _mm_malloc() */
#ifdef __GNUC__
#include <mm_malloc.h>
#define HAVE_MM_MALLOC
#else /* MSVC, Intel C++ */
#include <malloc.h>
#ifdef _mm_malloc
#define HAVE_MM_MALLOC
#endif
#endif
#else /* Not WIN32 */
#if defined(__sun)
#define HAVE_MEMALIGN
/* Linux x86_64 and OSX always align allocations to 16 bytes */
#elif !defined(__amd64__) && !defined(__APPLE__)
/* FIXME: Yes, this is a big assumption */
#define HAVE_POSIX_MEMALIGN
#endif
#endif
#define opj_aligned_malloc(size) malloc(size)
#define opj_aligned_free(m) free(m)
#ifdef HAVE_MM_MALLOC
#undef opj_aligned_malloc
#define opj_aligned_malloc(size) _mm_malloc(size, 16)
#undef opj_aligned_free
#define opj_aligned_free(m) _mm_free(m)
#endif
#ifdef HAVE_MEMALIGN
extern void* memalign(size_t, size_t);
#undef opj_aligned_malloc
#define opj_aligned_malloc(size) memalign(16, (size))
#undef opj_aligned_free
#define opj_aligned_free(m) free(m)
#endif
#ifdef HAVE_POSIX_MEMALIGN
#undef opj_aligned_malloc
extern int posix_memalign(void**, size_t, size_t);
static INLINE void* __attribute__ ((malloc)) opj_aligned_malloc(size_t size){
void* mem = NULL;
posix_memalign(&mem, 16, size);
return mem;
}
#undef opj_aligned_free
#define opj_aligned_free(m) free(m)
#endif
/**
Reallocate memory blocks.
@param memblock Pointer to previously allocated memory block
@param size New size in bytes
@return Returns a void pointer to the reallocated (and possibly moved) memory block
*/
#define opj_realloc(m, s) realloc(m, s)
#define my_opj_realloc(m,s) realloc(m,s)
/**
Deallocates or frees a memory block.
@param memblock Previously allocated memory block to be freed
*/
#define opj_free(m) free(m)
#ifdef __GNUC__
#pragma GCC poison malloc calloc realloc free
#endif
/* ----------------------------------------------------------------------- */
/*@}*/
/*@}*/
#endif /* __OPJ_MALLOC_H */

2166
libopenjpeg/pi.c
View File

File diff suppressed because it is too large Load Diff

189
libopenjpeg/pi.h
View File

@@ -1,11 +1,5 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -32,150 +26,47 @@
#ifndef __PI_H #ifndef __PI_H
#define __PI_H #define __PI_H
/**
@file pi.h
@brief Implementation of a packet iterator (PI)
The functions in PI.C have for goal to realize a packet iterator that permits to get the next #include "j2k.h"
packet following the progression order and change of it. The functions in PI.C are used #include "tcd.h"
by some function in T2.C.
typedef struct {
int pdx, pdy;
int pw, ph;
} pi_resolution_t;
typedef struct {
int dx, dy;
int numresolutions;
pi_resolution_t *resolutions;
} pi_comp_t;
typedef struct {
short int *include; /* precise if the packet has been already used (usefull for progression order change) */
int step_l, step_r, step_c, step_p; /* different steps (layer, resolution, component, precinct) to localize the packet in the include vector */
int compno, resno, precno, layno; /* component, resolution, precinct and layer that indentify the packet */
int first; /* 0 if the first packet */
j2k_poc_t poc;
int numcomps;
pi_comp_t *comps;
int tx0, ty0, tx1, ty1;
int x, y, dx, dy;
} pi_iterator_t; /* packet iterator */
/*
* Create a packet iterator
* img: raw image for which the packets will be listed
* cp: coding paremeters
* tileno: number that identifies the tile for which to list the packets
* return value: returns a packet iterator that points to the first packet of the tile
*/ */
#include "openjpeg.h" pi_iterator_t *pi_create(j2k_image_t * img, j2k_cp_t * cp, int tileno);
#include "t2.h"
/** @defgroup PI PI - Implementation of a packet iterator */
/*@{*/
struct opj_poc;
struct opj_image;
struct opj_cp;
/** /*
FIXME: documentation * Modify the packet iterator to point to the next packet
* pi: packet iterator to modify
* return value: returns 0 if pi pointed to the last packet or else returns 1
*/ */
typedef struct opj_pi_resolution { int pi_next(pi_iterator_t * pi);
OPJ_UINT32 pdx, pdy;
OPJ_UINT32 pw, ph;
} opj_pi_resolution_t;
/** #endif
FIXME: documentation
*/
typedef struct opj_pi_comp {
OPJ_UINT32 dx, dy;
/** number of resolution levels */
OPJ_UINT32 numresolutions;
opj_pi_resolution_t *resolutions;
} opj_pi_comp_t;
/**
Packet iterator
*/
typedef struct opj_pi_iterator {
/** Enabling Tile part generation*/
OPJ_BYTE tp_on;
/** precise if the packet has been already used (usefull for progression order change) */
OPJ_INT16 *include;
/** layer step used to localize the packet in the include vector */
OPJ_UINT32 step_l;
/** resolution step used to localize the packet in the include vector */
OPJ_UINT32 step_r;
/** component step used to localize the packet in the include vector */
OPJ_UINT32 step_c;
/** precinct step used to localize the packet in the include vector */
OPJ_UINT32 step_p;
/** component that identify the packet */
OPJ_UINT32 compno;
/** resolution that identify the packet */
OPJ_UINT32 resno;
/** precinct that identify the packet */
OPJ_UINT32 precno;
/** layer that identify the packet */
OPJ_UINT32 layno;
/** progression order change information */
struct opj_poc poc;
/** number of components in the image */
OPJ_UINT32 numcomps;
/** Components*/
opj_pi_comp_t *comps;
OPJ_INT32 tx0, ty0, tx1, ty1;
OPJ_INT32 x, y;
OPJ_UINT32 dx, dy;
/** 0 if the first packet */
OPJ_UINT32 first : 1;
} opj_pi_iterator_t;
/** @name Exported functions */
/*@{*/
/* ----------------------------------------------------------------------- */
/**
* Creates a packet iterator for encoding.
*
* @param p_image the image being encoded.
* @param p_cp the coding parameters.
* @param p_tile_no index of the tile being encoded.
* @param p_t2_mode the type of pass for generating the packet iterator
* @return a list of packet iterator that points to the first packet of the tile (not true).
*/
opj_pi_iterator_t *pi_initialise_encode(const struct opj_image *image,struct opj_cp *cp, OPJ_UINT32 tileno,J2K_T2_MODE t2_mode);
/**
* Updates the encoding parameters of the codec.
*
* @param p_image the image being encoded.
* @param p_cp the coding parameters.
* @param p_tile_no index of the tile being encoded.
*/
void pi_update_encoding_parameters(
const struct opj_image *p_image,
struct opj_cp *p_cp,
OPJ_UINT32 p_tile_no
);
/**
Modify the packet iterator for enabling tile part generation
@param pi Handle to the packet iterator generated in pi_initialise_encode
@param cp Coding parameters
@param tileno Number that identifies the tile for which to list the packets
@param tpnum Tile part number of the current tile
@param tppos The position of the tile part flag in the progression order
*/
void pi_create_encode( opj_pi_iterator_t *pi, struct opj_cp *cp,OPJ_UINT32 tileno, OPJ_UINT32 pino,OPJ_UINT32 tpnum, OPJ_INT32 tppos, J2K_T2_MODE t2_mode);
/**
Create a packet iterator for Decoder
@param image Raw image for which the packets will be listed
@param cp Coding parameters
@param tileno Number that identifies the tile for which to list the packets
@return Returns a packet iterator that points to the first packet of the tile
@see pi_destroy
*/
opj_pi_iterator_t *pi_create_decode(struct opj_image * image, struct opj_cp * cp, OPJ_UINT32 tileno);
/**
* Destroys a packet iterator array.
*
* @param p_pi the packet iterator array to destroy.
* @param p_nb_elements the number of elements in the array.
*/
void pi_destroy(
opj_pi_iterator_t *p_pi,
OPJ_UINT32 p_nb_elements);
/**
Modify the packet iterator to point to the next packet
@param pi Packet iterator to modify
@return Returns false if pi pointed to the last packet or else returns true
*/
bool pi_next(opj_pi_iterator_t * pi);
/* ----------------------------------------------------------------------- */
/*@}*/
/*@}*/
#endif /* __PI_H */

177
libopenjpeg/profile.c
View File

@@ -1,177 +0,0 @@
/*
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* 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.
*/
/**
* Adapted from Herb Marselas
"Profiling, Data Analysis, Scalability, and Magic Numbers: Meeting the Minimum System Requirements for AGE OF EMPIRES 2: THE AGE OF KINGS"
Game Developer magazine
June, 2000 issue.
*/
#include "profile.h"
#include <string.h>
#include <stdio.h>
#include <time.h>
//==============================================================================
static OPJ_PROFILE_LIST group_list [PGROUP_LASTGROUP];
//==============================================================================
static void GetTimeStamp(OPJ_UINT32 *pdwtime);
//==============================================================================
#define SetMajorSection(entry, major) \
{ group_list[ entry ].section = entry ; \
group_list[ entry ].sectionName = #major ; }
//==============================================================================
void _ProfInit(void)
{
// clear everything out
memset(group_list, 0, sizeof(group_list));
// set groups and parents for timing
SetMajorSection(PGROUP_DWT,PGROUP_DWT);
SetMajorSection(PGROUP_T1, PGROUP_T1);
SetMajorSection(PGROUP_T2, PGROUP_T2);
} // ProfInit
//==============================================================================
void _ProfStart (OPJ_PROFILE_GROUP group)
{
// make sure this hasn't been incorrectly started twice
if (group_list[group].start)
{
return;
}
// get the start time
GetTimeStamp(&(group_list[group].start));
} // _ProfStart
//==============================================================================
void _ProfStop(OPJ_PROFILE_GROUP group)
{
// make sure we called start first
if (!group_list[group].start)
{
return;
}
// get ending time
GetTimeStamp(&(group_list[group].end));
// calculate this latest elapsed interval
group_list[group].total_time += group_list[group].end - group_list[group].start;
// reset starting time
group_list[group].start = 0;
// incr the number of calls made
++group_list[group].totalCalls;
} // _ProfStop
//==============================================================================
#define proftracef(id,totalTime) \
fprintf(p, #id "\t%u\t\t%6.6f\t\t%12.6f\t%2.2f%%\n", \
group_list[ id ].totalCalls, \
(OPJ_FLOAT64) group_list[ id ].total_time / CLOCKS_PER_SEC, \
((OPJ_FLOAT64) group_list[ id ].total_time / (group_list[ id ].totalCalls ? group_list[ id ].totalCalls : 1)), \
((OPJ_FLOAT64) group_list[ id ].total_time / totalTime * 100))
#define proftracep(id,totalTime) \
printf(#id "\t%u\t\t%6.6f\t\t%12.6f\t%2.2f%%\n", \
group_list[ id ].totalCalls, \
(OPJ_FLOAT64) group_list[ id ].total_time / CLOCKS_PER_SEC, \
((OPJ_FLOAT64) group_list[ id ].total_time / (group_list[ id ].totalCalls ? group_list[ id ].totalCalls : 1)), \
((OPJ_FLOAT64) group_list[ id ].total_time / totalTime * 100))
//==============================================================================
void _ProfSave(const OPJ_CHAR * pFileName)
{
FILE *p = fopen(pFileName, "wt");
OPJ_FLOAT64 totalTime = 0.;
OPJ_UINT32 i;
if (!p)
{
return;
}
for
(i=0;i<PGROUP_LASTGROUP;++i)
{
totalTime += group_list[i].total_time;
}
fputs("\n\nProfile Data:\n", p);
fputs("description\tnb calls\ttotal time (sec)\ttime per call\t%% of section\n", p);
proftracef(PGROUP_DWT,totalTime);
proftracef(PGROUP_T1,totalTime);
proftracef(PGROUP_T2,totalTime);
fputs("=== end of profile list ===\n\n", p);
fclose(p);
} // _ProfSave
//==============================================================================
void _ProfPrint(void)
{
OPJ_FLOAT64 totalTime = 0.;
OPJ_UINT32 i;
for
(i=0;i<PGROUP_LASTGROUP;++i)
{
totalTime += group_list[i].total_time;
}
printf("\n\nProfile Data:\n");
printf("description\tnb calls\ttotal time (sec)\ttime per call\t%% of section\n");
proftracep(PGROUP_RATE, totalTime);
proftracep(PGROUP_DC_SHIFT, totalTime);
proftracep(PGROUP_MCT, totalTime);
proftracep(PGROUP_DWT, totalTime);
proftracep(PGROUP_T1, totalTime);
proftracep(PGROUP_T2, totalTime);
printf("\nTotal time: %6.3f second(s)\n", totalTime / CLOCKS_PER_SEC);
printf("=== end of profile list ===\n\n");
} // _ProfPrint
//==============================================================================
static void GetTimeStamp(unsigned *time)
{
*time = clock();
} // GetTimeStamp

83
libopenjpeg/profile.h
View File

@@ -1,83 +0,0 @@
/*
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* 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.
*/
/**
* Adapted from Herb Marselas
"Profiling, Data Analysis, Scalability, and Magic Numbers: Meeting the Minimum System Requirements for AGE OF EMPIRES 2: THE AGE OF KINGS"
Game Developer magazine
June, 2000 issue.
*/
#ifndef __PROFILE_H
#define __PROFILE_H
#include "openjpeg.h"
//==============================================================================
typedef enum
{
PGROUP_RATE,
PGROUP_DC_SHIFT,
PGROUP_MCT,
PGROUP_DWT,
PGROUP_T1,
PGROUP_T2,
PGROUP_LASTGROUP
} OPJ_PROFILE_GROUP;
//==============================================================================
typedef struct PROFILELIST
{
OPJ_UINT32 start;
OPJ_UINT32 end;
OPJ_UINT32 total_time;
OPJ_UINT32 totalCalls;
OPJ_PROFILE_GROUP section;
const OPJ_CHAR *sectionName; // string name of the profile group
} OPJ_PROFILE_LIST;
//==============================================================================
void _ProfStart(OPJ_PROFILE_GROUP group);
void _ProfStop (OPJ_PROFILE_GROUP group);
//==============================================================================
//==============================================================================
#ifdef _PROFILE
#define PROFINIT() _ProfInit();
#define PROFSTART (group) _ProfStart (group);
#define PROFSTOP (group) _ProfStop (group);
#define PROFSAVE(file) _ProfSave(file);
#define PROFPRINT() _ProfPrint();
#else
#define PROFINIT()
#define PROFSTART(group)
#define PROFSTOP (group)
#define PROFSAVE(file)
#define PROFPRINT()
#endif // !_PROFILE
//==============================================================================
#endif // __PROFILE_H

94
libopenjpeg/raw.c
View File

@@ -1,9 +1,5 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2002-2003, Antonin Descampe
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -29,61 +25,57 @@
*/ */
#include "raw.h" #include "raw.h"
#include "opj_malloc.h"
unsigned char raw_c; /* temporary buffer where bits are coded or decoded */
unsigned int raw_ct; /* number of bits already read or free to write */
unsigned int raw_lenmax; /* maximum length to decode */
unsigned int raw_len; /* length decoded */
unsigned char *raw_bp; /* pointer to the current position in the buffer */
unsigned char *raw_start; /* pointer to the start of the buffer */
unsigned char *raw_end; /* pointer to the end of the buffer */
/* /*
========================================================== * Return the number of bytes already encoded.
local functions
==========================================================
*/ */
int raw_numbytes()
{
return raw_bp - raw_start;
}
/* /*
========================================================== * Initialize raw-decoder.
RAW encoding interface *
========================================================== * bp : pointer to the start of the buffer from which the bytes will be read
* len : length of the input buffer
*/ */
void raw_init_dec(unsigned char *bp, int len)
opj_raw_t* raw_create(void) { {
opj_raw_t *raw = (opj_raw_t*)opj_malloc(sizeof(opj_raw_t)); raw_start = bp;
return raw; raw_lenmax = len;
raw_len = 0;
raw_c = 0;
raw_ct = 0;
} }
void raw_destroy(opj_raw_t *raw) { /*
if(raw) { * Decode a symbol using raw-decoder. Cfr p.506 TAUBMAN
opj_free(raw); */
int raw_decode()
{
int d;
if (raw_ct == 0) {
raw_ct = 8;
if (raw_len == raw_lenmax)
raw_c = 0xff;
else {
if (raw_c == 0xff)
raw_ct = 7;
raw_c = *(raw_start + raw_len);
raw_len++;
} }
} }
raw_ct--;
OPJ_UINT32 raw_numbytes(opj_raw_t *raw) { d = (raw_c >> raw_ct) & 0x01;
return raw->bp - raw->start;
}
void raw_init_dec(opj_raw_t *raw, OPJ_BYTE *bp, OPJ_UINT32 len) {
raw->start = bp;
raw->lenmax = len;
raw->len = 0;
raw->c = 0;
raw->ct = 0;
}
OPJ_UINT32 raw_decode(opj_raw_t *raw) {
OPJ_UINT32 d;
if (raw->ct == 0) {
raw->ct = 8;
if (raw->len == raw->lenmax) {
raw->c = 0xff;
} else {
if (raw->c == 0xff) {
raw->ct = 7;
}
raw->c = *(raw->start + raw->len);
raw->len++;
}
}
raw->ct--;
d = (raw->c >> raw->ct) & 0x01;
return d; return d;
} }

81
libopenjpeg/raw.h
View File

@@ -1,9 +1,6 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2002-2003, Antonin Descampe
* Copyright (c) 2002-2007, Professor Benoit Macq * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -30,72 +27,22 @@
#ifndef __RAW_H #ifndef __RAW_H
#define __RAW_H #define __RAW_H
/**
@file raw.h
@brief Implementation of operations for raw encoding (RAW)
The functions in RAW.C have for goal to realize the operation of raw encoding linked /*
with the corresponding mode switch. * Return the number of bytes written/read since initialisation
*/ */
#include "openjpeg.h" int raw_numbytes();
/** @defgroup RAW RAW - Implementation of operations for raw encoding */
/*@{*/
/** /*
RAW encoding operations * Initialize the decoder
* bp: pointer to the start of the buffer from which the bytes will be read
* len: length of the input buffer
*/ */
typedef struct opj_raw { void raw_init_dec(unsigned char *bp, int len);
/** temporary buffer where bits are coded or decoded */
OPJ_BYTE c;
/** number of bits already read or free to write */
OPJ_UINT32 ct;
/** maximum length to decode */
OPJ_UINT32 lenmax;
/** length decoded */
OPJ_UINT32 len;
/** pointer to the current position in the buffer */
OPJ_BYTE *bp;
/** pointer to the start of the buffer */
OPJ_BYTE *start;
/** pointer to the end of the buffer */
unsigned char *end;
} opj_raw_t;
/** @name Exported functions */ /*
/*@{*/ * Decode a bit (returns 0 or 1)
/* ----------------------------------------------------------------------- */
/**
Create a new RAW handle
@return Returns a new RAW handle if successful, returns NULL otherwise
*/ */
opj_raw_t* raw_create(void); int raw_decode();
/**
Destroy a previously created RAW handle
@param raw RAW handle to destroy
*/
void raw_destroy(opj_raw_t *raw);
/**
Return the number of bytes written/read since initialisation
@param raw RAW handle to destroy
@return Returns the number of bytes already encoded
*/
OPJ_UINT32 raw_numbytes(opj_raw_t *raw);
/**
Initialize the decoder
@param raw RAW handle
@param bp Pointer to the start of the buffer from which the bytes will be read
@param len Length of the input buffer
*/
void raw_init_dec(opj_raw_t *raw, OPJ_BYTE *bp, OPJ_UINT32 len);
/**
Decode a symbol using raw-decoder. Cfr p.506 TAUBMAN
@param raw RAW handle
@return Returns the decoded symbol (0 or 1)
*/
OPJ_UINT32 raw_decode(opj_raw_t *raw);
/* ----------------------------------------------------------------------- */
/*@}*/
/*@}*/ #endif
#endif /* __RAW_H */

1751
libopenjpeg/t1.c
View File

File diff suppressed because it is too large Load Diff

142
libopenjpeg/t1.h
View File

@@ -1,11 +1,5 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -29,128 +23,30 @@
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef __T1_H #ifndef __T1_H
#define __T1_H #define __T1_H
/**
@file t1.h
@brief Implementation of the tier-1 coding (coding of code-block coefficients) (T1)
The functions in T1.C have for goal to realize the tier-1 coding operation. The functions #include "tcd.h"
in T1.C are used by some function in TCD.C. #include "j2k.h"
/*
* Initialize the look-up tables of the Tier-1 coder/decoder
*/ */
#include "openjpeg.h" void t1_init_luts();
/** @defgroup T1 T1 - Implementation of the tier-1 coding */
/*@{*/
//#include "raw.h"
/* ----------------------------------------------------------------------- */
#define T1_NMSEDEC_BITS 7
#define T1_SIG_NE 0x0001 /**< Context orientation : North-East direction */ /*
#define T1_SIG_SE 0x0002 /**< Context orientation : South-East direction */ * Encode the code-blocks of a tile
#define T1_SIG_SW 0x0004 /**< Context orientation : South-West direction */ * tile: the tile to encode
#define T1_SIG_NW 0x0008 /**< Context orientation : North-West direction */ * tcp: tile coding parameters
#define T1_SIG_N 0x0010 /**< Context orientation : North direction */
#define T1_SIG_E 0x0020 /**< Context orientation : East direction */
#define T1_SIG_S 0x0040 /**< Context orientation : South direction */
#define T1_SIG_W 0x0080 /**< Context orientation : West direction */
#define T1_SIG_OTH (T1_SIG_N|T1_SIG_NE|T1_SIG_E|T1_SIG_SE|T1_SIG_S|T1_SIG_SW|T1_SIG_W|T1_SIG_NW)
#define T1_SIG_PRIM (T1_SIG_N|T1_SIG_E|T1_SIG_S|T1_SIG_W)
#define T1_SGN_N 0x0100
#define T1_SGN_E 0x0200
#define T1_SGN_S 0x0400
#define T1_SGN_W 0x0800
#define T1_SGN (T1_SGN_N|T1_SGN_E|T1_SGN_S|T1_SGN_W)
#define T1_SIG 0x1000
#define T1_REFINE 0x2000
#define T1_VISIT 0x4000
#define T1_NUMCTXS_ZC 9
#define T1_NUMCTXS_SC 5
#define T1_NUMCTXS_MAG 3
#define T1_NUMCTXS_AGG 1
#define T1_NUMCTXS_UNI 1
#define T1_CTXNO_ZC 0
#define T1_CTXNO_SC (T1_CTXNO_ZC+T1_NUMCTXS_ZC)
#define T1_CTXNO_MAG (T1_CTXNO_SC+T1_NUMCTXS_SC)
#define T1_CTXNO_AGG (T1_CTXNO_MAG+T1_NUMCTXS_MAG)
#define T1_CTXNO_UNI (T1_CTXNO_AGG+T1_NUMCTXS_AGG)
#define T1_NUMCTXS (T1_CTXNO_UNI+T1_NUMCTXS_UNI)
#define T1_NMSEDEC_FRACBITS (T1_NMSEDEC_BITS-1)
#define T1_TYPE_MQ 0 /**< Normal coding using entropy coder */
#define T1_TYPE_RAW 1 /**< No encoding the information is store under raw format in codestream (mode switch RAW)*/
/* ----------------------------------------------------------------------- */
struct opj_common_struct;
struct opj_tcd_tile;
struct opj_tcp;
struct opj_tcd_tilecomp;
struct opj_mqc;
struct opj_raw;
struct opj_tccp;
typedef short flag_t;
/**
Tier-1 coding (coding of code-block coefficients)
*/ */
typedef struct opj_t1 { void t1_encode_cblks(tcd_tile_t * tile, j2k_tcp_t * tcp);
/** MQC component */
struct opj_mqc *mqc;
/** RAW component */
struct opj_raw *raw;
OPJ_INT32 *data; /*
flag_t *flags; * Decode the code-blocks of a tile
OPJ_UINT32 w; * tile: the tile to encode
OPJ_UINT32 h; * tcp: tile coding parameters
OPJ_UINT32 datasize;
OPJ_UINT32 flagssize;
OPJ_UINT32 flags_stride;
} opj_t1_t;
#define MACRO_t1_flags(x,y) t1->flags[((x)*(t1->flags_stride))+(y)]
/** @name Exported functions */
/*@{*/
/* ----------------------------------------------------------------------- */
/**
* Creates a new Tier 1 handle
* and initializes the look-up tables of the Tier-1 coder/decoder
* @return a new T1 handle if successful, returns NULL otherwise
*/ */
opj_t1_t* t1_create(); void t1_decode_cblks(tcd_tile_t * tile, j2k_tcp_t * tcp);
/** #endif
* Destroys a previously created T1 handle
*
* @param p_t1 Tier 1 handle to destroy
*/
void t1_destroy(opj_t1_t *p_t1);
/**
Encode the code-blocks of a tile
@param t1 T1 handle
@param tile The tile to encode
@param tcp Tile coding parameters
*/
bool t1_encode_cblks(opj_t1_t *t1, struct opj_tcd_tile *tile, struct opj_tcp *tcp,const OPJ_FLOAT64 * mct_norms);
/**
Decode the code-blocks of a tile
@param t1 T1 handle
@param tile The tile to decode
@param tcp Tile coding parameters
*/
void t1_decode_cblks(opj_t1_t* t1, struct opj_tcd_tilecomp* tilec, struct opj_tccp* tccp);
/* ----------------------------------------------------------------------- */
/*@}*/
/*@}*/
#endif /* __T1_H */

143
libopenjpeg/t1_luts.h
View File

@@ -1,143 +0,0 @@
/* This file was automatically generated by t1_generate_luts.c */
static char lut_ctxno_zc[1024] = {
0, 1, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
0, 1, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
0, 1, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
0, 3, 3, 6, 3, 6, 6, 8, 3, 6, 6, 8, 6, 8, 8, 8, 1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8,
1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8,
1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8,
2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8,
1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8,
2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8,
2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8,
2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8
};
static char lut_ctxno_sc[256] = {
0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xd, 0xc, 0xd, 0xd, 0xd, 0xd, 0xd,
0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xb, 0xc, 0xb, 0xd, 0xc, 0xd, 0xc,
0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xd, 0x9, 0xa, 0xd, 0xd, 0xa, 0xa,
0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xb, 0x9, 0xa, 0xd, 0xc, 0xa, 0x9,
0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xd, 0xc, 0xd, 0xb, 0xc, 0xb, 0xc,
0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xb, 0xc, 0xb, 0xb, 0xb, 0xb, 0xb,
0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xd, 0x9, 0xa, 0xb, 0xc, 0xa, 0x9,
0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xb, 0x9, 0xa, 0xb, 0xb, 0xa, 0xa,
0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xb, 0x9, 0xa, 0xb, 0xb, 0xa, 0xa,
0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xd, 0x9, 0xa, 0xb, 0xc, 0xa, 0x9,
0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xb, 0xc, 0xb, 0xb, 0xb, 0xb, 0xb,
0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xd, 0xc, 0xd, 0xb, 0xc, 0xb, 0xc,
0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xb, 0x9, 0xa, 0xd, 0xc, 0xa, 0x9,
0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xd, 0x9, 0xa, 0xd, 0xd, 0xa, 0xa,
0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xb, 0xc, 0xb, 0xd, 0xc, 0xd, 0xc,
0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xd, 0xc, 0xd, 0xd, 0xd, 0xd, 0xd
};
static char lut_spb[256] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1,
0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
};
static short lut_nmsedec_sig[1 << T1_NMSEDEC_BITS] = {
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0180, 0x0300, 0x0480, 0x0600, 0x0780, 0x0900, 0x0a80,
0x0c00, 0x0d80, 0x0f00, 0x1080, 0x1200, 0x1380, 0x1500, 0x1680,
0x1800, 0x1980, 0x1b00, 0x1c80, 0x1e00, 0x1f80, 0x2100, 0x2280,
0x2400, 0x2580, 0x2700, 0x2880, 0x2a00, 0x2b80, 0x2d00, 0x2e80,
0x3000, 0x3180, 0x3300, 0x3480, 0x3600, 0x3780, 0x3900, 0x3a80,
0x3c00, 0x3d80, 0x3f00, 0x4080, 0x4200, 0x4380, 0x4500, 0x4680,
0x4800, 0x4980, 0x4b00, 0x4c80, 0x4e00, 0x4f80, 0x5100, 0x5280,
0x5400, 0x5580, 0x5700, 0x5880, 0x5a00, 0x5b80, 0x5d00, 0x5e80,
0x6000, 0x6180, 0x6300, 0x6480, 0x6600, 0x6780, 0x6900, 0x6a80,
0x6c00, 0x6d80, 0x6f00, 0x7080, 0x7200, 0x7380, 0x7500, 0x7680
};
static short lut_nmsedec_sig0[1 << T1_NMSEDEC_BITS] = {
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0080, 0x0080,
0x0080, 0x0080, 0x0100, 0x0100, 0x0100, 0x0180, 0x0180, 0x0200,
0x0200, 0x0280, 0x0280, 0x0300, 0x0300, 0x0380, 0x0400, 0x0400,
0x0480, 0x0500, 0x0580, 0x0580, 0x0600, 0x0680, 0x0700, 0x0780,
0x0800, 0x0880, 0x0900, 0x0980, 0x0a00, 0x0a80, 0x0b80, 0x0c00,
0x0c80, 0x0d00, 0x0e00, 0x0e80, 0x0f00, 0x1000, 0x1080, 0x1180,
0x1200, 0x1300, 0x1380, 0x1480, 0x1500, 0x1600, 0x1700, 0x1780,
0x1880, 0x1980, 0x1a80, 0x1b00, 0x1c00, 0x1d00, 0x1e00, 0x1f00,
0x2000, 0x2100, 0x2200, 0x2300, 0x2400, 0x2500, 0x2680, 0x2780,
0x2880, 0x2980, 0x2b00, 0x2c00, 0x2d00, 0x2e80, 0x2f80, 0x3100,
0x3200, 0x3380, 0x3480, 0x3600, 0x3700, 0x3880, 0x3a00, 0x3b00,
0x3c80, 0x3e00, 0x3f80, 0x4080, 0x4200, 0x4380, 0x4500, 0x4680,
0x4800, 0x4980, 0x4b00, 0x4c80, 0x4e00, 0x4f80, 0x5180, 0x5300,
0x5480, 0x5600, 0x5800, 0x5980, 0x5b00, 0x5d00, 0x5e80, 0x6080,
0x6200, 0x6400, 0x6580, 0x6780, 0x6900, 0x6b00, 0x6d00, 0x6e80,
0x7080, 0x7280, 0x7480, 0x7600, 0x7800, 0x7a00, 0x7c00, 0x7e00
};
static short lut_nmsedec_ref[1 << T1_NMSEDEC_BITS] = {
0x1800, 0x1780, 0x1700, 0x1680, 0x1600, 0x1580, 0x1500, 0x1480,
0x1400, 0x1380, 0x1300, 0x1280, 0x1200, 0x1180, 0x1100, 0x1080,
0x1000, 0x0f80, 0x0f00, 0x0e80, 0x0e00, 0x0d80, 0x0d00, 0x0c80,
0x0c00, 0x0b80, 0x0b00, 0x0a80, 0x0a00, 0x0980, 0x0900, 0x0880,
0x0800, 0x0780, 0x0700, 0x0680, 0x0600, 0x0580, 0x0500, 0x0480,
0x0400, 0x0380, 0x0300, 0x0280, 0x0200, 0x0180, 0x0100, 0x0080,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0080, 0x0100, 0x0180, 0x0200, 0x0280, 0x0300, 0x0380,
0x0400, 0x0480, 0x0500, 0x0580, 0x0600, 0x0680, 0x0700, 0x0780,
0x0800, 0x0880, 0x0900, 0x0980, 0x0a00, 0x0a80, 0x0b00, 0x0b80,
0x0c00, 0x0c80, 0x0d00, 0x0d80, 0x0e00, 0x0e80, 0x0f00, 0x0f80,
0x1000, 0x1080, 0x1100, 0x1180, 0x1200, 0x1280, 0x1300, 0x1380,
0x1400, 0x1480, 0x1500, 0x1580, 0x1600, 0x1680, 0x1700, 0x1780
};
static short lut_nmsedec_ref0[1 << T1_NMSEDEC_BITS] = {
0x2000, 0x1f00, 0x1e00, 0x1d00, 0x1c00, 0x1b00, 0x1a80, 0x1980,
0x1880, 0x1780, 0x1700, 0x1600, 0x1500, 0x1480, 0x1380, 0x1300,
0x1200, 0x1180, 0x1080, 0x1000, 0x0f00, 0x0e80, 0x0e00, 0x0d00,
0x0c80, 0x0c00, 0x0b80, 0x0a80, 0x0a00, 0x0980, 0x0900, 0x0880,
0x0800, 0x0780, 0x0700, 0x0680, 0x0600, 0x0580, 0x0580, 0x0500,
0x0480, 0x0400, 0x0400, 0x0380, 0x0300, 0x0300, 0x0280, 0x0280,
0x0200, 0x0200, 0x0180, 0x0180, 0x0100, 0x0100, 0x0100, 0x0080,
0x0080, 0x0080, 0x0080, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0080, 0x0080,
0x0080, 0x0080, 0x0100, 0x0100, 0x0100, 0x0180, 0x0180, 0x0200,
0x0200, 0x0280, 0x0280, 0x0300, 0x0300, 0x0380, 0x0400, 0x0400,
0x0480, 0x0500, 0x0580, 0x0580, 0x0600, 0x0680, 0x0700, 0x0780,
0x0800, 0x0880, 0x0900, 0x0980, 0x0a00, 0x0a80, 0x0b80, 0x0c00,
0x0c80, 0x0d00, 0x0e00, 0x0e80, 0x0f00, 0x1000, 0x1080, 0x1180,
0x1200, 0x1300, 0x1380, 0x1480, 0x1500, 0x1600, 0x1700, 0x1780,
0x1880, 0x1980, 0x1a80, 0x1b00, 0x1c00, 0x1d00, 0x1e00, 0x1f00
};

1626
libopenjpeg/t2.c
View File

File diff suppressed because it is too large Load Diff

114
libopenjpeg/t2.h
View File

@@ -1,11 +1,7 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren * Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -29,92 +25,40 @@
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef __T2_H #ifndef __T2_H
#define __T2_H #define __T2_H
/**
@file t2.h
@brief Implementation of a tier-2 coding (packetization of code-block data) (T2)
*/ #include "tcd.h"
#include "openjpeg.h" #include "j2k.h"
struct opj_common_struct; /*
struct opj_image; * Encode the packets of a tile to a destination buffer
struct opj_cp;
struct opj_tcd_tile;
struct opj_codestream_info;
/** @defgroup T2 T2 - Implementation of a tier-2 coding */
/*@{*/
/**
T2 encoding mode
*/
typedef enum T2_MODE
{
THRESH_CALC = 0, /** Function called in Rate allocation process*/
FINAL_PASS = 1 /** Function called in Tier 2 process*/
}
J2K_T2_MODE;
/**
Tier-2 coding
*/
typedef struct opj_t2 {
/** Encoding: pointer to the src image. Decoding: pointer to the dst image. */
struct opj_image *image;
/** pointer to the image coding parameters */
struct opj_cp *cp;
} opj_t2_t;
/** @name Exported functions */
/*@{*/
/* ----------------------------------------------------------------------- */
/**
Encode the packets of a tile to a destination buffer
@param t2 T2 handle
@param tileno number of the tile encoded
@param tile the tile for which to write the packets
@param maxlayers maximum number of layers
@param dest the destination buffer
@param len the length of the destination buffer
@param cstr_info Codestream information structure
@param tpnum Tile part number of the current tile
@param tppos The position of the tile part flag in the progression order
@param t2_mode If == 0 In Threshold calculation ,If == 1 Final pass
*/
bool t2_encode_packets(opj_t2_t* t2,OPJ_UINT32 tileno, struct opj_tcd_tile *tile, OPJ_UINT32 maxlayers, OPJ_BYTE *dest, OPJ_UINT32 * p_data_written, OPJ_UINT32 len, struct opj_codestream_info *cstr_info,OPJ_UINT32 tpnum, OPJ_INT32 tppos,OPJ_UINT32 pino,J2K_T2_MODE t2_mode);
/**
Decode the packets of a tile from a source buffer
@param t2 T2 handle
@param src the source buffer
@param len length of the source buffer
@param tileno number that identifies the tile for which to decode the packets
@param tile tile for which to decode the packets
*/
bool t2_decode_packets(opj_t2_t *t2, OPJ_UINT32 tileno,struct opj_tcd_tile *tile, OPJ_BYTE *src, OPJ_UINT32 * p_data_read, OPJ_UINT32 len, struct opj_codestream_info *cstr_info);
/**
* Creates a Tier 2 handle
* *
* @param p_image Source or destination image * img : the source image
* @param p_cp Image coding parameters. * cp : the image coding parameters
* @return a new T2 handle if successful, NULL otherwise. * tileno : number of the tile encoded
* tile : the tile for which to write the packets
* maxlayers : maximum number of layers
* dest : the destination buffer
* len : the length of the destination buffer
* info_IM : structure to create an index file
*/ */
opj_t2_t* t2_create(struct opj_image *p_image, struct opj_cp *p_cp); int t2_encode_packets(j2k_image_t * img, j2k_cp_t * cp, int tileno,
tcd_tile_t * tile, int maxlayers,
unsigned char *dest, int len, info_image * info_IM);
/** /*
* Destroys a Tier 2 handle. * Decode the packets of a tile from a source buffer
* *
* @param p_t2 the Tier 2 handle to destroy * src: the source buffer
* len: length of the source buffer
* img: destination image
* cp: image coding parameters
* tileno: number that identifies the tile for which to decode the packets
* tile: tile for which to decode the packets
*/ */
void t2_destroy(opj_t2_t *t2); int t2_decode_packets(unsigned char *src, int len, j2k_image_t * img,
j2k_cp_t * cp, int tileno, tcd_tile_t * tile);
/* ----------------------------------------------------------------------- */ #endif
/*@}*/
/*@}*/
#endif /* __T2_H */

3229
libopenjpeg/tcd.c
View File

File diff suppressed because it is too large Load Diff

439
libopenjpeg/tcd.h
View File

@@ -1,11 +1,7 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren * Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe * Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -29,316 +25,159 @@
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef __TCD_H #ifndef __TCD_H
#define __TCD_H #define __TCD_H
/**
@file tcd.h
@brief Implementation of a tile coder/decoder (TCD)
The functions in TCD.C have for goal to encode or decode each tile independently from #include "j2k.h"
each other. The functions in TCD.C are used by some function in J2K.C. #include "tgt.h"
typedef struct {
int numpasses;
int len;
unsigned char *data;
int maxpasses;
int numnewpasses;
int newlen;
} tcd_seg_t;
typedef struct {
int rate;
double distortiondec;
int term, len;
} tcd_pass_t;
typedef struct {
int numpasses; /* Number of passes in the layer */
int len; /* len of information */
double disto; /* add for index (Cfr. Marcela) */
unsigned char *data; /* data */
} tcd_layer_t;
typedef struct {
int x0, y0, x1, y1; /* dimension of the code-blocks : left upper corner (x0, y0) right low corner (x1,y1) */
int numbps;
int numlenbits;
int len; /* length */
int numpasses; /* number of pass already done for the code-blocks */
int numnewpasses; /* number of pass added to the code-blocks */
int numsegs; /* number of segments */
tcd_seg_t segs[100]; /* segments informations */
unsigned char data[8192]; /* Data */
int numpassesinlayers; /* number of passes in the layer */
tcd_layer_t layers[100]; /* layer information */
int totalpasses; /* total number of passes */
tcd_pass_t passes[100]; /* information about the passes */
} tcd_cblk_t;
typedef struct {
int x0, y0, x1, y1; /* dimension of the precinct : left upper corner (x0, y0) right low corner (x1,y1) */
int cw, ch; /* number of precinct in width and heigth */
tcd_cblk_t *cblks; /* code-blocks informations */
tgt_tree_t *incltree; /* inclusion tree */
tgt_tree_t *imsbtree; /* IMSB tree */
} tcd_precinct_t;
typedef struct {
int x0, y0, x1, y1; /* dimension of the subband : left upper corner (x0, y0) right low corner (x1,y1) */
int bandno;
tcd_precinct_t *precincts; /* precinct information */
int numbps;
float stepsize;
} tcd_band_t;
typedef struct {
int x0, y0, x1, y1; /* dimension of the resolution level : left upper corner (x0, y0) right low corner (x1,y1) */
int pw, ph;
int numbands; /* number sub-band for the resolution level */
tcd_band_t bands[3]; /* subband information */
} tcd_resolution_t;
typedef struct {
int x0, y0, x1, y1; /* dimension of component : left upper corner (x0, y0) right low corner (x1,y1) */
int numresolutions; /* number of resolutions level */
tcd_resolution_t *resolutions; /* resolutions information */
int *data; /* data of the component */
int nbpix; /* add fixed_quality */
} tcd_tilecomp_t;
typedef struct {
int x0, y0, x1, y1; /* dimension of the tile : left upper corner (x0, y0) right low corner (x1,y1) */
int numcomps; /* number of components in tile */
tcd_tilecomp_t *comps; /* Components information */
int nbpix; /* add fixed_quality */
double distotile; /* add fixed_quality */
double distolayer[100]; /* add fixed_quality */
} tcd_tile_t;
typedef struct {
int tw, th; /* number of tiles in width and heigth */
tcd_tile_t *tiles; /* Tiles information */
} tcd_image_t;
/*
* Initialize the tile coder (reuses the memory allocated by tcd_malloc_encode)
* img: raw image
* cp: coding parameters
* curtileno : number that identifies the tile that will be encoded
*/ */
#include "openjpeg.h" void tcd_init_encode(j2k_image_t * img, j2k_cp_t * cp, int curtileno);
/** @defgroup TCD TCD - Implementation of a tile coder/decoder */
/*@{*/
struct opj_common_struct;
struct opj_codestream_info;
struct opj_image;
struct opj_tcp;
struct opj_cp;
struct opj_tgt_tree;
/**
FIXME: documentation /*
* Initialize the tile coder (allocate the memory)
* img: raw image
* cp: coding parameters
* curtileno : number that identifies the tile that will be encoded
*/ */
typedef struct opj_tcd_seg { void tcd_malloc_encode(j2k_image_t * img, j2k_cp_t * cp, int curtileno);
OPJ_BYTE ** data;
OPJ_UINT32 dataindex;
OPJ_UINT32 numpasses;
OPJ_UINT32 real_num_passes;
OPJ_UINT32 len;
OPJ_UINT32 maxpasses;
OPJ_UINT32 numnewpasses;
OPJ_UINT32 newlen;
} opj_tcd_seg_t;
/**
FIXME: documentation /*
* Initialize the tile decoder
* img: raw image
* cp: coding parameters
*/ */
typedef struct opj_tcd_pass { void tcd_init(j2k_image_t * img, j2k_cp_t * cp);
OPJ_UINT32 rate;
OPJ_FLOAT64 distortiondec;
OPJ_UINT32 len;
OPJ_UINT32 term : 1;
} opj_tcd_pass_t;
/**
FIXME: documentation /*
* Free the memory allocated for encoding
* img: raw image
* cp: coding parameters
* curtileno : number that identifies the tile that will be encoded
*/ */
typedef struct opj_tcd_layer { void tcd_free_encode(j2k_image_t * img, j2k_cp_t * cp, int curtileno);
OPJ_UINT32 numpasses; /* Number of passes in the layer */
OPJ_UINT32 len; /* len of information */
OPJ_FLOAT64 disto; /* add for index (Cfr. Marcela) */
OPJ_BYTE *data; /* data */
} opj_tcd_layer_t;
/** /*
FIXME: documentation * Encode a tile from the raw image into a buffer, format pnm, pgm or ppm
* tileno: number that identifies one of the tiles to be encoded
* dest: destination buffer
* len: length of destination buffer
* info_IM: creation of index file
*/ */
typedef struct opj_tcd_cblk_enc { int tcd_encode_tile_pxm(int tileno, unsigned char *dest, int len,
OPJ_BYTE* data; /* Data */ info_image * info_IM);
opj_tcd_layer_t* layers; /* layer information */
opj_tcd_pass_t* passes; /* information about the passes */
OPJ_INT32 x0, y0, x1, y1; /* dimension of the code-blocks : left upper corner (x0, y0) right low corner (x1,y1) */
OPJ_UINT32 numbps;
OPJ_UINT32 numlenbits;
OPJ_UINT32 numpasses; /* number of pass already done for the code-blocks */
OPJ_UINT32 numpassesinlayers; /* number of passes in the layer */
OPJ_UINT32 totalpasses; /* total number of passes */
} opj_tcd_cblk_enc_t;
typedef struct opj_tcd_cblk_dec {
OPJ_BYTE * data; /* Data */
opj_tcd_seg_t* segs; /* segments informations */
OPJ_INT32 x0, y0, x1, y1; /* dimension of the code-blocks : left upper corner (x0, y0) right low corner (x1,y1) */
OPJ_UINT32 numbps;
OPJ_UINT32 numlenbits;
OPJ_UINT32 len; /* length */
OPJ_UINT32 numnewpasses; /* number of pass added to the code-blocks */
OPJ_UINT32 numsegs; /* number of segments */
OPJ_UINT32 real_num_segs;
OPJ_UINT32 m_current_max_segs;
} opj_tcd_cblk_dec_t;
/** /*
FIXME: documentation * Encode a tile from the raw image into a buffer, format pgx
* tileno: number that identifies one of the tiles to be encoded
* dest: destination buffer
* len: length of destination buffer
* info_IM: creation of index file
*/ */
typedef struct opj_tcd_precinct { int tcd_encode_tile_pgx(int tileno, unsigned char *dest, int len,
OPJ_INT32 x0, y0, x1, y1; /* dimension of the precinct : left upper corner (x0, y0) right low corner (x1,y1) */ info_image * info_IM);
OPJ_UINT32 cw, ch; /* number of precinct in width and heigth */
union{ /* code-blocks informations */
opj_tcd_cblk_enc_t* enc;
opj_tcd_cblk_dec_t* dec;
} cblks;
OPJ_UINT32 block_size; /* size taken by cblks (in bytes) */
struct opj_tgt_tree *incltree; /* inclusion tree */
struct opj_tgt_tree *imsbtree; /* IMSB tree */
} opj_tcd_precinct_t;
/** /*
FIXME: documentation * Decode a tile from a buffer into a raw image
* src: source buffer
* len: length of the source buffer
* tileno: number that identifies the tile that will be decoded
*/ */
typedef struct opj_tcd_band { int tcd_decode_tile(unsigned char *src, int len, int tileno);
OPJ_INT32 x0, y0, x1, y1; /* dimension of the subband : left upper corner (x0, y0) right low corner (x1,y1) */
OPJ_UINT32 bandno;
opj_tcd_precinct_t *precincts; /* precinct information */
OPJ_UINT32 precincts_data_size; /* size of data taken by precincts */
OPJ_INT32 numbps;
OPJ_FLOAT32 stepsize;
} opj_tcd_band_t;
/** void tcd_dec_release();
FIXME: documentation
*/
typedef struct opj_tcd_resolution {
OPJ_INT32 x0, y0, x1, y1; /* dimension of the resolution level : left upper corner (x0, y0) right low corner (x1,y1) */
OPJ_UINT32 pw, ph;
OPJ_UINT32 numbands; /* number sub-band for the resolution level */
opj_tcd_band_t bands[3]; /* subband information */
} opj_tcd_resolution_t;
/** #endif
FIXME: documentation
*/
typedef struct opj_tcd_tilecomp
{
OPJ_INT32 x0, y0, x1, y1; /* dimension of component : left upper corner (x0, y0) right low corner (x1,y1) */
OPJ_UINT32 numresolutions; /* number of resolutions level */
OPJ_UINT32 minimum_num_resolutions; /* number of resolutions level to decode (at max)*/
opj_tcd_resolution_t *resolutions; /* resolutions information */
OPJ_UINT32 resolutions_size; /* size of data for resolutions (in bytes) */
OPJ_INT32 *data; /* data of the component */
OPJ_UINT32 data_size; /* size of the data of the component */
OPJ_INT32 numpix; /* add fixed_quality */
} opj_tcd_tilecomp_t;
/**
FIXME: documentation
*/
typedef struct opj_tcd_tile {
OPJ_INT32 x0, y0, x1, y1; /* dimension of the tile : left upper corner (x0, y0) right low corner (x1,y1) */
OPJ_UINT32 numcomps; /* number of components in tile */
opj_tcd_tilecomp_t *comps; /* Components information */
OPJ_INT32 numpix; /* add fixed_quality */
OPJ_FLOAT64 distotile; /* add fixed_quality */
OPJ_FLOAT64 distolayer[100]; /* add fixed_quality */
/** packet number */
OPJ_UINT32 packno;
} opj_tcd_tile_t;
/**
FIXME: documentation
*/
typedef struct opj_tcd_image
{
opj_tcd_tile_t *tiles; /* Tiles information */
}
opj_tcd_image_t;
/**
Tile coder/decoder
*/
typedef struct opj_tcd
{
/** Position of the tilepart flag in Progression order*/
OPJ_INT32 tp_pos;
/** Tile part number*/
OPJ_UINT32 tp_num;
/** Current tile part number*/
OPJ_UINT32 cur_tp_num;
/** Total number of tileparts of the current tile*/
OPJ_UINT32 cur_totnum_tp;
/** Current Packet iterator number */
OPJ_UINT32 cur_pino;
/** info on each image tile */
struct opj_tcd_image *tcd_image;
/** image */
struct opj_image *image;
/** coding parameters */
struct opj_cp *cp;
/** coding/decoding parameters common to all tiles */
struct opj_tcp *tcp;
/** current encoded/decoded tile */
OPJ_UINT32 tcd_tileno;
/** tell if the tcd is a decoder. */
OPJ_UINT32 m_is_decoder : 1;
} opj_tcd_t;
/** @name Exported functions */
/*@{*/
/* ----------------------------------------------------------------------- */
/**
Dump the content of a tcd structure
*/
//void tcd_dump(FILE *fd, opj_tcd_t *tcd, opj_tcd_image_t *img);
/**
Create a new TCD handle
@param cinfo Codec context info
@return Returns a new TCD handle if successful returns NULL otherwise
*/
opj_tcd_t* tcd_create(bool p_is_decoder);
/**
Destroy a previously created TCD handle
@param tcd TCD handle to destroy
*/
void tcd_destroy(opj_tcd_t *tcd);
/**
* Initialize the tile coder and may reuse some meory.
* @param p_tcd TCD handle.
* @param p_image raw image.
* @param p_cp coding parameters.
* @param p_tile_no current tile index to encode.
*
* @return true if the encoding values could be set (false otherwise).
*/
bool tcd_init(
opj_tcd_t *p_tcd,
struct opj_image * p_image,
struct opj_cp * p_cp
);
/**
* Allocates memory for decoding a specific tile.
*
* @param p_tcd the tile decoder.
* @param p_image the image to decode.
* @param p_cp the decoding parameters.
* @param p_tile_no the index of the tile received in sequence. This not necesseraly lead to the
* tile at index p_tile_no.
* @param p_cstr_info codestream info (if any).
*
* @return true if the remaining data is sufficient.s
*/
bool tcd_init_decode_tile(
opj_tcd_t *p_tcd,
OPJ_UINT32 p_tile_no
);
/**
* Initialize the tile coder and may reuse some meory.
* @param p_tcd TCD handle.
* @param p_image raw image.
* @param p_cp coding parameters.
* @param p_tile_no current tile index to encode.
*
* @return true if the encoding values could be set (false otherwise).
*/
bool tcd_init_encode_tile
(
opj_tcd_t *p_tcd,
OPJ_UINT32 p_tile_no
);
void tcd_makelayer_fixed(opj_tcd_t *tcd, OPJ_UINT32 layno, OPJ_UINT32 final);
void tcd_rateallocate_fixed(opj_tcd_t *tcd);
void tcd_makelayer(opj_tcd_t *tcd, OPJ_UINT32 layno, OPJ_FLOAT64 thresh, OPJ_UINT32 final);
bool tcd_rateallocate(opj_tcd_t *tcd, OPJ_BYTE *dest, OPJ_UINT32 * p_data_written, OPJ_UINT32 len, struct opj_codestream_info *cstr_info);
/**
* Encodes a tile from the raw image into the given buffer.
* @param p_tcd Tile Coder handle
* @param p_tile_no Index of the tile to encode.
* @param p_dest Destination buffer
* @param p_data_written pointer to an int that is incremented by the number of bytes really written on p_dest
* @param p_len Maximum length of the destination buffer
* @param p_cstr_info Codestream information structure
* @return true if the coding is successfull.
*/
bool tcd_encode_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no, OPJ_BYTE *p_dest, OPJ_UINT32 * p_data_written, OPJ_UINT32 p_len, struct opj_codestream_info *p_cstr_info);
/**
Decode a tile from a buffer into a raw image
@param tcd TCD handle
@param src Source buffer
@param len Length of source buffer
@param tileno Number that identifies one of the tiles to be decoded
*/
bool tcd_decode_tile(opj_tcd_t *tcd, OPJ_BYTE *src, OPJ_UINT32 len, OPJ_UINT32 tileno, struct opj_codestream_info *cstr_info);
/**
* Copies tile data from the given memory block onto the system.
*/
bool tcd_copy_tile_data (
opj_tcd_t *p_tcd,
OPJ_BYTE * p_src,
OPJ_UINT32 p_src_length
);
/**
* Copies tile data from the system onto the given memory block.
*/
bool tcd_update_tile_data (
opj_tcd_t *p_tcd,
OPJ_BYTE * p_dest,
OPJ_UINT32 p_dest_length
);
/**
* Gets the maximum tile size that will be taken by the tile once decoded.
*/
OPJ_UINT32 tcd_get_decoded_tile_size (
opj_tcd_t *p_tcd
);
OPJ_UINT32 tcd_get_encoded_tile_size (
opj_tcd_t *p_tcd
);
/* ----------------------------------------------------------------------- */
/*@}*/
/*@}*/
#endif /* __TCD_H */

277
libopenjpeg/tgt.c
View File

@@ -1,11 +1,5 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -32,30 +26,42 @@
#include "tgt.h" #include "tgt.h"
#include "bio.h" #include "bio.h"
#include "opj_malloc.h" #include <stdlib.h>
#include <stdio.h>
/* /* <summary> */
========================================================== /* Reset tag-tree. */
Tag-tree coder interface /* </summary> */
========================================================== void tgt_reset(tgt_tree_t * tree)
*/ {
int i;
/* new */
if (!tree || tree == NULL)
return;
opj_tgt_tree_t *tgt_create(OPJ_UINT32 numleafsh, OPJ_UINT32 numleafsv) { for (i = 0; i < tree->numnodes; i++) {
OPJ_INT32 nplh[32]; tree->nodes[i].value = 999;
OPJ_INT32 nplv[32]; tree->nodes[i].low = 0;
opj_tgt_node_t *node = 00; tree->nodes[i].known = 0;
opj_tgt_node_t *l_parent_node = 00; }
opj_tgt_node_t *l_parent_node0 = 00; }
opj_tgt_tree_t *tree = 00;
OPJ_UINT32 i;
OPJ_INT32 j,k;
OPJ_UINT32 numlvls;
OPJ_UINT32 n;
tree = (opj_tgt_tree_t *) opj_malloc(sizeof(opj_tgt_tree_t)); /* <summary> */
if(!tree) return 00; /* Create tag-tree. */
memset(tree,0,sizeof(opj_tgt_tree_t)); /* </summary> */
tgt_tree_t *tgt_create(int numleafsh, int numleafsv)
{
int nplh[32];
int nplv[32];
tgt_node_t *node;
tgt_node_t *parentnode;
tgt_node_t *parentnode0;
tgt_tree_t *tree;
int i, j, k;
int numlvls;
int n;
tree = (tgt_tree_t *) malloc(sizeof(tgt_tree_t));
tree->numleafsh = numleafsh; tree->numleafsh = numleafsh;
tree->numleafsv = numleafsv; tree->numleafsv = numleafsv;
@@ -73,192 +79,58 @@ opj_tgt_tree_t *tgt_create(OPJ_UINT32 numleafsh, OPJ_UINT32 numleafsv) {
/* ADD */ /* ADD */
if (tree->numnodes == 0) { if (tree->numnodes == 0) {
opj_free(tree); free(tree);
return 00; return NULL;
} }
tree->nodes = (opj_tgt_node_t*) opj_calloc(tree->numnodes, sizeof(opj_tgt_node_t)); tree->nodes = (tgt_node_t *) malloc(tree->numnodes * sizeof(tgt_node_t));
if(!tree->nodes) {
opj_free(tree);
return 00;
}
memset(tree->nodes,0,tree->numnodes * sizeof(opj_tgt_node_t));
tree->nodes_size = tree->numnodes * sizeof(opj_tgt_node_t);
node = tree->nodes; node = tree->nodes;
l_parent_node = &tree->nodes[tree->numleafsh * tree->numleafsv]; parentnode = &tree->nodes[tree->numleafsh * tree->numleafsv];
l_parent_node0 = l_parent_node; parentnode0 = parentnode;
for (i = 0; i < numlvls - 1; ++i) { for (i = 0; i < numlvls - 1; ++i) {
for (j = 0; j < nplv[i]; ++j) { for (j = 0; j < nplv[i]; ++j) {
k = nplh[i]; k = nplh[i];
while (--k >= 0) { while (--k >= 0) {
node->parent = l_parent_node; node->parent = parentnode;
++node; ++node;
if (--k >= 0) { if (--k >= 0) {
node->parent = l_parent_node; node->parent = parentnode;
++node; ++node;
} }
++l_parent_node; ++parentnode;
} }
if ((j & 1) || j == nplv[i] - 1) { if ((j & 1) || j == nplv[i] - 1) {
l_parent_node0 = l_parent_node; parentnode0 = parentnode;
} else { } else {
l_parent_node = l_parent_node0; parentnode = parentnode0;
l_parent_node0 += nplh[i]; parentnode0 += nplh[i];
} }
} }
} }
node->parent = 0; node->parent = 0;
tgt_reset(tree); tgt_reset(tree);
return tree; return tree;
} }
/**
* Reinitialises a tag-tree from an exixting one.
*
* @param p_tree the tree to reinitialize.
* @param p_num_leafs_h the width of the array of leafs of the tree
* @param p_num_leafs_v the height of the array of leafs of the tree
* @return a new tag-tree if successful, NULL otherwise
*/
opj_tgt_tree_t *tgt_init(opj_tgt_tree_t * p_tree,OPJ_UINT32 p_num_leafs_h, OPJ_UINT32 p_num_leafs_v)
{
OPJ_INT32 l_nplh[32];
OPJ_INT32 l_nplv[32];
opj_tgt_node_t *l_node = 00;
opj_tgt_node_t *l_parent_node = 00;
opj_tgt_node_t *l_parent_node0 = 00;
OPJ_UINT32 i;
OPJ_INT32 j,k;
OPJ_UINT32 l_num_levels;
OPJ_UINT32 n;
OPJ_UINT32 l_node_size;
if /* <summary> */
(! p_tree) /* Destroy tag-tree. */
/* </summary> */
void tgt_destroy(tgt_tree_t * t)
{ {
return 00; free(t->nodes);
} free(t);
if
((p_tree->numleafsh != p_num_leafs_h) || (p_tree->numleafsv != p_num_leafs_v))
{
p_tree->numleafsh = p_num_leafs_h;
p_tree->numleafsv = p_num_leafs_v;
l_num_levels = 0;
l_nplh[0] = p_num_leafs_h;
l_nplv[0] = p_num_leafs_v;
p_tree->numnodes = 0;
do
{
n = l_nplh[l_num_levels] * l_nplv[l_num_levels];
l_nplh[l_num_levels + 1] = (l_nplh[l_num_levels] + 1) / 2;
l_nplv[l_num_levels + 1] = (l_nplv[l_num_levels] + 1) / 2;
p_tree->numnodes += n;
++l_num_levels;
}
while (n > 1);
/* ADD */
if
(p_tree->numnodes == 0)
{
tgt_destroy(p_tree);
return 00;
}
l_node_size = p_tree->numnodes * sizeof(opj_tgt_node_t);
if
(l_node_size > p_tree->nodes_size)
{
p_tree->nodes = (opj_tgt_node_t*) opj_realloc(p_tree->nodes, l_node_size);
if
(! p_tree->nodes)
{
tgt_destroy(p_tree);
return 00;
}
memset(((char *) p_tree->nodes) + p_tree->nodes_size, 0 , l_node_size - p_tree->nodes_size);
p_tree->nodes_size = l_node_size;
}
l_node = p_tree->nodes;
l_parent_node = &p_tree->nodes[p_tree->numleafsh * p_tree->numleafsv];
l_parent_node0 = l_parent_node;
for
(i = 0; i < l_num_levels - 1; ++i)
{
for
(j = 0; j < l_nplv[i]; ++j)
{
k = l_nplh[i];
while
(--k >= 0)
{
l_node->parent = l_parent_node;
++l_node;
if (--k >= 0)
{
l_node->parent = l_parent_node;
++l_node;
}
++l_parent_node;
}
if ((j & 1) || j == l_nplv[i] - 1)
{
l_parent_node0 = l_parent_node;
}
else
{
l_parent_node = l_parent_node0;
l_parent_node0 += l_nplh[i];
}
}
}
l_node->parent = 0;
}
tgt_reset(p_tree);
return p_tree;
} }
void tgt_destroy(opj_tgt_tree_t *p_tree) /* <summary> */
/* Set the value of a leaf of the tag-tree. */
/* </summary> */
void tgt_setvalue(tgt_tree_t * tree, int leafno, int value)
{ {
if tgt_node_t *node;
(! p_tree)
{
return;
}
if
(p_tree->nodes)
{
opj_free(p_tree->nodes);
p_tree->nodes = 00;
}
opj_free(p_tree);
}
void tgt_reset(opj_tgt_tree_t *p_tree) {
OPJ_UINT32 i;
opj_tgt_node_t * l_current_node = 00;;
if
(! p_tree)
{
return;
}
l_current_node = p_tree->nodes;
for
(i = 0; i < p_tree->numnodes; ++i)
{
l_current_node->value = 999;
l_current_node->low = 0;
l_current_node->known = 0;
++l_current_node;
}
}
void tgt_setvalue(opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT32 value) {
opj_tgt_node_t *node;
node = &tree->nodes[leafno]; node = &tree->nodes[leafno];
while (node && node->value > value) { while (node && node->value > value) {
node->value = value; node->value = value;
@@ -266,11 +138,15 @@ void tgt_setvalue(opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT32 value) {
} }
} }
void tgt_encode(opj_bio_t *bio, opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT32 threshold) { /* <summary> */
opj_tgt_node_t *stk[31]; /* Encode the value of a leaf of the tag-tree. */
opj_tgt_node_t **stkptr; /* </summary> */
opj_tgt_node_t *node; void tgt_encode(tgt_tree_t * tree, int leafno, int threshold)
OPJ_INT32 low; {
tgt_node_t *stk[31];
tgt_node_t **stkptr;
tgt_node_t *node;
int low;
stkptr = stk; stkptr = stk;
node = &tree->nodes[leafno]; node = &tree->nodes[leafno];
@@ -290,12 +166,12 @@ void tgt_encode(opj_bio_t *bio, opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT
while (low < threshold) { while (low < threshold) {
if (low >= node->value) { if (low >= node->value) {
if (!node->known) { if (!node->known) {
bio_write(bio, 1, 1); bio_write(1, 1);
node->known = 1; node->known = 1;
} }
break; break;
} }
bio_write(bio, 0, 1); bio_write(0, 1);
++low; ++low;
} }
@@ -304,13 +180,18 @@ void tgt_encode(opj_bio_t *bio, opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT
break; break;
node = *--stkptr; node = *--stkptr;
} }
} }
OPJ_UINT32 tgt_decode(opj_bio_t *bio, opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT32 threshold) { /* <summary> */
opj_tgt_node_t *stk[31]; /* Decode the value of a leaf of the tag-tree. */
opj_tgt_node_t **stkptr; /* </summary> */
opj_tgt_node_t *node; int tgt_decode(tgt_tree_t * tree, int leafno, int threshold)
OPJ_INT32 low; {
tgt_node_t *stk[31];
tgt_node_t **stkptr;
tgt_node_t *node;
int low;
stkptr = stk; stkptr = stk;
node = &tree->nodes[leafno]; node = &tree->nodes[leafno];
@@ -327,7 +208,7 @@ OPJ_UINT32 tgt_decode(opj_bio_t *bio, opj_tgt_tree_t *tree, OPJ_UINT32 leafno,
low = node->low; low = node->low;
} }
while (low < threshold && low < node->value) { while (low < threshold && low < node->value) {
if (bio_read(bio, 1)) { if (bio_read(1)) {
node->value = low; node->value = low;
} else { } else {
++low; ++low;

143
libopenjpeg/tgt.h
View File

@@ -1,11 +1,5 @@
/* /*
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium * Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2007, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -32,99 +26,62 @@
#ifndef __TGT_H #ifndef __TGT_H
#define __TGT_H #define __TGT_H
/**
@file tgt.h
@brief Implementation of a tag-tree coder (TGT)
The functions in TGT.C have for goal to realize a tag-tree coder. The functions in TGT.C typedef struct tgt_node {
are used by some function in T2.C. struct tgt_node *parent;
*/ int value;
#include "openjpeg.h" int low;
/** @defgroup TGT TGT - Implementation of a tag-tree coder */ int known;
/*@{*/ } tgt_node_t;
struct opj_bio;
/** typedef struct {
Tag node int numleafsh;
*/ int numleafsv;
typedef struct opj_tgt_node int numnodes;
{ tgt_node_t *nodes;
struct opj_tgt_node *parent; } tgt_tree_t;
OPJ_INT32 value;
OPJ_INT32 low;
OPJ_UINT32 known : 1;
} opj_tgt_node_t;
/**
Tag tree
*/
typedef struct opj_tgt_tree
{
OPJ_UINT32 numleafsh;
OPJ_UINT32 numleafsv;
OPJ_UINT32 numnodes;
opj_tgt_node_t *nodes;
OPJ_UINT32 nodes_size; /* maximum size taken by nodes */
} opj_tgt_tree_t;
/** @name Exported functions */
/*@{*/
/* ----------------------------------------------------------------------- */
/**
Create a tag-tree
@param numleafsh Width of the array of leafs of the tree
@param numleafsv Height of the array of leafs of the tree
@return Returns a new tag-tree if successful, returns NULL otherwise
*/
opj_tgt_tree_t *tgt_create(OPJ_UINT32 numleafsh, OPJ_UINT32 numleafsv);
/** /*
* Reinitialises a tag-tree from an exixting one. * Reset a tag-tree (set all leaves to 0)
* * tree: tag-tree to reset
* @param p_tree the tree to reinitialize.
* @param p_num_leafs_h the width of the array of leafs of the tree
* @param p_num_leafs_v the height of the array of leafs of the tree
* @return a new tag-tree if successful, NULL otherwise
*/ */
opj_tgt_tree_t *tgt_init(opj_tgt_tree_t * p_tree,OPJ_UINT32 p_num_leafs_h, OPJ_UINT32 p_num_leafs_v); void tgt_reset(tgt_tree_t * tree);
/** /*
Destroy a tag-tree, liberating memory * Create a tag-tree
@param tree Tag-tree to destroy * numleafsh: width of the array of leafs of the tree
* numleafsv: height of the array of leafs of the tree
*/ */
void tgt_destroy(opj_tgt_tree_t *tree); tgt_tree_t *tgt_create(int numleafsh, int numleafsv);
/**
Reset a tag-tree (set all leaves to 0)
@param tree Tag-tree to reset
*/
void tgt_reset(opj_tgt_tree_t *tree);
/**
Set the value of a leaf of a tag-tree
@param tree Tag-tree to modify
@param leafno Number that identifies the leaf to modify
@param value New value of the leaf
*/
void tgt_setvalue(opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT32 value);
/**
Encode the value of a leaf of the tag-tree up to a given threshold
@param bio Pointer to a BIO handle
@param tree Tag-tree to modify
@param leafno Number that identifies the leaf to encode
@param threshold Threshold to use when encoding value of the leaf
*/
void tgt_encode(struct opj_bio *bio, opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT32 threshold);
/**
Decode the value of a leaf of the tag-tree up to a given threshold
@param bio Pointer to a BIO handle
@param tree Tag-tree to decode
@param leafno Number that identifies the leaf to decode
@param threshold Threshold to use when decoding value of the leaf
@return Returns 1 if the node's value < threshold, returns 0 otherwise
*/
OPJ_UINT32 tgt_decode(struct opj_bio *bio, opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT32 threshold);
/* ----------------------------------------------------------------------- */
/*@}*/
/*@}*/ /*
* Destroy a tag-tree, liberating memory
* tree: tag-tree to destroy
*/
void tgt_destroy(tgt_tree_t * tree);
#endif /* __TGT_H */ /*
* Set the value of a leaf of a tag-tree
* tree: tag-tree to modify
* leafno: number that identifies the leaf to modify
* value: new value of the leaf
*/
void tgt_setvalue(tgt_tree_t * tree, int leafno, int value);
/*
* Encode the value of a leaf of the tag-tree up to a given threshold
* leafno: number that identifies the leaf to encode
* threshold: threshold to use when encoding value of the leaf
*/
void tgt_encode(tgt_tree_t * tree, int leafno, int threshold);
/*
* Decode the value of a leaf of the tag-tree up to a given threshold
* leafno: number that identifies the leaf to decode
* threshold: threshold to use when decoding value of the leaf
*/
int tgt_decode(tgt_tree_t * tree, int leafno, int threshold);
#endif

1046
libs/FreeImage/FreeImage.h
View File

File diff suppressed because it is too large Load Diff

BIN
libs/FreeImage/freeimage.s.lib
View File

Binary file not shown.

BIN
libs/FreeImage/libfreeimage.a
View File

Binary file not shown.

BIN
libs/FreeImage/libfreeimage.s.a
View File

Binary file not shown.

BIN
libs/libtiff/libtiff.lib
View File

Binary file not shown.

647
libs/libtiff/tiff.h
View File

@@ -1,647 +0,0 @@
/* $Id: tiff.h,v 1.42 2005/12/23 15:10:45 dron Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#ifndef _TIFF_
#define _TIFF_
#include "tiffconf.h"
/*
* Tag Image File Format (TIFF)
*
* Based on Rev 6.0 from:
* Developer's Desk
* Aldus Corporation
* 411 First Ave. South
* Suite 200
* Seattle, WA 98104
* 206-622-5500
*
* (http://partners.adobe.com/asn/developer/PDFS/TN/TIFF6.pdf)
*
* For Big TIFF design notes see the following link
* http://gdal.maptools.org/twiki/bin/view/libtiff/BigTIFFDesign
*/
#define TIFF_VERSION 42
#define TIFF_BIGTIFF_VERSION 43
#define TIFF_BIGENDIAN 0x4d4d
#define TIFF_LITTLEENDIAN 0x4949
#define MDI_LITTLEENDIAN 0x5045
#define MDI_BIGENDIAN 0x4550
/*
* Intrinsic data types required by the file format:
*
* 8-bit quantities int8/uint8
* 16-bit quantities int16/uint16
* 32-bit quantities int32/uint32
* strings unsigned char*
*/
#ifndef HAVE_INT8
typedef signed char int8; /* NB: non-ANSI compilers may not grok */
#endif
typedef unsigned char uint8;
#ifndef HAVE_INT16
typedef short int16;
#endif
typedef unsigned short uint16; /* sizeof (uint16) must == 2 */
#if SIZEOF_INT == 4
#ifndef HAVE_INT32
typedef int int32;
#endif
typedef unsigned int uint32; /* sizeof (uint32) must == 4 */
#elif SIZEOF_LONG == 4
#ifndef HAVE_INT32
typedef long int32;
#endif
typedef unsigned long uint32; /* sizeof (uint32) must == 4 */
#endif
/* For TIFFReassignTagToIgnore */
enum TIFFIgnoreSense /* IGNORE tag table */
{
TIS_STORE,
TIS_EXTRACT,
TIS_EMPTY
};
/*
* TIFF header.
*/
typedef struct {
uint16 tiff_magic; /* magic number (defines byte order) */
#define TIFF_MAGIC_SIZE 2
uint16 tiff_version; /* TIFF version number */
#define TIFF_VERSION_SIZE 2
uint32 tiff_diroff; /* byte offset to first directory */
#define TIFF_DIROFFSET_SIZE 4
} TIFFHeader;
/*
* TIFF Image File Directories are comprised of a table of field
* descriptors of the form shown below. The table is sorted in
* ascending order by tag. The values associated with each entry are
* disjoint and may appear anywhere in the file (so long as they are
* placed on a word boundary).
*
* If the value is 4 bytes or less, then it is placed in the offset
* field to save space. If the value is less than 4 bytes, it is
* left-justified in the offset field.
*/
typedef struct {
uint16 tdir_tag; /* see below */
uint16 tdir_type; /* data type; see below */
uint32 tdir_count; /* number of items; length in spec */
uint32 tdir_offset; /* byte offset to field data */
} TIFFDirEntry;
/*
* NB: In the comments below,
* - items marked with a + are obsoleted by revision 5.0,
* - items marked with a ! are introduced in revision 6.0.
* - items marked with a % are introduced post revision 6.0.
* - items marked with a $ are obsoleted by revision 6.0.
* - items marked with a & are introduced by Adobe DNG specification.
*/
/*
* Tag data type information.
*
* Note: RATIONALs are the ratio of two 32-bit integer values.
*/
typedef enum {
TIFF_NOTYPE = 0, /* placeholder */
TIFF_BYTE = 1, /* 8-bit unsigned integer */
TIFF_ASCII = 2, /* 8-bit bytes w/ last byte null */
TIFF_SHORT = 3, /* 16-bit unsigned integer */
TIFF_LONG = 4, /* 32-bit unsigned integer */
TIFF_RATIONAL = 5, /* 64-bit unsigned fraction */
TIFF_SBYTE = 6, /* !8-bit signed integer */
TIFF_UNDEFINED = 7, /* !8-bit untyped data */
TIFF_SSHORT = 8, /* !16-bit signed integer */
TIFF_SLONG = 9, /* !32-bit signed integer */
TIFF_SRATIONAL = 10, /* !64-bit signed fraction */
TIFF_FLOAT = 11, /* !32-bit IEEE floating point */
TIFF_DOUBLE = 12, /* !64-bit IEEE floating point */
TIFF_IFD = 13 /* %32-bit unsigned integer (offset) */
} TIFFDataType;
/*
* TIFF Tag Definitions.
*/
#define TIFFTAG_SUBFILETYPE 254 /* subfile data descriptor */
#define FILETYPE_REDUCEDIMAGE 0x1 /* reduced resolution version */
#define FILETYPE_PAGE 0x2 /* one page of many */
#define FILETYPE_MASK 0x4 /* transparency mask */
#define TIFFTAG_OSUBFILETYPE 255 /* +kind of data in subfile */
#define OFILETYPE_IMAGE 1 /* full resolution image data */
#define OFILETYPE_REDUCEDIMAGE 2 /* reduced size image data */
#define OFILETYPE_PAGE 3 /* one page of many */
#define TIFFTAG_IMAGEWIDTH 256 /* image width in pixels */
#define TIFFTAG_IMAGELENGTH 257 /* image height in pixels */
#define TIFFTAG_BITSPERSAMPLE 258 /* bits per channel (sample) */
#define TIFFTAG_COMPRESSION 259 /* data compression technique */
#define COMPRESSION_NONE 1 /* dump mode */
#define COMPRESSION_CCITTRLE 2 /* CCITT modified Huffman RLE */
#define COMPRESSION_CCITTFAX3 3 /* CCITT Group 3 fax encoding */
#define COMPRESSION_CCITT_T4 3 /* CCITT T.4 (TIFF 6 name) */
#define COMPRESSION_CCITTFAX4 4 /* CCITT Group 4 fax encoding */
#define COMPRESSION_CCITT_T6 4 /* CCITT T.6 (TIFF 6 name) */
#define COMPRESSION_LZW 5 /* Lempel-Ziv & Welch */
#define COMPRESSION_OJPEG 6 /* !6.0 JPEG */
#define COMPRESSION_JPEG 7 /* %JPEG DCT compression */
#define COMPRESSION_NEXT 32766 /* NeXT 2-bit RLE */
#define COMPRESSION_CCITTRLEW 32771 /* #1 w/ word alignment */
#define COMPRESSION_PACKBITS 32773 /* Macintosh RLE */
#define COMPRESSION_THUNDERSCAN 32809 /* ThunderScan RLE */
/* codes 32895-32898 are reserved for ANSI IT8 TIFF/IT <dkelly@apago.com) */
#define COMPRESSION_IT8CTPAD 32895 /* IT8 CT w/padding */
#define COMPRESSION_IT8LW 32896 /* IT8 Linework RLE */
#define COMPRESSION_IT8MP 32897 /* IT8 Monochrome picture */
#define COMPRESSION_IT8BL 32898 /* IT8 Binary line art */
/* compression codes 32908-32911 are reserved for Pixar */
#define COMPRESSION_PIXARFILM 32908 /* Pixar companded 10bit LZW */
#define COMPRESSION_PIXARLOG 32909 /* Pixar companded 11bit ZIP */
#define COMPRESSION_DEFLATE 32946 /* Deflate compression */
#define COMPRESSION_ADOBE_DEFLATE 8 /* Deflate compression,
as recognized by Adobe */
/* compression code 32947 is reserved for Oceana Matrix <dev@oceana.com> */
#define COMPRESSION_DCS 32947 /* Kodak DCS encoding */
#define COMPRESSION_JBIG 34661 /* ISO JBIG */
#define COMPRESSION_SGILOG 34676 /* SGI Log Luminance RLE */
#define COMPRESSION_SGILOG24 34677 /* SGI Log 24-bit packed */
#define COMPRESSION_JP2000 34712 /* Leadtools JPEG2000 */
#define TIFFTAG_PHOTOMETRIC 262 /* photometric interpretation */
#define PHOTOMETRIC_MINISWHITE 0 /* min value is white */
#define PHOTOMETRIC_MINISBLACK 1 /* min value is black */
#define PHOTOMETRIC_RGB 2 /* RGB color model */
#define PHOTOMETRIC_PALETTE 3 /* color map indexed */
#define PHOTOMETRIC_MASK 4 /* $holdout mask */
#define PHOTOMETRIC_SEPARATED 5 /* !color separations */
#define PHOTOMETRIC_YCBCR 6 /* !CCIR 601 */
#define PHOTOMETRIC_CIELAB 8 /* !1976 CIE L*a*b* */
#define PHOTOMETRIC_ICCLAB 9 /* ICC L*a*b* [Adobe TIFF Technote 4] */
#define PHOTOMETRIC_ITULAB 10 /* ITU L*a*b* */
#define PHOTOMETRIC_LOGL 32844 /* CIE Log2(L) */
#define PHOTOMETRIC_LOGLUV 32845 /* CIE Log2(L) (u',v') */
#define TIFFTAG_THRESHHOLDING 263 /* +thresholding used on data */
#define THRESHHOLD_BILEVEL 1 /* b&w art scan */
#define THRESHHOLD_HALFTONE 2 /* or dithered scan */
#define THRESHHOLD_ERRORDIFFUSE 3 /* usually floyd-steinberg */
#define TIFFTAG_CELLWIDTH 264 /* +dithering matrix width */
#define TIFFTAG_CELLLENGTH 265 /* +dithering matrix height */
#define TIFFTAG_FILLORDER 266 /* data order within a byte */
#define FILLORDER_MSB2LSB 1 /* most significant -> least */
#define FILLORDER_LSB2MSB 2 /* least significant -> most */
#define TIFFTAG_DOCUMENTNAME 269 /* name of doc. image is from */
#define TIFFTAG_IMAGEDESCRIPTION 270 /* info about image */
#define TIFFTAG_MAKE 271 /* scanner manufacturer name */
#define TIFFTAG_MODEL 272 /* scanner model name/number */
#define TIFFTAG_STRIPOFFSETS 273 /* offsets to data strips */
#define TIFFTAG_ORIENTATION 274 /* +image orientation */
#define ORIENTATION_TOPLEFT 1 /* row 0 top, col 0 lhs */
#define ORIENTATION_TOPRIGHT 2 /* row 0 top, col 0 rhs */
#define ORIENTATION_BOTRIGHT 3 /* row 0 bottom, col 0 rhs */
#define ORIENTATION_BOTLEFT 4 /* row 0 bottom, col 0 lhs */
#define ORIENTATION_LEFTTOP 5 /* row 0 lhs, col 0 top */
#define ORIENTATION_RIGHTTOP 6 /* row 0 rhs, col 0 top */
#define ORIENTATION_RIGHTBOT 7 /* row 0 rhs, col 0 bottom */
#define ORIENTATION_LEFTBOT 8 /* row 0 lhs, col 0 bottom */
#define TIFFTAG_SAMPLESPERPIXEL 277 /* samples per pixel */
#define TIFFTAG_ROWSPERSTRIP 278 /* rows per strip of data */
#define TIFFTAG_STRIPBYTECOUNTS 279 /* bytes counts for strips */
#define TIFFTAG_MINSAMPLEVALUE 280 /* +minimum sample value */
#define TIFFTAG_MAXSAMPLEVALUE 281 /* +maximum sample value */
#define TIFFTAG_XRESOLUTION 282 /* pixels/resolution in x */
#define TIFFTAG_YRESOLUTION 283 /* pixels/resolution in y */
#define TIFFTAG_PLANARCONFIG 284 /* storage organization */
#define PLANARCONFIG_CONTIG 1 /* single image plane */
#define PLANARCONFIG_SEPARATE 2 /* separate planes of data */
#define TIFFTAG_PAGENAME 285 /* page name image is from */
#define TIFFTAG_XPOSITION 286 /* x page offset of image lhs */
#define TIFFTAG_YPOSITION 287 /* y page offset of image lhs */
#define TIFFTAG_FREEOFFSETS 288 /* +byte offset to free block */
#define TIFFTAG_FREEBYTECOUNTS 289 /* +sizes of free blocks */
#define TIFFTAG_GRAYRESPONSEUNIT 290 /* $gray scale curve accuracy */
#define GRAYRESPONSEUNIT_10S 1 /* tenths of a unit */
#define GRAYRESPONSEUNIT_100S 2 /* hundredths of a unit */
#define GRAYRESPONSEUNIT_1000S 3 /* thousandths of a unit */
#define GRAYRESPONSEUNIT_10000S 4 /* ten-thousandths of a unit */
#define GRAYRESPONSEUNIT_100000S 5 /* hundred-thousandths */
#define TIFFTAG_GRAYRESPONSECURVE 291 /* $gray scale response curve */
#define TIFFTAG_GROUP3OPTIONS 292 /* 32 flag bits */
#define TIFFTAG_T4OPTIONS 292 /* TIFF 6.0 proper name alias */
#define GROUP3OPT_2DENCODING 0x1 /* 2-dimensional coding */
#define GROUP3OPT_UNCOMPRESSED 0x2 /* data not compressed */
#define GROUP3OPT_FILLBITS 0x4 /* fill to byte boundary */
#define TIFFTAG_GROUP4OPTIONS 293 /* 32 flag bits */
#define TIFFTAG_T6OPTIONS 293 /* TIFF 6.0 proper name */
#define GROUP4OPT_UNCOMPRESSED 0x2 /* data not compressed */
#define TIFFTAG_RESOLUTIONUNIT 296 /* units of resolutions */
#define RESUNIT_NONE 1 /* no meaningful units */
#define RESUNIT_INCH 2 /* english */
#define RESUNIT_CENTIMETER 3 /* metric */
#define TIFFTAG_PAGENUMBER 297 /* page numbers of multi-page */
#define TIFFTAG_COLORRESPONSEUNIT 300 /* $color curve accuracy */
#define COLORRESPONSEUNIT_10S 1 /* tenths of a unit */
#define COLORRESPONSEUNIT_100S 2 /* hundredths of a unit */
#define COLORRESPONSEUNIT_1000S 3 /* thousandths of a unit */
#define COLORRESPONSEUNIT_10000S 4 /* ten-thousandths of a unit */
#define COLORRESPONSEUNIT_100000S 5 /* hundred-thousandths */
#define TIFFTAG_TRANSFERFUNCTION 301 /* !colorimetry info */
#define TIFFTAG_SOFTWARE 305 /* name & release */
#define TIFFTAG_DATETIME 306 /* creation date and time */
#define TIFFTAG_ARTIST 315 /* creator of image */
#define TIFFTAG_HOSTCOMPUTER 316 /* machine where created */
#define TIFFTAG_PREDICTOR 317 /* prediction scheme w/ LZW */
#define PREDICTOR_NONE 1 /* no prediction scheme used */
#define PREDICTOR_HORIZONTAL 2 /* horizontal differencing */
#define PREDICTOR_FLOATINGPOINT 3 /* floating point predictor */
#define TIFFTAG_WHITEPOINT 318 /* image white point */
#define TIFFTAG_PRIMARYCHROMATICITIES 319 /* !primary chromaticities */
#define TIFFTAG_COLORMAP 320 /* RGB map for pallette image */
#define TIFFTAG_HALFTONEHINTS 321 /* !highlight+shadow info */
#define TIFFTAG_TILEWIDTH 322 /* !tile width in pixels */
#define TIFFTAG_TILELENGTH 323 /* !tile height in pixels */
#define TIFFTAG_TILEOFFSETS 324 /* !offsets to data tiles */
#define TIFFTAG_TILEBYTECOUNTS 325 /* !byte counts for tiles */
#define TIFFTAG_BADFAXLINES 326 /* lines w/ wrong pixel count */
#define TIFFTAG_CLEANFAXDATA 327 /* regenerated line info */
#define CLEANFAXDATA_CLEAN 0 /* no errors detected */
#define CLEANFAXDATA_REGENERATED 1 /* receiver regenerated lines */
#define CLEANFAXDATA_UNCLEAN 2 /* uncorrected errors exist */
#define TIFFTAG_CONSECUTIVEBADFAXLINES 328 /* max consecutive bad lines */
#define TIFFTAG_SUBIFD 330 /* subimage descriptors */
#define TIFFTAG_INKSET 332 /* !inks in separated image */
#define INKSET_CMYK 1 /* !cyan-magenta-yellow-black color */
#define INKSET_MULTIINK 2 /* !multi-ink or hi-fi color */
#define TIFFTAG_INKNAMES 333 /* !ascii names of inks */
#define TIFFTAG_NUMBEROFINKS 334 /* !number of inks */
#define TIFFTAG_DOTRANGE 336 /* !0% and 100% dot codes */
#define TIFFTAG_TARGETPRINTER 337 /* !separation target */
#define TIFFTAG_EXTRASAMPLES 338 /* !info about extra samples */
#define EXTRASAMPLE_UNSPECIFIED 0 /* !unspecified data */
#define EXTRASAMPLE_ASSOCALPHA 1 /* !associated alpha data */
#define EXTRASAMPLE_UNASSALPHA 2 /* !unassociated alpha data */
#define TIFFTAG_SAMPLEFORMAT 339 /* !data sample format */
#define SAMPLEFORMAT_UINT 1 /* !unsigned integer data */
#define SAMPLEFORMAT_INT 2 /* !signed integer data */
#define SAMPLEFORMAT_IEEEFP 3 /* !IEEE floating point data */
#define SAMPLEFORMAT_VOID 4 /* !untyped data */
#define SAMPLEFORMAT_COMPLEXINT 5 /* !complex signed int */
#define SAMPLEFORMAT_COMPLEXIEEEFP 6 /* !complex ieee floating */
#define TIFFTAG_SMINSAMPLEVALUE 340 /* !variable MinSampleValue */
#define TIFFTAG_SMAXSAMPLEVALUE 341 /* !variable MaxSampleValue */
#define TIFFTAG_CLIPPATH 343 /* %ClipPath
[Adobe TIFF technote 2] */
#define TIFFTAG_XCLIPPATHUNITS 344 /* %XClipPathUnits
[Adobe TIFF technote 2] */
#define TIFFTAG_YCLIPPATHUNITS 345 /* %YClipPathUnits
[Adobe TIFF technote 2] */
#define TIFFTAG_INDEXED 346 /* %Indexed
[Adobe TIFF Technote 3] */
#define TIFFTAG_JPEGTABLES 347 /* %JPEG table stream */
#define TIFFTAG_OPIPROXY 351 /* %OPI Proxy [Adobe TIFF technote] */
/*
* Tags 512-521 are obsoleted by Technical Note #2 which specifies a
* revised JPEG-in-TIFF scheme.
*/
#define TIFFTAG_JPEGPROC 512 /* !JPEG processing algorithm */
#define JPEGPROC_BASELINE 1 /* !baseline sequential */
#define JPEGPROC_LOSSLESS 14 /* !Huffman coded lossless */
#define TIFFTAG_JPEGIFOFFSET 513 /* !pointer to SOI marker */
#define TIFFTAG_JPEGIFBYTECOUNT 514 /* !JFIF stream length */
#define TIFFTAG_JPEGRESTARTINTERVAL 515 /* !restart interval length */
#define TIFFTAG_JPEGLOSSLESSPREDICTORS 517 /* !lossless proc predictor */
#define TIFFTAG_JPEGPOINTTRANSFORM 518 /* !lossless point transform */
#define TIFFTAG_JPEGQTABLES 519 /* !Q matrice offsets */
#define TIFFTAG_JPEGDCTABLES 520 /* !DCT table offsets */
#define TIFFTAG_JPEGACTABLES 521 /* !AC coefficient offsets */
#define TIFFTAG_YCBCRCOEFFICIENTS 529 /* !RGB -> YCbCr transform */
#define TIFFTAG_YCBCRSUBSAMPLING 530 /* !YCbCr subsampling factors */
#define TIFFTAG_YCBCRPOSITIONING 531 /* !subsample positioning */
#define YCBCRPOSITION_CENTERED 1 /* !as in PostScript Level 2 */
#define YCBCRPOSITION_COSITED 2 /* !as in CCIR 601-1 */
#define TIFFTAG_REFERENCEBLACKWHITE 532 /* !colorimetry info */
#define TIFFTAG_XMLPACKET 700 /* %XML packet
[Adobe XMP Specification,
January 2004 */
#define TIFFTAG_OPIIMAGEID 32781 /* %OPI ImageID
[Adobe TIFF technote] */
/* tags 32952-32956 are private tags registered to Island Graphics */
#define TIFFTAG_REFPTS 32953 /* image reference points */
#define TIFFTAG_REGIONTACKPOINT 32954 /* region-xform tack point */
#define TIFFTAG_REGIONWARPCORNERS 32955 /* warp quadrilateral */
#define TIFFTAG_REGIONAFFINE 32956 /* affine transformation mat */
/* tags 32995-32999 are private tags registered to SGI */
#define TIFFTAG_MATTEING 32995 /* $use ExtraSamples */
#define TIFFTAG_DATATYPE 32996 /* $use SampleFormat */
#define TIFFTAG_IMAGEDEPTH 32997 /* z depth of image */
#define TIFFTAG_TILEDEPTH 32998 /* z depth/data tile */
/* tags 33300-33309 are private tags registered to Pixar */
/*
* TIFFTAG_PIXAR_IMAGEFULLWIDTH and TIFFTAG_PIXAR_IMAGEFULLLENGTH
* are set when an image has been cropped out of a larger image.
* They reflect the size of the original uncropped image.
* The TIFFTAG_XPOSITION and TIFFTAG_YPOSITION can be used
* to determine the position of the smaller image in the larger one.
*/
#define TIFFTAG_PIXAR_IMAGEFULLWIDTH 33300 /* full image size in x */
#define TIFFTAG_PIXAR_IMAGEFULLLENGTH 33301 /* full image size in y */
/* Tags 33302-33306 are used to identify special image modes and data
* used by Pixar's texture formats.
*/
#define TIFFTAG_PIXAR_TEXTUREFORMAT 33302 /* texture map format */
#define TIFFTAG_PIXAR_WRAPMODES 33303 /* s & t wrap modes */
#define TIFFTAG_PIXAR_FOVCOT 33304 /* cotan(fov) for env. maps */
#define TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN 33305
#define TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA 33306
/* tag 33405 is a private tag registered to Eastman Kodak */
#define TIFFTAG_WRITERSERIALNUMBER 33405 /* device serial number */
/* tag 33432 is listed in the 6.0 spec w/ unknown ownership */
#define TIFFTAG_COPYRIGHT 33432 /* copyright string */
/* IPTC TAG from RichTIFF specifications */
#define TIFFTAG_RICHTIFFIPTC 33723
/* 34016-34029 are reserved for ANSI IT8 TIFF/IT <dkelly@apago.com) */
#define TIFFTAG_IT8SITE 34016 /* site name */
#define TIFFTAG_IT8COLORSEQUENCE 34017 /* color seq. [RGB,CMYK,etc] */
#define TIFFTAG_IT8HEADER 34018 /* DDES Header */
#define TIFFTAG_IT8RASTERPADDING 34019 /* raster scanline padding */
#define TIFFTAG_IT8BITSPERRUNLENGTH 34020 /* # of bits in short run */
#define TIFFTAG_IT8BITSPEREXTENDEDRUNLENGTH 34021/* # of bits in long run */
#define TIFFTAG_IT8COLORTABLE 34022 /* LW colortable */
#define TIFFTAG_IT8IMAGECOLORINDICATOR 34023 /* BP/BL image color switch */
#define TIFFTAG_IT8BKGCOLORINDICATOR 34024 /* BP/BL bg color switch */
#define TIFFTAG_IT8IMAGECOLORVALUE 34025 /* BP/BL image color value */
#define TIFFTAG_IT8BKGCOLORVALUE 34026 /* BP/BL bg color value */
#define TIFFTAG_IT8PIXELINTENSITYRANGE 34027 /* MP pixel intensity value */
#define TIFFTAG_IT8TRANSPARENCYINDICATOR 34028 /* HC transparency switch */
#define TIFFTAG_IT8COLORCHARACTERIZATION 34029 /* color character. table */
#define TIFFTAG_IT8HCUSAGE 34030 /* HC usage indicator */
#define TIFFTAG_IT8TRAPINDICATOR 34031 /* Trapping indicator
(untrapped=0, trapped=1) */
#define TIFFTAG_IT8CMYKEQUIVALENT 34032 /* CMYK color equivalents */
/* tags 34232-34236 are private tags registered to Texas Instruments */
#define TIFFTAG_FRAMECOUNT 34232 /* Sequence Frame Count */
/* tag 34377 is private tag registered to Adobe for PhotoShop */
#define TIFFTAG_PHOTOSHOP 34377
/* tags 34665, 34853 and 40965 are documented in EXIF specification */
#define TIFFTAG_EXIFIFD 34665 /* Pointer to EXIF private directory */
/* tag 34750 is a private tag registered to Adobe? */
#define TIFFTAG_ICCPROFILE 34675 /* ICC profile data */
/* tag 34750 is a private tag registered to Pixel Magic */
#define TIFFTAG_JBIGOPTIONS 34750 /* JBIG options */
#define TIFFTAG_GPSIFD 34853 /* Pointer to GPS private directory */
/* tags 34908-34914 are private tags registered to SGI */
#define TIFFTAG_FAXRECVPARAMS 34908 /* encoded Class 2 ses. parms */
#define TIFFTAG_FAXSUBADDRESS 34909 /* received SubAddr string */
#define TIFFTAG_FAXRECVTIME 34910 /* receive time (secs) */
#define TIFFTAG_FAXDCS 34911 /* encoded fax ses. params, Table 2/T.30 */
/* tags 37439-37443 are registered to SGI <gregl@sgi.com> */
#define TIFFTAG_STONITS 37439 /* Sample value to Nits */
/* tag 34929 is a private tag registered to FedEx */
#define TIFFTAG_FEDEX_EDR 34929 /* unknown use */
#define TIFFTAG_INTEROPERABILITYIFD 40965 /* Pointer to Interoperability private directory */
/* Adobe Digital Negative (DNG) format tags */
#define TIFFTAG_DNGVERSION 50706 /* &DNG version number */
#define TIFFTAG_DNGBACKWARDVERSION 50707 /* &DNG compatibility version */
#define TIFFTAG_UNIQUECAMERAMODEL 50708 /* &name for the camera model */
#define TIFFTAG_LOCALIZEDCAMERAMODEL 50709 /* &localized camera model
name */
#define TIFFTAG_CFAPLANECOLOR 50710 /* &CFAPattern->LinearRaw space
mapping */
#define TIFFTAG_CFALAYOUT 50711 /* &spatial layout of the CFA */
#define TIFFTAG_LINEARIZATIONTABLE 50712 /* &lookup table description */
#define TIFFTAG_BLACKLEVELREPEATDIM 50713 /* &repeat pattern size for
the BlackLevel tag */
#define TIFFTAG_BLACKLEVEL 50714 /* &zero light encoding level */
#define TIFFTAG_BLACKLEVELDELTAH 50715 /* &zero light encoding level
differences (columns) */
#define TIFFTAG_BLACKLEVELDELTAV 50716 /* &zero light encoding level
differences (rows) */
#define TIFFTAG_WHITELEVEL 50717 /* &fully saturated encoding
level */
#define TIFFTAG_DEFAULTSCALE 50718 /* &default scale factors */
#define TIFFTAG_DEFAULTCROPORIGIN 50719 /* &origin of the final image
area */
#define TIFFTAG_DEFAULTCROPSIZE 50720 /* &size of the final image
area */
#define TIFFTAG_COLORMATRIX1 50721 /* &XYZ->reference color space
transformation matrix 1 */
#define TIFFTAG_COLORMATRIX2 50722 /* &XYZ->reference color space
transformation matrix 2 */
#define TIFFTAG_CAMERACALIBRATION1 50723 /* &calibration matrix 1 */
#define TIFFTAG_CAMERACALIBRATION2 50724 /* &calibration matrix 2 */
#define TIFFTAG_REDUCTIONMATRIX1 50725 /* &dimensionality reduction
matrix 1 */
#define TIFFTAG_REDUCTIONMATRIX2 50726 /* &dimensionality reduction
matrix 2 */
#define TIFFTAG_ANALOGBALANCE 50727 /* &gain applied the stored raw
values*/
#define TIFFTAG_ASSHOTNEUTRAL 50728 /* &selected white balance in
linear reference space */
#define TIFFTAG_ASSHOTWHITEXY 50729 /* &selected white balance in
x-y chromaticity
coordinates */
#define TIFFTAG_BASELINEEXPOSURE 50730 /* &how much to move the zero
point */
#define TIFFTAG_BASELINENOISE 50731 /* &relative noise level */
#define TIFFTAG_BASELINESHARPNESS 50732 /* &relative amount of
sharpening */
#define TIFFTAG_BAYERGREENSPLIT 50733 /* &how closely the values of
the green pixels in the
blue/green rows track the
values of the green pixels
in the red/green rows */
#define TIFFTAG_LINEARRESPONSELIMIT 50734 /* &non-linear encoding range */
#define TIFFTAG_CAMERASERIALNUMBER 50735 /* &camera's serial number */
#define TIFFTAG_LENSINFO 50736 /* info about the lens */
#define TIFFTAG_CHROMABLURRADIUS 50737 /* &chroma blur radius */
#define TIFFTAG_ANTIALIASSTRENGTH 50738 /* &relative strength of the
camera's anti-alias filter */
#define TIFFTAG_SHADOWSCALE 50739 /* &used by Adobe Camera Raw */
#define TIFFTAG_DNGPRIVATEDATA 50740 /* &manufacturer's private data */
#define TIFFTAG_MAKERNOTESAFETY 50741 /* &whether the EXIF MakerNote
tag is safe to preserve
along with the rest of the
EXIF data */
#define TIFFTAG_CALIBRATIONILLUMINANT1 50778 /* &illuminant 1 */
#define TIFFTAG_CALIBRATIONILLUMINANT2 50779 /* &illuminant 2 */
#define TIFFTAG_BESTQUALITYSCALE 50780 /* &best quality multiplier */
#define TIFFTAG_RAWDATAUNIQUEID 50781 /* &unique identifier for
the raw image data */
#define TIFFTAG_ORIGINALRAWFILENAME 50827 /* &file name of the original
raw file */
#define TIFFTAG_ORIGINALRAWFILEDATA 50828 /* &contents of the original
raw file */
#define TIFFTAG_ACTIVEAREA 50829 /* &active (non-masked) pixels
of the sensor */
#define TIFFTAG_MASKEDAREAS 50830 /* &list of coordinates
of fully masked pixels */
#define TIFFTAG_ASSHOTICCPROFILE 50831 /* &these two tags used to */
#define TIFFTAG_ASSHOTPREPROFILEMATRIX 50832 /* map cameras's color space
into ICC profile space */
#define TIFFTAG_CURRENTICCPROFILE 50833 /* & */
#define TIFFTAG_CURRENTPREPROFILEMATRIX 50834 /* & */
/* tag 65535 is an undefined tag used by Eastman Kodak */
#define TIFFTAG_DCSHUESHIFTVALUES 65535 /* hue shift correction data */
/*
* The following are ``pseudo tags'' that can be used to control
* codec-specific functionality. These tags are not written to file.
* Note that these values start at 0xffff+1 so that they'll never
* collide with Aldus-assigned tags.
*
* If you want your private pseudo tags ``registered'' (i.e. added to
* this file), please post a bug report via the tracking system at
* http://www.remotesensing.org/libtiff/bugs.html with the appropriate
* C definitions to add.
*/
#define TIFFTAG_FAXMODE 65536 /* Group 3/4 format control */
#define FAXMODE_CLASSIC 0x0000 /* default, include RTC */
#define FAXMODE_NORTC 0x0001 /* no RTC at end of data */
#define FAXMODE_NOEOL 0x0002 /* no EOL code at end of row */
#define FAXMODE_BYTEALIGN 0x0004 /* byte align row */
#define FAXMODE_WORDALIGN 0x0008 /* word align row */
#define FAXMODE_CLASSF FAXMODE_NORTC /* TIFF Class F */
#define TIFFTAG_JPEGQUALITY 65537 /* Compression quality level */
/* Note: quality level is on the IJG 0-100 scale. Default value is 75 */
#define TIFFTAG_JPEGCOLORMODE 65538 /* Auto RGB<=>YCbCr convert? */
#define JPEGCOLORMODE_RAW 0x0000 /* no conversion (default) */
#define JPEGCOLORMODE_RGB 0x0001 /* do auto conversion */
#define TIFFTAG_JPEGTABLESMODE 65539 /* What to put in JPEGTables */
#define JPEGTABLESMODE_QUANT 0x0001 /* include quantization tbls */
#define JPEGTABLESMODE_HUFF 0x0002 /* include Huffman tbls */
/* Note: default is JPEGTABLESMODE_QUANT | JPEGTABLESMODE_HUFF */
#define TIFFTAG_FAXFILLFUNC 65540 /* G3/G4 fill function */
#define TIFFTAG_PIXARLOGDATAFMT 65549 /* PixarLogCodec I/O data sz */
#define PIXARLOGDATAFMT_8BIT 0 /* regular u_char samples */
#define PIXARLOGDATAFMT_8BITABGR 1 /* ABGR-order u_chars */
#define PIXARLOGDATAFMT_11BITLOG 2 /* 11-bit log-encoded (raw) */
#define PIXARLOGDATAFMT_12BITPICIO 3 /* as per PICIO (1.0==2048) */
#define PIXARLOGDATAFMT_16BIT 4 /* signed short samples */
#define PIXARLOGDATAFMT_FLOAT 5 /* IEEE float samples */
/* 65550-65556 are allocated to Oceana Matrix <dev@oceana.com> */
#define TIFFTAG_DCSIMAGERTYPE 65550 /* imager model & filter */
#define DCSIMAGERMODEL_M3 0 /* M3 chip (1280 x 1024) */
#define DCSIMAGERMODEL_M5 1 /* M5 chip (1536 x 1024) */
#define DCSIMAGERMODEL_M6 2 /* M6 chip (3072 x 2048) */
#define DCSIMAGERFILTER_IR 0 /* infrared filter */
#define DCSIMAGERFILTER_MONO 1 /* monochrome filter */
#define DCSIMAGERFILTER_CFA 2 /* color filter array */
#define DCSIMAGERFILTER_OTHER 3 /* other filter */
#define TIFFTAG_DCSINTERPMODE 65551 /* interpolation mode */
#define DCSINTERPMODE_NORMAL 0x0 /* whole image, default */
#define DCSINTERPMODE_PREVIEW 0x1 /* preview of image (384x256) */
#define TIFFTAG_DCSBALANCEARRAY 65552 /* color balance values */
#define TIFFTAG_DCSCORRECTMATRIX 65553 /* color correction values */
#define TIFFTAG_DCSGAMMA 65554 /* gamma value */
#define TIFFTAG_DCSTOESHOULDERPTS 65555 /* toe & shoulder points */
#define TIFFTAG_DCSCALIBRATIONFD 65556 /* calibration file desc */
/* Note: quality level is on the ZLIB 1-9 scale. Default value is -1 */
#define TIFFTAG_ZIPQUALITY 65557 /* compression quality level */
#define TIFFTAG_PIXARLOGQUALITY 65558 /* PixarLog uses same scale */
/* 65559 is allocated to Oceana Matrix <dev@oceana.com> */
#define TIFFTAG_DCSCLIPRECTANGLE 65559 /* area of image to acquire */
#define TIFFTAG_SGILOGDATAFMT 65560 /* SGILog user data format */
#define SGILOGDATAFMT_FLOAT 0 /* IEEE float samples */
#define SGILOGDATAFMT_16BIT 1 /* 16-bit samples */
#define SGILOGDATAFMT_RAW 2 /* uninterpreted data */
#define SGILOGDATAFMT_8BIT 3 /* 8-bit RGB monitor values */
#define TIFFTAG_SGILOGENCODE 65561 /* SGILog data encoding control*/
#define SGILOGENCODE_NODITHER 0 /* do not dither encoded values*/
#define SGILOGENCODE_RANDITHER 1 /* randomly dither encd values */
/*
* EXIF tags
*/
#define EXIFTAG_EXPOSURETIME 33434 /* Exposure time */
#define EXIFTAG_FNUMBER 33437 /* F number */
#define EXIFTAG_EXPOSUREPROGRAM 34850 /* Exposure program */
#define EXIFTAG_SPECTRALSENSITIVITY 34852 /* Spectral sensitivity */
#define EXIFTAG_ISOSPEEDRATINGS 34855 /* ISO speed rating */
#define EXIFTAG_OECF 34856 /* Optoelectric conversion
factor */
#define EXIFTAG_EXIFVERSION 36864 /* Exif version */
#define EXIFTAG_DATETIMEORIGINAL 36867 /* Date and time of original
data generation */
#define EXIFTAG_DATETIMEDIGITIZED 36868 /* Date and time of digital
data generation */
#define EXIFTAG_COMPONENTSCONFIGURATION 37121 /* Meaning of each component */
#define EXIFTAG_COMPRESSEDBITSPERPIXEL 37122 /* Image compression mode */
#define EXIFTAG_SHUTTERSPEEDVALUE 37377 /* Shutter speed */
#define EXIFTAG_APERTUREVALUE 37378 /* Aperture */
#define EXIFTAG_BRIGHTNESSVALUE 37379 /* Brightness */
#define EXIFTAG_EXPOSUREBIASVALUE 37380 /* Exposure bias */
#define EXIFTAG_MAXAPERTUREVALUE 37381 /* Maximum lens aperture */
#define EXIFTAG_SUBJECTDISTANCE 37382 /* Subject distance */
#define EXIFTAG_METERINGMODE 37383 /* Metering mode */
#define EXIFTAG_LIGHTSOURCE 37384 /* Light source */
#define EXIFTAG_FLASH 37385 /* Flash */
#define EXIFTAG_FOCALLENGTH 37386 /* Lens focal length */
#define EXIFTAG_SUBJECTAREA 37396 /* Subject area */
#define EXIFTAG_MAKERNOTE 37500 /* Manufacturer notes */
#define EXIFTAG_USERCOMMENT 37510 /* User comments */
#define EXIFTAG_SUBSECTIME 37520 /* DateTime subseconds */
#define EXIFTAG_SUBSECTIMEORIGINAL 37521 /* DateTimeOriginal subseconds */
#define EXIFTAG_SUBSECTIMEDIGITIZED 37522 /* DateTimeDigitized subseconds */
#define EXIFTAG_FLASHPIXVERSION 40960 /* Supported Flashpix version */
#define EXIFTAG_COLORSPACE 40961 /* Color space information */
#define EXIFTAG_PIXELXDIMENSION 40962 /* Valid image width */
#define EXIFTAG_PIXELYDIMENSION 40963 /* Valid image height */
#define EXIFTAG_RELATEDSOUNDFILE 40964 /* Related audio file */
#define EXIFTAG_FLASHENERGY 41483 /* Flash energy */
#define EXIFTAG_SPATIALFREQUENCYRESPONSE 41484 /* Spatial frequency response */
#define EXIFTAG_FOCALPLANEXRESOLUTION 41486 /* Focal plane X resolution */
#define EXIFTAG_FOCALPLANEYRESOLUTION 41487 /* Focal plane Y resolution */
#define EXIFTAG_FOCALPLANERESOLUTIONUNIT 41488 /* Focal plane resolution unit */
#define EXIFTAG_SUBJECTLOCATION 41492 /* Subject location */
#define EXIFTAG_EXPOSUREINDEX 41493 /* Exposure index */
#define EXIFTAG_SENSINGMETHOD 41495 /* Sensing method */
#define EXIFTAG_FILESOURCE 41728 /* File source */
#define EXIFTAG_SCENETYPE 41729 /* Scene type */
#define EXIFTAG_CFAPATTERN 41730 /* CFA pattern */
#define EXIFTAG_CUSTOMRENDERED 41985 /* Custom image processing */
#define EXIFTAG_EXPOSUREMODE 41986 /* Exposure mode */
#define EXIFTAG_WHITEBALANCE 41987 /* White balance */
#define EXIFTAG_DIGITALZOOMRATIO 41988 /* Digital zoom ratio */
#define EXIFTAG_FOCALLENGTHIN35MMFILM 41989 /* Focal length in 35 mm film */
#define EXIFTAG_SCENECAPTURETYPE 41990 /* Scene capture type */
#define EXIFTAG_GAINCONTROL 41991 /* Gain control */
#define EXIFTAG_CONTRAST 41992 /* Contrast */
#define EXIFTAG_SATURATION 41993 /* Saturation */
#define EXIFTAG_SHARPNESS 41994 /* Sharpness */
#define EXIFTAG_DEVICESETTINGDESCRIPTION 41995 /* Device settings description */
#define EXIFTAG_SUBJECTDISTANCERANGE 41996 /* Subject distance range */
#define EXIFTAG_GAINCONTROL 41991 /* Gain control */
#define EXIFTAG_GAINCONTROL 41991 /* Gain control */
#define EXIFTAG_IMAGEUNIQUEID 42016 /* Unique image ID */
#endif /* _TIFF_ */
/* vim: set ts=8 sts=8 sw=8 noet: */

101
libs/libtiff/tiffconf.h
View File

@@ -1,101 +0,0 @@
/* libtiff/tiffconf.h. Generated by configure. */
/*
Configuration defines for installed libtiff.
This file maintained for backward compatibility. Do not use definitions
from this file in your programs.
*/
#ifndef _TIFFCONF_
#define _TIFFCONF_
/* Define to 1 if the system has the type `int16'. */
/* #undef HAVE_INT16 */
/* Define to 1 if the system has the type `int32'. */
/* #undef HAVE_INT32 */
/* Define to 1 if the system has the type `int8'. */
/* #undef HAVE_INT8 */
/* The size of a `int', as computed by sizeof. */
#define SIZEOF_INT 4
/* The size of a `long', as computed by sizeof. */
#define SIZEOF_LONG 4
/* Compatibility stuff. */
/* Define as 0 or 1 according to the floating point format suported by the
machine */
#define HAVE_IEEEFP 1
/* Set the native cpu bit order (FILLORDER_LSB2MSB or FILLORDER_MSB2LSB) */
#define HOST_FILLORDER FILLORDER_LSB2MSB
/* Native cpu byte order: 1 if big-endian (Motorola) or 0 if little-endian
(Intel) */
#define HOST_BIGENDIAN 0
/* Support CCITT Group 3 & 4 algorithms */
#define CCITT_SUPPORT 1
/* Support JPEG compression (requires IJG JPEG library) */
#undef JPEG_SUPPORT
/* Support LogLuv high dynamic range encoding */
#define LOGLUV_SUPPORT 1
/* Support LZW algorithm */
#define LZW_SUPPORT 1
/* Support NeXT 2-bit RLE algorithm */
#define NEXT_SUPPORT 1
/* Support Old JPEG compresson (read contrib/ojpeg/README first! Compilation
fails with unpatched IJG JPEG library) */
/* #undef OJPEG_SUPPORT */
/* Support Macintosh PackBits algorithm */
#define PACKBITS_SUPPORT 1
/* Support Pixar log-format algorithm (requires Zlib) */
#define PIXARLOG_SUPPORT 1
/* Support ThunderScan 4-bit RLE algorithm */
#define THUNDER_SUPPORT 1
/* Support Deflate compression */
#define ZIP_SUPPORT 1
/* Support strip chopping (whether or not to convert single-strip uncompressed
images to mutiple strips of ~8Kb to reduce memory usage) */
#define STRIPCHOP_DEFAULT TIFF_STRIPCHOP
/* Enable SubIFD tag (330) support */
#define SUBIFD_SUPPORT 1
/* Treat extra sample as alpha (default enabled). The RGBA interface will
treat a fourth sample with no EXTRASAMPLE_ value as being ASSOCALPHA. Many
packages produce RGBA files but don't mark the alpha properly. */
#define DEFAULT_EXTRASAMPLE_AS_ALPHA 1
/* Pick up YCbCr subsampling info from the JPEG data stream to support files
lacking the tag (default enabled). */
#define CHECK_JPEG_YCBCR_SUBSAMPLING 1
/* Support MS MDI magic number files as TIFF */
#define MDI_SUPPORT 1
/*
* Feature support definitions.
* XXX: These macros are obsoleted. Don't use them in your apps!
* Macros stays here for backward compatibility and should be always defined.
*/
#define COLORIMETRY_SUPPORT
#define YCBCR_SUPPORT
#define CMYK_SUPPORT
#define ICC_SUPPORT
#define PHOTOSHOP_SUPPORT
#define IPTC_SUPPORT
#endif /* _TIFFCONF_ */

515
libs/libtiff/tiffio.h
View File

@@ -1,515 +0,0 @@
/* $Id: tiffio.h,v 1.50 2006/03/21 16:37:51 dron Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#ifndef _TIFFIO_
#define _TIFFIO_
/*
* TIFF I/O Library Definitions.
*/
#include "tiff.h"
#include "tiffvers.h"
/*
* TIFF is defined as an incomplete type to hide the
* library's internal data structures from clients.
*/
typedef struct tiff TIFF;
/*
* The following typedefs define the intrinsic size of
* data types used in the *exported* interfaces. These
* definitions depend on the proper definition of types
* in tiff.h. Note also that the varargs interface used
* to pass tag types and values uses the types defined in
* tiff.h directly.
*
* NB: ttag_t is unsigned int and not unsigned short because
* ANSI C requires that the type before the ellipsis be a
* promoted type (i.e. one of int, unsigned int, pointer,
* or double) and because we defined pseudo-tags that are
* outside the range of legal Aldus-assigned tags.
* NB: tsize_t is int32 and not uint32 because some functions
* return -1.
* NB: toff_t is not off_t for many reasons; TIFFs max out at
* 32-bit file offsets being the most important, and to ensure
* that it is unsigned, rather than signed.
*/
typedef uint32 ttag_t; /* directory tag */
typedef uint16 tdir_t; /* directory index */
typedef uint16 tsample_t; /* sample number */
typedef uint32 tstrip_t; /* strip number */
typedef uint32 ttile_t; /* tile number */
typedef int32 tsize_t; /* i/o size in bytes */
typedef void* tdata_t; /* image data ref */
typedef uint32 toff_t; /* file offset */
#if !defined(__WIN32__) && (defined(_WIN32) || defined(WIN32))
#define __WIN32__
#endif
/*
* On windows you should define USE_WIN32_FILEIO if you are using tif_win32.c
* or AVOID_WIN32_FILEIO if you are using something else (like tif_unix.c).
*
* By default tif_unix.c is assumed.
*/
#if defined(_WINDOWS) || defined(__WIN32__) || defined(_Windows)
# if !defined(__CYGWIN) && !defined(AVOID_WIN32_FILEIO) && !defined(USE_WIN32_FILEIO)
# define AVOID_WIN32_FILEIO
# endif
#endif
#if defined(USE_WIN32_FILEIO)
# define VC_EXTRALEAN
# include <windows.h>
# ifdef __WIN32__
DECLARE_HANDLE(thandle_t); /* Win32 file handle */
# else
typedef HFILE thandle_t; /* client data handle */
# endif /* __WIN32__ */
#else
typedef void* thandle_t; /* client data handle */
#endif /* USE_WIN32_FILEIO */
#ifndef NULL
# define NULL (void *)0
#endif
/*
* Flags to pass to TIFFPrintDirectory to control
* printing of data structures that are potentially
* very large. Bit-or these flags to enable printing
* multiple items.
*/
#define TIFFPRINT_NONE 0x0 /* no extra info */
#define TIFFPRINT_STRIPS 0x1 /* strips/tiles info */
#define TIFFPRINT_CURVES 0x2 /* color/gray response curves */
#define TIFFPRINT_COLORMAP 0x4 /* colormap */
#define TIFFPRINT_JPEGQTABLES 0x100 /* JPEG Q matrices */
#define TIFFPRINT_JPEGACTABLES 0x200 /* JPEG AC tables */
#define TIFFPRINT_JPEGDCTABLES 0x200 /* JPEG DC tables */
/*
* Colour conversion stuff
*/
/* reference white */
#define D65_X0 (95.0470F)
#define D65_Y0 (100.0F)
#define D65_Z0 (108.8827F)
#define D50_X0 (96.4250F)
#define D50_Y0 (100.0F)
#define D50_Z0 (82.4680F)
/* Structure for holding information about a display device. */
typedef unsigned char TIFFRGBValue; /* 8-bit samples */
typedef struct {
float d_mat[3][3]; /* XYZ -> luminance matrix */
float d_YCR; /* Light o/p for reference white */
float d_YCG;
float d_YCB;
uint32 d_Vrwr; /* Pixel values for ref. white */
uint32 d_Vrwg;
uint32 d_Vrwb;
float d_Y0R; /* Residual light for black pixel */
float d_Y0G;
float d_Y0B;
float d_gammaR; /* Gamma values for the three guns */
float d_gammaG;
float d_gammaB;
} TIFFDisplay;
typedef struct { /* YCbCr->RGB support */
TIFFRGBValue* clamptab; /* range clamping table */
int* Cr_r_tab;
int* Cb_b_tab;
int32* Cr_g_tab;
int32* Cb_g_tab;
int32* Y_tab;
} TIFFYCbCrToRGB;
typedef struct { /* CIE Lab 1976->RGB support */
int range; /* Size of conversion table */
#define CIELABTORGB_TABLE_RANGE 1500
float rstep, gstep, bstep;
float X0, Y0, Z0; /* Reference white point */
TIFFDisplay display;
float Yr2r[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yr to r */
float Yg2g[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yg to g */
float Yb2b[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yb to b */
} TIFFCIELabToRGB;
/*
* RGBA-style image support.
*/
typedef struct _TIFFRGBAImage TIFFRGBAImage;
/*
* The image reading and conversion routines invoke
* ``put routines'' to copy/image/whatever tiles of
* raw image data. A default set of routines are
* provided to convert/copy raw image data to 8-bit
* packed ABGR format rasters. Applications can supply
* alternate routines that unpack the data into a
* different format or, for example, unpack the data
* and draw the unpacked raster on the display.
*/
typedef void (*tileContigRoutine)
(TIFFRGBAImage*, uint32*, uint32, uint32, uint32, uint32, int32, int32,
unsigned char*);
typedef void (*tileSeparateRoutine)
(TIFFRGBAImage*, uint32*, uint32, uint32, uint32, uint32, int32, int32,
unsigned char*, unsigned char*, unsigned char*, unsigned char*);
/*
* RGBA-reader state.
*/
struct _TIFFRGBAImage {
TIFF* tif; /* image handle */
int stoponerr; /* stop on read error */
int isContig; /* data is packed/separate */
int alpha; /* type of alpha data present */
uint32 width; /* image width */
uint32 height; /* image height */
uint16 bitspersample; /* image bits/sample */
uint16 samplesperpixel; /* image samples/pixel */
uint16 orientation; /* image orientation */
uint16 req_orientation; /* requested orientation */
uint16 photometric; /* image photometric interp */
uint16* redcmap; /* colormap pallete */
uint16* greencmap;
uint16* bluecmap;
/* get image data routine */
int (*get)(TIFFRGBAImage*, uint32*, uint32, uint32);
union {
void (*any)(TIFFRGBAImage*);
tileContigRoutine contig;
tileSeparateRoutine separate;
} put; /* put decoded strip/tile */
TIFFRGBValue* Map; /* sample mapping array */
uint32** BWmap; /* black&white map */
uint32** PALmap; /* palette image map */
TIFFYCbCrToRGB* ycbcr; /* YCbCr conversion state */
TIFFCIELabToRGB* cielab; /* CIE L*a*b conversion state */
int row_offset;
int col_offset;
};
/*
* Macros for extracting components from the
* packed ABGR form returned by TIFFReadRGBAImage.
*/
#define TIFFGetR(abgr) ((abgr) & 0xff)
#define TIFFGetG(abgr) (((abgr) >> 8) & 0xff)
#define TIFFGetB(abgr) (((abgr) >> 16) & 0xff)
#define TIFFGetA(abgr) (((abgr) >> 24) & 0xff)
/*
* A CODEC is a software package that implements decoding,
* encoding, or decoding+encoding of a compression algorithm.
* The library provides a collection of builtin codecs.
* More codecs may be registered through calls to the library
* and/or the builtin implementations may be overridden.
*/
typedef int (*TIFFInitMethod)(TIFF*, int);
typedef struct {
char* name;
uint16 scheme;
TIFFInitMethod init;
} TIFFCodec;
#include <stdio.h>
#include <stdarg.h>
/* share internal LogLuv conversion routines? */
#ifndef LOGLUV_PUBLIC
#define LOGLUV_PUBLIC 1
#endif
#if defined(c_plusplus) || defined(__cplusplus)
extern "C" {
#endif
typedef void (*TIFFErrorHandler)(const char*, const char*, va_list);
typedef void (*TIFFErrorHandlerExt)(thandle_t, const char*, const char*, va_list);
typedef tsize_t (*TIFFReadWriteProc)(thandle_t, tdata_t, tsize_t);
typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int);
typedef int (*TIFFCloseProc)(thandle_t);
typedef toff_t (*TIFFSizeProc)(thandle_t);
typedef int (*TIFFMapFileProc)(thandle_t, tdata_t*, toff_t*);
typedef void (*TIFFUnmapFileProc)(thandle_t, tdata_t, toff_t);
typedef void (*TIFFExtendProc)(TIFF*);
extern const char* TIFFGetVersion(void);
extern const TIFFCodec* TIFFFindCODEC(uint16);
extern TIFFCodec* TIFFRegisterCODEC(uint16, const char*, TIFFInitMethod);
extern void TIFFUnRegisterCODEC(TIFFCodec*);
extern int TIFFIsCODECConfigured(uint16);
extern TIFFCodec* TIFFGetConfiguredCODECs(void);
/*
* Auxiliary functions.
*/
extern tdata_t _TIFFmalloc(tsize_t);
extern tdata_t _TIFFrealloc(tdata_t, tsize_t);
extern void _TIFFmemset(tdata_t, int, tsize_t);
extern void _TIFFmemcpy(tdata_t, const tdata_t, tsize_t);
extern int _TIFFmemcmp(const tdata_t, const tdata_t, tsize_t);
extern void _TIFFfree(tdata_t);
/*
** Stuff, related to tag handling and creating custom tags.
*/
extern int TIFFGetTagListCount( TIFF * );
extern ttag_t TIFFGetTagListEntry( TIFF *, int tag_index );
#define TIFF_ANY TIFF_NOTYPE /* for field descriptor searching */
#define TIFF_VARIABLE -1 /* marker for variable length tags */
#define TIFF_SPP -2 /* marker for SamplesPerPixel tags */
#define TIFF_VARIABLE2 -3 /* marker for uint32 var-length tags */
#define FIELD_CUSTOM 65
typedef struct {
ttag_t field_tag; /* field's tag */
short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */
short field_writecount; /* write count/TIFF_VARIABLE */
TIFFDataType field_type; /* type of associated data */
unsigned short field_bit; /* bit in fieldsset bit vector */
unsigned char field_oktochange; /* if true, can change while writing */
unsigned char field_passcount; /* if true, pass dir count on set */
char *field_name; /* ASCII name */
} TIFFFieldInfo;
typedef struct _TIFFTagValue {
const TIFFFieldInfo *info;
int count;
void *value;
} TIFFTagValue;
extern void TIFFMergeFieldInfo(TIFF*, const TIFFFieldInfo[], int);
extern const TIFFFieldInfo* TIFFFindFieldInfo(TIFF*, ttag_t, TIFFDataType);
extern const TIFFFieldInfo* TIFFFindFieldInfoByName(TIFF* , const char *,
TIFFDataType);
extern const TIFFFieldInfo* TIFFFieldWithTag(TIFF*, ttag_t);
extern const TIFFFieldInfo* TIFFFieldWithName(TIFF*, const char *);
typedef int (*TIFFVSetMethod)(TIFF*, ttag_t, va_list);
typedef int (*TIFFVGetMethod)(TIFF*, ttag_t, va_list);
typedef void (*TIFFPrintMethod)(TIFF*, FILE*, long);
typedef struct {
TIFFVSetMethod vsetfield; /* tag set routine */
TIFFVGetMethod vgetfield; /* tag get routine */
TIFFPrintMethod printdir; /* directory print routine */
} TIFFTagMethods;
extern TIFFTagMethods *TIFFAccessTagMethods( TIFF * );
extern void *TIFFGetClientInfo( TIFF *, const char * );
extern void TIFFSetClientInfo( TIFF *, void *, const char * );
extern void TIFFCleanup(TIFF*);
extern void TIFFClose(TIFF*);
extern int TIFFFlush(TIFF*);
extern int TIFFFlushData(TIFF*);
extern int TIFFGetField(TIFF*, ttag_t, ...);
extern int TIFFVGetField(TIFF*, ttag_t, va_list);
extern int TIFFGetFieldDefaulted(TIFF*, ttag_t, ...);
extern int TIFFVGetFieldDefaulted(TIFF*, ttag_t, va_list);
extern int TIFFReadDirectory(TIFF*);
extern int TIFFReadCustomDirectory(TIFF*, toff_t, const TIFFFieldInfo[],
size_t);
extern int TIFFReadEXIFDirectory(TIFF*, toff_t);
extern tsize_t TIFFScanlineSize(TIFF*);
extern tsize_t TIFFRasterScanlineSize(TIFF*);
extern tsize_t TIFFStripSize(TIFF*);
extern tsize_t TIFFRawStripSize(TIFF*, tstrip_t);
extern tsize_t TIFFVStripSize(TIFF*, uint32);
extern tsize_t TIFFTileRowSize(TIFF*);
extern tsize_t TIFFTileSize(TIFF*);
extern tsize_t TIFFVTileSize(TIFF*, uint32);
extern uint32 TIFFDefaultStripSize(TIFF*, uint32);
extern void TIFFDefaultTileSize(TIFF*, uint32*, uint32*);
extern int TIFFFileno(TIFF*);
extern int TIFFSetFileno(TIFF*, int);
extern thandle_t TIFFClientdata(TIFF*);
extern thandle_t TIFFSetClientdata(TIFF*, thandle_t);
extern int TIFFGetMode(TIFF*);
extern int TIFFSetMode(TIFF*, int);
extern int TIFFIsTiled(TIFF*);
extern int TIFFIsByteSwapped(TIFF*);
extern int TIFFIsUpSampled(TIFF*);
extern int TIFFIsMSB2LSB(TIFF*);
extern int TIFFIsBigEndian(TIFF*);
extern TIFFReadWriteProc TIFFGetReadProc(TIFF*);
extern TIFFReadWriteProc TIFFGetWriteProc(TIFF*);
extern TIFFSeekProc TIFFGetSeekProc(TIFF*);
extern TIFFCloseProc TIFFGetCloseProc(TIFF*);
extern TIFFSizeProc TIFFGetSizeProc(TIFF*);
extern TIFFMapFileProc TIFFGetMapFileProc(TIFF*);
extern TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF*);
extern uint32 TIFFCurrentRow(TIFF*);
extern tdir_t TIFFCurrentDirectory(TIFF*);
extern tdir_t TIFFNumberOfDirectories(TIFF*);
extern uint32 TIFFCurrentDirOffset(TIFF*);
extern tstrip_t TIFFCurrentStrip(TIFF*);
extern ttile_t TIFFCurrentTile(TIFF*);
extern int TIFFReadBufferSetup(TIFF*, tdata_t, tsize_t);
extern int TIFFWriteBufferSetup(TIFF*, tdata_t, tsize_t);
extern int TIFFSetupStrips(TIFF *);
extern int TIFFWriteCheck(TIFF*, int, const char *);
extern void TIFFFreeDirectory(TIFF*);
extern int TIFFCreateDirectory(TIFF*);
extern int TIFFLastDirectory(TIFF*);
extern int TIFFSetDirectory(TIFF*, tdir_t);
extern int TIFFSetSubDirectory(TIFF*, uint32);
extern int TIFFUnlinkDirectory(TIFF*, tdir_t);
extern int TIFFSetField(TIFF*, ttag_t, ...);
extern int TIFFVSetField(TIFF*, ttag_t, va_list);
extern int TIFFWriteDirectory(TIFF *);
extern int TIFFCheckpointDirectory(TIFF *);
extern int TIFFRewriteDirectory(TIFF *);
extern int TIFFReassignTagToIgnore(enum TIFFIgnoreSense, int);
#if defined(c_plusplus) || defined(__cplusplus)
extern void TIFFPrintDirectory(TIFF*, FILE*, long = 0);
extern int TIFFReadScanline(TIFF*, tdata_t, uint32, tsample_t = 0);
extern int TIFFWriteScanline(TIFF*, tdata_t, uint32, tsample_t = 0);
extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int = 0);
extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*,
int = ORIENTATION_BOTLEFT, int = 0);
#else
extern void TIFFPrintDirectory(TIFF*, FILE*, long);
extern int TIFFReadScanline(TIFF*, tdata_t, uint32, tsample_t);
extern int TIFFWriteScanline(TIFF*, tdata_t, uint32, tsample_t);
extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int);
extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*, int, int);
#endif
extern int TIFFReadRGBAStrip(TIFF*, tstrip_t, uint32 * );
extern int TIFFReadRGBATile(TIFF*, uint32, uint32, uint32 * );
extern int TIFFRGBAImageOK(TIFF*, char [1024]);
extern int TIFFRGBAImageBegin(TIFFRGBAImage*, TIFF*, int, char [1024]);
extern int TIFFRGBAImageGet(TIFFRGBAImage*, uint32*, uint32, uint32);
extern void TIFFRGBAImageEnd(TIFFRGBAImage*);
extern TIFF* TIFFOpen(const char*, const char*);
# ifdef __WIN32__
extern TIFF* TIFFOpenW(const wchar_t*, const char*);
# endif /* __WIN32__ */
extern TIFF* TIFFFdOpen(int, const char*, const char*);
extern TIFF* TIFFClientOpen(const char*, const char*,
thandle_t,
TIFFReadWriteProc, TIFFReadWriteProc,
TIFFSeekProc, TIFFCloseProc,
TIFFSizeProc,
TIFFMapFileProc, TIFFUnmapFileProc);
extern const char* TIFFFileName(TIFF*);
extern const char* TIFFSetFileName(TIFF*, const char *);
extern void TIFFError(const char*, const char*, ...);
extern void TIFFErrorExt(thandle_t, const char*, const char*, ...);
extern void TIFFWarning(const char*, const char*, ...);
extern void TIFFWarningExt(thandle_t, const char*, const char*, ...);
extern TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler);
extern TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt);
extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler);
extern TIFFErrorHandlerExt TIFFSetWarningHandlerExt(TIFFErrorHandlerExt);
extern TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc);
extern ttile_t TIFFComputeTile(TIFF*, uint32, uint32, uint32, tsample_t);
extern int TIFFCheckTile(TIFF*, uint32, uint32, uint32, tsample_t);
extern ttile_t TIFFNumberOfTiles(TIFF*);
extern tsize_t TIFFReadTile(TIFF*,
tdata_t, uint32, uint32, uint32, tsample_t);
extern tsize_t TIFFWriteTile(TIFF*,
tdata_t, uint32, uint32, uint32, tsample_t);
extern tstrip_t TIFFComputeStrip(TIFF*, uint32, tsample_t);
extern tstrip_t TIFFNumberOfStrips(TIFF*);
extern tsize_t TIFFReadEncodedStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
extern tsize_t TIFFReadRawStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
extern tsize_t TIFFReadEncodedTile(TIFF*, ttile_t, tdata_t, tsize_t);
extern tsize_t TIFFReadRawTile(TIFF*, ttile_t, tdata_t, tsize_t);
extern tsize_t TIFFWriteEncodedStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
extern tsize_t TIFFWriteRawStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
extern tsize_t TIFFWriteEncodedTile(TIFF*, ttile_t, tdata_t, tsize_t);
extern tsize_t TIFFWriteRawTile(TIFF*, ttile_t, tdata_t, tsize_t);
extern int TIFFDataWidth(TIFFDataType); /* table of tag datatype widths */
extern void TIFFSetWriteOffset(TIFF*, toff_t);
extern void TIFFSwabShort(uint16*);
extern void TIFFSwabLong(uint32*);
extern void TIFFSwabDouble(double*);
extern void TIFFSwabArrayOfShort(uint16*, unsigned long);
extern void TIFFSwabArrayOfTriples(uint8*, unsigned long);
extern void TIFFSwabArrayOfLong(uint32*, unsigned long);
extern void TIFFSwabArrayOfDouble(double*, unsigned long);
extern void TIFFReverseBits(unsigned char *, unsigned long);
extern const unsigned char* TIFFGetBitRevTable(int);
#ifdef LOGLUV_PUBLIC
#define U_NEU 0.210526316
#define V_NEU 0.473684211
#define UVSCALE 410.
extern double LogL16toY(int);
extern double LogL10toY(int);
extern void XYZtoRGB24(float*, uint8*);
extern int uv_decode(double*, double*, int);
extern void LogLuv24toXYZ(uint32, float*);
extern void LogLuv32toXYZ(uint32, float*);
#if defined(c_plusplus) || defined(__cplusplus)
extern int LogL16fromY(double, int = SGILOGENCODE_NODITHER);
extern int LogL10fromY(double, int = SGILOGENCODE_NODITHER);
extern int uv_encode(double, double, int = SGILOGENCODE_NODITHER);
extern uint32 LogLuv24fromXYZ(float*, int = SGILOGENCODE_NODITHER);
extern uint32 LogLuv32fromXYZ(float*, int = SGILOGENCODE_NODITHER);
#else
extern int LogL16fromY(double, int);
extern int LogL10fromY(double, int);
extern int uv_encode(double, double, int);
extern uint32 LogLuv24fromXYZ(float*, int);
extern uint32 LogLuv32fromXYZ(float*, int);
#endif
#endif /* LOGLUV_PUBLIC */
extern int TIFFCIELabToRGBInit(TIFFCIELabToRGB*, TIFFDisplay *, float*);
extern void TIFFCIELabToXYZ(TIFFCIELabToRGB *, uint32, int32, int32,
float *, float *, float *);
extern void TIFFXYZToRGB(TIFFCIELabToRGB *, float, float, float,
uint32 *, uint32 *, uint32 *);
extern int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB*, float*, float*);
extern void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *, uint32, int32, int32,
uint32 *, uint32 *, uint32 *);
#if defined(c_plusplus) || defined(__cplusplus)
}
#endif
#endif /* _TIFFIO_ */
/* vim: set ts=8 sts=8 sw=8 noet: */

9
libs/libtiff/tiffvers.h
View File

@@ -1,9 +0,0 @@
#define TIFFLIB_VERSION_STR "LIBTIFF, Version 3.8.2\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc."
/*
* This define can be used in code that requires
* compilation-related definitions specific to a
* version or versions of the library. Runtime
* version checking should be done based on the
* string returned by TIFFGetVersion.
*/
#define TIFFLIB_VERSION 20060323

128
mj2/MJ2_Extractor.dsp Normal file
View File

@@ -0,0 +1,128 @@
# Microsoft Developer Studio Project File - Name="MJ2_Extractor" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=MJ2_Extractor - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "MJ2_Extractor.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "MJ2_Extractor.mak" CFG="MJ2_Extractor - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "MJ2_Extractor - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "MJ2_Extractor - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "MJ2_Extractor - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /W3 /GX /O2 /I "../libopenjpeg" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x809 /d "NDEBUG"
# ADD RSC /l 0x809 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "MJ2_Extractor - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "MJ2_Extractor___Win32_Debug"
# PROP BASE Intermediate_Dir "MJ2_Extractor___Win32_Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "MJ2_Extractor___Win32_Debug"
# PROP Intermediate_Dir "MJ2_Extractor___Win32_Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../libopenjpeg" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x809 /d "_DEBUG"
# ADD RSC /l 0x809 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "MJ2_Extractor - Win32 Release"
# Name "MJ2_Extractor - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\libopenjpeg\cio.c
# End Source File
# Begin Source File
SOURCE=.\extract_j2k_from_mj2.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jp2.c
# End Source File
# Begin Source File
SOURCE=.\mj2.c
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=..\libopenjpeg\cio.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\j2k.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jp2.h
# End Source File
# Begin Source File
SOURCE=.\mj2.h
# End Source File
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

136
mj2/MJ2_Wrapper.dsp Normal file
View File

@@ -0,0 +1,136 @@
# Microsoft Developer Studio Project File - Name="MJ2_Wrapper" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=MJ2_Wrapper - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "MJ2_Wrapper.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "MJ2_Wrapper.mak" CFG="MJ2_Wrapper - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "MJ2_Wrapper - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "MJ2_Wrapper - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "MJ2_Wrapper - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /W3 /GX /O2 /I "../libopenjpeg" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x809 /d "NDEBUG"
# ADD RSC /l 0x809 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "MJ2_Wrapper - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "MJ2_Wrapper___Win32_Debug"
# PROP BASE Intermediate_Dir "MJ2_Wrapper___Win32_Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "MJ2_Wrapper___Win32_Debug"
# PROP Intermediate_Dir "MJ2_Wrapper___Win32_Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../libopenjpeg" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x809 /d "_DEBUG"
# ADD RSC /l 0x809 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "MJ2_Wrapper - Win32 Release"
# Name "MJ2_Wrapper - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\libopenjpeg\cio.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\int.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jp2.c
# End Source File
# Begin Source File
SOURCE=.\mj2.c
# End Source File
# Begin Source File
SOURCE=.\wrap_j2k_in_mj2.c
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=..\libopenjpeg\cio.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\int.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\j2k.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jp2.h
# End Source File
# Begin Source File
SOURCE=.\mj2.h
# End Source File
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

79
mj2/Makefile Normal file
View File

@@ -0,0 +1,79 @@
#
# Valentin Mesaros (Octalis | DICE/UCL Belgium)
# 19 April 2005
#
# Makefile for mj2 source files (frames_to_mj2, mj2_to_frames, extract_j2k_from_mj2, wrap_j2k_in_mj2)
#
INCLUDES = -Imj2 \
-I../libopenjpeg
C_OPT = -Wall
CFLAGS = $(INCLUDES) $(C_OPT)
CC = gcc
OBJ_MJ2_DIR = obj
BIN_MJ2_DIR = bin
LIB_OPENJPEG_DIR = ../libopenjpeg/lib
LIB_OPENJPEG = $(LIB_OPENJPEG_DIR)/libopenjpeg.a
all: $(OBJ_MJ2_DIR) $(BIN_MJ2_DIR) \
$(BIN_MJ2_DIR)/frames_to_mj2 \
$(BIN_MJ2_DIR)/mj2_to_frames \
$(BIN_MJ2_DIR)/extract_j2k_from_mj2 \
$(BIN_MJ2_DIR)/wrap_j2k_in_mj2
$(OBJ_MJ2_DIR):
mkdir $(OBJ_MJ2_DIR)
$(BIN_MJ2_DIR):
mkdir $(BIN_MJ2_DIR)
$(OBJ_MJ2_DIR)/%.o:
$(CC) -c $(CFLAGS) -o $@ $<
$(OBJ_MJ2_DIR)/frames_to_mj2.o: frames_to_mj2.c
$(OBJ_MJ2_DIR)/mj2_to_frames.o: mj2_to_frames.c
$(OBJ_MJ2_DIR)/mj2.o: mj2.c
$(OBJ_MJ2_DIR)/mj2_convert.o: mj2_convert.c
$(OBJ_MJ2_DIR)/extract_j2k_from_mj2.o: extract_j2k_from_mj2.c
$(OBJ_MJ2_DIR)/wrap_j2k_in_mj2.o: wrap_j2k_in_mj2.c
MJ2_OBJS = $(addprefix $(OBJ_MJ2_DIR)/, mj2.o mj2_convert.o)
$(BIN_MJ2_DIR)/frames_to_mj2: $(OBJ_MJ2_DIR)/frames_to_mj2.o $(MJ2_OBJS) $(LIB_OPENJPEG)
$(CC) $(CFLAGS) \
-o $(BIN_MJ2_DIR)/frames_to_mj2 \
$(MJ2_OBJS) $(OBJ_MJ2_DIR)/frames_to_mj2.o \
$(LIB_OPENJPEG) \
-lm
$(BIN_MJ2_DIR)/mj2_to_frames: $(OBJ_MJ2_DIR)/mj2_to_frames.o $(MJ2_OBJS) $(LIB_OPENJPEG)
$(CC) $(CFLAGS) \
-o $(BIN_MJ2_DIR)/mj2_to_frames \
$(MJ2_OBJS) $(OBJ_MJ2_DIR)/mj2_to_frames.o \
$(LIB_OPENJPEG) \
-lm
$(BIN_MJ2_DIR)/extract_j2k_from_mj2: $(OBJ_MJ2_DIR)/extract_j2k_from_mj2.o $(MJ2_OBJS) $(LIB_OPENJPEG)
$(CC) $(CFLAGS) \
-o $(BIN_MJ2_DIR)/extract_j2k_from_mj2 \
$(MJ2_OBJS) $(OBJ_MJ2_DIR)/extract_j2k_from_mj2.o \
$(LIB_OPENJPEG) \
-lm
$(BIN_MJ2_DIR)/wrap_j2k_in_mj2: $(OBJ_MJ2_DIR)/wrap_j2k_in_mj2.o $(MJ2_OBJS) $(LIB_OPENJPEG)
$(CC) $(CFLAGS) \
-o $(BIN_MJ2_DIR)/wrap_j2k_in_mj2 \
$(MJ2_OBJS) $(OBJ_MJ2_DIR)/wrap_j2k_in_mj2.o \
$(LIB_OPENJPEG) \
-lm
clean:
rm -f $(BIN_MJ2_DIR)/* $(OBJ_MJ2_DIR)/*

116
mj2/compat/getopt.c Normal file
View File

@@ -0,0 +1,116 @@
/*
* Copyright (c) 1987, 1993, 1994
* The Regents of the University of California. 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.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*/
/* last review : october 29th, 2002 */
#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)getopt.c 8.3 (Berkeley) 4/27/95";
#endif /* LIBC_SCCS and not lint */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int opterr = 1, /* if error message should be printed */
optind = 1, /* index into parent argv vector */
optopt, /* character checked for validity */
optreset; /* reset getopt */
char *optarg; /* argument associated with option */
#define BADCH (int)'?'
#define BADARG (int)':'
#define EMSG ""
/*
* getopt --
* Parse argc/argv argument vector.
*/
int getopt(nargc, nargv, ostr)
int nargc;
char *const *nargv;
const char *ostr;
{
# define __progname nargv[0]
static char *place = EMSG; /* option letter processing */
char *oli; /* option letter list index */
if (optreset || !*place) { /* update scanning pointer */
optreset = 0;
if (optind >= nargc || *(place = nargv[optind]) != '-') {
place = EMSG;
return (-1);
}
if (place[1] && *++place == '-') { /* found "--" */
++optind;
place = EMSG;
return (-1);
}
} /* option letter okay? */
if ((optopt = (int) *place++) == (int) ':' ||
!(oli = strchr(ostr, optopt))) {
/*
* if the user didn't specify '-' as an option,
* assume it means -1.
*/
if (optopt == (int) '-')
return (-1);
if (!*place)
++optind;
if (opterr && *ostr != ':')
(void) fprintf(stderr,
"%s: illegal option -- %c\n", __progname, optopt);
return (BADCH);
}
if (*++oli != ':') { /* don't need argument */
optarg = NULL;
if (!*place)
++optind;
} else { /* need an argument */
if (*place) /* no white space */
optarg = place;
else if (nargc <= ++optind) { /* no arg */
place = EMSG;
if (*ostr == ':')
return (BADARG);
if (opterr)
(void) fprintf(stderr,
"%s: option requires an argument -- %c\n",
__progname, optopt);
return (BADCH);
} else /* white space */
optarg = nargv[optind];
place = EMSG;
++optind;
}
return (optopt); /* dump back option letter */
}

14
mj2/compat/getopt.h Normal file
View File

@@ -0,0 +1,14 @@
/* last review : october 29th, 2002 */
#ifndef _GETOPT_H_
#define _GETOPT_H_
extern int opterr;
extern int optind;
extern int optopt;
extern int optreset;
extern char *optarg;
extern int getopt(int nargc, char *const *nargv, const char *ostr);
#endif /* _GETOPT_H_ */

81
mj2/extract_j2k_from_mj2.c Normal file
View File

@@ -0,0 +1,81 @@
#include <stdio.h>
#include <malloc.h>
#include <setjmp.h>
#include "mj2.h"
//MEMORY LEAK
#ifdef _DEBUG
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h> // Must be included first
#include <crtdbg.h>
#endif
//MEM
jmp_buf j2k_error;
int main(int argc, char *argv[]) {
int tnum;
unsigned int snum;
mj2_movie_t movie;
mj2_tk_t *track;
mj2_sample_t *sample;
unsigned char* frame_codestream;
FILE *file, *outfile;
char outfilename[50];
if (argc != 3) {
printf("Bad syntax: Usage: MJ2_extractor mj2filename output_location\n");
printf("Example: MJ2_extractor foreman.mj2 output/foreman\n");
return 1;
}
file = fopen(argv[1], "rb");
if (!file) {
fprintf(stderr, "failed to open %s for reading\n", argv[1]);
return 1;
}
if (mj2_read_struct(file, &movie)) // Creating the movie structure
return 1;
// Decode first video track
tnum = 0;
while (movie.tk[tnum].track_type != 0)
tnum ++;
track = &movie.tk[tnum];
fprintf(stdout,"Extracting %d frames from file...\n",track->num_samples);
for (snum=0; snum < track->num_samples; snum++)
{
sample = &track->sample[snum];
frame_codestream = (unsigned char*) malloc (sample->sample_size-8); // Skipping JP2C marker
fseek(file,sample->offset+8,SEEK_SET);
fread(frame_codestream,sample->sample_size-8,1, file); // Assuming that jp and ftyp markers size do
sprintf(outfilename,"%s_%d.j2k",argv[2],snum);
outfile = fopen(outfilename, "wb");
if (!outfile) {
fprintf(stderr, "failed to open %s for writing\n",outfilename);
return 1;
}
fwrite(frame_codestream,sample->sample_size-8,1,outfile);
fclose(outfile);
free(frame_codestream);
}
fclose(file);
fprintf(stdout, "%d frames correctly extracted\n", snum);
mj2_memory_free(&movie);
//MEMORY LEAK
#ifdef _DEBUG
_CrtDumpMemoryLeaks();
#endif
//MEM
return 0;
}

997
mj2/frames_to_mj2.c Normal file
View File

@@ -0,0 +1,997 @@
/*
* Copyright (c) 2003-2004, Fran<61>ois-Olivier Devaux
* Copyright (c) 2002-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* 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 <openjpeg.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <setjmp.h>
#ifndef DONT_HAVE_GETOPT
#include <getopt.h>
#else
#include "compat/getopt.h"
#endif
#include "mj2_convert.h"
#define MJ2_MDAT 0x6d646174
#define JP2_JP2C 0x6a703263
//MEMORY LEAK
#ifdef _DEBUG
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h> // Must be included first
#include <crtdbg.h>
#endif
//MEM
jmp_buf j2k_error;
void help_display()
{
fprintf(stdout,"HELP\n----\n\n");
fprintf(stdout,"- the -h option displays this help information on screen\n\n");
fprintf(stdout,"List of parameters for the MJ2 encoder:\n");
fprintf(stdout,"\n");
fprintf(stdout,"REMARKS:\n");
fprintf(stdout,"---------\n");
fprintf(stdout,"\n");
fprintf
(stdout,"The markers written to the main_header are : SOC SIZ COD QCD COM.\n");
fprintf
(stdout,"COD and QCD never appear in the tile_header.\n");
fprintf(stdout,"\n");
fprintf
(stdout,"- This coder can encode a mega image, a test was made on a 24000x24000 pixels \n");
fprintf
(stdout,"color image. You need enough disk space memory (twice the original) to encode \n");
fprintf
(stdout,"the image,i.e. for a 1.5 GB image you need a minimum of 3GB of disk memory)\n");
fprintf(stdout,"\n");
fprintf(stdout,"By default:\n");
fprintf(stdout,"------------\n");
fprintf(stdout,"\n");
fprintf(stdout," * Lossless\n");
fprintf(stdout," * 1 tile\n");
fprintf(stdout," * Size of precinct : 2^15 x 2^15 (means 1 precinct)\n");
fprintf(stdout," * Size of code-block : 64 x 64\n");
fprintf(stdout," * Number of resolutions: 6\n");
fprintf(stdout," * No SOP marker in the codestream\n");
fprintf(stdout," * No EPH marker in the codestream\n");
fprintf(stdout," * No sub-sampling in x or y direction\n");
fprintf(stdout," * No mode switch activated\n");
fprintf(stdout," * Progression order: LRCP\n");
fprintf(stdout," * No index file\n");
fprintf(stdout," * No ROI upshifted\n");
fprintf(stdout," * No offset of the origin of the image\n");
fprintf(stdout," * No offset of the origin of the tiles\n");
fprintf(stdout," * Reversible DWT 5-3\n");
fprintf(stdout,"\n");
fprintf(stdout,"Parameters:\n");
fprintf(stdout,"------------\n");
fprintf(stdout,"\n");
fprintf
(stdout,"Required Parameters (except with -h):\n");
fprintf
(stdout,"-i : source file (-i source.yuv) \n");
fprintf
(stdout,"-o : destination file (-o dest.mj2) \n");
fprintf
(stdout,"Optional Parameters:\n");
fprintf(stdout,"-h : display the help information \n");
fprintf(stdout,"-r : different compression ratios for successive layers (-r 20,10,5)\n ");
fprintf(stdout," - The rate specified for each quality level is the desired \n");
fprintf(stdout," compression factor.\n");
fprintf(stdout," Example: -r 20,10,1 means quality 1: compress 20x, \n");
fprintf(stdout," quality 2: compress 10x and quality 3: compress lossless\n");
fprintf(stdout," (options -r and -q cannot be used together)\n ");
fprintf(stdout,"-q : different psnr for successive layers (-q 30,40,50) \n ");
fprintf(stdout," (options -r and -q cannot be used together)\n ");
fprintf(stdout,"-n : number of resolutions (-n 3) \n");
fprintf(stdout,"-b : size of code block (-b 32,32) \n");
fprintf(stdout,"-c : size of precinct (-c 128,128) \n");
fprintf(stdout,"-t : size of tile (-t 512,512) \n");
fprintf
(stdout,"-p : progression order (-p LRCP) [LRCP, RLCP, RPCL, PCRL, CPRL] \n");
fprintf
(stdout,"-s : subsampling factor (-s 2,2) [-s X,Y] \n");
fprintf(stdout," Remark: subsampling bigger than 2 can produce error\n");
fprintf
(stdout,"-SOP : write SOP marker before each packet \n");
fprintf
(stdout,"-EPH : write EPH marker after each header packet \n");
fprintf
(stdout,"-M : mode switch (-M 3) [1=BYPASS(LAZY) 2=RESET 4=RESTART(TERMALL)\n");
fprintf
(stdout," 8=VSC 16=ERTERM(SEGTERM) 32=SEGMARK(SEGSYM)] \n");
fprintf
(stdout," Indicate multiple modes by adding their values. \n");
fprintf
(stdout," ex: RESTART(4) + RESET(2) + SEGMARK(32) = -M 38\n");
fprintf
(stdout,"-x : create an index file *.Idx (-x index_name.Idx) \n");
fprintf
(stdout,"-ROI : c=%%d,U=%%d : quantization indices upshifted \n");
fprintf
(stdout," for component c=%%d [%%d = 0,1,2]\n");
fprintf
(stdout," with a value of U=%%d [0 <= %%d <= 37] (i.e. -ROI:c=0,U=25) \n");
fprintf
(stdout,"-d : offset of the origin of the image (-d 150,300) \n");
fprintf
(stdout,"-T : offset of the origin of the tiles (-T 100,75) \n");
fprintf(stdout,"-I : use the irreversible DWT 9-7 (-I) \n");
fprintf(stdout,"-W : image width, height and the dx and dy subsampling \n");
fprintf(stdout," of the Cb and Cr components for YUV files \n");
fprintf(stdout," (default is '352,288,2,2' for CIF format's 352x288 and 4:2:0)\n");
fprintf(stdout,"-F : video frame rate (set to 25 by default)\n");
fprintf(stdout,"\n");
fprintf(stdout,"IMPORTANT:\n");
fprintf(stdout,"-----------\n");
fprintf(stdout,"\n");
fprintf(stdout,"The index file has the structure below:\n");
fprintf(stdout,"---------------------------------------\n");
fprintf(stdout,"\n");
fprintf(stdout,"Image_height Image_width\n");
fprintf(stdout,"progression order\n");
fprintf(stdout,"Tiles_size_X Tiles_size_Y\n");
fprintf(stdout,"Components_nb\n");
fprintf(stdout,"Layers_nb\n");
fprintf(stdout,"decomposition_levels\n");
fprintf(stdout,"[Precincts_size_X_res_Nr Precincts_size_Y_res_Nr]...\n");
fprintf(stdout," [Precincts_size_X_res_0 Precincts_size_Y_res_0]\n");
fprintf(stdout,"Main_header_end_position\n");
fprintf(stdout,"Codestream_size\n");
fprintf(stdout,"Tile_0 start_pos end_Theader end_pos TotalDisto NumPix MaxMSE\n");
fprintf(stdout,"Tile_1 '' '' '' '' '' ''\n");
fprintf(stdout,"...\n");
fprintf(stdout,"Tile_Nt '' '' '' '' '' ''\n");
fprintf(stdout,"Tpacket_0 Tile layer res. comp. prec. start_pos end_pos disto\n");
fprintf(stdout,"...\n");
fprintf(stdout,"Tpacket_Np '' '' '' '' '' '' '' ''\n");
fprintf(stdout,"MaxDisto\n");
fprintf(stdout,"TotalDisto\n\n");
}
int give_progression(char progression[4])
{
if (progression[0] == 'L' && progression[1] == 'R'
&& progression[2] == 'C' && progression[3] == 'P') {
return 0;
} else {
if (progression[0] == 'R' && progression[1] == 'L'
&& progression[2] == 'C' && progression[3] == 'P') {
return 1;
} else {
if (progression[0] == 'R' && progression[1] == 'P'
&& progression[2] == 'C' && progression[3] == 'L') {
return 2;
} else {
if (progression[0] == 'P' && progression[1] == 'C'
&& progression[2] == 'R' && progression[3] == 'L') {
return 3;
} else {
if (progression[0] == 'C' && progression[1] == 'P'
&& progression[2] == 'R' && progression[3] == 'L') {
return 4;
} else {
return -1;
}
}
}
}
}
}
double dwt_norms_97[4][10] = {
{1.000, 1.965, 4.177, 8.403, 16.90, 33.84, 67.69, 135.3, 270.6, 540.9},
{2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0},
{2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0},
{2.080, 3.865, 8.307, 17.18, 34.71, 69.59, 139.3, 278.6, 557.2}
};
int floorlog2(int a)
{
int l;
for (l = 0; a > 1; l++) {
a >>= 1;
}
return l;
}
void encode_stepsize(int stepsize, int numbps, int *expn, int *mant)
{
int p, n;
p = floorlog2(stepsize) - 13;
n = 11 - floorlog2(stepsize);
*mant = (n < 0 ? stepsize >> -n : stepsize << n) & 0x7ff;
*expn = numbps - p;
}
void calc_explicit_stepsizes(j2k_tccp_t * tccp, int prec)
{
int numbands, bandno;
numbands = 3 * tccp->numresolutions - 2;
for (bandno = 0; bandno < numbands; bandno++) {
double stepsize;
int resno, level, orient, gain;
resno = bandno == 0 ? 0 : (bandno - 1) / 3 + 1;
orient = bandno == 0 ? 0 : (bandno - 1) % 3 + 1;
level = tccp->numresolutions - 1 - resno;
gain =
tccp->qmfbid == 0 ? 0 : (orient ==
0 ? 0 : (orient == 1
|| orient == 2 ? 1 : 2));
if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
stepsize = 1.0;
} else {
double norm = dwt_norms_97[orient][level];
stepsize = (1 << (gain + 1)) / norm;
}
encode_stepsize((int) floor(stepsize * 8192.0), prec + gain,
&tccp->stepsizes[bandno].expn,
&tccp->stepsizes[bandno].mant);
}
}
int main(int argc, char **argv)
{
int NumResolution, numD_min; /* NumResolution : number of resolution */
int Tile_arg; /* Tile_arg = 0 (not in argument) ou = 1 (in argument) */
int CSty; /* CSty : coding style */
int Prog_order; /* progression order (default LRCP) */
char progression[4];
int numpocs, numpocs_tile; /* Number of progression order change (POC) default 0 */
int prcw_init[J2K_MAXRLVLS]; /* Initialisation Precinct width */
int prch_init[J2K_MAXRLVLS]; /* Initialisation Precinct height */
//int prcw_init, prch_init; /* Initialisation precincts' size */
int cblockw_init, cblockh_init; /* Initialisation codeblocks' size */
int mode, value; /* Mode switch (cblk_style) */
int subsampling_dx, subsampling_dy; /* subsampling value for dx and dy */
int ROI_compno, ROI_shift; /* region of interrest */
int Dim[2]; /* portion of the image coded */
int TX0, TY0; /* tile off-set */
mj2_movie_t movie;
j2k_cp_t cp, cp_init; /* cp_init is used to initialise in multiple tiles */
j2k_tcp_t *tcp, *tcp_init; /* tcp_init is used to initialise in multiple tile */
j2k_poc_t POC[32]; /* POC : used in case of Progression order change */
j2k_poc_t *tcp_poc;
j2k_tccp_t *tccp;
int i, tileno, l, j;
char *infile = 0;
char *outfile = 0;
char *index = 0;
char *s, S1, S2, S3;
char *buf;
int ir = 0;
int res_spec = 0; /* For various precinct sizes specification */
char sep;
int w; /* Width of YUV file */
int h; /* Height of YUV file */
int CbCr_subsampling_dx; /* Sample rate of YUV 4:4:4 4:2:2 or 4:2:0 */
int CbCr_subsampling_dy; /* Sample rate of YUV 4:4:4 4:2:2 or 4:2:0 */
int frame_rate; /* Video Frame Rate */
int numcomps; /* In YUV files, numcomps always considered as 3 */
int prec; /* In YUV files, precision always considered as 8 */
int x1, y1, len, jp2c_initpos, m, k, pos;
long mdat_initpos, offset;
FILE *mj2file, *yuvfile;
unsigned int sampleno;
j2k_image_t img;
/* default value */
/* ------------- */
NumResolution = 6;
CSty = 0;
cblockw_init = 64;
cblockh_init = 64;
cp.tw = 1;
cp.th = 1;
cp.index_on = 0;
Prog_order = 0;
numpocs = 0;
mode = 0;
subsampling_dx = 1;
subsampling_dy = 1;
ROI_compno = -1; /* no ROI */
ROI_shift = 0;
Dim[0] = 0;
Dim[1] = 0;
TX0 = 0;
TY0 = 0;
cp.comment = NULL;
cp.disto_alloc = 0;
cp.fixed_alloc = 0;
cp.fixed_quality = 0; //add fixed_quality
w = 352; // CIF default value
h = 288; // CIF default value
CbCr_subsampling_dx = 2; // CIF default value
CbCr_subsampling_dy = 2; // CIF default value
frame_rate = 25;
Tile_arg = 0;
cp_init.tcps = (j2k_tcp_t *) malloc(sizeof(j2k_tcp_t)); /* initialisation if only one tile */
tcp_init = &cp_init.tcps[0];
tcp_init->numlayers = 0;
cp.intermed_file = 0; // Don't store each tile in a file during processing
while (1) {
int c = getopt(argc, argv,
"i:o:r:q:f:t:n:c:b:x:p:s:d:h:P:S:E:M:R:T:C:I:W:F:");
if (c == -1)
break;
switch (c) {
case 'i': /* IN fill */
infile = optarg;
s = optarg;
while (*s) {
s++;
}
s--;
S3 = *s;
s--;
S2 = *s;
s--;
S1 = *s;
if ((S1 == 'y' && S2 == 'u' && S3 == 'v')
|| (S1 == 'Y' && S2 == 'U' && S3 == 'V')) {
cp.decod_format = YUV_DFMT;
break;
}
fprintf(stderr,
"!! Unrecognized format for infile : %c%c%c [accept only *.yuv] !!\n\n",
S1, S2, S3);
return 1;
break;
/* ----------------------------------------------------- */
case 'o': /* OUT fill */
outfile = optarg;
while (*outfile) {
outfile++;
}
outfile--;
S3 = *outfile;
outfile--;
S2 = *outfile;
outfile--;
S1 = *outfile;
outfile = optarg;
if ((S1 == 'm' && S2 == 'j' && S3 == '2')
|| (S1 == 'M' && S2 == 'J' && S3 == '2'))
cp.cod_format = MJ2_CFMT;
else {
fprintf(stderr,
"Unknown output format image *.%c%c%c [only *.mj2]!! \n",
S1, S2, S3);
return 1;
}
break;
/* ----------------------------------------------------- */
case 'r': /* rates rates/distorsion */
s = optarg;
while (sscanf(s, "%d", &tcp_init->rates[tcp_init->numlayers])
== 1) {
tcp_init->numlayers++;
while (*s && *s != ',') {
s++;
}
if (!*s)
break;
s++;
}
cp.disto_alloc = 1;
cp.matrice = NULL;
break;
/* ----------------------------------------------------- */
case 'q': /* add fixed_quality */
s = optarg;
while (sscanf
(s, "%f", &tcp_init->distoratio[tcp_init->numlayers]) == 1) {
tcp_init->numlayers++;
while (*s && *s != ',') {
s++;
}
if (!*s)
break;
s++;
}
cp.fixed_quality = 1;
cp.matrice = NULL;
break;
/* dda */
/* ----------------------------------------------------- */
case 'f': /* mod fixed_quality (before : -q) */
s = optarg;
sscanf(s, "%d", &tcp_init->numlayers);
s++;
if (tcp_init->numlayers > 9)
s++;
cp.matrice =
(int *) malloc(tcp_init->numlayers * NumResolution * 3 *
sizeof(int));
s = s + 2;
for (i = 0; i < tcp_init->numlayers; i++) {
tcp_init->rates[i] = 1;
sscanf(s, "%d,", &cp.matrice[i * NumResolution * 3]);
s += 2;
if (cp.matrice[i * NumResolution * 3] > 9)
s++;
cp.matrice[i * NumResolution * 3 + 1] = 0;
cp.matrice[i * NumResolution * 3 + 2] = 0;
for (j = 1; j < NumResolution; j++) {
sscanf(s, "%d,%d,%d",
&cp.matrice[i * NumResolution * 3 + j * 3 + 0],
&cp.matrice[i * NumResolution * 3 + j * 3 + 1],
&cp.matrice[i * NumResolution * 3 + j * 3 + 2]);
s += 6;
if (cp.matrice[i * NumResolution * 3 + j * 3] > 9)
s++;
if (cp.matrice[i * NumResolution * 3 + j * 3 + 1] > 9)
s++;
if (cp.matrice[i * NumResolution * 3 + j * 3 + 2] > 9)
s++;
}
if (i < tcp_init->numlayers - 1)
s++;
}
cp.fixed_alloc = 1;
break;
/* ----------------------------------------------------- */
case 't': /* tiles */
sscanf(optarg, "%d,%d", &cp.tdx, &cp.tdy);
Tile_arg = 1;
break;
/* ----------------------------------------------------- */
case 'n': /* resolution */
sscanf(optarg, "%d", &NumResolution);
break;
/* ----------------------------------------------------- */
case 'c': /* precinct dimension */
s = optarg;
do {
sep = 0;
sscanf(s, "[%d,%d]%c", &prcw_init[res_spec],
&prch_init[res_spec], &sep);
CSty |= 0x01;
res_spec++;
s = strpbrk(s, "]") + 2;
} while (sep == ',');
break;
/* ----------------------------------------------------- */
case 'b': /* code-block dimension */
sscanf(optarg, "%d,%d", &cblockw_init, &cblockh_init);
if (cblockw_init * cblockh_init > 4096 || cblockw_init > 1024
|| cblockw_init < 4 || cblockh_init > 1024 || cblockh_init < 4) {
fprintf(stderr,
"!! Size of code_block error (option -b) !!\n\nRestriction :\n * width*height<=4096\n * 4<=width,height<= 1024\n\n");
return 1;
}
break;
/* ----------------------------------------------------- */
case 'x': /* creation of index file */
index = optarg;
cp.index_on = 1;
break;
/* ----------------------------------------------------- */
case 'p': /* progression order */
s = optarg;
for (i = 0; i < 4; i++) {
progression[i] = *s;
s++;
}
Prog_order = give_progression(progression);
if (Prog_order == -1) {
fprintf(stderr,
"Unrecognized progression order [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n");
return 1;
}
break;
/* ----------------------------------------------------- */
case 's': /* subsampling factor */
if (sscanf(optarg, "%d,%d", &subsampling_dx, &subsampling_dy)
!= 2) {
fprintf(stderr,
"'-s' sub-sampling argument error ! [-s dx,dy]\n");
return 1;
}
break;
/* ----------------------------------------------------- */
case 'd': /* coordonnate of the reference grid */
if (sscanf(optarg, "%d,%d", &Dim[0], &Dim[1]) != 2) {
fprintf(stderr,
"-d 'coordonnate of the reference grid' argument error !! [-d x0,y0]\n");
return 1;
}
break;
/* ----------------------------------------------------- */
case 'h': /* Display an help description */
help_display();
return 0;
break;
/* ----------------------------------------------------- */
case 'P': /* POC */
fprintf(stderr, "/----------------------------------\\\n");
fprintf(stderr, "| POC option not fully tested !! |\n");
fprintf(stderr, "\\----------------------------------/\n");
s = optarg;
while (sscanf(s, "T%d=%d,%d,%d,%d,%d,%s", &POC[numpocs].tile,
&POC[numpocs].resno0, &POC[numpocs].compno0,
&POC[numpocs].layno1, &POC[numpocs].resno1,
&POC[numpocs].compno1, POC[numpocs].progorder) == 7) {
POC[numpocs].prg = give_progression(POC[numpocs].progorder);
/* POC[numpocs].tile; */
numpocs++;
while (*s && *s != '/') {
s++;
}
if (!*s)
break;
s++;
}
break;
/* ------------------------------------------------------ */
case 'S': /* SOP marker */
CSty |= 0x02;
break;
/* ------------------------------------------------------ */
case 'E': /* EPH marker */
CSty |= 0x04;
break;
/* ------------------------------------------------------ */
case 'M': /* Mode switch pas tous au point !! */
if (sscanf(optarg, "%d", &value) == 1) {
for (i = 0; i <= 5; i++) {
int cache = value & (1 << i);
if (cache)
mode |= (1 << i);
}
}
break;
/* ------------------------------------------------------ */
case 'R': /* ROI */
if (sscanf(optarg, "OI:c=%d,U=%d", &ROI_compno, &ROI_shift) != 2) {
fprintf(stderr, "ROI error !! [-ROI:c='compno',U='shift']\n");
return 1;
}
break;
/* ------------------------------------------------------ */
case 'T': /* Tile offset */
if (sscanf(optarg, "%d,%d", &TX0, &TY0) != 2) {
fprintf(stderr, "-T 'tile offset' argument error !! [-T X0,Y0]");
return 1;
}
break;
/* ------------------------------------------------------ */
case 'C': /* Add a comment */
cp.comment = optarg;
break;
/* ------------------------------------------------------ */
case 'I': /* reversible or not */
ir = 1;
break;
/* ------------------------------------------------------ */
case 'W': /* Width and Height and Cb and Cr subsampling in case of YUV format files */
if (sscanf
(optarg, "%d,%d,%d,%d", &w, &h, &CbCr_subsampling_dx,
&CbCr_subsampling_dy) != 4) {
fprintf(stderr, "-W argument error");
return 1;
}
break;
/* ------------------------------------------------------ */
case 'F': /* Video frame rate */
if (sscanf(optarg, "%d", &frame_rate) != 1) {
fprintf(stderr, "-F argument error");
return 1;
}
break;
/* ------------------------------------------------------ */
default:
return 1;
}
}
cp.tx0 = TX0;
cp.ty0 = TY0;
/* Error messages */
/* -------------- */
if (!infile || !outfile) {
fprintf(stderr,
"Correct usage: mj2_encoder -i yuv-file -o mj2-file (+ options)\n");
return 1;
}
if ((cp.disto_alloc || cp.fixed_alloc || cp.fixed_quality)
&& (!(cp.disto_alloc ^ cp.fixed_alloc ^ cp.fixed_quality))) {
fprintf(stderr,
"Error: options -r -q and -f can not be used together !!\n");
return 1;
} // mod fixed_quality
/* if no rate entered, lossless by default */
if (tcp_init->numlayers == 0) {
tcp_init->rates[tcp_init->numlayers] = 0; //MOD antonin : losslessbug
tcp_init->numlayers++;
cp.disto_alloc = 1;
}
if (TX0 > Dim[0] || TY0 > Dim[1]) {
fprintf(stderr,
"Error: Tile offset dimension is unnappropriate --> TX0(%d)<=IMG_X0(%d) TYO(%d)<=IMG_Y0(%d) \n",
TX0, Dim[0], TY0, Dim[1]);
return 1;
}
for (i = 0; i < numpocs; i++) {
if (POC[i].prg == -1) {
fprintf(stderr,
"Unrecognized progression order in option -P (POC n %d) [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n",
i + 1);
}
}
/* to respect profile - 0 */
/* ---------------------- */
numD_min = 0;
x1 = !Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w -
1) *
subsampling_dx + 1;
y1 = !Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h -
1) *
subsampling_dy + 1;
if (Tile_arg == 1) {
cp.tw = int_ceildiv(x1 - cp.tx0, cp.tdx);
cp.th = int_ceildiv(y1 - cp.ty0, cp.tdy);
} else {
cp.tdx = x1 - cp.tx0;
cp.tdy = y1 - cp.ty0;
}
/* Initialization for PPM marker */
cp.ppm = 0;
cp.ppm_data = NULL;
cp.ppm_previous = 0;
cp.ppm_store = 0;
numcomps = 3; /* Because YUV files only have 3 components */
tcp_init->mct = 0; /* No component transform needed */
prec = 8; /* Because in YUV files, components have 8-bit depth */
/* Init the mutiple tiles */
/* ---------------------- */
cp.tcps = (j2k_tcp_t *) malloc(cp.tw * cp.th * sizeof(j2k_tcp_t));
for (tileno = 0; tileno < cp.tw * cp.th; tileno++) {
tcp = &cp.tcps[tileno];
tcp->numlayers = tcp_init->numlayers;
for (j = 0; j < tcp->numlayers; j++) {
if (cp.fixed_quality) // add fixed_quality
tcp->distoratio[j] = tcp_init->distoratio[j];
else
tcp->rates[j] = tcp_init->rates[j];
}
tcp->csty = CSty;
tcp->prg = Prog_order;
tcp->mct = tcp_init->mct;
tcp->ppt = 0;
tcp->ppt_data = NULL;
tcp->ppt_store = 0;
numpocs_tile = 0;
tcp->POC = 0;
if (numpocs) {
/* intialisation of POC */
tcp->POC = 1;
for (i = 0; i < numpocs; i++) {
if (tileno == POC[i].tile - 1 || POC[i].tile == -1) {
tcp_poc = &tcp->pocs[numpocs_tile];
tcp_poc->resno0 = POC[numpocs_tile].resno0;
tcp_poc->compno0 = POC[numpocs_tile].compno0;
tcp_poc->layno1 = POC[numpocs_tile].layno1;
tcp_poc->resno1 = POC[numpocs_tile].resno1;
tcp_poc->compno1 = POC[numpocs_tile].compno1;
tcp_poc->prg = POC[numpocs_tile].prg;
tcp_poc->tile = POC[numpocs_tile].tile;
numpocs_tile++;
}
}
}
tcp->numpocs = numpocs_tile;
tcp->tccps = (j2k_tccp_t *) malloc(numcomps * sizeof(j2k_tccp_t));
for (i = 0; i < numcomps; i++) {
tccp = &tcp->tccps[i];
tccp->csty = CSty & 0x01; /* 0 => one precinct || 1 => custom precinct */
tccp->numresolutions = NumResolution;
tccp->cblkw = int_floorlog2(cblockw_init);
tccp->cblkh = int_floorlog2(cblockh_init);
tccp->cblksty = mode;
tccp->qmfbid = ir ? 0 : 1;
tccp->qntsty = ir ? J2K_CCP_QNTSTY_SEQNT : J2K_CCP_QNTSTY_NOQNT;
tccp->numgbits = 2;
if (i == ROI_compno)
tccp->roishift = ROI_shift;
else
tccp->roishift = 0;
if (CSty & J2K_CCP_CSTY_PRT) {
int p = 0;
for (j = tccp->numresolutions - 1; j >= 0; j--) {
if (p < res_spec) {
if (prcw_init[p] < 1)
tccp->prcw[j] = 1;
else
tccp->prcw[j] = int_floorlog2(prcw_init[p]);
if (prch_init[p] < 1)
tccp->prch[j] = 1;
else
tccp->prch[j] = int_floorlog2(prch_init[p]);
} else {
int size_prcw, size_prch;
size_prcw = prcw_init[res_spec - 1] >> (p - (res_spec - 1));
size_prch = prch_init[res_spec - 1] >> (p - (res_spec - 1));
if (size_prcw < 1)
tccp->prcw[j] = 1;
else
tccp->prcw[j] = int_floorlog2(size_prcw);
if (size_prch < 1)
tccp->prch[j] = 1;
else
tccp->prch[j] = int_floorlog2(size_prch);
}
p++;
/*printf("\nsize precinct pour level %d : %d,%d\n", j,
tccp->prcw[j], tccp->prch[j]); */
}
} else {
for (j = 0; j < tccp->numresolutions; j++) {
tccp->prcw[j] = 15;
tccp->prch[j] = 15;
}
}
calc_explicit_stepsizes(tccp, prec);
}
}
mj2file = fopen(outfile, "wb");
if (!mj2file) {
fprintf(stderr, "failed to open %s for writing\n", argv[2]);
return 1;
}
movie.tk = (mj2_tk_t *) malloc(sizeof(mj2_tk_t));
movie.num_vtk = 1;
movie.num_stk = 0;
movie.num_htk = 0;
movie.tk[0].track_type = 0; // Video Track
movie.tk[0].track_ID = 1;
movie.tk[0].Dim[0] = Dim[0];
movie.tk[0].Dim[1] = Dim[1];
movie.tk[0].w = w;
movie.tk[0].h = h;
movie.tk[0].CbCr_subsampling_dx = CbCr_subsampling_dx;
movie.tk[0].CbCr_subsampling_dy = CbCr_subsampling_dy;
movie.tk[0].sample_rate = frame_rate;
movie.tk[0].jp2_struct.numcomps = 3; // NC
jp2_init_stdjp2(&movie.tk[0].jp2_struct);
movie.tk[0].jp2_struct.w = w;
movie.tk[0].jp2_struct.h = h;
movie.tk[0].jp2_struct.bpc = 7;
movie.tk[0].jp2_struct.meth = 1;
movie.tk[0].jp2_struct.enumcs = 18; // YUV
yuvfile = fopen(infile,"rb");
if (!yuvfile) {
fprintf(stderr, "failed to open %s for reading\n",infile);
return 1;
}
movie.tk[0].num_samples = yuv_num_frames(&movie.tk[0],yuvfile);
if (!movie.tk[0].num_samples) {
fprintf(stderr,"Unable to count the number of frames in YUV input file\n");
}
// One sample per chunk
movie.tk[0].chunk = (mj2_chunk_t*) malloc(movie.tk[0].num_samples * sizeof(mj2_chunk_t));
movie.tk[0].sample = (mj2_sample_t*) malloc(movie.tk[0].num_samples * sizeof(mj2_sample_t));
if (mj2_init_stdmovie(&movie)) {
fprintf(stderr, "Error with movie initialization");
return 1;
};
// Writing JP, FTYP and MDAT boxes
buf = (char*) malloc (300 * sizeof(char)); // Assuming that the JP and FTYP
// boxes won't be longer than 300 bytes
cio_init(buf , 300);
mj2_write_jp();
mj2_write_ftyp(&movie);
mdat_initpos = cio_tell();
cio_skip(4);
cio_write(MJ2_MDAT, 4);
fwrite(buf,cio_tell(),1,mj2file);
offset = cio_tell();
free(buf);
for (i = 0; i < movie.num_stk + movie.num_htk + movie.num_vtk; i++) {
if (movie.tk[i].track_type != 0) {
fprintf(stderr, "Unable to write sound or hint tracks\n");
} else {
//j2k_cp_t cp_init;
mj2_tk_t *tk;
tk = &movie.tk[i];
//tk->sample =
//(mj2_sample_t *) malloc(tk->num_samples * sizeof(mj2_sample_t));
tk->num_chunks = tk->num_samples;
//tk->chunk =
//(mj2_chunk_t *) malloc(tk->num_chunks * sizeof(mj2_chunk_t));
fprintf(stderr, "Video Track number %d\n", i + 1);
// Copy the first tile coding parameters (tcp) to cp_init
//cp_init.tcps =
//(j2k_tcp_t *) malloc(cp.tw * cp.th * sizeof(j2k_tcp_t));
for (tileno = 0; tileno < cp.tw * cp.th; tileno++) {
for (l = 0; l < cp.tcps[tileno].numlayers; l++) {
cp_init.tcps[tileno].rates[l] = cp.tcps[tileno].rates[l];
//tileno = cp.tcps[tileno].rates[l];
}
}
for (sampleno = 0; sampleno < tk->num_samples; sampleno++) {
buf = (char *) malloc(cp.tdx * cp.tdy * cp.th * cp.tw * 2);
cio_init(buf, cp.tdx * cp.tdy * cp.th * cp.tw * 2);
fprintf(stderr, "Frame number %d/%d: ", sampleno + 1, tk->num_samples);
if (!yuvtoimage(yuvfile, tk, &img, sampleno, subsampling_dx, subsampling_dy)) {
fprintf(stderr, "Error with frame number %d in YUV file\n", sampleno);
return 1;
}
jp2c_initpos = cio_tell();
cio_skip(4);
cio_write(JP2_JP2C, 4); // JP2C
len = j2k_encode(&img, &cp, buf, cp.tdx * cp.tdy * 2, index);
if (len ==0) {
fprintf(stderr,"Unable to encode image");
return 1;
}
cio_seek(jp2c_initpos);
cio_write(len+8,4);
for (m = 0; m < img.numcomps; m++) {
free(img.comps[m].data);
}
free(img.comps);
tk->sample[sampleno].sample_size = len+8;
tk->sample[sampleno].offset = offset;
tk->chunk[sampleno].offset = offset; // There is one sample per chunk
fwrite(buf, 1, len+8, mj2file);
offset += len+8;
free(buf);
// Copy the cp_init parameters to cp.tcps
for (tileno = 0; tileno < cp.tw * cp.th; tileno++) {
for (k = 0; k < cp.tcps[tileno].numlayers; k++) {
cp.tcps[tileno].rates[k] = cp_init.tcps[tileno].rates[k];
}
}
}
}
}
fseek(mj2file, mdat_initpos, SEEK_SET);
buf = (char*) malloc(4*sizeof(char));
cio_init(buf, 4); // Init a cio to write box length variable in a little endian way
cio_write(offset - mdat_initpos, 4);
fwrite(buf, 4, 1, mj2file);
fseek(mj2file,0,SEEK_END);
free(buf);
// Writing MOOV box
i=1;
buf = (char*) malloc (10000 * sizeof(char));
cio_init(buf , i*10000);
if (setjmp(j2k_error)) {
i++;
realloc(buf,i*10000* sizeof(char));
pos = cio_tell();
cio_init(buf , i*10000);
cio_seek(pos);
}
mj2_write_moov(&movie);
fwrite(buf,cio_tell(),1,mj2file);
// Ending program
mj2_memory_free(&movie);
free(cp_init.tcps);
if (tcp_init->numlayers > 9)
free(cp.matrice);
for (tileno = 0; tileno < cp.tw * cp.th; tileno++)
free(cp.tcps[tileno].tccps);
free(cp.tcps);
fclose(mj2file);
free(buf);
remove("Compo0");
remove("Compo1");
remove("Compo2");
//MEMORY LEAK
#ifdef _DEBUG
_CrtDumpMemoryLeaks();
#endif
//MEM
return 0;
}

269
mj2/frames_to_mj2.dsp Normal file
View File

@@ -0,0 +1,269 @@
# Microsoft Developer Studio Project File - Name="frames_to_mj2" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=frames_to_mj2 - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "frames_to_mj2.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "frames_to_mj2.mak" CFG="frames_to_mj2 - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "frames_to_mj2 - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "frames_to_mj2 - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "frames_to_mj2 - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /W3 /GX /O2 /I "../libopenjpeg" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "DONT_HAVE_GETOPT" /YX /FD /c
# ADD BASE RSC /l 0x809 /d "NDEBUG"
# ADD RSC /l 0x809 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "frames_to_mj2 - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "frames_to_mj2___Win32_Debug0"
# PROP BASE Intermediate_Dir "frames_to_mj2___Win32_Debug0"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "frames_to_mj2___Win32_Debug0"
# PROP Intermediate_Dir "frames_to_mj2___Win32_Debug0"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../libopenjpeg" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "DONT_HAVE_GETOPT" /YX /FD /GZ /c
# ADD BASE RSC /l 0x809 /d "_DEBUG"
# ADD RSC /l 0x809 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "frames_to_mj2 - Win32 Release"
# Name "frames_to_mj2 - Win32 Debug"
# Begin Group "MJ2"
# PROP Default_Filter ""
# Begin Group "MJ2 Header Files"
# PROP Default_Filter ""
# Begin Source File
SOURCE=.\compat\getopt.h
# End Source File
# Begin Source File
SOURCE=.\mj2.h
# End Source File
# Begin Source File
SOURCE=.\mj2_convert.h
# End Source File
# End Group
# Begin Group "MJ2 Source Files"
# PROP Default_Filter ""
# Begin Source File
SOURCE=.\frames_to_mj2.c
# End Source File
# Begin Source File
SOURCE=.\compat\getopt.c
# End Source File
# Begin Source File
SOURCE=.\mj2.c
# End Source File
# Begin Source File
SOURCE=.\mj2_convert.c
# End Source File
# End Group
# End Group
# Begin Group "OpenJPEG"
# PROP Default_Filter ""
# Begin Group "OpenJPEG Header Files"
# PROP Default_Filter ""
# Begin Source File
SOURCE=..\libopenjpeg\bio.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\cio.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\dwt.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\fix.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\int.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\j2k.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jp2.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jpt.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\mct.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\mqc.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\openjpeg.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\pi.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\raw.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\t1.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\t2.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\tcd.h
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\tgt.h
# End Source File
# End Group
# Begin Group "OpenJPEG Source Files"
# PROP Default_Filter ""
# Begin Source File
SOURCE=..\libopenjpeg\bio.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\cio.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\dwt.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\fix.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\int.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\j2k.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jp2.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\jpt.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\mct.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\mqc.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\pi.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\raw.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\t1.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\t2.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\tcd.c
# End Source File
# Begin Source File
SOURCE=..\libopenjpeg\tgt.c
# End Source File
# End Group
# End Group
# End Target
# End Project

2185
mj2/meta_out.c Normal file
View File

File diff suppressed because it is too large Load Diff

13
mj2/meta_out.h Normal file
View File

@@ -0,0 +1,13 @@
/* meta_out.h */
/* Dump MJ2, JP2 metadata (partial so far) to xml file */
/* Callable from mj2_to_metadata */
/* Contributed to Open JPEG by Glenn Pearson, U.S. National Library of Medicine */
#define BOOL int
#define FALSE 0
#define TRUE 1
void xml_write_init(BOOL n, BOOL t, BOOL r, BOOL d);
int xml_write_struct(FILE *file, FILE *xmlout, mj2_movie_t * movie, unsigned int sampleframe, char* stringDTD);

Some files were not shown because too many files have changed in this diff Show More