diff options
78 files changed, 39290 insertions, 0 deletions
diff --git a/v2/CMakeLists.txt b/v2/CMakeLists.txt new file mode 100755 index 00000000..444092ef --- /dev/null +++ b/v2/CMakeLists.txt @@ -0,0 +1,139 @@ +# 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.4)
+
+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 1)
+SET(OPENJPEG_VERSION_MINOR 2)
+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}"
+)
+
+#----------------------------------------------------------------------------- +# Test for some required system information. +INCLUDE (${CMAKE_ROOT}/Modules/CMakeBackwardCompatibilityC.cmake) +
+#-----------------------------------------------------------------------------
+# 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
+ codec
+ test_V2_tile_handling
+ test_Free_image_V2_tile_handling
+ # mj2
+ # cmake 2.4.5 has poor java support
+ #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 Dart+CMake
+#IF(OPENJPEG_STANDALONE)
+# INCLUDE(Dart)
+# MARK_AS_ADVANCED(BUILD_TESTING DART_ROOT TCL_TCLSH)
+# IF(BUILD_TESTING)
+# ENABLE_TESTING()
+# SET(BUILDNAME "OpenJPEG-${CMAKE_SYSTEM}-${CMAKE_C_COMPILER}" CACHE STRING "Name of build on the dashboard")
+# MARK_AS_ADVANCED(BUILDNAME)
+# ENDIF(BUILD_TESTING)
+#ENDIF(OPENJPEG_STANDALONE)
+
+# Adding test with dataset from:
+# http://www.crc.ricoh.com/~gormish/jpeg2000conformance/
+# 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}")
+ # 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)
+
diff --git a/v2/Free_CMakeImport.cmake b/v2/Free_CMakeImport.cmake new file mode 100755 index 00000000..bcebe6ef --- /dev/null +++ b/v2/Free_CMakeImport.cmake @@ -0,0 +1,14 @@ +# Import library
+#________________
+
+ # MESSAGE(STATUS "IMPORT : FreeImagelibrary")
+
+ # Include directories
+ INCLUDE_DIRECTORIES(${OPENJPEG_SOURCE_DIR}/libs/FreeImage)
+
+ # Link libraries
+ LINK_DIRECTORIES(${OPENJPEG_SOURCE_DIR}/libs/FreeImage)
+
+ LINK_LIBRARIES(freeimage.s)
+ ADD_DEFINITIONS ( -DFREEIMAGE_LIB )
+
diff --git a/v2/codec/CMakeLists.txt b/v2/codec/CMakeLists.txt new file mode 100755 index 00000000..69538ce6 --- /dev/null +++ b/v2/codec/CMakeLists.txt @@ -0,0 +1,68 @@ +# 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)
+
+# Loop over all executables:
+FOREACH(exe j2k_to_image image_to_j2k)
+ ADD_EXECUTABLE(${exe} ${exe}.c ${common_SRCS})
+ TARGET_LINK_LIBRARIES(${exe} ${OPJ_PREFIX}openjpeg ${TIFF_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(/bin/ ${exe})
+ENDFOREACH(exe)
+
+# 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)
+ ADD_TEST(j2i-${filename_temp} ${EXECUTABLE_OUTPUT_PATH}/j2k_to_image -i ${filename} -o ${filename_temp}.tif)
+ENDFOREACH(filename)
+
diff --git a/v2/codec/compat/getopt.c b/v2/codec/compat/getopt.c new file mode 100755 index 00000000..75bbb279 --- /dev/null +++ b/v2/codec/compat/getopt.c @@ -0,0 +1,257 @@ +/*
+ * 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 */
+const char *optarg; /* argument associated with option */
+
+typedef struct option
+{
+ char *name;
+ int has_arg;
+ int *flag;
+ int val;
+}option_t;
+
+#define BADCH (int)'?'
+#define BADARG (int)':'
+#define EMSG ""
+
+
+
+/*
+ * getopt --
+ * Parse argc/argv argument vector.
+ */
+int getopt(int nargc, char *const *nargv, const char *ostr) {
+# define __progname nargv[0]
+ static const 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 != ':') {
+ 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) {
+ 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 */
+}
+
+
+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
diff --git a/v2/codec/compat/getopt.h b/v2/codec/compat/getopt.h new file mode 100755 index 00000000..7a04b302 --- /dev/null +++ b/v2/codec/compat/getopt.h @@ -0,0 +1,29 @@ +/* last review : october 29th, 2002 */
+
+#ifndef _GETOPT_H_
+#define _GETOPT_H_
+
+typedef struct option
+{
+ 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 optind;
+extern int optopt;
+extern int optreset;
+extern char *optarg;
+
+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_ */
diff --git a/v2/codec/convert.c b/v2/codec/convert.c new file mode 100755 index 00000000..99e3e455 --- /dev/null +++ b/v2/codec/convert.c @@ -0,0 +1,2138 @@ +/*
+ * 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
+ * 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 <stdlib.h>
+#include <string.h>
+#include "openjpeg.h"
+#include "../libs/libtiff/tiffio.h"
+#include "convert.h"
+
+/*
+ * Get logarithm of an integer and round downwards.
+ *
+ * log2(a)
+ */
+static int int_floorlog2(int a) {
+ int l;
+ for (l = 0; a > 1; l++) {
+ a >>= 1;
+ }
+ return l;
+}
+
+/*
+ * Divide an integer by a power of 2 and round upwards.
+ *
+ * a divided by 2^b
+ */
+static int int_ceildivpow2(int a, int b) {
+ return (a + (1 << b) - 1) >> b;
+}
+
+/*
+ * Divide an integer and round upwards.
+ *
+ * a divided by b
+ */
+static int int_ceildiv(int a, int b) {
+ return (a + b - 1) / b;
+}
+
+
+/* -->> -->> -->> -->>
+
+ TGA IMAGE FORMAT
+
+ <<-- <<-- <<-- <<-- */
+
+// TGA header definition.
+#pragma pack(push,1) // Pack structure byte aligned
+typedef struct tga_header
+{
+ uint8 id_length; /* Image id field length */
+ uint8 colour_map_type; /* Colour map type */
+ uint8 image_type; /* Image type */
+ /*
+ ** Colour map specification
+ */
+ uint16 colour_map_index; /* First entry index */
+ uint16 colour_map_length; /* Colour map length */
+ uint8 colour_map_entry_size; /* Colour map entry size */
+ /*
+ ** Image specification
+ */
+ uint16 x_origin; /* x origin of image */
+ uint16 y_origin; /* u origin of image */
+ uint16 image_width; /* Image width */
+ uint16 image_height; /* Image height */
+ uint8 pixel_depth; /* Pixel depth */
+ uint8 image_desc; /* Image descriptor */
+} tga_header;
+#pragma pack(pop) // Return to normal structure packing alignment.
+
+int tga_readheader(FILE *fp, int *bits_per_pixel, int *width, int *height, int *flip_image)
+{
+ int palette_size;
+ tga_header tga ;
+
+ if (!bits_per_pixel || !width || !height || !flip_image)
+ return 0;
+
+ // Read TGA header
+ fread((uint8*)&tga, sizeof(tga_header), 1, fp);
+
+ *bits_per_pixel = tga.pixel_depth;
+
+ *width = tga.image_width;
+ *height = tga.image_height ;
+
+ // Ignore tga identifier, if present ...
+ if (tga.id_length)
+ {
+ uint8 *id = (uint8 *) malloc(tga.id_length);
+ fread(id, tga.id_length, 1, fp);
+ free(id);
+ }
+
+ // Test for compressed formats ... not yet supported ...
+ // Note :- 9 - RLE encoded palettized.
+ // 10 - RLE encoded RGB.
+ if (tga.image_type > 8)
+ {
+ fprintf(stderr, "Sorry, compressed tga files are not currently supported.\n");
+ return 0 ;
+ }
+
+ *flip_image = !(tga.image_desc & 32);
+
+ // Palettized formats are not yet supported, skip over the palette, if present ...
+ palette_size = tga.colour_map_length * (tga.colour_map_entry_size/8);
+
+ if (palette_size>0)
+ {
+ fprintf(stderr, "File contains a palette - not yet supported.");
+ fseek(fp, palette_size, SEEK_CUR);
+ }
+ return 1;
+}
+
+int tga_writeheader(FILE *fp, int bits_per_pixel, int width, int height, bool flip_image)
+{
+ tga_header tga;
+
+ if (!bits_per_pixel || !width || !height)
+ return 0;
+
+ memset(&tga, 0, sizeof(tga_header));
+
+ tga.pixel_depth = bits_per_pixel;
+ tga.image_width = width;
+ tga.image_height = height;
+ tga.image_type = 2; // Uncompressed.
+ tga.image_desc = 8; // 8 bits per component.
+
+ if (flip_image)
+ tga.image_desc |= 32;
+
+ // Write TGA header
+ fwrite((uint8*)&tga, sizeof(tga_header), 1, fp);
+
+ return 1;
+}
+
+opj_image_t* tgatoimage(const char *filename, opj_cparameters_t *parameters) {
+ FILE *f;
+ opj_image_t *image;
+ uint32 image_width, image_height, pixel_bit_depth;
+ uint32 x, y;
+ int flip_image=0;
+ opj_image_cmptparm_t cmptparm[4]; /* maximum 4 components */
+ int numcomps;
+ OPJ_COLOR_SPACE color_space;
+ bool mono ;
+ bool save_alpha;
+ int subsampling_dx, subsampling_dy;
+ int i;
+
+ f = fopen(filename, "rb");
+ if (!f) {
+ fprintf(stderr, "Failed to open %s for reading !!\n", filename);
+ return 0;
+ }
+
+ if (!tga_readheader(f, &pixel_bit_depth, &image_width, &image_height, &flip_image))
+ return NULL;
+
+ // We currently only support 24 & 32 bit tga's ...
+ if (!((pixel_bit_depth == 24) || (pixel_bit_depth == 32)))
+ return NULL;
+
+ /* initialize image components */
+ memset(&cmptparm[0], 0, 4 * sizeof(opj_image_cmptparm_t));
+
+ mono = (pixel_bit_depth == 8) || (pixel_bit_depth == 16); // Mono with & without alpha.
+ save_alpha = (pixel_bit_depth == 16) || (pixel_bit_depth == 32); // Mono with alpha, or RGB with alpha
+
+ if (mono) {
+ color_space = CLRSPC_GRAY;
+ numcomps = save_alpha ? 2 : 1;
+ }
+ else {
+ numcomps = save_alpha ? 4 : 3;
+ color_space = CLRSPC_SRGB;
+ }
+
+ subsampling_dx = parameters->subsampling_dx;
+ subsampling_dy = parameters->subsampling_dy;
+
+ for (i = 0; i < numcomps; i++) {
+ cmptparm[i].prec = 8;
+ cmptparm[i].bpp = 8;
+ cmptparm[i].sgnd = 0;
+ cmptparm[i].dx = subsampling_dx;
+ cmptparm[i].dy = subsampling_dy;
+ cmptparm[i].w = image_width;
+ cmptparm[i].h = image_height;
+ }
+
+ /* create the image */
+ image = opj_image_create(numcomps, &cmptparm[0], color_space);
+
+ if (!image)
+ return NULL;
+
+ /* set image offset and reference grid */
+ image->x0 = parameters->image_offset_x0;
+ image->y0 = parameters->image_offset_y0;
+ image->x1 = !image->x0 ? (image_width - 1) * subsampling_dx + 1 : image->x0 + (image_width - 1) * subsampling_dx + 1;
+ image->y1 = !image->y0 ? (image_height - 1) * subsampling_dy + 1 : image->y0 + (image_height - 1) * subsampling_dy + 1;
+
+ /* set image data */
+ for (y=0; y < image_height; y++)
+ {
+ int index;
+
+ if (flip_image)
+ index = (image_height-y-1)*image_width;
+ else
+ index = y*image_width;
+
+ if (numcomps==3)
+ {
+ for (x=0;x<image_width;x++)
+ {
+ uint8 r,g,b;
+ fread(&b, 1, 1, f);
+ fread(&g, 1, 1, f);
+ fread(&r, 1, 1, f);
+
+ image->comps[0].data[index]=r;
+ image->comps[1].data[index]=g;
+ image->comps[2].data[index]=b;
+ index++;
+ }
+ }
+ else if (numcomps==4)
+ {
+ for (x=0;x<image_width;x++)
+ {
+ uint8 r,g,b,a;
+ fread(&b, 1, 1, f);
+ fread(&g, 1, 1, f);
+ fread(&r, 1, 1, f);
+ fread(&a, 1, 1, f);
+
+ image->comps[0].data[index]=r;
+ image->comps[1].data[index]=g;
+ image->comps[2].data[index]=b;
+ image->comps[3].data[index]=a;
+ index++;
+ }
+ }
+ else {
+ fprintf(stderr, "Currently unsupported bit depth : %s\n", filename);
+ }
+ }
+ return image;
+}
+
+int imagetotga(opj_image_t * image, const char *outfile) {
+ int width, height, bpp, x, y;
+ bool write_alpha;
+ int i;
+ uint32 alpha_channel;
+ float r,g,b,a;
+ uint8 value;
+ float scale;
+ FILE *fdest;
+
+ fdest = fopen(outfile, "wb");
+ if (!fdest) {
+ fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
+ return 1;
+ }
+
+ for (i = 0; i < image->numcomps-1; i++) {
+ if ((image->comps[0].dx != image->comps[i+1].dx)
+ ||(image->comps[0].dy != image->comps[i+1].dy)
+ ||(image->comps[0].prec != image->comps[i+1].prec)) {
+ fprintf(stderr, "Unable to create a tga file with such J2K image charateristics.");
+ return 1;
+ }
+ }
+
+ width = image->comps[0].w;
+ height = image->comps[0].h;
+
+ // Mono with alpha, or RGB with alpha.
+ write_alpha = (image->numcomps==2) || (image->numcomps==4);
+
+ // Write TGA header
+ bpp = write_alpha ? 32 : 24;
+ if (!tga_writeheader(fdest, bpp, width , height, true))
+ return 1;
+
+ alpha_channel = image->numcomps-1;
+
+ scale = 255.0f / (float)((1<<image->comps[0].prec)-1);
+
+ for (y=0; y < height; y++) {
+ uint32 index=y*width;
+
+ for (x=0; x < width; x++, index++) {
+ r = (float)(image->comps[0].data[index]);
+
+ if (image->numcomps>2) {
+ g = (float)(image->comps[1].data[index]);
+ b = (float)(image->comps[2].data[index]);
+ }
+ else {// Greyscale ...
+ g = r;
+ b = r;
+ }
+
+ // TGA format writes BGR ...
+ value = (uint8)(b*scale);
+ fwrite(&value,1,1,fdest);
+
+ value = (uint8)(g*scale);
+ fwrite(&value,1,1,fdest);
+
+ value = (uint8)(r*scale);
+ fwrite(&value,1,1,fdest);
+
+ if (write_alpha) {
+ a = (float)(image->comps[alpha_channel].data[index]);
+ value = (uint8)(a*scale);
+ fwrite(&value,1,1,fdest);
+ }
+ }
+ }
+
+ return 0;
+}
+
+/* -->> -->> -->> -->>
+
+ BMP IMAGE FORMAT
+
+ <<-- <<-- <<-- <<-- */
+
+/* WORD defines a two byte word */
+typedef unsigned short int WORD;
+
+/* DWORD defines a four byte word */
+typedef unsigned long int DWORD;
+
+typedef struct {
+ WORD bfType; /* 'BM' for Bitmap (19776) */
+ DWORD bfSize; /* Size of the file */
+ WORD bfReserved1; /* Reserved : 0 */
+ WORD bfReserved2; /* Reserved : 0 */
+ DWORD bfOffBits; /* Offset */
+} BITMAPFILEHEADER_t;
+
+typedef struct {
+ DWORD biSize; /* Size of the structure in bytes */
+ DWORD biWidth; /* Width of the image in pixels */
+ DWORD biHeight; /* Heigth of the image in pixels */
+ WORD biPlanes; /* 1 */
+ WORD biBitCount; /* Number of color bits by pixels */
+ DWORD biCompression; /* Type of encoding 0: none 1: RLE8 2: RLE4 */
+ DWORD biSizeImage; /* Size of the image in bytes */
+ DWORD biXpelsPerMeter; /* Horizontal (X) resolution in pixels/meter */
+ DWORD biYpelsPerMeter; /* Vertical (Y) resolution in pixels/meter */
+ DWORD biClrUsed; /* Number of color used in the image (0: ALL) */
+ DWORD biClrImportant; /* Number of important color (0: ALL) */
+} BITMAPINFOHEADER_t;
+
+opj_image_t* bmptoimage(const char *filename, opj_cparameters_t *parameters) {
+ int subsampling_dx = parameters->subsampling_dx;
+ int subsampling_dy = parameters->subsampling_dy;
+
+ int i, numcomps, w, h;
+ OPJ_COLOR_SPACE color_space;
+ opj_image_cmptparm_t cmptparm[3]; /* maximum of 3 components */
+ opj_image_t * image = NULL;
+
+ FILE *IN;
+ BITMAPFILEHEADER_t File_h;
+ BITMAPINFOHEADER_t Info_h;
+ unsigned char *RGB;
+ unsigned char *table_R, *table_G, *table_B;
+ unsigned int j, PAD = 0;
+
+ int x, y, index;
+ int gray_scale = 1, not_end_file = 1;
+
+ unsigned int line = 0, col = 0;
+ unsigned char v, v2;
+ DWORD W, H;
+
+ IN = fopen(filename, "rb");
+ if (!IN) {
+ fprintf(stderr, "Failed to open %s for reading !!\n", filename);
+ return 0;
+ }
+
+ File_h.bfType = getc(IN);
+ File_h.bfType = (getc(IN) << 8) + File_h.bfType;
+
+ if (File_h.bfType != 19778) {
+ fprintf(stderr,"Error, not a BMP file!\n");
+ return 0;
+ } else {
+ /* FILE HEADER */
+ /* ------------- */
+ File_h.bfSize = getc(IN);
+ File_h.bfSize = (getc(IN) << 8) + File_h.bfSize;
+ File_h.bfSize = (getc(IN) << 16) + File_h.bfSize;
+ File_h.bfSize = (getc(IN) << 24) + File_h.bfSize;
+
+ File_h.bfReserved1 = getc(IN);
+ File_h.bfReserved1 = (getc(IN) << 8) + File_h.bfReserved1;
+
+ File_h.bfReserved2 = getc(IN);
+ File_h.bfReserved2 = (getc(IN) << 8) + File_h.bfReserved2;
+
+ File_h.bfOffBits = getc(IN);
+ File_h.bfOffBits = (getc(IN) << 8) + File_h.bfOffBits;
+ File_h.bfOffBits = (getc(IN) << 16) + File_h.bfOffBits;
+ File_h.bfOffBits = (getc(IN) << 24) + File_h.bfOffBits;
+
+ /* INFO HEADER */
+ /* ------------- */
+
+ Info_h.biSize = getc(IN);
+ Info_h.biSize = (getc(IN) << 8) + Info_h.biSize;
+ Info_h.biSize = (getc(IN) << 16) + Info_h.biSize;
+ Info_h.biSize = (getc(IN) << 24) + Info_h.biSize;
+
+ Info_h.biWidth = getc(IN);
+ Info_h.biWidth = (getc(IN) << 8) + Info_h.biWidth;
+ Info_h.biWidth = (getc(IN) << 16) + Info_h.biWidth;
+ Info_h.biWidth = (getc(IN) << 24) + Info_h.biWidth;
+ w = Info_h.biWidth;
+
+ Info_h.biHeight = getc(IN);
+ Info_h.biHeight = (getc(IN) << 8) + Info_h.biHeight;
+ Info_h.biHeight = (getc(IN) << 16) + Info_h.biHeight;
+ Info_h.biHeight = (getc(IN) << 24) + Info_h.biHeight;
+ h = Info_h.biHeight;
+
+ Info_h.biPlanes = getc(IN);
+ Info_h.biPlanes = (getc(IN) << 8) + Info_h.biPlanes;
+
+ Info_h.biBitCount = getc(IN);
+ Info_h.biBitCount = (getc(IN) << 8) + Info_h.biBitCount;
+
+ Info_h.biCompression = getc(IN);
+ Info_h.biCompression = (getc(IN) << 8) + Info_h.biCompression;
+ Info_h.biCompression = (getc(IN) << 16) + Info_h.biCompression;
+ Info_h.biCompression = (getc(IN) << 24) + Info_h.biCompression;
+
+ Info_h.biSizeImage = getc(IN);
+ Info_h.biSizeImage = (getc(IN) << 8) + Info_h.biSizeImage;
+ Info_h.biSizeImage = (getc(IN) << 16) + Info_h.biSizeImage;
+ Info_h.biSizeImage = (getc(IN) << 24) + Info_h.biSizeImage;
+
+ Info_h.biXpelsPerMeter = getc(IN);
+ Info_h.biXpelsPerMeter = (getc(IN) << 8) + Info_h.biXpelsPerMeter;
+ Info_h.biXpelsPerMeter = (getc(IN) << 16) + Info_h.biXpelsPerMeter;
+ Info_h.biXpelsPerMeter = (getc(IN) << 24) + Info_h.biXpelsPerMeter;
+
+ Info_h.biYpelsPerMeter = getc(IN);
+ Info_h.biYpelsPerMeter = (getc(IN) << 8) + Info_h.biYpelsPerMeter;
+ Info_h.biYpelsPerMeter = (getc(IN) << 16) + Info_h.biYpelsPerMeter;
+ Info_h.biYpelsPerMeter = (getc(IN) << 24) + Info_h.biYpelsPerMeter;
+
+ Info_h.biClrUsed = getc(IN);
+ Info_h.biClrUsed = (getc(IN) << 8) + Info_h.biClrUsed;
+ Info_h.biClrUsed = (getc(IN) << 16) + Info_h.biClrUsed;
+ Info_h.biClrUsed = (getc(IN) << 24) + Info_h.biClrUsed;
+
+ Info_h.biClrImportant = getc(IN);
+ Info_h.biClrImportant = (getc(IN) << 8) + Info_h.biClrImportant;
+ Info_h.biClrImportant = (getc(IN) << 16) + Info_h.biClrImportant;
+ Info_h.biClrImportant = (getc(IN) << 24) + Info_h.biClrImportant;
+
+ /* Read the data and store them in the OUT file */
+
+ if (Info_h.biBitCount == 24) {
+ numcomps = 3;
+ color_space = CLRSPC_SRGB;
+ /* initialize image components */
+ memset(&cmptparm[0], 0, 3 * sizeof(opj_image_cmptparm_t));
+ for(i = 0; i < numcomps; i++) {
+ cmptparm[i].prec = 8;
+ cmptparm[i].bpp = 8;
+ cmptparm[i].sgnd = 0;
+ cmptparm[i].dx = subsampling_dx;
+ cmptparm[i].dy = subsampling_dy;
+ cmptparm[i].w = w;
+ cmptparm[i].h = h;
+ }
+ /* create the image */
+ image = opj_image_create(numcomps, &cmptparm[0], color_space);
+ if(!image) {
+ fclose(IN);
+ return NULL;
+ }
+
+ /* set image offset and reference grid */
+ image->x0 = parameters->image_offset_x0;
+ image->y0 = parameters->image_offset_y0;
+ image->x1 = !image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1;
+ image->y1 = !image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1;
+
+ /* set image data */
+
+ /* Place the cursor at the beginning of the image information */
+ fseek(IN, 0, SEEK_SET);
+ fseek(IN, File_h.bfOffBits, SEEK_SET);
+
+ W = Info_h.biWidth;
+ H = Info_h.biHeight;
+
+ /* PAD = 4 - (3 * W) % 4; */
+ /* PAD = (PAD == 4) ? 0 : PAD; */
+ PAD = (3 * W) % 4 ? 4 - (3 * W) % 4 : 0;
+
+ RGB = (unsigned char *) malloc((3 * W + PAD) * H * sizeof(unsigned char));
+
+ fread(RGB, sizeof(unsigned char), (3 * W + PAD) * H, IN);
+
+ index = 0;
+
+ for(y = 0; y < (int)H; y++) {
+ unsigned char *scanline = RGB + (3 * W + PAD) * (H - 1 - y);
+ for(x = 0; x < (int)W; x++) {
+ unsigned char *pixel = &scanline[3 * x];
+ image->comps[0].data[index] = pixel[2]; /* R */
+ image->comps[1].data[index] = pixel[1]; /* G */
+ image->comps[2].data[index] = pixel[0]; /* B */
+ index++;
+ }
+ }
+
+ free(RGB);
+
+ } else if (Info_h.biBitCount == 8 && Info_h.biCompression == 0) {
+ table_R = (unsigned char *) malloc(256 * sizeof(unsigned char));
+ table_G = (unsigned char *) malloc(256 * sizeof(unsigned char));
+ table_B = (unsigned char *) malloc(256 * sizeof(unsigned char));
+
+ for (j = 0; j < Info_h.biClrUsed; j++) {
+ table_B[j] = getc(IN);
+ table_G[j] = getc(IN);
+ table_R[j] = getc(IN);
+ getc(IN);
+ if (table_R[j] != table_G[j] && table_R[j] != table_B[j] && table_G[j] != table_B[j])
+ gray_scale = 0;
+ }
+
+ /* Place the cursor at the beginning of the image information */
+ fseek(IN, 0, SEEK_SET);
+ fseek(IN, File_h.bfOffBits, SEEK_SET);
+
+ W = Info_h.biWidth;
+ H = Info_h.biHeight;
+ if (Info_h.biWidth % 2)
+ W++;
+
+ numcomps = gray_scale ? 1 : 3;
+ color_space = gray_scale ? CLRSPC_GRAY : CLRSPC_SRGB;
+ /* initialize image components */
+ memset(&cmptparm[0], 0, 3 * sizeof(opj_image_cmptparm_t));
+ for(i = 0; i < numcomps; i++) {
+ cmptparm[i].prec = 8;
+ cmptparm[i].bpp = 8;
+ cmptparm[i].sgnd = 0;
+ cmptparm[i].dx = subsampling_dx;
+ cmptparm[i].dy = subsampling_dy;
+ cmptparm[i].w = w;
+ cmptparm[i].h = h;
+ }
+ /* create the image */
+ image = opj_image_create(numcomps, &cmptparm[0], color_space);
+ if(!image) {
+ fclose(IN);
+ return NULL;
+ }
+
+ /* set image offset and reference grid */
+ image->x0 = parameters->image_offset_x0;
+ image->y0 = parameters->image_offset_y0;
+ image->x1 = !image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1;
+ image->y1 = !image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1;
+
+ /* set image data */
+
+ RGB = (unsigned char *) malloc(W * H * sizeof(unsigned char));
+
+ fread(RGB, sizeof(unsigned char), W * H, IN);
+ if (gray_scale) {
+ index = 0;
+ for (j = 0; j < W * H; j++) {
+ if ((j % W < W - 1 && Info_h.biWidth % 2) || !(Info_h.biWidth % 2)) {
+ image->comps[0].data[index] = table_R[RGB[W * H - ((j) / (W) + 1) * W + (j) % (W)]];
+ index++;
+ }
+ }
+
+ } else {
+ index = 0;
+ for (j = 0; j < W * H; j++) {
+ if ((j % W < W - 1 && Info_h.biWidth % 2) || !(Info_h.biWidth % 2)) {
+ unsigned char pixel_index = RGB[W * H - ((j) / (W) + 1) * W + (j) % (W)];
+ image->comps[0].data[index] = table_R[pixel_index];
+ image->comps[1].data[index] = table_G[pixel_index];
+ image->comps[2].data[index] = table_B[pixel_index];
+ index++;
+ }
+ }
+ }
+ free(RGB);
+ free(table_R);
+ free(table_G);
+ free(table_B);
+ } else if (Info_h.biBitCount == 8 && Info_h.biCompression == 1) {
+ table_R = (unsigned char *) malloc(256 * sizeof(unsigned char));
+ table_G = (unsigned char *) malloc(256 * sizeof(unsigned char));
+ table_B = (unsigned char *) malloc(256 * sizeof(unsigned char));
+
+ for (j = 0; j < Info_h.biClrUsed; j++) {
+ table_B[j] = getc(IN);
+ table_G[j] = getc(IN);
+ table_R[j] = getc(IN);
+ getc(IN);
+ if (table_R[j] != table_G[j] && table_R[j] != table_B[j] && table_G[j] != table_B[j])
+ gray_scale = 0;
+ }
+
+ numcomps = gray_scale ? 1 : 3;
+ color_space = gray_scale ? CLRSPC_GRAY : CLRSPC_SRGB;
+ /* initialize image components */
+ memset(&cmptparm[0], 0, 3 * sizeof(opj_image_cmptparm_t));
+ for(i = 0; i < numcomps; i++) {
+ cmptparm[i].prec = 8;
+ cmptparm[i].bpp = 8;
+ cmptparm[i].sgnd = 0;
+ cmptparm[i].dx = subsampling_dx;
+ cmptparm[i].dy = subsampling_dy;
+ cmptparm[i].w = w;
+ cmptparm[i].h = h;
+ }
+ /* create the image */
+ image = opj_image_create(numcomps, &cmptparm[0], color_space);
+ if(!image) {
+ fclose(IN);
+ return NULL;
+ }
+
+ /* set image offset and reference grid */
+ image->x0 = parameters->image_offset_x0;
+ image->y0 = parameters->image_offset_y0;
+ image->x1 = !image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1;
+ image->y1 = !image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1;
+
+ /* set image data */
+
+ /* Place the cursor at the beginning of the image information */
+ fseek(IN, 0, SEEK_SET);
+ fseek(IN, File_h.bfOffBits, SEEK_SET);
+
+ RGB = (unsigned char *) malloc(Info_h.biWidth * Info_h.biHeight * sizeof(unsigned char));
+
+ while (not_end_file) {
+ v = getc(IN);
+ if (v) {
+ v2 = getc(IN);
+ for (i = 0; i < (int) v; i++) {
+ RGB[line * Info_h.biWidth + col] = v2;
+ col++;
+ }
+ } else {
+ v = getc(IN);
+ switch (v) {
+ case 0:
+ col = 0;
+ line++;
+ break;
+ case 1:
+ line++;
+ not_end_file = 0;
+ break;
+ case 2:
+ fprintf(stderr,"No Delta supported\n");
+ opj_image_destroy(image);
+ fclose(IN);
+ return NULL;
+ default:
+ for (i = 0; i < v; i++) {
+ v2 = getc(IN);
+ RGB[line * Info_h.biWidth + col] = v2;
+ col++;
+ }
+ if (v % 2)
+ v2 = getc(IN);
+ break;
+ }
+ }
+ }
+ if (gray_scale) {
+ index = 0;
+ for (line = 0; line < Info_h.biHeight; line++) {
+ for (col = 0; col < Info_h.biWidth; col++) {
+ image->comps[0].data[index] = table_R[(int)RGB[(Info_h.biHeight - line - 1) * Info_h.biWidth + col]];
+ index++;
+ }
+ }
+ } else {
+ index = 0;
+ for (line = 0; line < Info_h.biHeight; line++) {
+ for (col = 0; col < Info_h.biWidth; col++) {
+ unsigned char pixel_index = (int)RGB[(Info_h.biHeight - line - 1) * Info_h.biWidth + col];
+ image->comps[0].data[index] = table_R[pixel_index];
+ image->comps[1].data[index] = table_G[pixel_index];
+ image->comps[2].data[index] = table_B[pixel_index];
+ index++;
+ }
+ }
+ }
+ free(RGB);
+ free(table_R);
+ free(table_G);
+ free(table_B);
+ } else {
+ fprintf(stderr,
+ "Other system than 24 bits/pixels or 8 bits (no RLE coding) is not yet implemented [%d]\n", Info_h.biBitCount);
+ }
+ fclose(IN);
+ }
+
+ return image;
+}
+
+int imagetobmp(opj_image_t * image, const char *outfile) {
+ int w, h;
+ int i, pad;
+ FILE *fdest = NULL;
+ int adjustR, adjustG, adjustB;
+
+ if (image->numcomps == 3 && image->comps[0].dx == image->comps[1].dx
+ && image->comps[1].dx == image->comps[2].dx
+ && image->comps[0].dy == image->comps[1].dy
+ && image->comps[1].dy == image->comps[2].dy
+ && image->comps[0].prec == image->comps[1].prec
+ && image->comps[1].prec == image->comps[2].prec) {
+
+ /* -->> -->> -->> -->>
+ 24 bits color
+ <<-- <<-- <<-- <<-- */
+
+ fdest = fopen(outfile, "wb");
+ if (!fdest) {
+ fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
+ return 1;
+ }
+
+ w = image->comps[0].w;
+ h = image->comps[0].h;
+
+ fprintf(fdest, "BM");
+
+ /* FILE HEADER */
+ /* ------------- */
+ fprintf(fdest, "%c%c%c%c",
+ (unsigned char) (h * w * 3 + 3 * h * (w % 2) + 54) & 0xff,
+ (unsigned char) ((h * w * 3 + 3 * h * (w % 2) + 54) >> 8) & 0xff,
+ (unsigned char) ((h * w * 3 + 3 * h * (w % 2) + 54) >> 16) & 0xff,
+ (unsigned char) ((h * w * 3 + 3 * h * (w % 2) + 54) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, ((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (54) & 0xff, ((54) >> 8) & 0xff,((54) >> 16) & 0xff, ((54) >> 24) & 0xff);
+
+ /* INFO HEADER */
+ /* ------------- */
+ fprintf(fdest, "%c%c%c%c", (40) & 0xff, ((40) >> 8) & 0xff, ((40) >> 16) & 0xff, ((40) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (unsigned char) ((w) & 0xff),
+ (unsigned char) ((w) >> 8) & 0xff,
+ (unsigned char) ((w) >> 16) & 0xff,
+ (unsigned char) ((w) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (unsigned char) ((h) & 0xff),
+ (unsigned char) ((h) >> 8) & 0xff,
+ (unsigned char) ((h) >> 16) & 0xff,
+ (unsigned char) ((h) >> 24) & 0xff);
+ fprintf(fdest, "%c%c", (1) & 0xff, ((1) >> 8) & 0xff);
+ fprintf(fdest, "%c%c", (24) & 0xff, ((24) >> 8) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, ((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (unsigned char) (3 * h * w + 3 * h * (w % 2)) & 0xff,
+ (unsigned char) ((h * w * 3 + 3 * h * (w % 2)) >> 8) & 0xff,
+ (unsigned char) ((h * w * 3 + 3 * h * (w % 2)) >> 16) & 0xff,
+ (unsigned char) ((h * w * 3 + 3 * h * (w % 2)) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (7834) & 0xff, ((7834) >> 8) & 0xff, ((7834) >> 16) & 0xff, ((7834) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (7834) & 0xff, ((7834) >> 8) & 0xff, ((7834) >> 16) & 0xff, ((7834) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, ((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, ((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
+
+ if (image->comps[0].prec > 8) {
+ adjustR = image->comps[0].prec - 8;
+ printf("BMP CONVERSION: Truncating component 0 from %d bits to 8 bits\n", image->comps[0].prec);
+ }
+ else
+ adjustR = 0;
+ if (image->comps[1].prec > 8) {
+ adjustG = image->comps[1].prec - 8;
+ printf("BMP CONVERSION: Truncating component 1 from %d bits to 8 bits\n", image->comps[1].prec);
+ }
+ else
+ adjustG = 0;
+ if (image->comps[2].prec > 8) {
+ adjustB = image->comps[2].prec - 8;
+ printf("BMP CONVERSION: Truncating component 2 from %d bits to 8 bits\n", image->comps[2].prec);
+ }
+ else
+ adjustB = 0;
+
+ for (i = 0; i < w * h; i++) {
+ unsigned char rc, gc, bc;
+ int r, g, b;
+
+ r = image->comps[0].data[w * h - ((i) / (w) + 1) * w + (i) % (w)];
+ r += (image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0);
+ rc = (unsigned char) ((r >> adjustR)+((r >> (adjustR-1))%2));
+ g = image->comps[1].data[w * h - ((i) / (w) + 1) * w + (i) % (w)];
+ g += (image->comps[1].sgnd ? 1 << (image->comps[1].prec - 1) : 0);
+ gc = (unsigned char) ((g >> adjustG)+((g >> (adjustG-1))%2));
+ b = image->comps[2].data[w * h - ((i) / (w) + 1) * w + (i) % (w)];
+ b += (image->comps[2].sgnd ? 1 << (image->comps[2].prec - 1) : 0);
+ bc = (unsigned char) ((b >> adjustB)+((b >> (adjustB-1))%2));
+
+ fprintf(fdest, "%c%c%c", bc, gc, rc);
+
+ if ((i + 1) % w == 0) {
+ for (pad = (3 * w) % 4 ? 4 - (3 * w) % 4 : 0; pad > 0; pad--) /* ADD */
+ fprintf(fdest, "%c", 0);
+ }
+ }
+ fclose(fdest);
+ } else { /* Gray-scale */
+
+ /* -->> -->> -->> -->>
+ 8 bits non code (Gray scale)
+ <<-- <<-- <<-- <<-- */
+
+ fdest = fopen(outfile, "wb");
+ w = image->comps[0].w;
+ h = image->comps[0].h;
+
+ fprintf(fdest, "BM");
+
+ /* FILE HEADER */
+ /* ------------- */
+ fprintf(fdest, "%c%c%c%c", (unsigned char) (h * w + 54 + 1024 + h * (w % 2)) & 0xff,
+ (unsigned char) ((h * w + 54 + 1024 + h * (w % 2)) >> 8) & 0xff,
+ (unsigned char) ((h * w + 54 + 1024 + h * (w % 2)) >> 16) & 0xff,
+ (unsigned char) ((h * w + 54 + 1024 + w * (w % 2)) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, ((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (54 + 1024) & 0xff, ((54 + 1024) >> 8) & 0xff,
+ ((54 + 1024) >> 16) & 0xff,
+ ((54 + 1024) >> 24) & 0xff);
+
+ /* INFO HEADER */
+ /* ------------- */
+ fprintf(fdest, "%c%c%c%c", (40) & 0xff, ((40) >> 8) & 0xff, ((40) >> 16) & 0xff, ((40) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (unsigned char) ((w) & 0xff),
+ (unsigned char) ((w) >> 8) & 0xff,
+ (unsigned char) ((w) >> 16) & 0xff,
+ (unsigned char) ((w) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (unsigned char) ((h) & 0xff),
+ (unsigned char) ((h) >> 8) & 0xff,
+ (unsigned char) ((h) >> 16) & 0xff,
+ (unsigned char) ((h) >> 24) & 0xff);
+ fprintf(fdest, "%c%c", (1) & 0xff, ((1) >> 8) & 0xff);
+ fprintf(fdest, "%c%c", (8) & 0xff, ((8) >> 8) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, ((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (unsigned char) (h * w + h * (w % 2)) & 0xff,
+ (unsigned char) ((h * w + h * (w % 2)) >> 8) & 0xff,
+ (unsigned char) ((h * w + h * (w % 2)) >> 16) & 0xff,
+ (unsigned char) ((h * w + h * (w % 2)) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (7834) & 0xff, ((7834) >> 8) & 0xff, ((7834) >> 16) & 0xff, ((7834) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (7834) & 0xff, ((7834) >> 8) & 0xff, ((7834) >> 16) & 0xff, ((7834) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (256) & 0xff, ((256) >> 8) & 0xff, ((256) >> 16) & 0xff, ((256) >> 24) & 0xff);
+ fprintf(fdest, "%c%c%c%c", (256) & 0xff, ((256) >> 8) & 0xff, ((256) >> 16) & 0xff, ((256) >> 24) & 0xff);
+
+ if (image->comps[0].prec > 8) {
+ adjustR = image->comps[0].prec - 8;
+ printf("BMP CONVERSION: Truncating component 0 from %d bits to 8 bits\n", image->comps[0].prec);
+ }
+
+ for (i = 0; i < 256; i++) {
+ fprintf(fdest, "%c%c%c%c", i, i, i, 0);
+ }
+
+ for (i = 0; i < w * h; i++) {
+ unsigned char rc;
+ int r;
+
+ r = image->comps[0].data[w * h - ((i) / (w) + 1) * w + (i) % (w)];
+ r += (image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0);
+ rc = (unsigned char) ((r >> adjustR)+((r >> (adjustR-1))%2));
+
+ fprintf(fdest, "%c", rc);
+
+ if ((i + 1) % w == 0) {
+ for (pad = w % 4 ? 4 - w % 4 : 0; pad > 0; pad--) /* ADD */
+ fprintf(fdest, "%c", 0);
+ }
+ }
+ fclose(fdest);
+ }
+
+ return 0;
+}
+
+/* -->> -->> -->> -->>
+
+PGX IMAGE FORMAT
+
+<<-- <<-- <<-- <<-- */
+
+
+unsigned char readuchar(FILE * f)
+{
+ unsigned char c1;
+ fread(&c1, 1, 1, f);
+ return c1;
+}
+
+unsigned short readushort(FILE * f, int bigendian)
+{
+ unsigned char c1, c2;
+ fread(&c1, 1, 1, f);
+ fread(&c2, 1, 1, f);
+ if (bigendian)
+ return (c1 << 8) + c2;
+ else
+ return (c2 << 8) + c1;
+}
+
+unsigned int readuint(FILE * f, int bigendian)
+{
+ unsigned char c1, c2, c3, c4;
+ fread(&c1, 1, 1, f);
+ fread(&c2, 1, 1, f);
+ fread(&c3, 1, 1, f);
+ fread(&c4, 1, 1, f);
+ if (bigendian)
+ return (c1 << 24) + (c2 << 16) + (c3 << 8) + c4;
+ else
+ return (c4 << 24) + (c3 << 16) + (c2 << 8) + c1;
+}
+
+opj_image_t* pgxtoimage(const char *filename, opj_cparameters_t *parameters) {
+ FILE *f = NULL;
+ int w, h, prec;
+ int i, numcomps, max;
+ OPJ_COLOR_SPACE color_space;
+ opj_image_cmptparm_t cmptparm; /* maximum of 1 component */
+ opj_image_t * image = NULL;
+
+ char endian1,endian2,sign;
+ char signtmp[32];
+
+ char temp[32];
+ int bigendian;
+ opj_image_comp_t *comp = NULL;
+
+ numcomps = 1;
+ color_space = CLRSPC_GRAY;
+
+ memset(&cmptparm, 0, sizeof(opj_image_cmptparm_t));
+
+ max = 0;
+
+ f = fopen(filename, "rb");
+ if (!f) {
+ fprintf(stderr, "Failed to open %s for reading !\n", filename);
+ return NULL;
+ }
+
+ fseek(f, 0, SEEK_SET);
+ fscanf(f, "PG%[ \t]%c%c%[ \t+-]%d%[ \t]%d%[ \t]%d",temp,&endian1,&endian2,signtmp,&prec,temp,&w,temp,&h);
+
+ i=0;
+ sign='+';
+ while (signtmp[i]!='\0') {
+ if (signtmp[i]=='-') sign='-';
+ i++;
+ }
+
+ fgetc(f);
+ if (endian1=='M' && endian2=='L') {
+ bigendian = 1;
+ } else if (endian2=='M' && endian1=='L') {
+ bigendian = 0;
+ } else {
+ fprintf(stderr, "Bad pgx header, please check input file\n");
+ return NULL;
+ }
+
+ /* initialize image component */
+
+ cmptparm.x0 = parameters->image_offset_x0;
+ cmptparm.y0 = parameters->image_offset_y0;
+ cmptparm.w = !cmptparm.x0 ? (w - 1) * parameters->subsampling_dx + 1 : cmptparm.x0 + (w - 1) * parameters->subsampling_dx + 1;
+ cmptparm.h = !cmptparm.y0 ? (h - 1) * parameters->subsampling_dy + 1 : cmptparm.y0 + (h - 1) * parameters->subsampling_dy + 1;
+
+ if (sign == '-') {
+ cmptparm.sgnd = 1;
+ } else {
+ cmptparm.sgnd = 0;
+ }
+ cmptparm.prec = prec;
+ cmptparm.bpp = prec;
+ cmptparm.dx = parameters->subsampling_dx;
+ cmptparm.dy = parameters->subsampling_dy;
+
+ /* create the image */
+ image = opj_image_create(numcomps, &cmptparm, color_space);
+ if(!image) {
+ fclose(f);
+ return NULL;
+ }
+ /* set image offset and reference grid */
+ image->x0 = cmptparm.x0;
+ image->y0 = cmptparm.x0;
+ image->x1 = cmptparm.w;
+ image->y1 = cmptparm.h;
+
+ /* set image data */
+
+ comp = &image->comps[0];
+
+ for (i = 0; i < w * h; i++) {
+ int v;
+ if (comp->prec <= 8) {
+ if (!comp->sgnd) {
+ v = readuchar(f);
+ } else {
+ v = (char) readuchar(f);
+ }
+ } else if (comp->prec <= 16) {
+ if (!comp->sgnd) {
+ v = readushort(f, bigendian);
+ } else {
+ v = (short) readushort(f, bigendian);
+ }
+ } else {
+ if (!comp->sgnd) {
+ v = readuint(f, bigendian);
+ } else {
+ v = (int) readuint(f, bigendian);
+ }
+ }
+ if (v > max)
+ max = v;
+ comp->data[i] = v;
+ }
+ fclose(f);
+ //comp->bpp = int_floorlog2(max) + 1;
+
+ return image;
+}
+
+int imagetopgx(opj_image_t * image, const char *outfile) {
+ int w, h;
+ int i, j, compno;
+ FILE *fdest = NULL;
+
+ for (compno = 0; compno < image->numcomps; compno++) {
+ opj_image_comp_t *comp = &image->comps[compno];
+ char bname[256]; /* buffer for name */
+ char *name = bname; /* pointer */
+ int nbytes = 0;
+ const size_t olen = strlen(outfile);
+ const size_t dotpos = olen - 4;
+ const size_t total = dotpos + 1 + 1 + 4; /* '-' + '[1-3]' + '.pgx' */
+ if( outfile[dotpos] != '.' ) {
+ /* `pgx` was recognized but there is no dot at expected position */
+ fprintf(stderr, "ERROR -> Impossible happen." );
+ return 1;
+ }
+ if( total > 256 ) {
+ name = (char*)malloc(total+1);
+ }
+ strncpy(name, outfile, dotpos);
+ if (image->numcomps > 1) {
+ sprintf(name+dotpos, "-%d.pgx", compno);
+ } else {
+ strcpy(name+dotpos, ".pgx");
+ }
+ fdest = fopen(name, "wb");
+ if (!fdest) {
+ fprintf(stderr, "ERROR -> failed to open %s for writing\n", name);
+ return 1;
+ }
+ /* dont need name anymore */
+ if( total > 256 ) {
+ free(name);
+ }
+
+ w = image->comps[compno].w;
+ h = image->comps[compno].h;
+
+ fprintf(fdest, "PG ML %c %d %d %d\n", comp->sgnd ? '-' : '+', comp->prec, w, h);
+ if (comp->prec <= 8) {
+ nbytes = 1;
+ } else if (comp->prec <= 16) {
+ nbytes = 2;
+ } else {
+ nbytes = 4;
+ }
+ for (i = 0; i < w * h; i++) {
+ int v = image->comps[compno].data[i];
+ for (j = nbytes - 1; j >= 0; j--) {
+ char byte = (char) (v >> (j * 8));
+ fwrite(&byte, 1, 1, fdest);
+ }
+ }
+ fclose(fdest);
+ }
+
+ return 0;
+}
+
+/* -->> -->> -->> -->>
+
+PNM IMAGE FORMAT
+
+<<-- <<-- <<-- <<-- */
+
+opj_image_t* pnmtoimage(const char *filename, opj_cparameters_t *parameters) {
+ int subsampling_dx = parameters->subsampling_dx;
+ int subsampling_dy = parameters->subsampling_dy;
+
+ FILE *f = NULL;
+ int i, compno, numcomps, w, h;
+ OPJ_COLOR_SPACE color_space;
+ opj_image_cmptparm_t cmptparm[3]; /* maximum of 3 components */
+ opj_image_t * image = NULL;
+ char value;
+
+ f = fopen(filename, "rb");
+ if (!f) {
+ fprintf(stderr, "Failed to open %s for reading !!\n", filename);
+ return 0;
+ }
+
+ if (fgetc(f) != 'P')
+ return 0;
+ value = fgetc(f);
+
+ switch(value) {
+ case '2': /* greyscale image type */
+ case '5':
+ numcomps = 1;
+ color_space = CLRSPC_GRAY;
+ break;
+
+ case '3': /* RGB image type */
+ case '6':
+ numcomps = 3;
+ color_space = CLRSPC_SRGB;
+ break;
+
+ default:
+ fclose(f);
+ return NULL;
+ }
+
+ fgetc(f);
+
+ /* skip comments */
+ while(fgetc(f) == '#') while(fgetc(f) != '\n');
+
+ fseek(f, -1, SEEK_CUR);
+ fscanf(f, "%d %d\n255", &w, &h);
+ fgetc(f); /* <cr><lf> */
+
+ /* initialize image components */
+ memset(&cmptparm[0], 0, 3 * sizeof(opj_image_cmptparm_t));
+ for(i = 0; i < numcomps; i++) {
+ cmptparm[i].prec = 8;
+ cmptparm[i].bpp = 8;
+ cmptparm[i].sgnd = 0;
+ cmptparm[i].dx = subsampling_dx;
+ cmptparm[i].dy = subsampling_dy;
+ cmptparm[i].w = w;
+ cmptparm[i].h = h;
+ }
+ /* create the image */
+ image = opj_image_create(numcomps, &cmptparm[0], color_space);
+ if(!image) {
+ fclose(f);
+ return NULL;
+ }
+
+ /* set image offset and reference grid */
+ image->x0 = parameters->image_offset_x0;
+ image->y0 = parameters->image_offset_y0;
+ image->x1 = parameters->image_offset_x0 + (w - 1) * subsampling_dx + 1;
+ image->y1 = parameters->image_offset_y0 + (h - 1) * subsampling_dy + 1;
+
+ /* set image data */
+
+ if ((value == '2') || (value == '3')) { /* ASCII */
+ for (i = 0; i < w * h; i++) {
+ for(compno = 0; compno < numcomps; compno++) {
+ unsigned int index = 0;
+ fscanf(f, "%u", &index);
+ /* compno : 0 = GREY, (0, 1, 2) = (R, G, B) */
+ image->comps[compno].data[i] = index;
+ }
+ }
+ } else if ((value == '5') || (value == '6')) { /* BINARY */
+ for (i = 0; i < w * h; i++) {
+ for(compno = 0; compno < numcomps; compno++) {
+ unsigned char index = 0;
+ fread(&index, 1, 1, f);
+ /* compno : 0 = GREY, (0, 1, 2) = (R, G, B) */
+ image->comps[compno].data[i] = index;
+ }
+ }
+ }
+
+ fclose(f);
+
+ return image;
+}
+
+int imagetopnm(opj_image_t * image, const char *outfile) {
+ int w, wr, h, hr, max;
+ int i, compno;
+ int adjustR, adjustG, adjustB, adjustX;
+ FILE *fdest = NULL;
+ char S2;
+ const char *tmp = outfile;
+
+ while (*tmp) {
+ tmp++;
+ }
+ tmp--;
+ tmp--;
+ S2 = *tmp;
+
+ if (image->numcomps == 3 && image->comps[0].dx == image->comps[1].dx
+ && image->comps[1].dx == image->comps[2].dx
+ && image->comps[0].dy == image->comps[1].dy
+ && image->comps[1].dy == image->comps[2].dy
+ && image->comps[0].prec == image->comps[1].prec
+ && image->comps[1].prec == image->comps[2].prec
+ && S2 !='g' && S2 !='G') {
+
+ fdest = fopen(outfile, "wb");
+ if (!fdest) {
+ fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
+ return 1;
+ }
+
+ w = int_ceildiv(image->x1 - image->x0, image->comps[0].dx);
+ wr = image->comps[0].w;
+
+ h = int_ceildiv(image->y1 - image->y0, image->comps[0].dy);
+ hr = image->comps[0].h;
+
+ max = image->comps[0].prec > 8 ? 255 : (1 << image->comps[0].prec) - 1;
+
+ image->comps[0].x0 = int_ceildivpow2(image->comps[0].x0 - int_ceildiv(image->x0, image->comps[0].dx), image->comps[0].factor);
+ image->comps[0].y0 = int_ceildivpow2(image->comps[0].y0 - int_ceildiv(image->y0, image->comps[0].dy), image->comps[0].factor);
+
+ fprintf(fdest, "P6\n%d %d\n%d\n", wr, hr, max);
+
+ if (image->comps[0].prec > 8) {
+ adjustR = image->comps[0].prec - 8;
+ printf("PNM CONVERSION: Truncating component 0 from %d bits to 8 bits\n", image->comps[0].prec);
+ }
+ else
+ adjustR = 0;
+ if (image->comps[1].prec > 8) {
+ adjustG = image->comps[1].prec - 8;
+ printf("PNM CONVERSION: Truncating component 1 from %d bits to 8 bits\n", image->comps[1].prec);
+ }
+ else
+ adjustG = 0;
+ if (image->comps[2].prec > 8) {
+ adjustB = image->comps[2].prec - 8;
+ printf("PNM CONVERSION: Truncating component 2 from %d bits to 8 bits\n", image->comps[2].prec);
+ }
+ else
+ adjustB = 0;
+
+
+ for (i = 0; i < wr * hr; i++) {
+ int r, g, b;
+ unsigned char rc,gc,bc;
+ r = image->comps[0].data[i];
+ r += (image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0);
+ rc = (unsigned char) ((r >> adjustR)+((r >> (adjustR-1))%2));
+
+ g = image->comps[1].data[i];
+ g += (image->comps[1].sgnd ? 1 << (image->comps[1].prec - 1) : 0);
+ gc = (unsigned char) ((g >> adjustG)+((g >> (adjustG-1))%2));
+
+ b = image->comps[2].data[i];
+ b += (image->comps[2].sgnd ? 1 << (image->comps[2].prec - 1) : 0);
+ bc = (unsigned char) ((b >> adjustB)+((b >> (adjustB-1))%2));
+
+ fprintf(fdest, "%c%c%c", rc, gc, bc);
+ }
+ fclose(fdest);
+
+ } else {
+ int ncomp=(S2=='g' || S2=='G')?1:image->numcomps;
+ if (image->numcomps > ncomp) {
+ fprintf(stderr,"WARNING -> [PGM files] Only the first component\n");
+ fprintf(stderr," is written to the file\n");
+ }
+ for (compno = 0; compno < ncomp; compno++) {
+ char name[256];
+ if (ncomp > 1) {
+ sprintf(name, "%d.%s", compno, outfile);
+ } else {
+ sprintf(name, "%s", outfile);
+ }
+
+ fdest = fopen(name, "wb");
+ if (!fdest) {
+ fprintf(stderr, "ERROR -> failed to open %s for writing\n", name);
+ return 1;
+ }
+
+ w = int_ceildiv(image->x1 - image->x0, image->comps[compno].dx);
+ wr = image->comps[compno].w;
+
+ h = int_ceildiv(image->y1 - image->y0, image->comps[compno].dy);
+ hr = image->comps[compno].h;
+
+ max = image->comps[compno].prec > 8 ? 255 : (1 << image->comps[compno].prec) - 1;
+
+ image->comps[compno].x0 = int_ceildivpow2(image->comps[compno].x0 - int_ceildiv(image->x0, image->comps[compno].dx), image->comps[compno].factor);
+ image->comps[compno].y0 = int_ceildivpow2(image->comps[compno].y0 - int_ceildiv(image->y0, image->comps[compno].dy), image->comps[compno].factor);
+
+ fprintf(fdest, "P5\n%d %d\n%d\n", wr, hr, max);
+
+ if (image->comps[compno].prec > 8) {
+ adjustX = image->comps[0].prec - 8;
+ printf("PNM CONVERSION: Truncating component %d from %d bits to 8 bits\n",compno, image->comps[compno].prec);
+ }
+ else
+ adjustX = 0;
+
+ for (i = 0; i < wr * hr; i++) {
+ int l;
+ unsigned char lc;
+ l = image->comps[compno].data[i];
+ l += (image->comps[compno].sgnd ? 1 << (image->comps[compno].prec - 1) : 0);
+ lc = (unsigned char) ((l >> adjustX)+((l >> (adjustX-1))%2));
+ fprintf(fdest, "%c", lc);
+ }
+ fclose(fdest);
+ }
+ }
+
+ return 0;
+}
+
+/* -->> -->> -->> -->>
+
+ TIFF IMAGE FORMAT
+
+ <<-- <<-- <<-- <<-- */
+
+typedef struct tiff_infoheader{
+ DWORD tiWidth; // Width of Image in pixel
+ DWORD tiHeight; // Height of Image in pixel
+ DWORD tiPhoto; // Photometric
+ WORD tiBps; // Bits per sample
+ WORD tiSf; // Sample Format
+ WORD tiSpp; // Sample per pixel 1-bilevel,gray scale , 2- RGB
+ WORD tiPC; // Planar config (1-Interleaved, 2-Planarcomp)
+}tiff_infoheader_t;
+
+int imagetotif(opj_image_t * image, const char *outfile) {
+ int width, height, imgsize;
+ int bps,index,adjust = 0;
+ int last_i=0;
+ TIFF *tif;
+ tdata_t buf;
+ tstrip_t strip;
+ tsize_t strip_size;
+
+ if (image->numcomps == 3 && image->comps[0].dx == image->comps[1].dx
+ && image->comps[1].dx == image->comps[2].dx
+ && image->comps[0].dy == image->comps[1].dy
+ && image->comps[1].dy == image->comps[2].dy
+ && image->comps[0].prec == image->comps[1].prec
+ && image->comps[1].prec == image->comps[2].prec) {
+
+ /* -->> -->> -->>
+ RGB color
+ <<-- <<-- <<-- */
+
+ tif = TIFFOpen(outfile, "wb");
+ if (!tif) {
+ fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
+ return 1;
+ }
+
+ width = image->comps[0].w;
+ height = image->comps[0].h;
+ imgsize = width * height ;
+ bps = image->comps[0].prec;
+ /* Set tags */
+ TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
+ TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
+ TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 3);
+ TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps);
+ TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
+ TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+ TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
+ TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
+
+ /* Get a buffer for the data */
+ strip_size=TIFFStripSize(tif);
+ buf = _TIFFmalloc(strip_size);
+ index=0;
+ adjust = image->comps[0].sgnd ? 1 << (image->comps[0].prec - 1) : 0;
+ for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
+ unsigned char *dat8;
+ int i, ssize;
+ ssize = TIFFStripSize(tif);
+ dat8 = buf;
+ if (image->comps[0].prec == 8){
+ for (i=0; i<ssize-2; i+=3) { // 8 bits per pixel
+ int r = 0,g = 0,b = 0;
+ if(index < imgsize){
+ r = image->comps[0].data[index];
+ g = image->comps[1].data[index];
+ b = image->comps[2].data[index];
+ if (image->comps[0].sgnd){
+ r += adjust;
+ g += adjust;
+ b += adjust;
+ }
+ dat8[i+0] = r ; // R
+ dat8[i+1] = g ; // G
+ dat8[i+2] = b ; // B
+ index++;
+ last_i = i+3;
+ }else
+ break;
+ }
+ if(last_i < ssize){
+ for (i=last_i; i<ssize; i+=3) { // 8 bits per pixel
+ int r = 0,g = 0,b = 0;
+ if(index < imgsize){
+ r = image->comps[0].data[index];
+ g = image->comps[1].data[index];
+ b = image->comps[2].data[index];
+ if (image->comps[0].sgnd){
+ r += adjust;
+ g += adjust;
+ b += adjust;
+ }
+ dat8[i+0] = r ; // R
+ if(i+1 <ssize) dat8[i+1] = g ; else break;// G
+ if(i+2 <ssize) dat8[i+2] = b ; else break;// B
+ index++;
+ }else
+ break;
+ }
+ }
+ }else if (image->comps[0].prec == 12){
+ for (i=0; i<ssize-8; i+=9) { // 12 bits per pixel
+ int r = 0,g = 0,b = 0;
+ int r1 = 0,g1 = 0,b1 = 0;
+ if((index < imgsize)&(index+1 < imgsize)){
+ r = image->comps[0].data[index];
+ g = image->comps[1].data[index];
+ b = image->comps[2].data[index];
+ r1 = image->comps[0].data[index+1];
+ g1 = image->comps[1].data[index+1];
+ b1 = image->comps[2].data[index+1];
+ if (image->comps[0].sgnd){
+ r += adjust;
+ g += adjust;
+ b += adjust;
+ r1 += adjust;
+ g1 += adjust;
+ b1 += adjust;
+ }
+ dat8[i+0] = (r >> 4);
+ dat8[i+1] = ((r & 0x0f) << 4 )|((g >> 8)& 0x0f);
+ dat8[i+2] = g ;
+ dat8[i+3] = (b >> 4);
+ dat8[i+4] = ((b & 0x0f) << 4 )|((r1 >> 8)& 0x0f);
+ dat8[i+5] = r1;
+ dat8[i+6] = (g1 >> 4);
+ dat8[i+7] = ((g1 & 0x0f)<< 4 )|((b1 >> 8)& 0x0f);
+ dat8[i+8] = b1;
+ index+=2;
+ last_i = i+9;
+ }else
+ break;
+ }
+ if(last_i < ssize){
+ for (i= last_i; i<ssize; i+=9) { // 12 bits per pixel
+ int r = 0,g = 0,b = 0;
+ int r1 = 0,g1 = 0,b1 = 0;
+ if((index < imgsize)&(index+1 < imgsize)){
+ r = image->comps[0].data[index];
+ g = image->comps[1].data[index];
+ b = image->comps[2].data[index];
+ r1 = image->comps[0].data[index+1];
+ g1 = image->comps[1].data[index+1];
+ b1 = image->comps[2].data[index+1];
+ if (image->comps[0].sgnd){
+ r += adjust;
+ g += adjust;
+ b += adjust;
+ r1 += adjust;
+ g1 += adjust;
+ b1 += adjust;
+ }
+ dat8[i+0] = (r >> 4);
+ if(i+1 <ssize) dat8[i+1] = ((r & 0x0f) << 4 )|((g >> 8)& 0x0f); else break;
+ if(i+2 <ssize) dat8[i+2] = g ; else break;
+ if(i+3 <ssize) dat8[i+3] = (b >> 4); else break;
+ if(i+4 <ssize) dat8[i+4] = ((b & 0x0f) << 4 )|((r1 >> 8)& 0x0f);else break;
+ if(i+5 <ssize) dat8[i+5] = r1; else break;
+ if(i+6 <ssize) dat8[i+6] = (g1 >> 4); else break;
+ if(i+7 <ssize) dat8[i+7] = ((g1 & 0x0f)<< 4 )|((b1 >> 8)& 0x0f);else break;
+ if(i+8 <ssize) dat8[i+8] = b1; else break;
+ index+=2;
+ }else
+ break;
+ }
+ }
+ }else if (image->comps[0].prec == 16){
+ for (i=0 ; i<ssize-5 ; i+=6) { // 16 bits per pixel
+ int r = 0,g = 0,b = 0;
+ if(index < imgsize){
+ r = image->comps[0].data[index];
+ g = image->comps[1].data[index];
+ b = image->comps[2].data[index];
+ if (image->comps[0].sgnd){
+ r += adjust;
+ g += adjust;
+ b += adjust;
+ }
+ dat8[i+0] = r;//LSB
+ dat8[i+1] = (r >> 8);//MSB
+ dat8[i+2] = g;
+ dat8[i+3] = (g >> 8);
+ dat8[i+4] = b;
+ dat8[i+5] = (b >> 8);
+ index++;
+ last_i = i+6;
+ }else
+ break;
+ }
+ if(last_i < ssize){
+ for (i=0 ; i<ssize ; i+=6) { // 16 bits per pixel
+ int r = 0,g = 0,b = 0;
+ if(index < imgsize){
+ r = image->comps[0].data[index];
+ g = image->comps[1].data[index];
+ b = image->comps[2].data[index];
+ if (image->comps[0].sgnd){
+ r += adjust;
+ g += adjust;
+ b += adjust;
+ }
+ dat8[i+0] = r;//LSB
+ if(i+1 <ssize) dat8[i+1] = (r >> 8);else break;//MSB
+ if(i+2 <ssize) dat8[i+2] = g; else break;
+ if(i+3 <ssize) dat8[i+3] = (g >> 8);else break;
+ if(i+4 <ssize) dat8[i+4] = b; else break;
+ if(i+5 <ssize) dat8[i+5] = (b >> 8);else break;
+ index++;
+ }else
+ break;
+ }
+ }
+ }else{
+ fprintf(stderr,"Bits=%d, Only 8,12,16 bits implemented\n",image->comps[0].prec);
+ fprintf(stderr,"Aborting\n");
+ return 1;
+ }
+ TIFFWriteEncodedStrip(tif, strip, buf, strip_size);
+ }
+ _TIFFfree(buf);
+ TIFFClose(tif);
+ }else if (image->numcomps == 1){
+ /* -->> -->> -->>
+ Black and White
+ <<-- <<-- <<-- */
+
+ tif = TIFFOpen(outfile, "wb");
+ if (!tif) {
+ fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile);
+ return 1;
+ }
+
+ width = image->comps[0].w;
+ height = image->comps[0].h;
+ imgsize = width * height;
+ bps = image->comps[0].prec;
+
+ /* Set tags */
+ TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
+ TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
+ TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
+ TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps);
+ TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
+ TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+ TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
+ TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
+
+ /* Get a buffer for the data */
+ strip_size = TIFFStripSize(tif);
+ buf = _TIFFmalloc(strip_size);
+ index = 0;
+ for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
+ unsigned char *dat8;
+ int i;
+ dat8 = buf;
+ if (image->comps[0].prec == 8){
+ for (i=0; i<TIFFStripSize(tif); i+=1) { // 8 bits per pixel
+ if(index < imgsize){
+ int r = 0;
+ r = image->comps[0].data[index];
+ if (image->comps[0].sgnd){
+ r += adjust;
+ }
+ dat8[i+0] = r;
+ index++;
+ }else
+ break;
+ }
+ }else if (image->comps[0].prec == 12){
+ for (i = 0; i<TIFFStripSize(tif); i+=3) { // 12 bits per pixel
+ if(index < imgsize){
+ int r = 0, r1 = 0;
+ r = image->comps[0].data[index];
+ r1 = image->comps[0].data[index+1];
+ if (image->comps[0].sgnd){
+ r += adjust;
+ r1 += adjust;
+ }
+ dat8[i+0] = (r >> 4);
+ dat8[i+1] = ((r & 0x0f) << 4 )|((r1 >> 8)& 0x0f);
+ dat8[i+2] = r1 ;
+ index+=2;
+ }else
+ break;
+ }
+ }else if (image->comps[0].prec == 16){
+ for (i=0; i<TIFFStripSize(tif); i+=2) { // 16 bits per pixel
+ if(index < imgsize){
+ int r = 0;
+ r = image->comps[0].data[index];
+ if (image->comps[0].sgnd){
+ r += adjust;
+ }
+ dat8[i+0] = r;
+ dat8[i+1] = r >> 8;
+ index++;
+ }else
+ break;
+ }
+ }else{
+ fprintf(stderr,"TIFF file creation. Bits=%d, Only 8,12,16 bits implemented\n",image->comps[0].prec);
+ fprintf(stderr,"Aborting\n");
+ return 1;
+ }
+ TIFFWriteEncodedStrip(tif, strip, buf, strip_size);
+ }
+ _TIFFfree(buf);
+ TIFFClose(tif);
+ }else{
+ fprintf(stderr,"TIFF file creation. Bad color format. Only RGB & Grayscale has been implemented\n");
+ fprintf(stderr,"Aborting\n");
+ return 1;
+ }
+ return 0;
+}
+
+opj_image_t* tiftoimage(const char *filename, opj_cparameters_t *parameters)
+{
+ int subsampling_dx = parameters->subsampling_dx;
+ int subsampling_dy = parameters->subsampling_dy;
+ TIFF *tif;
+ tiff_infoheader_t Info;
+ tdata_t buf;
+ tstrip_t strip;
+ tsize_t strip_size;
+ int j, numcomps, w, h,index;
+ OPJ_COLOR_SPACE color_space;
+ opj_image_cmptparm_t cmptparm[3];
+ opj_image_t * image = NULL;
+ int imgsize = 0;
+
+ tif = TIFFOpen(filename, "r");
+
+ if (!tif) {
+ fprintf(stderr, "Failed to open %s for reading\n", filename);
+ return 0;
+ }
+
+ TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &Info.tiWidth);
+ TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &Info.tiHeight);
+ TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &Info.tiBps);
+ TIFFGetField(tif, TIFFTAG_SAMPLEFORMAT, &Info.tiSf);
+ TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &Info.tiSpp);
+ Info.tiPhoto = 0;
+ TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &Info.tiPhoto);
+ TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &Info.tiPC);
+ w= Info.tiWidth;
+ h= Info.tiHeight;
+
+ if (Info.tiPhoto == 2) {
+ /* -->> -->> -->>
+ RGB color
+ <<-- <<-- <<-- */
+
+ numcomps = 3;
+ color_space = CLRSPC_SRGB;
+ /* initialize image components*/
+ memset(&cmptparm[0], 0, 3 * sizeof(opj_image_cmptparm_t));
+ for(j = 0; j < numcomps; j++) {
+ if (parameters->cp_cinema) {
+ cmptparm[j].prec = 12;
+ cmptparm[j].bpp = 12;
+ }else{
+ cmptparm[j].prec = Info.tiBps;
+ cmptparm[j].bpp = Info.tiBps;
+ }
+ cmptparm[j].sgnd = 0;
+ cmptparm[j].dx = subsampling_dx;
+ cmptparm[j].dy = subsampling_dy;
+ cmptparm[j].w = w;
+ cmptparm[j].h = h;
+ }
+ /* create the image*/
+ image = opj_image_create(numcomps, &cmptparm[0], color_space);
+ if(!image) {
+ TIFFClose(tif);
+ return NULL;
+ }
+
+ /* set image offset and reference grid */
+ image->x0 = parameters->image_offset_x0;
+ image->y0 = parameters->image_offset_y0;
+ image->x1 = !image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1;
+ image->y1 = !image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1;
+
+ buf = _TIFFmalloc(TIFFStripSize(tif));
+ strip_size=0;
+ strip_size=TIFFStripSize(tif);
+ index = 0;
+ imgsize = image->comps[0].w * image->comps[0].h ;
+ /* Read the Image components*/
+ for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
+ unsigned char *dat8;
+ int i, ssize;
+ ssize = TIFFReadEncodedStrip(tif, strip, buf, strip_size);
+ dat8 = buf;
+
+ if (Info.tiBps==12){
+ for (i=0; i<ssize; i+=9) { /*12 bits per pixel*/
+ if((index < imgsize)&(index+1 < imgsize)){
+ image->comps[0].data[index] = ( dat8[i+0]<<4 ) |(dat8[i+1]>>4);
+ image->comps[1].data[index] = ((dat8[i+1]& 0x0f)<< 8) | dat8[i+2];
+ image->comps[2].data[index] = ( dat8[i+3]<<4) |(dat8[i+4]>>4);
+ image->comps[0].data[index+1] = ((dat8[i+4]& 0x0f)<< 8) | dat8[i+5];
+ image->comps[1].data[index+1] = ( dat8[i+6] <<4) |(dat8[i+7]>>4);
+ image->comps[2].data[index+1] = ((dat8[i+7]& 0x0f)<< 8) | dat8[i+8];
+ index+=2;
+ }else
+ break;
+ }
+ }
+ else if( Info.tiBps==16){
+ for (i=0; i<ssize; i+=6) { /* 16 bits per pixel */
+ if(index < imgsize){
+ image->comps[0].data[index] = ( dat8[i+1] << 8 ) | dat8[i+0]; // R
+ image->comps[1].data[index] = ( dat8[i+3] << 8 ) | dat8[i+2]; // G
+ image->comps[2].data[index] = ( dat8[i+5] << 8 ) | dat8[i+4]; // B
+ if(parameters->cp_cinema){/* Rounding to 12 bits*/
+ image->comps[0].data[index] = (image->comps[0].data[index] + 0x08) >> 4 ;
+ image->comps[1].data[index] = (image->comps[1].data[index] + 0x08) >> 4 ;
+ image->comps[2].data[index] = (image->comps[2].data[index] + 0x08) >> 4 ;
+ }
+ index++;
+ }else
+ break;
+ }
+ }
+ else if ( Info.tiBps==8){
+ for (i=0; i<ssize; i+=3) { /* 8 bits per pixel */
+ if(index < imgsize){
+ image->comps[0].data[index] = dat8[i+0];// R
+ image->comps[1].data[index] = dat8[i+1];// G
+ image->comps[2].data[index] = dat8[i+2];// B
+ if(parameters->cp_cinema){/* Rounding to 12 bits*/
+ image->comps[0].data[index] = image->comps[0].data[index] << 4 ;
+ image->comps[1].data[index] = image->comps[1].data[index] << 4 ;
+ image->comps[2].data[index] = image->comps[2].data[index] << 4 ;
+ }
+ index++;
+ }else
+ break;
+ }
+ }
+ else{
+ fprintf(stderr,"TIFF file creation. Bits=%d, Only 8,12,16 bits implemented\n",Info.tiBps);
+ fprintf(stderr,"Aborting\n");
+ return NULL;
+ }
+ }
+
+ _TIFFfree(buf);
+ TIFFClose(tif);
+ }else if(Info.tiPhoto == 1) {
+ /* -->> -->> -->>
+ Black and White
+ <<-- <<-- <<-- */
+
+ numcomps = 1;
+ color_space = CLRSPC_GRAY;
+ /* initialize image components*/
+ memset(&cmptparm[0], 0, sizeof(opj_image_cmptparm_t));
+ cmptparm[0].prec = Info.tiBps;
+ cmptparm[0].bpp = Info.tiBps;
+ cmptparm[0].sgnd = 0;
+ cmptparm[0].dx = subsampling_dx;
+ cmptparm[0].dy = subsampling_dy;
+ cmptparm[0].w = w;
+ cmptparm[0].h = h;
+
+ /* create the image*/
+ image = opj_image_create(numcomps, &cmptparm[0], color_space);
+ if(!image) {
+ TIFFClose(tif);
+ return NULL;
+ }
+ /* set image offset and reference grid */
+ image->x0 = parameters->image_offset_x0;
+ image->y0 = parameters->image_offset_y0;
+ image->x1 = !image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1;
+ image->y1 = !image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1;
+
+ buf = _TIFFmalloc(TIFFStripSize(tif));
+ strip_size = 0;
+ strip_size = TIFFStripSize(tif);
+ index = 0;
+ imgsize = image->comps[0].w * image->comps[0].h ;
+ /* Read the Image components*/
+ for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
+ unsigned char *dat8;
+ int i, ssize;
+ ssize = TIFFReadEncodedStrip(tif, strip, buf, strip_size);
+ dat8 = buf;
+
+ if (Info.tiBps==12){
+ for (i=0; i<ssize; i+=3) { /* 12 bits per pixel*/
+ if(index < imgsize){
+ image->comps[0].data[index] = ( dat8[i+0]<<4 ) |(dat8[i+1]>>4) ;
+ image->comps[0].data[index+1] = ((dat8[i+1]& 0x0f)<< 8) | dat8[i+2];
+ index+=2;
+ }else
+ break;
+ }
+ }
+ else if( Info.tiBps==16){
+ for (i=0; i<ssize; i+=2) { /* 16 bits per pixel */
+ if(index < imgsize){
+ image->comps[0].data[index] = ( dat8[i+1] << 8 ) | dat8[i+0];
+ index++;
+ }else
+ break;
+ }
+ }
+ else if ( Info.tiBps==8){
+ for (i=0; i<ssize; i+=1) { /* 8 bits per pixel */
+ if(index < imgsize){
+ image->comps[0].data[index] = dat8[i+0];
+ index++;
+ }else
+ break;
+ }
+ }
+ else{
+ fprintf(stderr,"TIFF file creation. Bits=%d, Only 8,12,16 bits implemented\n",Info.tiBps);
+ fprintf(stderr,"Aborting\n");
+ return NULL;
+ }
+ }
+
+ _TIFFfree(buf);
+ TIFFClose(tif);
+ }else{
+ fprintf(stderr,"TIFF file creation. Bad color format. Only RGB & Grayscale has been implemented\n");
+ fprintf(stderr,"Aborting\n");
+ return NULL;
+ }
+ return image;
+}
+
+/* -->> -->> -->> -->>
+
+ RAW IMAGE FORMAT
+
+ <<-- <<-- <<-- <<-- */
+
+opj_image_t* rawtoimage(const char *filename, opj_cparameters_t *parameters, raw_cparameters_t *raw_cp) {
+ int subsampling_dx = parameters->subsampling_dx;
+ int subsampling_dy = parameters->subsampling_dy;
+
+ FILE *f = NULL;
+ int i, compno, numcomps, w, h;
+ OPJ_COLOR_SPACE color_space;
+ opj_image_cmptparm_t *cmptparm;
+ opj_image_t * image = NULL;
+ unsigned short ch;
+
+ if((! (raw_cp->rawWidth & raw_cp->rawHeight & raw_cp->rawComp & raw_cp->rawBitDepth)) == 0)
+ {
+ fprintf(stderr,"\nError: invalid raw image parameters\n");
+ fprintf(stderr,"Please use the Format option -F:\n");
+ fprintf(stderr,"-F rawWidth,rawHeight,rawComp,rawBitDepth,s/u (Signed/Unsigned)\n");
+ fprintf(stderr,"Example: -i lena.raw -o lena.j2k -F 512,512,3,8,u\n");
+ fprintf(stderr,"Aborting\n");
+ return NULL;
+ }
+
+ f = fopen(filename, "rb");
+ if (!f) {
+ fprintf(stderr, "Failed to open %s for reading !!\n", filename);
+ fprintf(stderr,"Aborting\n");
+ return NULL;
+ }
+ numcomps = raw_cp->rawComp;
+ color_space = CLRSPC_SRGB;
+ w = raw_cp->rawWidth;
+ h = raw_cp->rawHeight;
+ cmptparm = (opj_image_cmptparm_t*) malloc(numcomps * sizeof(opj_image_cmptparm_t));
+
+ /* initialize image components */
+ memset(&cmptparm[0], 0, numcomps * sizeof(opj_image_cmptparm_t));
+ for(i = 0; i < numcomps; i++) {
+ cmptparm[i].prec = raw_cp->rawBitDepth;
+ cmptparm[i].bpp = raw_cp->rawBitDepth;
+ cmptparm[i].sgnd = raw_cp->rawSigned;
+ cmptparm[i].dx = subsampling_dx;
+ cmptparm[i].dy = subsampling_dy;
+ cmptparm[i].w = w;
+ cmptparm[i].h = h;
+ }
+ /* create the image */
+ image = opj_image_create(numcomps, &cmptparm[0], color_space);
+ if(!image) {
+ fclose(f);
+ return NULL;
+ }
+ /* set image offset and reference grid */
+ image->x0 = parameters->image_offset_x0;
+ image->y0 = parameters->image_offset_y0;
+ image->x1 = parameters->image_offset_x0 + (w - 1) * subsampling_dx + 1;
+ image->y1 = parameters->image_offset_y0 + (h - 1) * subsampling_dy + 1;
+
+ if(raw_cp->rawBitDepth <= 8)
+ {
+ unsigned char value = 0;
+ for(compno = 0; compno < numcomps; compno++) {
+ for (i = 0; i < w * h; i++) {
+ if (!fread(&value, 1, 1, f)) {
+ fprintf(stderr,"Error reading raw file. End of file probably reached.\n");
+ return NULL;
+ }
+ image->comps[compno].data[i] = raw_cp->rawSigned?(char)value:value;
+ }
+ }
+ }
+ else
+ {
+ unsigned short value = 0;
+ for(compno = 0; compno < numcomps; compno++) {
+ for (i = 0; i < w * h; i++) {
+ if (!fread(&value, 2, 1, f)) {
+ fprintf(stderr,"Error reading raw file. End of file probably reached.\n");
+ return NULL;
+ }
+ image->comps[compno].data[i] = raw_cp->rawSigned?(short)value:value;
+ }
+ }
+ }
+
+ if (fread(&ch, 1, 1, f)) {
+ fprintf(stderr,"Warning. End of raw file not reached... processing anyway\n");
+ }
+ fclose(f);
+
+ return image;
+}
+
+int imagetoraw(opj_image_t * image, const char *outfile)
+{
+ FILE *rawFile = NULL;
+ int compno;
+ int w, h;
+ int line, row;
+ int *ptr;
+
+ if((image->numcomps * image->x1 * image->y1) == 0)
+ {
+ fprintf(stderr,"\nError: invalid raw image parameters\n");
+ return 1;
+ }
+
+ rawFile = fopen(outfile, "wb");
+ if (!rawFile) {
+ fprintf(stderr, "Failed to open %s for writing !!\n", outfile);
+ return 1;
+ }
+
+ fprintf(stdout,"Raw image characteristics: %d components\n", image->numcomps);
+
+ for(compno = 0; compno < image->numcomps; compno++)
+ {
+ fprintf(stdout,"Component %d characteristics: %dx%dx%d %s\n", compno, image->comps[compno].w,
+ image->comps[compno].h, image->comps[compno].prec, image->comps[compno].sgnd==1 ? "signed": "unsigned");
+
+ w = image->comps[compno].w;
+ h = image->comps[compno].h;
+
+ if(image->comps[compno].prec <= 8)
+ {
+ if(image->comps[compno].sgnd == 1)
+ {
+ signed char curr;
+ int mask = (1 << image->comps[compno].prec) - 1;
+ ptr = image->comps[compno].data;
+ for (line = 0; line < h; line++) {
+ for(row = 0; row < w; row++) {
+ curr = (signed char) (*ptr & mask);
+ fwrite(&curr, sizeof(signed char), 1, rawFile);
+ ptr++;
+ }
+ }
+ }
+ else if(image->comps[compno].sgnd == 0)
+ {
+ unsigned char curr;
+ int mask = (1 << image->comps[compno].prec) - 1;
+ ptr = image->comps[compno].data;
+ for (line = 0; line < h; line++) {
+ for(row = 0; row < w; row++) {
+ curr = (unsigned char) (*ptr & mask);
+ fwrite(&curr, sizeof(unsigned char), 1, rawFile);
+ ptr++;
+ }
+ }
+ }
+ }
+ else if(image->comps[compno].prec <= 16)
+ {
+ if(image->comps[compno].sgnd == 1)
+ {
+ signed short int curr;
+ int mask = (1 << image->comps[compno].prec) - 1;
+ ptr = image->comps[compno].data;
+ for (line = 0; line < h; line++) {
+ for(row = 0; row < w; row++) {
+ curr = (signed short int) (*ptr & mask);
+ fwrite(&curr, sizeof(signed short int), 1, rawFile);
+ ptr++;
+ }
+ }
+ }
+ else if(image->comps[compno].sgnd == 0)
+ {
+ unsigned short int curr;
+ int mask = (1 << image->comps[compno].prec) - 1;
+ ptr = image->comps[compno].data;
+ for (line = 0; line < h; line++) {
+ for(row = 0; row < w; row++) {
+ curr = (unsigned short int) (*ptr & mask);
+ fwrite(&curr, sizeof(unsigned short int), 1, rawFile);
+ ptr++;
+ }
+ }
+ }
+ }
+ else if (image->comps[compno].prec <= 32)
+ {
+ fprintf(stderr,"More than 16 bits per component no handled yet\n");
+ return 1;
+ }
+ else
+ {
+ fprintf(stderr,"Error: invalid precision: %d\n", image->comps[compno].prec);
+ return 1;
+ }
+ }
+ fclose(rawFile);
+ return 0;
+}
diff --git a/v2/codec/convert.h b/v2/codec/convert.h new file mode 100755 index 00000000..99eaf1ad --- /dev/null +++ b/v2/codec/convert.h @@ -0,0 +1,78 @@ +/*
+ * 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.
+ */
+#ifndef __J2K_CONVERT_H
+#define __J2K_CONVERT_H
+
+/**@name RAW image encoding parameters */
+/*@{*/
+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 */
+opj_image_t* tgatoimage(const char *filename, opj_cparameters_t *parameters);
+int imagetotga(opj_image_t * image, const char *outfile);
+
+/* BMP conversion */
+opj_image_t* bmptoimage(const char *filename, opj_cparameters_t *parameters);
+int imagetobmp(opj_image_t *image, const char *outfile);
+
+/* 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 */
+
diff --git a/v2/codec/dirent.h b/v2/codec/dirent.h new file mode 100755 index 00000000..a2b9176f --- /dev/null +++ b/v2/codec/dirent.h @@ -0,0 +1,677 @@ +
+/*
+ * 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__) /* 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*/
diff --git a/v2/codec/image_to_j2k.c b/v2/codec/image_to_j2k.c new file mode 100755 index 00000000..5b3ea525 --- /dev/null +++ b/v2/codec/image_to_j2k.c @@ -0,0 +1,1786 @@ +/*
+ * 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>
+#define __USE_BSD
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#define USE_OPJ_DEPRECATED
+#include "openjpeg.h"
+#include "compat/getopt.h"
+#include "convert.h"
+#include "dirent.h"
+#include "index.h"
+
+#ifndef WIN32
+#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
+
+/* ----------------------------------------------------------------------- */
+#define CINEMA_24_CS 1302083 /*Codestream length for 24fps*/
+#define CINEMA_48_CS 651041 /*Codestream length for 48fps*/
+#define COMP_24_CS 1041666 /*Maximum size per color component for 2K & 4K @ 24fps*/
+#define COMP_48_CS 520833 /*Maximum size per color component for 2K @ 48fps*/
+
+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*/
+ char *out_format;
+ /** Enable option*/
+ char set_imgdir;
+ /** Enable Cod Format for output*/
+ char set_out_format;
+ /** User specified rate stored in case of cinema option*/
+ float *rates;
+}img_fol_t;
+
+void encode_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 */
+ "encoder:\n");
+/* <<UniPG */
+ 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,"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");
+/* UniPG>> */
+#ifdef USE_JPWL
+ fprintf(stdout," * No JPWL protection\n");
+#endif /* USE_JPWL */
+/* <<UniPG */
+ fprintf(stdout,"\n");
+ fprintf(stdout,"Parameters:\n");
+ fprintf(stdout,"------------\n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"Required Parameters (except with -h):\n");
+ fprintf(stdout,"One of the two options -ImgDir or -i must be used\n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-ImgDir : Image file Directory path (example ../Images) \n");
+ fprintf(stdout," When using this option -OutFor must be used\n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-OutFor \n");
+ fprintf(stdout," REQUIRED only if -ImgDir is used\n");
+ fprintf(stdout," Need to specify only format without filename <BMP> \n");
+ fprintf(stdout," Currently accepts PGM, PPM, PNM, PGX, BMP, TIF, RAW and TGA formats\n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-i : source file (-i source.pnm also *.pgm, *.ppm, *.bmp, *.tif, *.raw, *.tga) \n");
+ fprintf(stdout," When using this option -o must be used\n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-o : destination file (-o dest.j2k or .jp2) \n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"Optional Parameters:\n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-h : display the help information \n ");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-cinema2K : Digital Cinema 2K profile compliant codestream for 2K resolution.(-cinema2k 24 or 48) \n");
+ fprintf(stdout," Need to specify the frames per second for a 2K resolution. Only 24 or 48 fps is allowed\n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-cinema4K : Digital Cinema 4K profile compliant codestream for 4K resolution \n");
+ fprintf(stdout," Frames per second not required. Default value is 24fps\n");
+ fprintf(stdout,"\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,"\n");
+ fprintf(stdout," (options -r and -q cannot be used together)\n ");
+ fprintf(stdout,"\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");
+ fprintf(stdout,"-n : number of resolutions (-n 3) \n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-b : size of code block (-b 32,32) \n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-c : size of precinct (-c 128,128) \n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-t : size of tile (-t 512,512) \n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-p : progression order (-p LRCP) [LRCP, RLCP, RPCL, PCRL, CPRL] \n");
+ fprintf(stdout,"\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,"\n");
+ fprintf(stdout,"-POC : Progression order change (-POC T1=0,0,1,5,3,CPRL/T1=5,0,1,6,3,CPRL) \n");
+ fprintf(stdout," Example: T1=0,0,1,5,3,CPRL \n");
+ fprintf(stdout," : Ttilenumber=Resolution num start,Component num start,Layer num end,Resolution num end,Component num end,Progression order\n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-SOP : write SOP marker before each packet \n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-EPH : write EPH marker after each header packet \n");
+ fprintf(stdout,"\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,"\n");
+ fprintf(stdout,"-x : create an index file *.Idx (-x index_name.Idx) \n");
+ fprintf(stdout,"\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,"\n");
+ fprintf(stdout,"-d : offset of the origin of the image (-d 150,300) \n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-T : offset of the origin of the tiles (-T 100,75) \n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-I : use the irreversible DWT 9-7 (-I) \n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"-m : use array-based MCT, values are coma separated, line by line\n");
+ fprintf(stdout," no specific separators between lines, no space allowed between values\n");
+ fprintf(stdout,"\n");
+/* UniPG>> */
+#ifdef USE_JPWL
+ fprintf(stdout,"-W : adoption of JPWL (Part 11) capabilities (-W params)\n");
+ fprintf(stdout," The parameters can be written and repeated in any order:\n");
+ fprintf(stdout," [h<tilepart><=type>,s<tilepart><=method>,a=<addr>,...\n");
+ fprintf(stdout," ...,z=<size>,g=<range>,p<tilepart:pack><=type>]\n");
+ fprintf(stdout,"\n");
+ fprintf(stdout," h selects the header error protection (EPB): 'type' can be\n");
+ fprintf(stdout," [0=none 1,absent=predefined 16=CRC-16 32=CRC-32 37-128=RS]\n");
+ fprintf(stdout," if 'tilepart' is absent, it is for main and tile headers\n");
+ fprintf(stdout," if 'tilepart' is present, it applies from that tile\n");
+ fprintf(stdout," onwards, up to the next h<> spec, or to the last tilepart\n");
+ fprintf(stdout," in the codestream (max. %d specs)\n", JPWL_MAX_NO_TILESPECS);
+ fprintf(stdout,"\n");
+ fprintf(stdout," p selects the packet error protection (EEP/UEP with EPBs)\n");
+ fprintf(stdout," to be applied to raw data: 'type' can be\n");
+ fprintf(stdout," [0=none 1,absent=predefined 16=CRC-16 32=CRC-32 37-128=RS]\n");
+ fprintf(stdout," if 'tilepart:pack' is absent, it is from tile 0, packet 0\n");
+ fprintf(stdout," if 'tilepart:pack' is present, it applies from that tile\n");
+ fprintf(stdout," and that packet onwards, up to the next packet spec\n");
+ fprintf(stdout," or to the last packet in the last tilepart in the stream\n");
+ fprintf(stdout," (max. %d specs)\n", JPWL_MAX_NO_PACKSPECS);
+ fprintf(stdout,"\n");
+ fprintf(stdout," s enables sensitivity data insertion (ESD): 'method' can be\n");
+ fprintf(stdout," [-1=NO ESD 0=RELATIVE ERROR 1=MSE 2=MSE REDUCTION 3=PSNR\n");
+ fprintf(stdout," 4=PSNR INCREMENT 5=MAXERR 6=TSE 7=RESERVED]\n");
+ fprintf(stdout," if 'tilepart' is absent, it is for main header only\n");
+ fprintf(stdout," if 'tilepart' is present, it applies from that tile\n");
+ fprintf(stdout," onwards, up to the next s<> spec, or to the last tilepart\n");
+ fprintf(stdout," in the codestream (max. %d specs)\n", JPWL_MAX_NO_TILESPECS);
+ fprintf(stdout,"\n");
+ fprintf(stdout," g determines the addressing mode: <range> can be\n");
+ fprintf(stdout," [0=PACKET 1=BYTE RANGE 2=PACKET RANGE]\n");
+ fprintf(stdout,"\n");
+ fprintf(stdout," a determines the size of data addressing: <addr> can be\n");
+ fprintf(stdout," 2/4 bytes (small/large codestreams). If not set, auto-mode\n");
+ fprintf(stdout,"\n");
+ fprintf(stdout," z determines the size of sensitivity values: <size> can be\n");
+ fprintf(stdout," 1/2 bytes, for the transformed pseudo-floating point value\n");
+ fprintf(stdout,"\n");
+ fprintf(stdout," ex.:\n");
+ fprintf(stdout," h,h0=64,h3=16,h5=32,p0=78,p0:24=56,p1,p3:0=0,p3:20=32,s=0,\n");
+ fprintf(stdout," s0=6,s3=-1,a=0,g=1,z=1\n");
+ fprintf(stdout," means\n");
+ fprintf(stdout," predefined EPB in MH, rs(64,32) from TPH 0 to TPH 2,\n");
+ fprintf(stdout," CRC-16 in TPH 3 and TPH 4, CRC-32 in remaining TPHs,\n");
+ fprintf(stdout," UEP rs(78,32) for packets 0 to 23 of tile 0,\n");
+ fprintf(stdout," UEP rs(56,32) for packs. 24 to the last of tilepart 0,\n");
+ fprintf(stdout," UEP rs default for packets of tilepart 1,\n");
+ fprintf(stdout," no UEP for packets 0 to 19 of tilepart 3,\n");
+ fprintf(stdout," UEP CRC-32 for packs. 20 of tilepart 3 to last tilepart,\n");
+ fprintf(stdout," relative sensitivity ESD for MH,\n");
+ fprintf(stdout," TSE ESD from TPH 0 to TPH 2, byte range with automatic\n");
+ fprintf(stdout," size of addresses and 1 byte for each sensitivity value\n");
+ fprintf(stdout,"\n");
+ fprintf(stdout," ex.:\n");
+ fprintf(stdout," h,s,p\n");
+ fprintf(stdout," means\n");
+ fprintf(stdout," default protection to headers (MH and TPHs) as well as\n");
+ fprintf(stdout," data packets, one ESD in MH\n");
+ fprintf(stdout,"\n");
+ fprintf(stdout," N.B.: use the following recommendations when specifying\n");
+ fprintf(stdout," the JPWL parameters list\n");
+ fprintf(stdout," - when you use UEP, always pair the 'p' option with 'h'\n");
+ fprintf(stdout," \n");
+#endif /* USE_JPWL */
+/* <<UniPG */
+ 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,"Tiles_nb_X Tiles_nb_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_start_position\n");
+ fprintf(stdout,"Main_header_end_position\n");
+ fprintf(stdout,"Codestream_size\n");
+ fprintf(stdout,"\n");
+ fprintf(stdout,"INFO ON TILES\n");
+ fprintf(stdout,"tileno start_pos end_hd end_tile nbparts disto nbpix disto/nbpix\n");
+ fprintf(stdout,"Tile_0 start_pos end_Theader end_pos NumParts TotalDisto NumPix MaxMSE\n");
+ fprintf(stdout,"Tile_1 '' '' '' '' '' '' ''\n");
+ fprintf(stdout,"...\n");
+ fprintf(stdout,"Tile_Nt '' '' '' '' '' '' ''\n");
+ fprintf(stdout,"...\n");
+ fprintf(stdout,"TILE 0 DETAILS\n");
+ fprintf(stdout,"part_nb tileno num_packs start_pos end_tph_pos end_pos\n");
+ fprintf(stdout,"...\n");
+ fprintf(stdout,"Progression_string\n");
+ fprintf(stdout,"pack_nb tileno layno resno compno precno start_pos end_ph_pos end_pos disto\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");
+}
+
+OPJ_PROG_ORDER give_progression(char progression[4]) {
+ if(strncmp(progression, "LRCP", 4) == 0) {
+ return LRCP;
+ }
+ if(strncmp(progression, "RLCP", 4) == 0) {
+ return RLCP;
+ }
+ if(strncmp(progression, "RPCL", 4) == 0) {
+ return RPCL;
+ }
+ if(strncmp(progression, "PCRL", 4) == 0) {
+ return PCRL;
+ }
+ if(strncmp(progression, "CPRL", 4) == 0) {
+ return CPRL;
+ }
+
+ return PROG_UNKNOWN;
+}
+
+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;
+ }
+
+ num_images=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", "j2c"
+ };
+ static const int format[] = {
+ PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT, TIF_DFMT, RAW_DFMT, TGA_DFMT, J2K_CFMT, JP2_CFMT, J2K_CFMT
+ };
+ char * ext = strrchr(filename, '.');
+ if (ext == NULL)
+ return -1;
+ ext++;
+ for(i = 0; i < sizeof(format)/sizeof(*format); i++) {
+ if(strnicmp(ext, extension[i], 3) == 0) {
+ return format[i];
+ }
+ }
+ return -1;
+}
+
+char * get_file_name(char *name){
+ char *fname;
+ fname= (char*)malloc(OPJ_PATH_LEN*sizeof(char));
+ fname= strtok(name,".");
+ return fname;
+}
+
+char get_next_file(int imageno,dircnt_t *dirptr,img_fol_t *img_fol, opj_cparameters_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,get_file_name(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;
+}
+
+static int initialise_4K_poc(opj_poc_t *POC, int numres){
+ POC[0].tile = 1;
+ POC[0].resno0 = 0;
+ POC[0].compno0 = 0;
+ POC[0].layno1 = 1;
+ POC[0].resno1 = numres-1;
+ POC[0].compno1 = 3;
+ POC[0].prg1 = CPRL;
+ POC[1].tile = 1;
+ POC[1].resno0 = numres-1;
+ POC[1].compno0 = 0;
+ POC[1].layno1 = 1;
+ POC[1].resno1 = numres;
+ POC[1].compno1 = 3;
+ POC[1].prg1 = CPRL;
+ return 2;
+}
+
+void cinema_parameters(opj_cparameters_t *parameters){
+ parameters->tile_size_on = false;
+ parameters->cp_tdx=1;
+ parameters->cp_tdy=1;
+
+ /*Tile part*/
+ parameters->tp_flag = 'C';
+ parameters->tp_on = 1;
+
+ /*Tile and Image shall be at (0,0)*/
+ parameters->cp_tx0 = 0;
+ parameters->cp_ty0 = 0;
+ parameters->image_offset_x0 = 0;
+ parameters->image_offset_y0 = 0;
+
+ /*Codeblock size= 32*32*/
+ parameters->cblockw_init = 32;
+ parameters->cblockh_init = 32;
+ parameters->csty |= 0x01;
+
+ /*The progression order shall be CPRL*/
+ parameters->prog_order = CPRL;
+
+ /* No ROI */
+ parameters->roi_compno = -1;
+
+ parameters->subsampling_dx = 1; parameters->subsampling_dy = 1;
+
+ /* 9-7 transform */
+ parameters->irreversible = 1;
+
+}
+
+void cinema_setup_encoder(opj_cparameters_t *parameters,opj_image_t *image, img_fol_t *img_fol){
+ int i;
+ float temp_rate;
+ opj_poc_t *POC = NULL;
+
+ switch (parameters->cp_cinema){
+ case CINEMA2K_24:
+ case CINEMA2K_48:
+ if(parameters->numresolution > 6){
+ parameters->numresolution = 6;
+ }
+ if (!((image->comps[0].w == 2048) | (image->comps[0].h == 1080))){
+ fprintf(stdout,"Image coordinates %d x %d is not 2K compliant.\nJPEG Digital Cinema Profile-3 "
+ "(2K profile) compliance requires that at least one of coordinates match 2048 x 1080\n",
+ image->comps[0].w,image->comps[0].h);
+ parameters->cp_rsiz = STD_RSIZ;
+ }
+ break;
+
+ case CINEMA4K_24:
+ if(parameters->numresolution < 1){
+ parameters->numresolution = 1;
+ }else if(parameters->numresolution > 7){
+ parameters->numresolution = 7;
+ }
+ if (!((image->comps[0].w == 4096) | (image->comps[0].h == 2160))){
+ fprintf(stdout,"Image coordinates %d x %d is not 4K compliant.\nJPEG Digital Cinema Profile-4"
+ "(4K profile) compliance requires that at least one of coordinates match 4096 x 2160\n",
+ image->comps[0].w,image->comps[0].h);
+ parameters->cp_rsiz = STD_RSIZ;
+ }
+ parameters->numpocs = initialise_4K_poc(parameters->POC,parameters->numresolution);
+ break;
+ default :
+ break;
+ }
+
+ switch (parameters->cp_cinema){
+ case CINEMA2K_24:
+ case CINEMA4K_24:
+ for(i=0 ; i<parameters->tcp_numlayers ; i++){
+ temp_rate = 0 ;
+ if (img_fol->rates[i]== 0){
+ parameters->tcp_rates[0]= ((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
+ (CINEMA_24_CS * 8 * image->comps[0].dx * image->comps[0].dy);
+ }else{
+ temp_rate =((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
+ (img_fol->rates[i] * 8 * image->comps[0].dx * image->comps[0].dy);
+ if (temp_rate > CINEMA_24_CS ){
+ parameters->tcp_rates[i]= ((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
+ (CINEMA_24_CS * 8 * image->comps[0].dx * image->comps[0].dy);
+ }else{
+ parameters->tcp_rates[i]= img_fol->rates[i];
+ }
+ }
+ }
+ parameters->max_comp_size = COMP_24_CS;
+ break;
+
+ case CINEMA2K_48:
+ for(i=0 ; i<parameters->tcp_numlayers ; i++){
+ temp_rate = 0 ;
+ if (img_fol->rates[i]== 0){
+ parameters->tcp_rates[0]= ((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
+ (CINEMA_48_CS * 8 * image->comps[0].dx * image->comps[0].dy);
+ }else{
+ temp_rate =((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
+ (img_fol->rates[i] * 8 * image->comps[0].dx * image->comps[0].dy);
+ if (temp_rate > CINEMA_48_CS ){
+ parameters->tcp_rates[0]= ((float) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec))/
+ (CINEMA_48_CS * 8 * image->comps[0].dx * image->comps[0].dy);
+ }else{
+ parameters->tcp_rates[i]= img_fol->rates[i];
+ }
+ }
+ }
+ parameters->max_comp_size = COMP_48_CS;
+ break;
+ default:
+ break;
+ }
+ parameters->cp_disto_alloc = 1;
+}
+
+/* ------------------------------------------------------------------------------------ */
+
+int parse_cmdline_encoder(int argc, char **argv, opj_cparameters_t *parameters,
+ img_fol_t *img_fol, raw_cparameters_t *raw_cp, char *indexfilename) {
+ int i, j,totlen;
+ option_t long_option[]={
+ {"cinema2K",REQ_ARG, NULL ,'w'},
+ {"cinema4K",NO_ARG, NULL ,'y'},
+ {"ImgDir",REQ_ARG, NULL ,'z'},
+ {"TP",REQ_ARG, NULL ,'v'},
+ {"SOP",NO_ARG, NULL ,'S'},
+ {"EPH",NO_ARG, NULL ,'E'},
+ {"OutFor",REQ_ARG, NULL ,'O'},
+ {"POC",REQ_ARG, NULL ,'P'},
+ {"ROI",REQ_ARG, NULL ,'R'},
+ };
+
+ /* parse the command line */
+ const char optlist[] = "i:o:hr:q:n:b:c:t:p:s:SEM:x:R:d:T:If:P:C:F:m:"
+#ifdef USE_JPWL
+ "W:"
+#endif /* USE_JPWL */
+ ;
+
+ totlen=sizeof(long_option);
+ img_fol->set_out_format=0;
+ raw_cp->rawWidth = 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 PGX_DFMT:
+ case PXM_DFMT:
+ case BMP_DFMT:
+ case TIF_DFMT:
+ case RAW_DFMT:
+ case TGA_DFMT:
+ break;
+ default:
+ fprintf(stderr,
+ "!! Unrecognized format for infile : %s "
+ "[accept only *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga] !!\n\n",
+ infile);
+ return 1;
+ }
+ strncpy(parameters->infile, infile, sizeof(parameters->infile)-1);
+ }
+ break;
+
+ /* ----------------------------------------------------- */
+
+ case 'o': /* output file */
+ {
+ char *outfile = optarg;
+ parameters->cod_format = get_file_format(outfile);
+ switch(parameters->cod_format) {
+ case J2K_CFMT:
+ case JP2_CFMT:
+ break;
+ default:
+ fprintf(stderr, "Unknown output format image %s [only *.j2k, *.j2c or *.jp2]!! \n", outfile);
+ return 1;
+ }
+ strncpy(parameters->outfile, outfile, sizeof(parameters->outfile)-1);
+ }
+ break;
+
+ /* ----------------------------------------------------- */
+ case 'O': /* output format */
+ {
+ char outformat[50];
+ char *of = optarg;
+ sprintf(outformat,".%s",of);
+ img_fol->set_out_format = 1;
+ parameters->cod_format = get_file_format(outformat);
+ switch(parameters->cod_format) {
+ case J2K_CFMT:
+ case JP2_CFMT:
+ img_fol->out_format = optarg;
+ break;
+ default:
+ fprintf(stderr, "Unknown output format image [only j2k, j2c, jp2]!! \n");
+ return 1;
+ }
+ }
+ break;
+
+
+ /* ----------------------------------------------------- */
+
+
+ case 'r': /* rates rates/distorsion */
+ {
+ char *s = optarg;
+ while (sscanf(s, "%f", ¶meters->tcp_rates[parameters->tcp_numlayers]) == 1) {
+ parameters->tcp_numlayers++;
+ while (*s && *s != ',') {
+ s++;
+ }
+ if (!*s)
+ break;
+ s++;
+ }
+ parameters->cp_disto_alloc = 1;
+ }
+ break;
+
+ /* ----------------------------------------------------- */
+
+
+ case 'F': /* Raw image format parameters */
+ {
+ char signo;
+ char *s = optarg;
+ if (sscanf(s, "%d,%d,%d,%d,%c", &raw_cp->rawWidth, &raw_cp->rawHeight, &raw_cp->rawComp, &raw_cp->rawBitDepth, &signo) == 5) {
+ if (signo == 's') {
+ raw_cp->rawSigned = true;
+ fprintf(stdout,"\nRaw file parameters: %d,%d,%d,%d Signed\n", raw_cp->rawWidth, raw_cp->rawHeight, raw_cp->rawComp, raw_cp->rawBitDepth);
+ }
+ else if (signo == 'u') {
+ raw_cp->rawSigned = false;
+ fprintf(stdout,"\nRaw file parameters: %d,%d,%d,%d Unsigned\n", raw_cp->rawWidth, raw_cp->rawHeight, raw_cp->rawComp, raw_cp->rawBitDepth);
+ }
+ else {
+ fprintf(stderr,"\nError: invalid raw image parameters: Unknown sign of raw file\n");
+ fprintf(stderr,"Please use the Format option -F:\n");
+ fprintf(stderr,"-F rawWidth,rawHeight,rawComp,rawBitDepth,s/u (Signed/Unsigned)\n");
+ fprintf(stderr,"Example: -i lena.raw -o lena.j2k -F 512,512,3,8,u\n");
+ fprintf(stderr,"Aborting\n");
+ }
+ }
+ else {
+ fprintf(stderr,"\nError: invalid raw image parameters\n");
+ fprintf(stderr,"Please use the Format option -F:\n");
+ fprintf(stderr,"-F rawWidth,rawHeight,rawComp,rawBitDepth,s/u (Signed/Unsigned)\n");
+ fprintf(stderr,"Example: -i lena.raw -o lena.j2k -F 512,512,3,8,u\n");
+ fprintf(stderr,"Aborting\n");
+ return 1;
+ }
+ }
+ break;
+
+ /* ----------------------------------------------------- */
+
+ case 'q': /* add fixed_quality */
+ {
+ char *s = optarg;
+ while (sscanf(s, "%f", ¶meters->tcp_distoratio[parameters->tcp_numlayers]) == 1) {
+ parameters->tcp_numlayers++;
+ while (*s && *s != ',') {
+ s++;
+ }
+ if (!*s)
+ break;
+ s++;
+ }
+ parameters->cp_fixed_quality = 1;
+ }
+ break;
+
+ /* dda */
+ /* ----------------------------------------------------- */
+
+ case 'f': /* mod fixed_quality (before : -q) */
+ {
+ int *row = NULL, *col = NULL;
+ int numlayers = 0, numresolution = 0, matrix_width = 0;
+
+ char *s = optarg;
+ sscanf(s, "%d", &numlayers);
+ s++;
+ if (numlayers > 9)
+ s++;
+
+ parameters->tcp_numlayers = numlayers;
+ numresolution = parameters->numresolution;
+ matrix_width = numresolution * 3;
+ parameters->cp_matrice = (int *) malloc(numlayers * matrix_width * sizeof(int));
+ s = s + 2;
+
+ for (i = 0; i < numlayers; i++) {
+ row = ¶meters->cp_matrice[i * matrix_width];
+ col = row;
+ parameters->tcp_rates[i] = 1;
+ sscanf(s, "%d,", &col[0]);
+ s += 2;
+ if (col[0] > 9)
+ s++;
+ col[1] = 0;
+ col[2] = 0;
+ for (j = 1; j < numresolution; j++) {
+ col += 3;
+ sscanf(s, "%d,%d,%d", &col[0], &col[1], &col[2]);
+ s += 6;
+ if (col[0] > 9)
+ s++;
+ if (col[1] > 9)
+ s++;
+ if (col[2] > 9)
+ s++;
+ }
+ if (i < numlayers - 1)
+ s++;
+ }
+ parameters->cp_fixed_alloc = 1;
+ }
+ break;
+
+ /* ----------------------------------------------------- */
+
+ case 't': /* tiles */
+ {
+ sscanf(optarg, "%d,%d", ¶meters->cp_tdx, ¶meters->cp_tdy);
+ parameters->tile_size_on = true;
+ }
+ break;
+
+ /* ----------------------------------------------------- */
+
+ case 'n': /* resolution */
+ {
+ sscanf(optarg, "%d", ¶meters->numresolution);
+ }
+ break;
+
+ /* ----------------------------------------------------- */
+ case 'c': /* precinct dimension */
+ {
+ char sep;
+ int res_spec = 0;
+
+ char *s = optarg;
+ do {
+ sep = 0;
+ sscanf(s, "[%d,%d]%c", ¶meters->prcw_init[res_spec],
+ ¶meters->prch_init[res_spec], &sep);
+ parameters->csty |= 0x01;
+ res_spec++;
+ s = strpbrk(s, "]") + 2;
+ }
+ while (sep == ',');
+ parameters->res_spec = res_spec;
+ }
+ break;
+
+ /* ----------------------------------------------------- */
+
+ case 'b': /* code-block dimension */
+ {
+ int cblockw_init = 0, cblockh_init = 0;
+ 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;
+ }
+ parameters->cblockw_init = cblockw_init;
+ parameters->cblockh_init = cblockh_init;
+ }
+ break;
+
+ /* ----------------------------------------------------- */
+
+ case 'x': /* creation of index file */
+ {
+ char *index = optarg;
+ strncpy(indexfilename, index, OPJ_PATH_LEN);
+ }
+ break;
+
+ /* ----------------------------------------------------- */
+
+ case 'p': /* progression order */
+ {
+ char progression[4];
+
+ strncpy(progression, optarg, 4);
+ parameters->prog_order = give_progression(progression);
+ if (parameters->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", ¶meters->subsampling_dx,
+ ¶meters->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", ¶meters->image_offset_x0,
+ ¶meters->image_offset_y0) != 2) {
+ fprintf(stderr, "-d 'coordonnate of the reference grid' argument "
+ "error !! [-d x0,y0]\n");
+ return 1;
+ }
+ }
+ break;
+
+ /* ----------------------------------------------------- */
+
+ case 'h': /* display an help description */
+ encode_help_display();
+ return 1;
+
+ /* ----------------------------------------------------- */
+
+ case 'P': /* POC */
+ {
+ int numpocs = 0; /* number of progression order change (POC) default 0 */
+ opj_poc_t *POC = NULL; /* POC : used in case of Progression order change */
+
+ char *s = optarg;
+ POC = parameters->POC;
+
+ while (sscanf(s, "T%d=%d,%d,%d,%d,%d,%4s", &POC[numpocs].tile,
+ &POC[numpocs].resno0, &POC[numpocs].compno0,
+ &POC[numpocs].layno1, &POC[numpocs].resno1,
+ &POC[numpocs].compno1, POC[numpocs].progorder) == 7) {
+ POC[numpocs].prg1 = give_progression(POC[numpocs].progorder);
+ numpocs++;
+ while (*s && *s != '/') {
+ s++;
+ }
+ if (!*s) {
+ break;
+ }
+ s++;
+ }
+ parameters->numpocs = numpocs;
+ }
+ break;
+
+ /* ------------------------------------------------------ */
+
+ case 'S': /* SOP marker */
+ {
+ parameters->csty |= 0x02;
+ }
+ break;
+
+ /* ------------------------------------------------------ */
+
+ case 'E': /* EPH marker */
+ {
+ parameters->csty |= 0x04;
+ }
+ break;
+
+ /* ------------------------------------------------------ */
+
+ case 'M': /* Mode switch pas tous au point !! */
+ {
+ int value = 0;
+ if (sscanf(optarg, "%d", &value) == 1) {
+ for (i = 0; i <= 5; i++) {
+ int cache = value & (1 << i);
+ if (cache)
+ parameters->mode |= (1 << i);
+ }
+ }
+ }
+ break;
+
+ /* ------------------------------------------------------ */
+
+ case 'R': /* ROI */
+ {
+ if (sscanf(optarg, "c=%d,U=%d", ¶meters->roi_compno,
+ ¶meters->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", ¶meters->cp_tx0, ¶meters->cp_ty0) != 2) {
+ fprintf(stderr, "-T 'tile offset' argument error !! [-T X0,Y0]");
+ return 1;
+ }
+ }
+ break;
+
+ /* ------------------------------------------------------ */
+
+ case 'C': /* add a comment */
+ {
+ parameters->cp_comment = (char*)malloc(strlen(optarg) + 1);
+ if(parameters->cp_comment) {
+ strcpy(parameters->cp_comment, optarg);
+ }
+ }
+ break;
+
+
+ /* ------------------------------------------------------ */
+
+ case 'I': /* reversible or not */
+ {
+ parameters->irreversible = 1;
+ }
+ break;
+
+ /* ------------------------------------------------------ */
+
+ case 'v': /* Tile part generation*/
+ {
+ parameters->tp_flag = optarg[0];
+ parameters->tp_on = 1;
+ }
+ break;
+
+ /* ------------------------------------------------------ */
+
+ case 'z': /* Image Directory path */
+ {
+ img_fol->imgdirpath = (char*)malloc(strlen(optarg) + 1);
+ strcpy(img_fol->imgdirpath,optarg);
+ img_fol->set_imgdir=1;
+ }
+ break;
+
+ /* ------------------------------------------------------ */
+
+ case 'w': /* Digital Cinema 2K profile compliance*/
+ {
+ int fps=0;
+ sscanf(optarg,"%d",&fps);
+ if(fps == 24){
+ parameters->cp_cinema = CINEMA2K_24;
+ }else if(fps == 48 ){
+ parameters->cp_cinema = CINEMA2K_48;
+ }else {
+ fprintf(stderr,"Incorrect value!! must be 24 or 48\n");
+ return 1;
+ }
+ fprintf(stdout,"CINEMA 2K compliant codestream\n");
+ parameters->cp_rsiz = CINEMA2K;
+
+ }
+ break;
+
+ /* ------------------------------------------------------ */
+
+ case 'y': /* Digital Cinema 4K profile compliance*/
+ {
+ parameters->cp_cinema = CINEMA4K_24;
+ fprintf(stdout,"CINEMA 4K compliant codestream\n");
+ parameters->cp_rsiz = CINEMA4K;
+ }
+ break;
+
+ case 'm': /* output file */
+ {
+ char *lFilename = optarg;
+ char * lMatrix;
+ char *lCurrentPtr ;
+ int lNbComp = 0;
+ int lTotalComp;
+ int lMctComp;
+ float * lCurrentDoublePtr;
+ float * lSpace;
+ int * l_int_ptr;
+ int i;
+ int lStrLen;
+
+ FILE * lFile = fopen(lFilename,"r");
+ if
+ (lFile == NULL)
+ {
+ return 1;
+ }
+ fseek(lFile,0,SEEK_END);
+ lStrLen = ftell(lFile);
+ fseek(lFile,0,SEEK_SET);
+ lMatrix = (char *) malloc(lStrLen + 1);
+ fread(lMatrix,lStrLen,1,lFile);
+ fclose(lFile);
+ lMatrix[lStrLen] = 0;
+ lCurrentPtr = lMatrix;
+
+ // replace ',' by 0
+ while
+ (*lCurrentPtr != 0 )
+ {
+ if
+ (*lCurrentPtr == ' ')
+ {
+ *lCurrentPtr = 0;
+ ++lNbComp;
+ }
+ ++lCurrentPtr;
+ }
+ ++lNbComp;
+ lCurrentPtr = lMatrix;
+
+ lNbComp = (int) (sqrt(4*lNbComp + 1)/2. - 0.5);
+ lMctComp = lNbComp * lNbComp;
+ lTotalComp = lMctComp + lNbComp;
+ lSpace = (float *) malloc(lTotalComp * sizeof(float));
+ lCurrentDoublePtr = lSpace;
+ for
+ (i=0;i<lMctComp;++i)
+ {
+ lStrLen = strlen(lCurrentPtr) + 1;
+ *lCurrentDoublePtr++ = (float) atof(lCurrentPtr);
+ lCurrentPtr += lStrLen;
+ }
+ l_int_ptr = (int*) lCurrentDoublePtr;
+ for
+ (i=0;i<lNbComp;++i)
+ {
+ lStrLen = strlen(lCurrentPtr) + 1;
+ *l_int_ptr++ = atoi(lCurrentPtr);
+ lCurrentPtr += lStrLen;
+ }
+ opj_set_MCT(parameters,lSpace,(int *)(lSpace + lMctComp), lNbComp);
+ free(lSpace);
+ free(lMatrix);
+ }
+ break;
+
+ /* ------------------------------------------------------ */
+
+/* UniPG>> */
+#ifdef USE_JPWL
+ /* ------------------------------------------------------ */
+
+ case 'W': /* JPWL capabilities switched on */
+ {
+ char *token = NULL;
+ int hprot, pprot, sens, addr, size, range;
+
+ /* we need to enable indexing */
+ if (!indexfilename) {
+ strncpy(indexfilename, JPWL_PRIVATEINDEX_NAME, OPJ_PATH_LEN);
+ }
+
+ /* search for different protection methods */
+
+ /* break the option in comma points and parse the result */
+ token = strtok(optarg, ",");
+ while(token != NULL) {
+
+ /* search header error protection method */
+ if (*token == 'h') {
+
+ static int tile = 0, tilespec = 0, lasttileno = 0;
+
+ hprot = 1; /* predefined method */
+
+ if(sscanf(token, "h=%d", &hprot) == 1) {
+ /* Main header, specified */
+ if (!((hprot == 0) || (hprot == 1) || (hprot == 16) || (hprot == 32) ||
+ ((hprot >= 37) && (hprot <= 128)))) {
+ fprintf(stderr, "ERROR -> invalid main header protection method h = %d\n", hprot);
+ return 1;
+ }
+ parameters->jpwl_hprot_MH = hprot;
+
+ } else if(sscanf(token, "h%d=%d", &tile, &hprot) == 2) {
+ /* Tile part header, specified */
+ if (!((hprot == 0) || (hprot == 1) || (hprot == 16) || (hprot == 32) ||
+ ((hprot >= 37) && (hprot <= 128)))) {
+ fprintf(stderr, "ERROR -> invalid tile part header protection method h = %d\n", hprot);
+ return 1;
+ }
+ if (tile < 0) {
+ fprintf(stderr, "ERROR -> invalid tile part number on protection method t = %d\n", tile);
+ return 1;
+ }
+ if (tilespec < JPWL_MAX_NO_TILESPECS) {
+ parameters->jpwl_hprot_TPH_tileno[tilespec] = lasttileno = tile;
+ parameters->jpwl_hprot_TPH[tilespec++] = hprot;
+ }
+
+ } else if(sscanf(token, "h%d", &tile) == 1) {
+ /* Tile part header, unspecified */
+ if (tile < 0) {
+ fprintf(stderr, "ERROR -> invalid tile part number on protection method t = %d\n", tile);
+ return 1;
+ }
+ if (tilespec < JPWL_MAX_NO_TILESPECS) {
+ parameters->jpwl_hprot_TPH_tileno[tilespec] = lasttileno = tile;
+ parameters->jpwl_hprot_TPH[tilespec++] = hprot;
+ }
+
+
+ } else if (!strcmp(token, "h")) {
+ /* Main header, unspecified */
+ parameters->jpwl_hprot_MH = hprot;
+
+ } else {
+ fprintf(stderr, "ERROR -> invalid protection method selection = %s\n", token);
+ return 1;
+ };
+
+ }
+
+ /* search packet error protection method */
+ if (*token == 'p') {
+
+ static int pack = 0, tile = 0, packspec = 0, lastpackno = 0;
+
+ pprot = 1; /* predefined method */
+
+ if (sscanf(token, "p=%d", &pprot) == 1) {
+ /* Method for all tiles and all packets */
+ if (!((pprot == 0) || (pprot == 1) || (pprot == 16) || (pprot == 32) ||
+ ((pprot >= 37) && (pprot <= 128)))) {
+ fprintf(stderr, "ERROR -> invalid default packet protection method p = %d\n", pprot);
+ return 1;
+ }
+ parameters->jpwl_pprot_tileno[0] = 0;
+ parameters->jpwl_pprot_packno[0] = 0;
+ parameters->jpwl_pprot[0] = pprot;
+
+ } else if (sscanf(token, "p%d=%d", &tile, &pprot) == 2) {
+ /* method specified from that tile on */
+ if (!((pprot == 0) || (pprot == 1) || (pprot == 16) || (pprot == 32) ||
+ ((pprot >= 37) && (pprot <= 128)))) {
+ fprintf(stderr, "ERROR -> invalid packet protection method p = %d\n", pprot);
+ return 1;
+ }
+ if (tile < 0) {
+ fprintf(stderr, "ERROR -> invalid tile part number on protection method p = %d\n", tile);
+ return 1;
+ }
+ if (packspec < JPWL_MAX_NO_PACKSPECS) {
+ parameters->jpwl_pprot_tileno[packspec] = tile;
+ parameters->jpwl_pprot_packno[packspec] = 0;
+ parameters->jpwl_pprot[packspec++] = pprot;
+ }
+
+ } else if (sscanf(token, "p%d:%d=%d", &tile, &pack, &pprot) == 3) {
+ /* method fully specified from that tile and that packet on */
+ if (!((pprot == 0) || (pprot == 1) || (pprot == 16) || (pprot == 32) ||
+ ((pprot >= 37) && (pprot <= 128)))) {
+ fprintf(stderr, "ERROR -> invalid packet protection method p = %d\n", pprot);
+ return 1;
+ }
+ if (tile < 0) {
+ fprintf(stderr, "ERROR -> invalid tile part number on protection method p = %d\n", tile);
+ return 1;
+ }
+ if (pack < 0) {
+ fprintf(stderr, "ERROR -> invalid packet number on protection method p = %d\n", pack);
+ return 1;
+ }
+ if (packspec < JPWL_MAX_NO_PACKSPECS) {
+ parameters->jpwl_pprot_tileno[packspec] = tile;
+ parameters->jpwl_pprot_packno[packspec] = pack;
+ parameters->jpwl_pprot[packspec++] = pprot;
+ }
+
+ } else if (sscanf(token, "p%d:%d", &tile, &pack) == 2) {
+ /* default method from that tile and that packet on */
+ if (!((pprot == 0) || (pprot == 1) || (pprot == 16) || (pprot == 32) ||
+ ((pprot >= 37) && (pprot <= 128)))) {
+ fprintf(stderr, "ERROR -> invalid packet protection method p = %d\n", pprot);
+ return 1;
+ }
+ if (tile < 0) {
+ fprintf(stderr, "ERROR -> invalid tile part number on protection method p = %d\n", tile);
+ return 1;
+ }
+ if (pack < 0) {
+ fprintf(stderr, "ERROR -> invalid packet number on protection method p = %d\n", pack);
+ return 1;
+ }
+ if (packspec < JPWL_MAX_NO_PACKSPECS) {
+ parameters->jpwl_pprot_tileno[packspec] = tile;
+ parameters->jpwl_pprot_packno[packspec] = pack;
+ parameters->jpwl_pprot[packspec++] = pprot;
+ }
+
+ } else if (sscanf(token, "p%d", &tile) == 1) {
+ /* default from a tile on */
+ if (tile < 0) {
+ fprintf(stderr, "ERROR -> invalid tile part number on protection method p = %d\n", tile);
+ return 1;
+ }
+ if (packspec < JPWL_MAX_NO_PACKSPECS) {
+ parameters->jpwl_pprot_tileno[packspec] = tile;
+ parameters->jpwl_pprot_packno[packspec] = 0;
+ parameters->jpwl_pprot[packspec++] = pprot;
+ }
+
+
+ } else if (!strcmp(token, "p")) {
+ /* all default */
+ parameters->jpwl_pprot_tileno[0] = 0;
+ parameters->jpwl_pprot_packno[0] = 0;
+ parameters->jpwl_pprot[0] = pprot;
+
+ } else {
+ fprintf(stderr, "ERROR -> invalid protection method selection = %s\n", token);
+ return 1;
+ };
+
+ }
+
+ /* search sensitivity method */
+ if (*token == 's') {
+
+ static int tile = 0, tilespec = 0, lasttileno = 0;
+
+ sens = 0; /* predefined: relative error */
+
+ if(sscanf(token, "s=%d", &sens) == 1) {
+ /* Main header, specified */
+ if ((sens < -1) || (sens > 7)) {
+ fprintf(stderr, "ERROR -> invalid main header sensitivity method s = %d\n", sens);
+ return 1;
+ }
+ parameters->jpwl_sens_MH = sens;
+
+ } else if(sscanf(token, "s%d=%d", &tile, &sens) == 2) {
+ /* Tile part header, specified */
+ if ((sens < -1) || (sens > 7)) {
+ fprintf(stderr, "ERROR -> invalid tile part header sensitivity method s = %d\n", sens);
+ return 1;
+ }
+ if (tile < 0) {
+ fprintf(stderr, "ERROR -> invalid tile part number on sensitivity method t = %d\n", tile);
+ return 1;
+ }
+ if (tilespec < JPWL_MAX_NO_TILESPECS) {
+ parameters->jpwl_sens_TPH_tileno[tilespec] = lasttileno = tile;
+ parameters->jpwl_sens_TPH[tilespec++] = sens;
+ }
+
+ } else if(sscanf(token, "s%d", &tile) == 1) {
+ /* Tile part header, unspecified */
+ if (tile < 0) {
+ fprintf(stderr, "ERROR -> invalid tile part number on sensitivity method t = %d\n", tile);
+ return 1;
+ }
+ if (tilespec < JPWL_MAX_NO_TILESPECS) {
+ parameters->jpwl_sens_TPH_tileno[tilespec] = lasttileno = tile;
+ parameters->jpwl_sens_TPH[tilespec++] = hprot;
+ }
+
+ } else if (!strcmp(token, "s")) {
+ /* Main header, unspecified */
+ parameters->jpwl_sens_MH = sens;
+
+ } else {
+ fprintf(stderr, "ERROR -> invalid sensitivity method selection = %s\n", token);
+ return 1;
+ };
+
+ parameters->jpwl_sens_size = 2; /* 2 bytes for default size */
+ }
+
+ /* search addressing size */
+ if (*token == 'a') {
+
+ static int tile = 0, tilespec = 0, lasttileno = 0;
+
+ addr = 0; /* predefined: auto */
+
+ if(sscanf(token, "a=%d", &addr) == 1) {
+ /* Specified */
+ if ((addr != 0) && (addr != 2) && (addr != 4)) {
+ fprintf(stderr, "ERROR -> invalid addressing size a = %d\n", addr);
+ return 1;
+ }
+ parameters->jpwl_sens_addr = addr;
+
+ } else if (!strcmp(token, "a")) {
+ /* default */
+ parameters->jpwl_sens_addr = addr; /* auto for default size */
+
+ } else {
+ fprintf(stderr, "ERROR -> invalid addressing selection = %s\n", token);
+ return 1;
+ };
+
+ }
+
+ /* search sensitivity size */
+ if (*token == 'z') {
+
+ static int tile = 0, tilespec = 0, lasttileno = 0;
+
+ size = 1; /* predefined: 1 byte */
+
+ if(sscanf(token, "z=%d", &size) == 1) {
+ /* Specified */
+ if ((size != 0) && (size != 1) && (size != 2)) {
+ fprintf(stderr, "ERROR -> invalid sensitivity size z = %d\n", size);
+ return 1;
+ }
+ parameters->jpwl_sens_size = size;
+
+ } else if (!strcmp(token, "a")) {
+ /* default */
+ parameters->jpwl_sens_size = size; /* 1 for default size */
+
+ } else {
+ fprintf(stderr, "ERROR -> invalid size selection = %s\n", token);
+ return 1;
+ };
+
+ }
+
+ /* search range method */
+ if (*token == 'g') {
+
+ static int tile = 0, tilespec = 0, lasttileno = 0;
+
+ range = 0; /* predefined: 0 (packet) */
+
+ if(sscanf(token, "g=%d", &range) == 1) {
+ /* Specified */
+ if ((range < 0) || (range > 3)) {
+ fprintf(stderr, "ERROR -> invalid sensitivity range method g = %d\n", range);
+ return 1;
+ }
+ parameters->jpwl_sens_range = range;
+
+ } else if (!strcmp(token, "g")) {
+ /* default */
+ parameters->jpwl_sens_range = range;
+
+ } else {
+ fprintf(stderr, "ERROR -> invalid range selection = %s\n", token);
+ return 1;
+ };
+
+ }
+
+ /* next token or bust */
+ token = strtok(NULL, ",");
+ };
+
+
+ /* some info */
+ fprintf(stdout, "Info: JPWL capabilities enabled\n");
+ parameters->jpwl_epc_on = true;
+
+ }
+ break;
+#endif /* USE_JPWL */
+/* <<UniPG */
+
+ /* ------------------------------------------------------ */
+
+ default:
+ fprintf(stderr, "ERROR -> Command line not valid\n");
+ return 1;
+ }
+ }
+
+ /* check for possible errors */
+ if (parameters->cp_cinema){
+ if(parameters->tcp_numlayers > 1){
+ parameters->cp_rsiz = STD_RSIZ;
+ fprintf(stdout,"Warning: DC profiles do not allow more than one quality layer. The codestream created will not be compliant with the DC profile\n");
+ }
+ }
+ 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 formats are j2k and jp2!!\n");
+ return 1;
+ }
+ if(!((parameters->outfile[0] == 0))){
+ fprintf(stderr, "Error: options -ImgDir and -o cannot be used together !!\n");
+ fprintf(stderr, "Specify OutputFormat using -OutFor<FORMAT> !!\n");
+ return 1;
+ }
+ }else{
+ if((parameters->infile[0] == 0) || (parameters->outfile[0] == 0)) {
+ fprintf(stderr, "Error: One of the options; -i or -ImgDir must be specified\n");
+ fprintf(stderr, "Error: When using -i; -o must be used\n");
+ fprintf(stderr, "usage: image_to_j2k -i image-file -o j2k/jp2-file (+ options)\n");
+ return 1;
+ }
+ }
+
+ if (parameters->decod_format == RAW_DFMT && raw_cp->rawWidth == 0) {
+ fprintf(stderr,"\nError: invalid raw image parameters\n");
+ fprintf(stderr,"Please use the Format option -F:\n");
+ fprintf(stderr,"-F rawWidth,rawHeight,rawComp,rawBitDepth,s/u (Signed/Unsigned)\n");
+ fprintf(stderr,"Example: -i lena.raw -o lena.j2k -F 512,512,3,8,u\n");
+ fprintf(stderr,"Aborting\n");
+ return 1;
+ }
+
+ if ((parameters->cp_disto_alloc || parameters->cp_fixed_alloc || parameters->cp_fixed_quality)
+ && (!(parameters->cp_disto_alloc ^ parameters->cp_fixed_alloc ^ parameters->cp_fixed_quality))) {
+ fprintf(stderr, "Error: options -r -q and -f cannot be used together !!\n");
+ return 1;
+ } /* mod fixed_quality */
+
+ /* if no rate entered, lossless by default */
+ if (parameters->tcp_numlayers == 0) {
+ parameters->tcp_rates[0] = 0; /* MOD antonin : losslessbug */
+ parameters->tcp_numlayers++;
+ parameters->cp_disto_alloc = 1;
+ }
+
+ if((parameters->cp_tx0 > parameters->image_offset_x0) || (parameters->cp_ty0 > parameters->image_offset_y0)) {
+ fprintf(stderr,
+ "Error: Tile offset dimension is unnappropriate --> TX0(%d)<=IMG_X0(%d) TYO(%d)<=IMG_Y0(%d) \n",
+ parameters->cp_tx0, parameters->image_offset_x0, parameters->cp_ty0, parameters->image_offset_y0);
+ return 1;
+ }
+
+ for (i = 0; i < parameters->numpocs; i++) {
+ if (parameters->POC[i].prg == -1) {
+ fprintf(stderr,
+ "Unrecognized progression order in option -P (POC n %d) [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n",
+ i + 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 a FILE* client object
+*/
+void info_callback(const char *msg, void *client_data) {
+ FILE *stream = (FILE*)client_data;
+ fprintf(stream, "[INFO] %s", msg);
+}
+
+/* -------------------------------------------------------------------------- */
+
+int main(int argc, char **argv) {
+ bool bSuccess;
+ opj_cparameters_t parameters; /* compression parameters */
+ img_fol_t img_fol;
+ opj_image_t *image = NULL;
+ int i,num_images;
+ int imageno;
+ dircnt_t *dirptr;
+ raw_cparameters_t raw_cp;
+ opj_codestream_info_t cstr_info; /* Codestream information structure */
+ char indexfilename[OPJ_PATH_LEN]; /* index file name */
+ opj_stream_t *cio = 00;
+ opj_codec_t* cinfo = 00;
+ FILE *f = NULL;
+
+ /*
+ configure the event callbacks (not required)
+ setting of each callback is optionnal
+ */
+ /* set encoding parameters to default values */
+ opj_set_default_encoder_parameters(¶meters);
+
+ /* 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_encoder(argc, argv, ¶meters,&img_fol, &raw_cp, indexfilename) == 1) {
+ return 1;
+ }
+
+ if (parameters.cp_cinema){
+ img_fol.rates = (float*)malloc(parameters.tcp_numlayers * sizeof(float));
+ for(i=0; i< parameters.tcp_numlayers; i++){
+ img_fol.rates[i] = parameters.tcp_rates[i];
+ }
+ cinema_parameters(¶meters);
+ }
+
+ /* Create comment for codestream */
+ if(parameters.cp_comment == NULL) {
+ const char comment[] = "Created by OpenJPEG version ";
+ const size_t clen = strlen(comment);
+ const char *version = opj_version();
+/* UniPG>> */
+#ifdef USE_JPWL
+ parameters.cp_comment = (char*)malloc(clen+strlen(version)+11);
+ sprintf(parameters.cp_comment,"%s%s with JPWL", comment, version);
+#else
+ parameters.cp_comment = (char*)malloc(clen+strlen(version)+1);
+ sprintf(parameters.cp_comment,"%s%s", comment, version);
+#endif
+/* <<UniPG */
+ }
+
+ /* Read directory if necessary */
+ 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 0;
+ }
+ 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 0;
+ }
+ if (num_images==0){
+ fprintf(stdout,"Folder is empty\n");
+ return 0;
+ }
+ }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, ¶meters)) {
+ fprintf(stderr,"skipping file...\n");
+ continue;
+ }
+ }
+ switch(parameters.decod_format) {
+ case PGX_DFMT:
+ break;
+ case PXM_DFMT:
+ break;
+ case BMP_DFMT:
+ break;
+ case TIF_DFMT:
+ break;
+ case RAW_DFMT:
+ break;
+ case TGA_DFMT:
+ break;
+ default:
+ fprintf(stderr,"skipping file...\n");
+ continue;
+ }
+
+ /* decode the source image */
+ /* ----------------------- */
+
+ switch (parameters.decod_format) {
+ case PGX_DFMT:
+ image = pgxtoimage(parameters.infile, ¶meters);
+ if (!image) {
+ fprintf(stderr, "Unable to load pgx file\n");
+ return 1;
+ }
+ break;
+
+ case PXM_DFMT:
+ image = pnmtoimage(parameters.infile, ¶meters);
+ if (!image) {
+ fprintf(stderr, "Unable to load pnm file\n");
+ return 1;
+ }
+ break;
+
+ case BMP_DFMT:
+ image = bmptoimage(parameters.infile, ¶meters);
+ if (!image) {
+ fprintf(stderr, "Unable to load bmp file\n");
+ return 1;
+ }
+ break;
+
+ case TIF_DFMT:
+ image = tiftoimage(parameters.infile, ¶meters);
+ if (!image) {
+ fprintf(stderr, "Unable to load tiff file\n");
+ return 1;
+ }
+ break;
+
+ case RAW_DFMT:
+ image = rawtoimage(parameters.infile, ¶meters, &raw_cp);
+ if (!image) {
+ fprintf(stderr, "Unable to load raw file\n");
+ return 1;
+ }
+ break;
+
+ case TGA_DFMT:
+ image = tgatoimage(parameters.infile, ¶meters);
+ if (!image) {
+ fprintf(stderr, "Unable to load tga file\n");
+ return 1;
+ }
+ break;
+ }
+ /* Decide if MCT should be used */
+ parameters.tcp_mct = image->numcomps == 3 ? 1 : 0;
+
+ if(parameters.cp_cinema){
+ cinema_setup_encoder(¶meters,image,&img_fol);
+ }
+
+ /* encode the destination image */
+ /* ---------------------------- */
+
+
+ cinfo = parameters.cod_format == J2K_CFMT ? opj_create_compress(CODEC_J2K) : opj_create_compress(CODEC_JP2);
+ opj_setup_encoder(cinfo, ¶meters, image);
+ f = fopen(parameters.outfile, "wb");
+ if
+ (! f)
+ {
+ fprintf(stderr, "failed to encode image\n");
+ return 1;
+ }
+ /* open a byte stream for writing */
+ /* allocate memory for all tiles */
+ cio = opj_stream_create_default_file_stream(f,false);
+ if
+ (! cio)
+ {
+ return 1;
+ }
+ /* encode the image */
+ /*if (*indexfilename) // If need to extract codestream information
+ bSuccess = opj_encode_with_info(cinfo, cio, image, &cstr_info);
+ else*/
+ bSuccess = opj_start_compress(cinfo,image,cio);
+ bSuccess = bSuccess && opj_encode(cinfo, cio);
+ bSuccess = bSuccess && opj_end_compress(cinfo, cio);
+
+ if
+ (!bSuccess)
+ {
+ opj_stream_destroy(cio);
+ fclose(f);
+ fprintf(stderr, "failed to encode image\n");
+ return 1;
+ }
+
+ fprintf(stderr,"Generated outfile %s\n",parameters.outfile);
+ /* close and free the byte stream */
+ opj_stream_destroy(cio);
+ fclose(f);
+
+ /* Write the index to disk */
+ if (*indexfilename) {
+ bSuccess = write_index_file(&cstr_info, indexfilename);
+ if (bSuccess) {
+ fprintf(stderr, "Failed to output index file\n");
+ }
+ }
+
+ /* free remaining compression structures */
+ opj_destroy_codec(cinfo);
+ if (*indexfilename)
+ opj_destroy_cstr_info(&cstr_info);
+
+ /* free image data */
+ opj_image_destroy(image);
+ }
+
+ /* free user parameters structure */
+ if(parameters.cp_comment) free(parameters.cp_comment);
+ if(parameters.cp_matrice) free(parameters.cp_matrice);
+
+ return 0;
+}
diff --git a/v2/codec/index.c b/v2/codec/index.c new file mode 100755 index 00000000..2e0283dd --- /dev/null +++ b/v2/codec/index.c @@ -0,0 +1,391 @@ +/*
+ * 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);
+
+ 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;
+}
diff --git a/v2/codec/index.h b/v2/codec/index.h new file mode 100755 index 00000000..29f673a1 --- /dev/null +++ b/v2/codec/index.h @@ -0,0 +1,49 @@ +/*
+ * 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 */
+
diff --git a/v2/codec/j2k_to_image.c b/v2/codec/j2k_to_image.c new file mode 100755 index 00000000..950e8ca6 --- /dev/null +++ b/v2/codec/j2k_to_image.c @@ -0,0 +1,745 @@ +/*
+ * 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>
+#define __USE_BSD
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#define USE_OPJ_DEPRECATED
+#include "openjpeg.h"
+#include "compat/getopt.h"
+#include "convert.h"
+#include "dirent.h"
+#include "index.h"
+
+#ifndef WIN32
+#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*/
+ 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," -OutFor \n");
+ fprintf(stdout," REQUIRED only if -ImgDir is used\n");
+ fprintf(stdout," Need to specify only format without filename <BMP> \n");
+ fprintf(stdout," Currently accepts PGM, PPM, PNM, PGX, BMP, TIF, RAW and TGA formats\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," -o <decompressed file>\n");
+ fprintf(stdout," REQUIRED\n");
+ fprintf(stdout," Currently accepts PGM, PPM, PNM, PGX, BMP, TIF, RAW and TGA files\n");
+ fprintf(stdout," Binary data is written to the file (not ascii). If a PGX\n");
+ fprintf(stdout," filename is given, there will be as many output files as there are\n");
+ fprintf(stdout," components: an indice starting from 0 will then be appended to the\n");
+ fprintf(stdout," output filename, just before the \"pgx\" extension. If a PGM filename\n");
+ fprintf(stdout," is given and there are more than one component, only the first component\n");
+ fprintf(stdout," will be written to the file.\n");
+ fprintf(stdout," -r <reduce factor>\n");
+ fprintf(stdout," Set the number of highest resolution levels to be discarded. The\n");
+ fprintf(stdout," image resolution is effectively divided by 2 to the power of the\n");
+ fprintf(stdout," number of discarded levels. The reduce factor is limited by the\n");
+ fprintf(stdout," smallest total number of decomposition levels among tiles.\n");
+ fprintf(stdout," -l <number of quality layers to decode>\n");
+ fprintf(stdout," Set the maximum number of quality layers to decode. If there are\n");
+ fprintf(stdout," less quality layers than the specified number, all the quality layers\n");
+ fprintf(stdout," are decoded.\n");
+ fprintf(stdout," -x \n");
+ fprintf(stdout," Create an index file *.Idx (-x index_name.Idx) \n");
+ fprintf(stdout,"\n");
+/* UniPG>> */
+#ifdef USE_JPWL
+ fprintf(stdout," -W <options>\n");
+ fprintf(stdout," Activates the JPWL correction capability, if the codestream complies.\n");
+ fprintf(stdout," Options can be a comma separated list of <param=val> tokens:\n");
+ fprintf(stdout," c, c=numcomps\n");
+ fprintf(stdout," numcomps is the number of expected components in the codestream\n");
+ fprintf(stdout," (search of first EPB rely upon this, default is %d)\n", JPWL_EXPECTED_COMPONENTS);
+#endif /* USE_JPWL */
+/* <<UniPG */
+ 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" };
+ 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 };
+ 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'},
+ {"OutFor",REQ_ARG, NULL ,'O'},
+ };
+
+ const char optlist[] = "i:o:r:l:hx:"
+
+/* UniPG>> */
+#ifdef USE_JPWL
+ "W:"
+#endif /* USE_JPWL */
+/* <<UniPG */
+ ;
+ 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 'o': /* output file */
+ {
+ char *outfile = optarg;
+ parameters->cod_format = get_file_format(outfile);
+ switch(parameters->cod_format) {
+ case PGX_DFMT:
+ case PXM_DFMT:
+ case BMP_DFMT:
+ case TIF_DFMT:
+ case RAW_DFMT:
+ case TGA_DFMT:
+ break;
+ default:
+ fprintf(stderr, "Unknown output format image %s [only *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!! \n", outfile);
+ return 1;
+ }
+ strncpy(parameters->outfile, outfile, sizeof(parameters->outfile)-1);
+ }
+ break;
+
+ /* ----------------------------------------------------- */
+
+ case 'O': /* output format */
+ {
+ char outformat[50];
+ char *of = optarg;
+ sprintf(outformat,".%s",of);
+ img_fol->set_out_format = 1;
+ parameters->cod_format = get_file_format(outformat);
+ switch(parameters->cod_format) {
+ case PGX_DFMT:
+ img_fol->out_format = "pgx";
+ break;
+ case PXM_DFMT:
+ img_fol->out_format = "ppm";
+ break;
+ case BMP_DFMT:
+ img_fol->out_format = "bmp";
+ break;
+ case TIF_DFMT:
+ img_fol->out_format = "tif";
+ break;
+ case RAW_DFMT:
+ img_fol->out_format = "raw";
+ break;
+ case TGA_DFMT:
+ img_fol->out_format = "raw";
+ break;
+ default:
+ fprintf(stderr, "Unknown output format image %s [only *.pnm, *.pgm, *.ppm, *.pgx, *.bmp, *.tif, *.raw or *.tga]!! \n", outformat);
+ return 1;
+ break;
+ }
+ }
+ break;
+
+ /* ----------------------------------------------------- */
+
+
+ case 'r': /* reduce option */
+ {
+ sscanf(optarg, "%d", ¶meters->cp_reduce);
+ }
+ break;
+
+ /* ----------------------------------------------------- */
+
+
+ case 'l': /* layering option */
+ {
+ sscanf(optarg, "%d", ¶meters->cp_layer);
+ }
+ 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;
+ /* ----------------------------------------------------- */
+ case 'x': /* Creation of index file */
+ {
+ char *index = optarg;
+ strncpy(indexfilename, index, OPJ_PATH_LEN);
+ }
+ break;
+ /* ----------------------------------------------------- */
+ /* UniPG>> */
+#ifdef USE_JPWL
+
+ case 'W': /* activate JPWL correction */
+ {
+ char *token = NULL;
+
+ token = strtok(optarg, ",");
+ while(token != NULL) {
+
+ /* search expected number of components */
+ if (*token == 'c') {
+
+ static int compno;
+
+ compno = JPWL_EXPECTED_COMPONENTS; /* predefined no. of components */
+
+ if(sscanf(token, "c=%d", &compno) == 1) {
+ /* Specified */
+ if ((compno < 1) || (compno > 256)) {
+ fprintf(stderr, "ERROR -> invalid number of components c = %d\n", compno);
+ return 1;
+ }
+ parameters->jpwl_exp_comps = compno;
+
+ } else if (!strcmp(token, "c")) {
+ /* default */
+ parameters->jpwl_exp_comps = compno; /* auto for default size */
+
+ } else {
+ fprintf(stderr, "ERROR -> invalid components specified = %s\n", token);
+ return 1;
+ };
+ }
+
+ /* search maximum number of tiles */
+ if (*token == 't') {
+
+ static int tileno;
+
+ tileno = JPWL_MAXIMUM_TILES; /* maximum no. of tiles */
+
+ if(sscanf(token, "t=%d", &tileno) == 1) {
+ /* Specified */
+ if ((tileno < 1) || (tileno > JPWL_MAXIMUM_TILES)) {
+ fprintf(stderr, "ERROR -> invalid number of tiles t = %d\n", tileno);
+ return 1;
+ }
+ parameters->jpwl_max_tiles = tileno;
+
+ } else if (!strcmp(token, "t")) {
+ /* default */
+ parameters->jpwl_max_tiles = tileno; /* auto for default size */
+
+ } else {
+ fprintf(stderr, "ERROR -> invalid tiles specified = %s\n", token);
+ return 1;
+ };
+ }
+
+ /* next token or bust */
+ token = strtok(NULL, ",");
+ };
+ parameters->jpwl_correct = true;
+ fprintf(stdout, "JPWL correction capability activated\n");
+ fprintf(stdout, "- expecting %d components\n", parameters->jpwl_exp_comps);
+ }
+ break;
+#endif /* USE_JPWL */
+/* <<UniPG */
+
+ /* ----------------------------------------------------- */
+
+ 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) || (parameters->outfile[0] == 0)) {
+ fprintf(stderr, "Error: One of the options -i or -ImgDir must be specified\n");
+ fprintf(stderr, "Error: When using -i, -o must be used\n");
+ fprintf(stderr, "usage: image_to_j2k -i *.j2k/jp2/j2c -o *.pgm/ppm/pnm/pgx/bmp/tif/raw/tga(+ 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)
+{
+ 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(¶meters);
+
+ /* 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, ¶meters,&img_fol, indexfilename) == 1) {
+ return 1;
+ }
+
+ /* 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 0;
+ }
+ 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 0;
+ }
+ if (num_images==0){
+ fprintf(stdout,"Folder is empty\n");
+ return 0;
+ }
+ }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, ¶meters)) {
+ 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 1;
+ }
+ 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, ¶meters);
+
+ /* 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 1;
+ }
+
+ /* 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");
+ }
+ }
+
+ /* create output image */
+ /* ------------------- */
+ switch (parameters.cod_format) {
+ case PXM_DFMT: /* PNM PGM PPM */
+ if (imagetopnm(image, parameters.outfile)) {
+ fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
+ }
+ else {
+ fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
+ }
+ break;
+
+ case PGX_DFMT: /* PGX */
+ if(imagetopgx(image, parameters.outfile)){
+ fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
+ }
+ else {
+ fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
+ }
+ break;
+
+ case BMP_DFMT: /* BMP */
+ if(imagetobmp(image, parameters.outfile)){
+ fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
+ }
+ else {
+ fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
+ }
+ break;
+
+ case TIF_DFMT: /* TIFF */
+ if(imagetotif(image, parameters.outfile)){
+ fprintf(stdout,"Outfile %s not generated\n",parameters.outfile);
+ }
+ else {
+ fprintf(stdout,"Generated Outfile %s\n",parameters.outfile);
+ }
+ break;
+
+ case RAW_DFMT: /* RAW */
+ if(imagetoraw(image, parameters.outfile)){
+ fprintf(stdout,"Error generating raw file. Outfile %s not generated\n",parameters.outfile);
+ }
+ else {
+ fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
+ }
+ break;
+
+ case TGA_DFMT: /* TGA */
+ if(imagetotga(image, parameters.outfile)){
+ fprintf(stdout,"Error generating tga file. Outfile %s not generated\n",parameters.outfile);
+ }
+ else {
+ fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile);
+ }
+ break;
+ }
+
+ /* 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 0;
+}
+//end main
+
+
+
+
diff --git a/v2/libopenjpeg/CMakeLists.txt b/v2/libopenjpeg/CMakeLists.txt new file mode 100755 index 00000000..492c7196 --- /dev/null +++ b/v2/libopenjpeg/CMakeLists.txt @@ -0,0 +1,73 @@ +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})
+
+# Install library
+INSTALL(TARGETS ${OPENJPEG_LIBRARY_NAME}
+ DESTINATION lib)
+
+# Install includes files
+INSTALL(FILES openjpeg.h
+ DESTINATION ${INCLUDE_INSTALL_DIR}/openjpeg)
diff --git a/v2/libopenjpeg/bio.c b/v2/libopenjpeg/bio.c new file mode 100755 index 00000000..81a1081f --- /dev/null +++ b/v2/libopenjpeg/bio.c @@ -0,0 +1,189 @@ +/*
+ * 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) 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 "bio.h"
+#include "opj_malloc.h"
+
+/** @defgroup BIO BIO - Individual bit input-output stream */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+/**
+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);
+
+/*@}*/
+
+/*@}*/
+
+/*
+==========================================================
+ local functions
+==========================================================
+*/
+
+static bool bio_byteout(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->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;
+}
+
+/*
+==========================================================
+ Bit Input/Output interface
+==========================================================
+*/
+
+opj_bio_t* bio_create(void) {
+ opj_bio_t *bio = (opj_bio_t*)opj_malloc(sizeof(opj_bio_t));
+ return bio;
+}
+
+void bio_destroy(opj_bio_t *bio) {
+ if(bio) {
+ opj_free(bio);
+ }
+}
+
+OPJ_UINT32 bio_numbytes(opj_bio_t *bio) {
+ return (bio->bp - bio->start);
+}
+
+void bio_init_enc(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 = 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;
+ for (i = n - 1; i != -1 ; --i) {
+ v += bio_getbit(bio) << i;
+ }
+ return v;
+}
+
+bool bio_flush(opj_bio_t *bio) {
+ bio->ct = 0;
+ if (bio_byteout(bio)) {
+ return true;
+ }
+ if (bio->ct == 7) {
+ bio->ct = 0;
+ if (bio_byteout(bio)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool bio_inalign(opj_bio_t *bio) {
+ bio->ct = 0;
+ if ((bio->buf & 0xff) == 0xff) {
+ if (bio_bytein(bio)) {
+ return true;
+ }
+ bio->ct = 0;
+ }
+ return false;
+}
diff --git a/v2/libopenjpeg/bio.h b/v2/libopenjpeg/bio.h new file mode 100755 index 00000000..2e6feec3 --- /dev/null +++ b/v2/libopenjpeg/bio.h @@ -0,0 +1,126 @@ +/*
+ * 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) 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 __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.
+*/
+#include "openjpeg.h"
+/** @defgroup BIO BIO - Individual bit input-output stream */
+/*@{*/
+
+/**
+Individual bit input-output stream (BIO)
+*/
+typedef struct opj_bio {
+ /** 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 */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Create a new BIO handle
+@return Returns a new BIO handle if successful, returns NULL otherwise
+*/
+opj_bio_t* bio_create(void);
+/**
+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);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __BIO_H */
+
diff --git a/v2/libopenjpeg/cio.c b/v2/libopenjpeg/cio.c new file mode 100755 index 00000000..81c1cca7 --- /dev/null +++ b/v2/libopenjpeg/cio.c @@ -0,0 +1,820 @@ +/*
+ * 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) 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 "cio.h"
+#include "opj_includes.h"
+#include "opj_malloc.h"
+#include "event.h"
+
+/* ----------------------------------------------------------------------- */
+
+
+/**
+ * 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)
+{
+ const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + p_nb_bytes;
+ 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.
+ * @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)
+{
+ const OPJ_BYTE * l_data_ptr = ((const OPJ_BYTE *) &p_value) + p_nb_bytes - 1;
+ 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.
+ * @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_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_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;
+ }
+
+ 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.
+ *
+ * @return the current position o fthe stream.
+ */
+OPJ_SIZE_T opj_stream_tell (const opj_stream_private_t * p_stream)
+{
+ return p_stream->m_byte_offset;
+}
+
+/**
+ * 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, opj_event_mgr_t * p_event_mgr)
+{
+ return p_stream->m_opj_skip(p_stream,p_size,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.
+ */
+bool opj_stream_read_seek (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, opj_event_mgr_t * p_event_mgr)
+{
+ p_stream->m_current_data = p_stream->m_stored_data;
+ p_stream->m_bytes_in_buffer = 0;
+ if
+ (! 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.
+ * @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_write_seek (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, opj_event_mgr_t * p_event_mgr)
+{
+ if
+ (! opj_stream_flush(p_stream,p_event_mgr))
+ {
+ 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;
+
+ if
+ (! p_stream->m_seek_fn(p_size,p_stream->m_user_data))
+ {
+ 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)
+{
+ return p_stream->m_opj_seek(p_stream,p_size,p_event_mgr);
+}
+
+/**
+ * Tells if the given stream is seekable.
+ */
+bool opj_stream_has_seek (const opj_stream_private_t * p_stream)
+{
+ return p_stream->m_seek_fn != opj_stream_default_seek;
+}
+
+
+
+
+
+OPJ_UINT32 opj_stream_default_read (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data)
+{
+ return (OPJ_UINT32) -1;
+}
+OPJ_UINT32 opj_stream_default_write (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data)
+{
+ 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)
+{
+ return false;
+}
+
+
+
diff --git a/v2/libopenjpeg/cio.h b/v2/libopenjpeg/cio.h new file mode 100755 index 00000000..6315e8f4 --- /dev/null +++ b/v2/libopenjpeg/cio.h @@ -0,0 +1,359 @@ +/*
+ * 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) 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 __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.
+*/
+
+/** @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.
+ *
+ * @return the current position o fthe stream.
+ */
+OPJ_SIZE_T opj_stream_tell (const opj_stream_private_t * p_stream);
+
+/**
+ * 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, 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_read_skip (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, 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.
+ */
+bool opj_stream_read_seek (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, 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.
+ */
+bool opj_stream_write_seek (opj_stream_private_t * p_stream, OPJ_SIZE_T p_size, struct opj_event_mgr * p_event_mgr);
+
+/**
+ * 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);
+
+/**
+ * Tells if the given stream is seekable.
+ */
+bool opj_stream_has_seek (const opj_stream_private_t * p_stream);
+
+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);
+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);
+
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __CIO_H */
+
diff --git a/v2/libopenjpeg/dwt.c b/v2/libopenjpeg/dwt.c new file mode 100755 index 00000000..0e41f805 --- /dev/null +++ b/v2/libopenjpeg/dwt.c @@ -0,0 +1,873 @@ +/*
+ * 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) 2007, Jonathan Ballard <dzonatas@dzonux.net>
+ * 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.
+ */
+
+#ifdef __SSE__
+#include <xmmintrin.h>
+#endif
+
+#include "dwt.h"
+#include "j2k.h"
+#include "tcd.h"
+#include "fix.h"
+#include "opj_malloc.h"
+#include "int.h"
+
+/** @defgroup DWT DWT - Implementation of a discrete wavelet transform */
+/*@{*/
+
+#define WS(i) v->mem[(i)*2]
+#define WD(i) v->mem[(1+(i)*2)]
+
+/** @name Local data structures */
+/*@{*/
+
+typedef struct dwt_local {
+ OPJ_INT32* mem;
+ OPJ_INT32 dn;
+ OPJ_INT32 sn;
+ OPJ_INT32 cas;
+} dwt_t;
+
+typedef union {
+ OPJ_FLOAT32 f[4];
+} v4;
+
+typedef struct v4dwt_local {
+ v4* wavelet ;
+ OPJ_INT32 dn ;
+ OPJ_INT32 sn ;
+ OPJ_INT32 cas ;
+} v4dwt_t ;
+
+static const OPJ_FLOAT32 dwt_alpha = 1.586134342f; // 12994
+static const OPJ_FLOAT32 dwt_beta = 0.052980118f; // 434
+static const OPJ_FLOAT32 dwt_gamma = -0.882911075f; // -7233
+static const OPJ_FLOAT32 delta = -0.443506852f; // -3633
+
+static const OPJ_FLOAT32 K = 1.230174105f; // 10078
+/* FIXME: What is this constant? */
+static const OPJ_FLOAT32 c13318 = 1.625732422f;
+
+/*@}*/
+
+/**
+Virtual function type for wavelet transform in 1-D
+*/
+typedef void (*DWT1DFN)(dwt_t* v);
+
+/** @name Local static functions */
+/*@{*/
+
+/**
+Forward lazy transform (horizontal)
+*/
+static void dwt_deinterleave_h(OPJ_INT32 *a, OPJ_INT32 *b, OPJ_INT32 dn, OPJ_INT32 sn, OPJ_INT32 cas);
+/**
+Forward lazy transform (vertical)
+*/
+static void dwt_deinterleave_v(OPJ_INT32 *a, OPJ_INT32 *b, OPJ_INT32 dn, OPJ_INT32 sn, OPJ_INT32 x, OPJ_INT32 cas);
+/**
+Inverse lazy transform (horizontal)
+*/
+static void dwt_interleave_h(dwt_t* h, OPJ_INT32 *a);
+/**
+Inverse lazy transform (vertical)
+*/
+static void dwt_interleave_v(dwt_t* v, OPJ_INT32 *a, OPJ_INT32 x);
+/**
+Forward 5-3 wavelet transform in 1-D
+*/
+static void dwt_encode_1(OPJ_INT32 *a, OPJ_INT32 dn, OPJ_INT32 sn, OPJ_INT32 cas);
+/**
+Inverse 5-3 wavelet transform in 1-D
+*/
+static void dwt_decode_1(dwt_t *v);
+/**
+Forward 9-7 wavelet transform in 1-D
+*/
+static void dwt_encode_1_real(OPJ_INT32 *a, OPJ_INT32 dn, OPJ_INT32 sn, OPJ_INT32 cas);
+/**
+Explicit calculation of the Quantization Stepsizes
+*/
+static void dwt_encode_stepsize(OPJ_INT32 stepsize, OPJ_INT32 numbps, opj_stepsize_t *bandno_stepsize);
+/**
+Inverse wavelet transform in 2-D.
+*/
+static bool dwt_decode_tile(opj_tcd_tilecomp_t* tilec, OPJ_UINT32 i, DWT1DFN fn);
+
+static OPJ_UINT32 dwt_max_resolution(opj_tcd_resolution_t* restrict r, OPJ_UINT32 i);
+
+static INLINE bool dwt_encode_procedure(opj_tcd_tilecomp_t * tilec,void (*p_function)(OPJ_INT32 *, OPJ_INT32,OPJ_INT32,OPJ_INT32) );
+/*@}*/
+
+/*@}*/
+
+#define S(i) a[(i)*2]
+#define D(i) a[(1+(i)*2)]
+#define S_(i) ((i)<0?S(0):((i)>=sn?S(sn-1):S(i)))
+#define D_(i) ((i)<0?D(0):((i)>=dn?D(dn-1):D(i)))
+/* new */
+#define SS_(i) ((i)<0?S(0):((i)>=dn?S(dn-1):S(i)))
+#define DD_(i) ((i)<0?D(0):((i)>=sn?D(sn-1):D(i)))
+
+/* <summary> */
+/* This table contains the norms of the 5-3 wavelets for different bands. */
+/* </summary> */
+static const OPJ_FLOAT64 dwt_norms[4][10] = {
+ {1.000, 1.500, 2.750, 5.375, 10.68, 21.34, 42.67, 85.33, 170.7, 341.3},
+ {1.038, 1.592, 2.919, 5.703, 11.33, 22.64, 45.25, 90.48, 180.9},
+ {1.038, 1.592, 2.919, 5.703, 11.33, 22.64, 45.25, 90.48, 180.9},
+ {.7186, .9218, 1.586, 3.043, 6.019, 12.01, 24.00, 47.97, 95.93}
+};
+
+/* <summary> */
+/* This table contains the norms of the 9-7 wavelets for different bands. */
+/* </summary> */
+static const OPJ_FLOAT64 dwt_norms_real[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}
+};
+
+/*
+==========================================================
+ local functions
+==========================================================
+*/
+
+/* <summary> */
+/* Forward lazy transform (horizontal). */
+/* </summary> */
+static void dwt_deinterleave_h(OPJ_INT32 *a, OPJ_INT32 *b, OPJ_INT32 dn, OPJ_INT32 sn, OPJ_INT32 cas) {
+ OPJ_INT32 i;
+
+ OPJ_INT32 * l_dest = b;
+ OPJ_INT32 * l_src = a+cas;
+ for
+ (i=0; i<sn; ++i)
+ {
+ *l_dest++ = *l_src;
+ l_src += 2;
+ }
+ l_dest = b + sn;
+ l_src = a + 1 - cas;
+ for
+ (i=0; i<dn; ++i)
+ {
+ *l_dest++=*l_src;
+ l_src += 2;
+ }
+}
+
+/* <summary> */
+/* Forward lazy transform (vertical). */
+/* </summary> */
+static void dwt_deinterleave_v(OPJ_INT32 *a, OPJ_INT32 *b, OPJ_INT32 dn, OPJ_INT32 sn, OPJ_INT32 x, OPJ_INT32 cas) {
+ OPJ_INT32 i = sn;
+ OPJ_INT32 * l_dest = b;
+ OPJ_INT32 * l_src = a+cas;
+
+ while
+ (i--)
+ {
+ *l_dest = *l_src;
+ l_dest += x;
+ l_src += 2;
+ /* b[i*x]=a[2*i+cas]; */
+ }
+ l_dest = b + sn * x;
+ l_src = a + 1 - cas;
+
+ i = dn;
+ while
+ (i--)
+ {
+ *l_dest = *l_src;
+ l_dest += x;
+ l_src += 2;
+ /*b[(sn+i)*x]=a[(2*i+1-cas)];*/
+ }
+}
+
+/* <summary> */
+/* Inverse lazy transform (horizontal). */
+/* </summary> */
+static void dwt_interleave_h(dwt_t* h, OPJ_INT32 *a) {
+ OPJ_INT32 *ai = a;
+ OPJ_INT32 *bi = h->mem + h->cas;
+ OPJ_INT32 i = h->sn;
+ while
+ ( i-- )
+ {
+ *bi = *(ai++);
+ bi += 2;
+ }
+ ai = a + h->sn;
+ bi = h->mem + 1 - h->cas;
+ i = h->dn ;
+ while
+ ( i-- )
+ {
+ *bi = *(ai++);
+ bi += 2;
+ }
+}
+
+/* <summary> */
+/* Inverse lazy transform (vertical). */
+/* </summary> */
+static void dwt_interleave_v(dwt_t* v, OPJ_INT32 *a, OPJ_INT32 x) {
+ OPJ_INT32 *ai = a;
+ OPJ_INT32 *bi = v->mem + v->cas;
+ OPJ_INT32 i = v->sn;
+ while( i-- ) {
+ *bi = *ai;
+ bi += 2;
+ ai += x;
+ }
+ ai = a + (v->sn * x);
+ bi = v->mem + 1 - v->cas;
+ i = v->dn ;
+ while( i-- ) {
+ *bi = *ai;
+ bi += 2;
+ ai += x;
+ }
+}
+
+
+/* <summary> */
+/* Forward 5-3 wavelet transform in 1-D. */
+/* </summary> */
+static void dwt_encode_1(OPJ_INT32 *a, OPJ_INT32 dn, OPJ_INT32 sn, OPJ_INT32 cas) {
+ OPJ_INT32 i;
+
+ if (!cas) {
+ if ((dn > 0) || (sn > 1)) { /* NEW : CASE ONE ELEMENT */
+ for (i = 0; i < dn; i++) D(i) -= (S_(i) + S_(i + 1)) >> 1;
+ for (i = 0; i < sn; i++) S(i) += (D_(i - 1) + D_(i) + 2) >> 2;
+ }
+ } else {
+ if (!sn && dn == 1) /* NEW : CASE ONE ELEMENT */
+ S(0) *= 2;
+ else {
+ for (i = 0; i < dn; i++) S(i) -= (DD_(i) + DD_(i - 1)) >> 1;
+ for (i = 0; i < sn; i++) D(i) += (SS_(i) + SS_(i + 1) + 2) >> 2;
+ }
+ }
+}
+
+/* <summary> */
+/* Inverse 5-3 wavelet transform in 1-D. */
+/* </summary> */
+static void dwt_decode_1_(OPJ_INT32 *a, OPJ_INT32 dn, OPJ_INT32 sn, OPJ_INT32 cas) {
+ OPJ_INT32 i;
+
+ if (!cas) {
+ if ((dn > 0) || (sn > 1)) { /* NEW : CASE ONE ELEMENT */
+ for (i = 0; i < sn; i++) S(i) -= (D_(i - 1) + D_(i) + 2) >> 2;
+ for (i = 0; i < dn; i++) D(i) += (S_(i) + S_(i + 1)) >> 1;
+ }
+ } else {
+ if (!sn && dn == 1) /* NEW : CASE ONE ELEMENT */
+ S(0) /= 2;
+ else {
+ for (i = 0; i < sn; i++) D(i) -= (SS_(i) + SS_(i + 1) + 2) >> 2;
+ for (i = 0; i < dn; i++) S(i) += (DD_(i) + DD_(i - 1)) >> 1;
+ }
+ }
+}
+
+/* <summary> */
+/* Inverse 5-3 wavelet transform in 1-D. */
+/* </summary> */
+static void dwt_decode_1(dwt_t *v) {
+ dwt_decode_1_(v->mem, v->dn, v->sn, v->cas);
+}
+
+/* <summary> */
+/* Forward 9-7 wavelet transform in 1-D. */
+/* </summary> */
+static void dwt_encode_1_real(OPJ_INT32 *a, OPJ_INT32 dn, OPJ_INT32 sn, OPJ_INT32 cas) {
+ OPJ_INT32 i;
+ if (!cas) {
+ if ((dn > 0) || (sn > 1)) { /* NEW : CASE ONE ELEMENT */
+ for (i = 0; i < dn; i++)
+ D(i) -= fix_mul(S_(i) + S_(i + 1), 12993);
+ for (i = 0; i < sn; i++)
+ S(i) -= fix_mul(D_(i - 1) + D_(i), 434);
+ for (i = 0; i < dn; i++)
+ D(i) += fix_mul(S_(i) + S_(i + 1), 7233);
+ for (i = 0; i < sn; i++)
+ S(i) += fix_mul(D_(i - 1) + D_(i), 3633);
+ for (i = 0; i < dn; i++)
+ D(i) = fix_mul(D(i), 5038); /*5038 */
+ for (i = 0; i < sn; i++)
+ S(i) = fix_mul(S(i), 6659); /*6660 */
+ }
+ } else {
+ if ((sn > 0) || (dn > 1)) { /* NEW : CASE ONE ELEMENT */
+ for (i = 0; i < dn; i++)
+ S(i) -= fix_mul(DD_(i) + DD_(i - 1), 12993);
+ for (i = 0; i < sn; i++)
+ D(i) -= fix_mul(SS_(i) + SS_(i + 1), 434);
+ for (i = 0; i < dn; i++)
+ S(i) += fix_mul(DD_(i) + DD_(i - 1), 7233);
+ for (i = 0; i < sn; i++)
+ D(i) += fix_mul(SS_(i) + SS_(i + 1), 3633);
+ for (i = 0; i < dn; i++)
+ S(i) = fix_mul(S(i), 5038); /*5038 */
+ for (i = 0; i < sn; i++)
+ D(i) = fix_mul(D(i), 6659); /*6660 */
+ }
+ }
+}
+
+static void dwt_encode_stepsize(OPJ_INT32 stepsize, OPJ_INT32 numbps, opj_stepsize_t *bandno_stepsize) {
+ OPJ_INT32 p, n;
+ p = int_floorlog2(stepsize) - 13;
+ n = 11 - int_floorlog2(stepsize);
+ bandno_stepsize->mant = (n < 0 ? stepsize >> -n : stepsize << n) & 0x7ff;
+ bandno_stepsize->expn = numbps - p;
+}
+
+/*
+==========================================================
+ DWT interface
+==========================================================
+*/
+
+/* <summary> */
+/* Forward 5-3 wavelet transform in 2-D. */
+/* </summary> */
+INLINE bool dwt_encode_procedure(opj_tcd_tilecomp_t * tilec,void (*p_function)(OPJ_INT32 *, OPJ_INT32,OPJ_INT32,OPJ_INT32) )
+{
+ OPJ_INT32 i, j, k;
+ OPJ_INT32 *a = 00;
+ OPJ_INT32 *aj = 00;
+ OPJ_INT32 *bj = 00;
+ OPJ_INT32 w, l;
+
+ OPJ_INT32 rw; /* width of the resolution level computed */
+ OPJ_INT32 rh; /* height of the resolution level computed */
+ OPJ_INT32 l_data_size;
+
+ opj_tcd_resolution_t * l_cur_res = 0;
+ opj_tcd_resolution_t * l_last_res = 0;
+
+ w = tilec->x1-tilec->x0;
+ l = tilec->numresolutions-1;
+ a = tilec->data;
+
+ l_cur_res = tilec->resolutions + l;
+ l_last_res = l_cur_res - 1;
+
+ rw = l_cur_res->x1 - l_cur_res->x0;
+ rh = l_cur_res->y1 - l_cur_res->y0;
+
+ l_data_size = dwt_max_resolution( tilec->resolutions,tilec->numresolutions) * sizeof(OPJ_INT32);
+ bj = opj_malloc(l_data_size);
+ if
+ (! bj)
+ {
+ return false;
+ }
+ i = l;
+
+ while
+ (i--)
+ {
+ OPJ_INT32 rw1; /* width of the resolution level once lower than computed one */
+ OPJ_INT32 rh1; /* height of the resolution level once lower than computed one */
+ OPJ_INT32 cas_col; /* 0 = non inversion on horizontal filtering 1 = inversion between low-pass and high-pass filtering */
+ OPJ_INT32 cas_row; /* 0 = non inversion on vertical filtering 1 = inversion between low-pass and high-pass filtering */
+ OPJ_INT32 dn, sn;
+
+ rw = l_cur_res->x1 - l_cur_res->x0;
+ rh = l_cur_res->y1 - l_cur_res->y0;
+ rw1 = l_last_res->x1 - l_last_res->x0;
+ rh1 = l_last_res->y1 - l_last_res->y0;
+
+ cas_row = l_cur_res->x0 & 1;
+ cas_col = l_cur_res->y0 & 1;
+
+ sn = rh1;
+ dn = rh - rh1;
+ for
+ (j = 0; j < rw; ++j)
+ {
+ aj = a + j;
+ for
+ (k = 0; k < rh; ++k)
+ {
+ bj[k] = aj[k*w];
+ }
+ (*p_function) (bj, dn, sn, cas_col);
+ dwt_deinterleave_v(bj, aj, dn, sn, w, cas_col);
+ }
+ sn = rw1;
+ dn = rw - rw1;
+ for (j = 0; j < rh; j++)
+ {
+ aj = a + j * w;
+ for (k = 0; k < rw; k++) bj[k] = aj[k];
+ (*p_function) (bj, dn, sn, cas_row);
+ dwt_deinterleave_h(bj, aj, dn, sn, cas_row);
+ }
+ l_cur_res = l_last_res;
+ --l_last_res;
+ }
+ opj_free(bj);
+ return true;
+}
+/* Forward 5-3 wavelet transform in 2-D. */
+/* </summary> */
+bool dwt_encode(opj_tcd_tilecomp_t * tilec)
+{
+ return dwt_encode_procedure(tilec,dwt_encode_1);
+}
+
+/* <summary> */
+/* Inverse 5-3 wavelet transform in 2-D. */
+/* </summary> */
+bool dwt_decode(opj_tcd_tilecomp_t* tilec, OPJ_UINT32 numres) {
+ return dwt_decode_tile(tilec, numres, &dwt_decode_1);
+}
+
+
+/* <summary> */
+/* Get gain of 5-3 wavelet transform. */
+/* </summary> */
+OPJ_UINT32 dwt_getgain(OPJ_UINT32 orient) {
+ if (orient == 0)
+ return 0;
+ if (orient == 1 || orient == 2)
+ return 1;
+ return 2;
+}
+
+/* <summary> */
+/* Get norm of 5-3 wavelet. */
+/* </summary> */
+OPJ_FLOAT64 dwt_getnorm(OPJ_UINT32 level, OPJ_UINT32 orient) {
+ return dwt_norms[orient][level];
+}
+
+/* <summary> */
+/* Forward 9-7 wavelet transform in 2-D. */
+/* </summary> */
+bool dwt_encode_real(opj_tcd_tilecomp_t * tilec)
+{
+ return dwt_encode_procedure(tilec,dwt_encode_1_real);
+}
+
+
+
+/* <summary> */
+/* Get gain of 9-7 wavelet transform. */
+/* </summary> */
+OPJ_UINT32 dwt_getgain_real(OPJ_UINT32 orient) {
+ (void)orient;
+ return 0;
+}
+
+/* <summary> */
+/* Get norm of 9-7 wavelet. */
+/* </summary> */
+OPJ_FLOAT64 dwt_getnorm_real(OPJ_UINT32 level, OPJ_UINT32 orient) {
+ return dwt_norms_real[orient][level];
+}
+
+void dwt_calc_explicit_stepsizes(opj_tccp_t * tccp, OPJ_UINT32 prec) {
+ OPJ_UINT32 numbands, bandno;
+ numbands = 3 * tccp->numresolutions - 2;
+ for (bandno = 0; bandno < numbands; bandno++) {
+ OPJ_FLOAT64 stepsize;
+ OPJ_UINT32 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 {
+ OPJ_FLOAT64 norm = dwt_norms_real[orient][level];
+ stepsize = (1 << (gain)) / norm;
+ }
+ dwt_encode_stepsize((OPJ_INT32) floor(stepsize * 8192.0), prec + gain, &tccp->stepsizes[bandno]);
+ }
+}
+
+
+/* <summary> */
+/* Determine maximum computed resolution level for inverse wavelet transform */
+/* </summary> */
+static OPJ_UINT32 dwt_max_resolution(opj_tcd_resolution_t* restrict r, OPJ_UINT32 i) {
+ OPJ_UINT32 mr = 0;
+ OPJ_UINT32 w;
+ while( --i ) {
+ ++r;
+ if( mr < ( w = r->x1 - r->x0 ) )
+ mr = w ;
+ if( mr < ( w = r->y1 - r->y0 ) )
+ mr = w ;
+ }
+ return mr ;
+}
+
+
+/* <summary> */
+/* Inverse wavelet transform in 2-D. */
+/* </summary> */
+static bool dwt_decode_tile(opj_tcd_tilecomp_t* tilec, OPJ_UINT32 numres, DWT1DFN dwt_1D) {
+ dwt_t h;
+ dwt_t v;
+
+ opj_tcd_resolution_t* tr = tilec->resolutions;
+
+ OPJ_UINT32 rw = tr->x1 - tr->x0; /* width of the resolution level computed */
+ OPJ_UINT32 rh = tr->y1 - tr->y0; /* height of the resolution level computed */
+
+ OPJ_UINT32 w = tilec->x1 - tilec->x0;
+
+ h.mem = opj_aligned_malloc(dwt_max_resolution(tr, numres) * sizeof(OPJ_INT32));
+ if
+ (! h.mem)
+ {
+ return false;
+ }
+
+ v.mem = h.mem;
+
+ while( --numres) {
+ OPJ_INT32 * restrict tiledp = tilec->data;
+ OPJ_UINT32 j;
+
+ ++tr;
+ h.sn = rw;
+ v.sn = rh;
+
+ rw = tr->x1 - tr->x0;
+ rh = tr->y1 - tr->y0;
+
+ h.dn = rw - h.sn;
+ h.cas = tr->x0 % 2;
+
+ for(j = 0; j < rh; ++j) {
+ dwt_interleave_h(&h, &tiledp[j*w]);
+ (dwt_1D)(&h);
+ memcpy(&tiledp[j*w], h.mem, rw * sizeof(OPJ_INT32));
+ }
+
+ v.dn = rh - v.sn;
+ v.cas = tr->y0 % 2;
+
+ for(j = 0; j < rw; ++j){
+ OPJ_UINT32 k;
+ dwt_interleave_v(&v, &tiledp[j], w);
+ (dwt_1D)(&v);
+ for(k = 0; k < rh; ++k) {
+ tiledp[k * w + j] = v.mem[k];
+ }
+ }
+ }
+ opj_aligned_free(h.mem);
+ return true;
+}
+
+static void v4dwt_interleave_h(v4dwt_t* restrict w, OPJ_FLOAT32* restrict a, OPJ_INT32 x, OPJ_INT32 size){
+ OPJ_FLOAT32* restrict bi = (OPJ_FLOAT32*) (w->wavelet + w->cas);
+ OPJ_INT32 count = w->sn;
+ OPJ_INT32 i, k;
+ for(k = 0; k < 2; ++k){
+ for(i = 0; i < count; ++i){
+ OPJ_INT32 j = i;
+ bi[i*8 ] = a[j];
+ j += x;
+ if(j >= size) continue;
+ bi[i*8 + 1] = a[j];
+ j += x;
+ if(j >= size) continue;
+ bi[i*8 + 2] = a[j];
+ j += x;
+ if(j >= size) continue;
+ bi[i*8 + 3] = a[j];
+ }
+ bi = (OPJ_FLOAT32*) (w->wavelet + 1 - w->cas);
+ a += w->sn;
+ size -= w->sn;
+ count = w->dn;
+ }
+}
+
+static void v4dwt_interleave_v(v4dwt_t* restrict v , OPJ_FLOAT32* restrict a , OPJ_INT32 x){
+ v4* restrict bi = v->wavelet + v->cas;
+ OPJ_INT32 i;
+ for(i = 0; i < v->sn; ++i){
+ memcpy(&bi[i*2], &a[i*x], 4 * sizeof(OPJ_FLOAT32));
+ }
+ a += v->sn * x;
+ bi = v->wavelet + 1 - v->cas;
+ for(i = 0; i < v->dn; ++i){
+ memcpy(&bi[i*2], &a[i*x], 4 * sizeof(OPJ_FLOAT32));
+ }
+}
+
+#ifdef __SSE__
+
+static void v4dwt_decode_step1_sse(v4* w, OPJ_INT32 count, const __m128 c){
+ __m128* restrict vw = (__m128*) w;
+ OPJ_INT32 i;
+ for(i = 0; i < count; ++i){
+ __m128 tmp = vw[i*2];
+ vw[i*2] = tmp * c;
+ }
+}
+
+static void v4dwt_decode_step2_sse(v4* l, v4* w, OPJ_INT32 k, OPJ_INT32 m, __m128 c){
+ __m128* restrict vl = (__m128*) l;
+ __m128* restrict vw = (__m128*) w;
+ OPJ_INT32 i;
+ for(i = 0; i < m; ++i){
+ __m128 tmp1 = vl[ 0];
+ __m128 tmp2 = vw[-1];
+ __m128 tmp3 = vw[ 0];
+ vw[-1] = tmp2 + ((tmp1 + tmp3) * c);
+ vl = vw;
+ vw += 2;
+ }
+ if(m >= k){
+ return;
+ }
+ c += c;
+ c *= vl[0];
+ for(; m < k; ++m){
+ __m128 tmp = vw[-1];
+ vw[-1] = tmp + c;
+ vw += 2;
+ }
+}
+
+#else
+
+static void v4dwt_decode_step1(v4* w, OPJ_INT32 count, const OPJ_FLOAT32 c){
+ OPJ_FLOAT32* restrict fw = (OPJ_FLOAT32*) w;
+ OPJ_INT32 i;
+ for(i = 0; i < count; ++i){
+ OPJ_FLOAT32 tmp1 = fw[i*8 ];
+ OPJ_FLOAT32 tmp2 = fw[i*8 + 1];
+ OPJ_FLOAT32 tmp3 = fw[i*8 + 2];
+ OPJ_FLOAT32 tmp4 = fw[i*8 + 3];
+ fw[i*8 ] = tmp1 * c;
+ fw[i*8 + 1] = tmp2 * c;
+ fw[i*8 + 2] = tmp3 * c;
+ fw[i*8 + 3] = tmp4 * c;
+ }
+}
+
+static void v4dwt_decode_step2(v4* l, v4* w, OPJ_INT32 k, OPJ_INT32 m, OPJ_FLOAT32 c){
+ OPJ_FLOAT32* restrict fl = (OPJ_FLOAT32*) l;
+ OPJ_FLOAT32* restrict fw = (OPJ_FLOAT32*) w;
+ OPJ_INT32 i;
+ for(i = 0; i < m; ++i){
+ OPJ_FLOAT32 tmp1_1 = fl[0];
+ OPJ_FLOAT32 tmp1_2 = fl[1];
+ OPJ_FLOAT32 tmp1_3 = fl[2];
+ OPJ_FLOAT32 tmp1_4 = fl[3];
+ OPJ_FLOAT32 tmp2_1 = fw[-4];
+ OPJ_FLOAT32 tmp2_2 = fw[-3];
+ OPJ_FLOAT32 tmp2_3 = fw[-2];
+ OPJ_FLOAT32 tmp2_4 = fw[-1];
+ OPJ_FLOAT32 tmp3_1 = fw[0];
+ OPJ_FLOAT32 tmp3_2 = fw[1];
+ OPJ_FLOAT32 tmp3_3 = fw[2];
+ OPJ_FLOAT32 tmp3_4 = fw[3];
+ fw[-4] = tmp2_1 + ((tmp1_1 + tmp3_1) * c);
+ fw[-3] = tmp2_2 + ((tmp1_2 + tmp3_2) * c);
+ fw[-2] = tmp2_3 + ((tmp1_3 + tmp3_3) * c);
+ fw[-1] = tmp2_4 + ((tmp1_4 + tmp3_4) * c);
+ fl = fw;
+ fw += 8;
+ }
+ if(m < k){
+ OPJ_FLOAT32 c1;
+ OPJ_FLOAT32 c2;
+ OPJ_FLOAT32 c3;
+ OPJ_FLOAT32 c4;
+ c += c;
+ c1 = fl[0] * c;
+ c2 = fl[1] * c;
+ c3 = fl[2] * c;
+ c4 = fl[3] * c;
+ for(; m < k; ++m){
+ OPJ_FLOAT32 tmp1 = fw[-4];
+ OPJ_FLOAT32 tmp2 = fw[-3];
+ OPJ_FLOAT32 tmp3 = fw[-2];
+ OPJ_FLOAT32 tmp4 = fw[-1];
+ fw[-4] = tmp1 + c1;
+ fw[-3] = tmp2 + c2;
+ fw[-2] = tmp3 + c3;
+ fw[-1] = tmp4 + c4;
+ fw += 8;
+ }
+ }
+}
+
+#endif
+
+/* <summary> */
+/* Inverse 9-7 wavelet transform in 1-D. */
+/* </summary> */
+static void v4dwt_decode(v4dwt_t* restrict dwt){
+ OPJ_INT32 a, b;
+ if(dwt->cas == 0) {
+ if(!((dwt->dn > 0) || (dwt->sn > 1))){
+ return;
+ }
+ a = 0;
+ b = 1;
+ }else{
+ if(!((dwt->sn > 0) || (dwt->dn > 1))) {
+ return;
+ }
+ a = 1;
+ b = 0;
+ }
+#ifdef __SSE__
+ v4dwt_decode_step1_sse(dwt->wavelet+a, dwt->sn, _mm_set1_ps(K));
+ v4dwt_decode_step1_sse(dwt->wavelet+b, dwt->dn, _mm_set1_ps(c13318));
+ v4dwt_decode_step2_sse(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), _mm_set1_ps(delta));
+ v4dwt_decode_step2_sse(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), _mm_set1_ps(dwt_gamma));
+ v4dwt_decode_step2_sse(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), _mm_set1_ps(dwt_beta));
+ v4dwt_decode_step2_sse(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), _mm_set1_ps(dwt_alpha));
+#else
+ v4dwt_decode_step1(dwt->wavelet+a, dwt->sn, K);
+ v4dwt_decode_step1(dwt->wavelet+b, dwt->dn, c13318);
+ v4dwt_decode_step2(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), delta);
+ v4dwt_decode_step2(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), dwt_gamma);
+ v4dwt_decode_step2(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), dwt_beta);
+ v4dwt_decode_step2(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), dwt_alpha);
+#endif
+}
+
+/* <summary> */
+/* Inverse 9-7 wavelet transform in 2-D. */
+/* </summary> */
+bool dwt_decode_real(opj_tcd_tilecomp_t* restrict tilec, OPJ_UINT32 numres){
+ v4dwt_t h;
+ v4dwt_t v;
+
+ opj_tcd_resolution_t* res = tilec->resolutions;
+
+ OPJ_UINT32 rw = res->x1 - res->x0; /* width of the resolution level computed */
+ OPJ_UINT32 rh = res->y1 - res->y0; /* height of the resolution level computed */
+
+ OPJ_UINT32 w = tilec->x1 - tilec->x0;
+
+ h.wavelet = (v4*) opj_aligned_malloc((dwt_max_resolution(res, numres)+5) * sizeof(v4));
+ v.wavelet = h.wavelet;
+
+ while( --numres) {
+ OPJ_FLOAT32 * restrict aj = (OPJ_FLOAT32*) tilec->data;
+ OPJ_UINT32 bufsize = (tilec->x1 - tilec->x0) * (tilec->y1 - tilec->y0);
+ OPJ_INT32 j;
+
+ h.sn = rw;
+ v.sn = rh;
+
+ ++res;
+
+ rw = res->x1 - res->x0; /* width of the resolution level computed */
+ rh = res->y1 - res->y0; /* height of the resolution level computed */
+
+ h.dn = rw - h.sn;
+ h.cas = res->x0 & 1;
+
+ for(j = rh; j > 0; j -= 4){
+ v4dwt_interleave_h(&h, aj, w, bufsize);
+ v4dwt_decode(&h);
+ if(j >= 4){
+ OPJ_INT32 k = rw;
+ while
+ (--k >= 0)
+ {
+ aj[k ] = h.wavelet[k].f[0];
+ aj[k+w ] = h.wavelet[k].f[1];
+ aj[k+w*2] = h.wavelet[k].f[2];
+ aj[k+w*3] = h.wavelet[k].f[3];
+ }
+ }else{
+ OPJ_INT32 k = rw;
+ while
+ (--k >= 0)
+ {
+ switch(j) {
+ case 3: aj[k+w*2] = h.wavelet[k].f[2];
+ case 2: aj[k+w ] = h.wavelet[k].f[1];
+ case 1: aj[k ] = h.wavelet[k].f[0];
+ }
+ }
+ }
+ aj += w*4;
+ bufsize -= w*4;
+ }
+
+ v.dn = rh - v.sn;
+ v.cas = res->y0 % 2;
+
+ aj = (OPJ_FLOAT32*) tilec->data;
+ for(j = rw; j > 0; j -= 4){
+ v4dwt_interleave_v(&v, aj, w);
+ v4dwt_decode(&v);
+ if(j >= 4){
+ OPJ_UINT32 k;
+ for(k = 0; k < rh; ++k){
+ memcpy(&aj[k*w], &v.wavelet[k], 4 * sizeof(OPJ_FLOAT32));
+ }
+ }else{
+ OPJ_UINT32 k;
+ for(k = 0; k < rh; ++k){
+ memcpy(&aj[k*w], &v.wavelet[k], j * sizeof(OPJ_FLOAT32));
+ }
+ }
+ aj += 4;
+ }
+ }
+
+ opj_aligned_free(h.wavelet);
+ return true;
+}
+
diff --git a/v2/libopenjpeg/dwt.h b/v2/libopenjpeg/dwt.h new file mode 100755 index 00000000..2729c5d0 --- /dev/null +++ b/v2/libopenjpeg/dwt.h @@ -0,0 +1,118 @@ +/*
+ * 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) 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 __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
+DWT.C are used by some function in TCD.C.
+*/
+#include "openjpeg.h"
+
+struct opj_tcd_tilecomp;
+struct opj_tccp;
+
+/** @defgroup DWT DWT - Implementation of a discrete wavelet transform */
+/*@{*/
+
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+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);
+/**
+Inverse 5-3 wavelet tranform in 2-D.
+Apply a reversible 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(struct opj_tcd_tilecomp* tilec, OPJ_UINT32 numres);
+/**
+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);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __DWT_H */
diff --git a/v2/libopenjpeg/event.c b/v2/libopenjpeg/event.c new file mode 100755 index 00000000..71d52861 --- /dev/null +++ b/v2/libopenjpeg/event.c @@ -0,0 +1,96 @@ +/*
+ * Copyright (c) 2005, Hervé 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;
+}
+
diff --git a/v2/libopenjpeg/event.h b/v2/libopenjpeg/event.h new file mode 100755 index 00000000..7d5bb6af --- /dev/null +++ b/v2/libopenjpeg/event.h @@ -0,0 +1,86 @@ +/*
+ * Copyright (c) 2005, Hervé 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 */
diff --git a/v2/libopenjpeg/fix.h b/v2/libopenjpeg/fix.h new file mode 100755 index 00000000..40295c27 --- /dev/null +++ b/v2/libopenjpeg/fix.h @@ -0,0 +1,60 @@ +/*
+ * 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.
+ */
+#ifndef __FIX_H
+#define __FIX_H
+
+#include "openjpeg.h"
+#include "opj_includes.h"
+
+/**
+@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 */
diff --git a/v2/libopenjpeg/function_list.c b/v2/libopenjpeg/function_list.c new file mode 100755 index 00000000..54fe818f --- /dev/null +++ b/v2/libopenjpeg/function_list.c @@ -0,0 +1,147 @@ +/*
+ * 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 = 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 = 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;
+}
diff --git a/v2/libopenjpeg/function_list.h b/v2/libopenjpeg/function_list.h new file mode 100755 index 00000000..c3f82ca1 --- /dev/null +++ b/v2/libopenjpeg/function_list.h @@ -0,0 +1,131 @@ +/*
+ * 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 */
+
diff --git a/v2/libopenjpeg/image.c b/v2/libopenjpeg/image.c new file mode 100755 index 00000000..11b5fc1b --- /dev/null +++ b/v2/libopenjpeg/image.c @@ -0,0 +1,175 @@ +/*
+ * Copyright (c) 2005, Hervé 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;
+ }
+}
+
diff --git a/v2/libopenjpeg/image.h b/v2/libopenjpeg/image.h new file mode 100755 index 00000000..bcdca0e4 --- /dev/null +++ b/v2/libopenjpeg/image.h @@ -0,0 +1,58 @@ +/*
+ * Copyright (c) 2005, Hervé 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 __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.
+*/
+struct opj_image;
+struct opj_cp;
+/** @defgroup IMAGE IMAGE - Implementation of operations on images */
+/*@{*/
+
+/**
+Create an empty image
+@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.
+ * @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);
+
+/*@}*/
+
+#endif /* __IMAGE_H */
+
diff --git a/v2/libopenjpeg/int.h b/v2/libopenjpeg/int.h new file mode 100755 index 00000000..5012cf67 --- /dev/null +++ b/v2/libopenjpeg/int.h @@ -0,0 +1,159 @@ +/*
+ * 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) 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 __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.
+*/
+#include "openjpeg.h"
+#include "opj_includes.h"
+/** @defgroup INT INT - Implementation of operations on integers */
+/*@{*/
+
+/** @name Exported functions (see also openjpeg.h) */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+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) {
+ return a < b ? a : b;
+}
+
+/**
+Get the minimum of two integers
+@return Returns a if a < b else b
+*/
+static INLINE OPJ_UINT32 uint_min(OPJ_UINT32 a, OPJ_UINT32 b) {
+ return a < b ? a : b;
+}
+
+/**
+Get the maximum of two integers
+@return Returns a if a > b else b
+*/
+static INLINE OPJ_INT32 int_max(OPJ_INT32 a, OPJ_INT32 b) {
+ return (a > b) ? a : b;
+}
+
+/**
+Get the maximum of two integers
+@return Returns a if a > b else b
+*/
+static INLINE OPJ_UINT32 uint_max(OPJ_UINT32 a, OPJ_UINT32 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
+@return Returns a divided by b
+*/
+static INLINE OPJ_UINT32 uint_ceildiv(OPJ_UINT32 a, OPJ_UINT32 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
+@return Returns log2(a)
+*/
+static INLINE OPJ_UINT32 uint_floorlog2(OPJ_UINT32 a) {
+ OPJ_UINT32 l;
+ for (l = 0; a > 1; ++l)
+ {
+ a >>= 1;
+ }
+ return l;
+}
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif
diff --git a/v2/libopenjpeg/invert.c b/v2/libopenjpeg/invert.c new file mode 100755 index 00000000..2c38f538 --- /dev/null +++ b/v2/libopenjpeg/invert.c @@ -0,0 +1,291 @@ +/*
+ * 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;
+ }
+ }
+}
+
diff --git a/v2/libopenjpeg/invert.h b/v2/libopenjpeg/invert.h new file mode 100755 index 00000000..cbb717fd --- /dev/null +++ b/v2/libopenjpeg/invert.h @@ -0,0 +1,40 @@ +/*
+ * 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
+
diff --git a/v2/libopenjpeg/j2k.c b/v2/libopenjpeg/j2k.c new file mode 100755 index 00000000..5b293fd0 --- /dev/null +++ b/v2/libopenjpeg/j2k.c @@ -0,0 +1,9307 @@ +/*
+ * 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 "j2k.h"
+#include "opj_malloc.h"
+#include "opj_includes.h"
+#include "pi.h"
+#include "event.h"
+#include "cio.h"
+#include "int.h"
+#include "tcd.h"
+#include "function_list.h"
+#include "invert.h"
+#include "dwt.h"
+#include "mct.h"
+#include "image.h"
+
+/** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */
+/*@{*/
+
+
+/***************************************************************************
+ ********************** TYPEDEFS *******************************************
+ ***************************************************************************/
+/**
+ * Correspondance prog order <-> string representation
+ */
+typedef struct j2k_prog_order
+{
+ OPJ_PROG_ORDER enum_prog;
+ OPJ_CHAR str_prog[4];
+}
+j2k_prog_order_t;
+
+typedef struct opj_dec_memory_marker_handler
+{
+ /** marker value */
+ OPJ_UINT32 id;
+ /** value of the state when the marker can appear */
+ OPJ_UINT32 states;
+ /** action linked to the marker */
+ bool (*handler) (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+}
+opj_dec_memory_marker_handler_t;
+
+
+
+/** @name Local static functions */
+/*@{*/
+/**
+ * Writes a SPCod or SPCoc element, i.e. the coding style of a given component of a tile.
+ *
+ * @param p_comp_no the component number to output.
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+ *
+*/
+static bool j2k_write_SPCod_SPCoc(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_tile_no,
+ OPJ_UINT32 p_comp_no,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Reads a SPCod or SPCoc element, i.e. the coding style of a given component of a tile.
+ * @param p_header_data the data contained in the COM box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the COM marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_SPCod_SPCoc(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 compno,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 * p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Gets the size taken by writting a SPCod or SPCoc for the given tile and component.
+ *
+ * @param p_tile_no the tile indix.
+ * @param p_comp_no the component being outputted.
+ * @param p_j2k the J2K codec.
+ *
+ * @return the number of bytes taken by the SPCod element.
+ */
+static OPJ_UINT32 j2k_get_SPCod_SPCoc_size (
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_tile_no,
+ OPJ_UINT32 p_comp_no
+ );
+
+/**
+ * Writes a SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
+ *
+ * @param p_tile_no the tile to output.
+ * @param p_comp_no the component number to output.
+ * @param p_data the data buffer.
+ * @param p_header_size pointer to the size of the data buffer, it is changed by the function.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+ *
+*/
+static bool j2k_write_SQcd_SQcc(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_tile_no,
+ OPJ_UINT32 p_comp_no,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Reads a SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
+ *
+ * @param p_tile_no the tile to output.
+ * @param p_comp_no the component number to output.
+ * @param p_data the data buffer.
+ * @param p_header_size pointer to the size of the data buffer, it is changed by the function.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+ *
+*/
+static bool j2k_read_SQcd_SQcc(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 compno,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 * p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Updates the Tile Length Marker.
+ */
+static void j2k_update_tlm (
+ opj_j2k_t * p_j2k,
+ OPJ_UINT32 p_tile_part_size);
+
+/**
+ * Gets the size taken by writting SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
+ *
+ * @param p_tile_no the tile indix.
+ * @param p_comp_no the component being outputted.
+ * @param p_j2k the J2K codec.
+ *
+ * @return the number of bytes taken by the SPCod element.
+ */
+static OPJ_UINT32 j2k_get_SQcd_SQcc_size (
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_tile_no,
+ OPJ_UINT32 p_comp_no
+
+ );
+
+/**
+ * Copies the tile component parameters of all the component from the first tile component.
+ *
+ * @param p_j2k the J2k codec.
+ */
+static void j2k_copy_tile_component_parameters(
+ opj_j2k_t *p_j2k
+ );
+
+/**
+ * Writes the SOC marker (Start Of Codestream)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+
+static bool j2k_write_soc(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Reads a SOC marker (Start of Codestream)
+ * @param p_header_data the data contained in the SOC box.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_header_size the size of the data contained in the SOC marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_soc(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Writes the SIZ marker (image and tile size)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_siz(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Writes the CBD-MCT-MCC-MCO markers (Multi components transform)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_mct_data_group(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Reads a SIZ marker (image and tile size)
+ * @param p_header_data the data contained in the SIZ box.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_header_size the size of the data contained in the SIZ marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_siz (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Writes the COM marker (comment)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_com(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Reads a COM marker (comments)
+ * @param p_header_data the data contained in the COM box.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_header_size the size of the data contained in the COM marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_com (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+
+
+
+/**
+ * Writes the COD marker (Coding style default)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_cod(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Reads a COD marker (Coding Styke defaults)
+ * @param p_header_data the data contained in the COD box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the COD marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_cod (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Writes the COC marker (Coding style component)
+ *
+ * @param p_comp_number the index of the component to output.
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_coc(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_comp_number,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Writes the COC marker (Coding style component)
+ *
+ * @param p_comp_no the index of the component to output.
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static void j2k_write_coc_in_memory(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_comp_no,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_data_written,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Gets the maximum size taken by a coc.
+ *
+ * @param p_j2k the jpeg2000 codec to use.
+ */
+static OPJ_UINT32 j2k_get_max_coc_size(opj_j2k_t *p_j2k);
+
+/**
+ * Reads a COC marker (Coding Style Component)
+ * @param p_header_data the data contained in the COC box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the COC marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_coc (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Writes the QCD marker (quantization default)
+ *
+ * @param p_comp_number the index of the component to output.
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_qcd(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+
+/**
+ * Reads a QCD marker (Quantization defaults)
+ * @param p_header_data the data contained in the QCD box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the QCD marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_qcd (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Writes the QCC marker (quantization component)
+ *
+ * @param p_comp_no the index of the component to output.
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_qcc(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_comp_no,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Writes the QCC marker (quantization component)
+ *
+ * @param p_comp_no the index of the component to output.
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static void j2k_write_qcc_in_memory(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_comp_no,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_data_written,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Gets the maximum size taken by a qcc.
+ */
+static OPJ_UINT32 j2k_get_max_qcc_size (opj_j2k_t *p_j2k);
+
+/**
+ * Reads a QCC marker (Quantization component)
+ * @param p_header_data the data contained in the QCC box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the QCC marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_qcc(
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager);
+/**
+ * Writes the POC marker (Progression Order Change)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_poc(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Writes the updated tlm.
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_updated_tlm(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Writes the POC marker (Progression Order Change)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+ */
+static void j2k_write_poc_in_memory(
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_data_written,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Gets the maximum size taken by the writting of a POC.
+ */
+static OPJ_UINT32 j2k_get_max_poc_size(opj_j2k_t *p_j2k);
+
+/**
+ * Gets the maximum size taken by the toc headers of all the tile parts of any given tile.
+ */
+static OPJ_UINT32 j2k_get_max_toc_size (opj_j2k_t *p_j2k);
+
+/**
+ * Gets the maximum size taken by the headers of the SOT.
+ *
+ * @param p_j2k the jpeg2000 codec to use.
+ */
+static OPJ_UINT32 j2k_get_specific_header_sizes(opj_j2k_t *p_j2k);
+
+/**
+ * Reads a POC marker (Progression Order Change)
+ *
+ * @param p_header_data the data contained in the POC box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the POC marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_poc (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Reads a CRG marker (Component registration)
+ *
+ * @param p_header_data the data contained in the TLM box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the TLM marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_crg (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Reads a TLM marker (Tile Length Marker)
+ *
+ * @param p_header_data the data contained in the TLM box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the TLM marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_tlm (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Reads a PLM marker (Packet length, main header marker)
+ *
+ * @param p_header_data the data contained in the TLM box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the TLM marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_plm (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Reads a PLT marker (Packet length, tile-part header)
+ *
+ * @param p_header_data the data contained in the PLT box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the PLT marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_plt (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Reads a PPM marker (Packed packet headers, main header)
+ *
+ * @param p_header_data the data contained in the POC box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the POC marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_ppm (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Reads a PPT marker (Packed packet headers, tile-part header)
+ *
+ * @param p_header_data the data contained in the PPT box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the PPT marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_ppt (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Writes the TLM marker (Tile Length Marker)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_tlm(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Writes the SOT marker (Start of tile-part)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_sot(
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_data_written,
+ const struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Reads a PPT marker (Packed packet headers, tile-part header)
+ *
+ * @param p_header_data the data contained in the PPT box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the PPT marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_sot (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Writes the SOD marker (Start of data)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_sod(
+ opj_j2k_t *p_j2k,
+ struct opj_tcd * p_tile_coder,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_data_written,
+ OPJ_UINT32 p_total_data_size,
+ const struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Reads a SOD marker (Start Of Data)
+ *
+ * @param p_header_data the data contained in the SOD box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the SOD marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_sod (
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Writes the RGN marker (Region Of Interest)
+ *
+ * @param p_tile_no the tile to output
+ * @param p_comp_no the component to output
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_rgn(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_tile_no,
+ OPJ_UINT32 p_comp_no,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Reads a RGN marker (Region Of Interest)
+ *
+ * @param p_header_data the data contained in the POC box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the POC marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_rgn (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ ) ;
+/**
+ * Writes the EOC marker (End of Codestream)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_eoc(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Copies the tile component parameters of all the component from the first tile component.
+ *
+ * @param p_j2k the J2k codec.
+ */
+static void j2k_copy_tile_quantization_parameters(
+ opj_j2k_t *p_j2k
+ );
+
+/**
+ * Reads a EOC marker (End Of Codestream)
+ *
+ * @param p_header_data the data contained in the SOD box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the SOD marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_eoc (
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ ) ;
+
+/**
+ * Inits the Info
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_init_info(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Reads an unknown marker
+ *
+ * @param p_stream the stream object to read from.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the marker could be deduced.
+*/
+static bool j2k_read_unk (
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Ends the encoding, i.e. frees memory.
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_end_encoding(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Writes the CBD marker (Component bit depth definition)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_cbd(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Reads a CBD marker (Component bit depth definition)
+ * @param p_header_data the data contained in the CBD box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the CBD marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_cbd (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager);
+
+/**
+ * Writes the MCT marker (Multiple Component Transform)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_mct_record(
+ opj_j2k_t *p_j2k,
+ opj_mct_data_t * p_mct_record,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Reads a MCT marker (Multiple Component Transform)
+ *
+ * @param p_header_data the data contained in the MCT box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the MCT marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_mct (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Writes the MCC marker (Multiple Component Collection)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_mcc_record(
+ opj_j2k_t *p_j2k,
+ struct opj_simple_mcc_decorrelation_data * p_mcc_record,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Reads a MCC marker (Multiple Component Collection)
+ *
+ * @param p_header_data the data contained in the MCC box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the MCC marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_mcc (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Writes the MCO marker (Multiple component transformation ordering)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_mco(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Reads a MCO marker (Multiple Component Transform Ordering)
+ *
+ * @param p_header_data the data contained in the MCO box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the MCO marker.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_read_mco (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Writes the image components.
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_image_components(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Writes regions of interests.
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_regions(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Writes EPC ????
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_write_epc(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Checks the progression order changes values. Tells of the poc given as input are valid.
+ * A nice message is outputted at errors.
+ *
+ * @param p_pocs the progression order changes.
+ * @param p_nb_pocs the number of progression order changes.
+ * @param p_nb_resolutions the number of resolutions.
+ * @param numcomps the number of components
+ * @param numlayers the number of layers.
+ *
+ * @return true if the pocs are valid.
+ */
+static bool j2k_check_poc_val(
+ const opj_poc_t *p_pocs,
+ OPJ_UINT32 p_nb_pocs,
+ OPJ_UINT32 p_nb_resolutions,
+ OPJ_UINT32 numcomps,
+ OPJ_UINT32 numlayers,
+ opj_event_mgr_t * p_manager);
+
+/**
+ * Gets the number of tile parts used for the given change of progression (if any) and the given tile.
+ *
+ * @param cp the coding parameters.
+ * @param pino the offset of the given poc (i.e. its position in the coding parameter).
+ * @param tileno the given tile.
+ *
+ * @return the number of tile parts.
+ */
+static OPJ_UINT32 j2k_get_num_tp(
+ opj_cp_t *cp,
+ OPJ_UINT32 pino,
+ OPJ_UINT32 tileno);
+/**
+ * Calculates the total number of tile parts needed by the encoder to
+ * encode such an image. If not enough memory is available, then the function return false.
+ *
+ * @param p_nb_tiles pointer that will hold the number of tile parts.
+ * @param cp the coding parameters for the image.
+ * @param image the image to encode.
+ * @param p_j2k the p_j2k encoder.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the function was successful, false else.
+ */
+static bool j2k_calculate_tp(
+ opj_j2k_t *p_j2k,
+ opj_cp_t *cp,
+ OPJ_UINT32 * p_nb_tiles,
+ opj_image_t *image,
+ opj_event_mgr_t * p_manager);
+
+static bool j2k_write_first_tile_part (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_data_written,
+ OPJ_UINT32 p_total_data_size,
+ opj_stream_private_t *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+static bool j2k_write_all_tile_parts(
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_data_written,
+ OPJ_UINT32 p_total_data_size,
+ opj_stream_private_t *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Reads the lookup table containing all the marker, status and action, and returns the handler associated
+ * with the marker value.
+ * @param p_id Marker value to look up
+ *
+ * @return the handler associated with the id.
+*/
+static const struct opj_dec_memory_marker_handler * j2k_get_marker_handler (OPJ_UINT32 p_id);
+
+/**
+ * Destroys a tile coding parameter structure.
+ *
+ * @param p_tcp the tile coding parameter to destroy.
+ */
+static void j2k_tcp_destroy (opj_tcp_t *p_tcp);
+
+static void j2k_get_tile_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data);
+
+/**
+ * Destroys a coding parameter structure.
+ *
+ * @param p_cp the coding parameter to destroy.
+ */
+static void j2k_cp_destroy (opj_cp_t *p_cp);
+
+/**
+ * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
+ * are valid. Developpers wanting to extend the library can add their own validation procedures.
+ */
+static void j2k_setup_encoding_validation (opj_j2k_t *p_j2k);
+
+/**
+ * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
+ * are valid. Developpers wanting to extend the library can add their own validation procedures.
+ */
+static void j2k_setup_decoding_validation (opj_j2k_t *p_j2k);
+
+/**
+ * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
+ * are valid. Developpers wanting to extend the library can add their own validation procedures.
+ */
+static void j2k_setup_end_compress (opj_j2k_t *p_j2k);
+
+/**
+ * Creates a tile-coder decoder.
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_create_tcd(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Excutes the given procedures on the given codec.
+ *
+ * @param p_procedure_list the list of procedures to execute
+ * @param p_j2k the jpeg2000 codec to execute the procedures on.
+ * @param p_stream the stream to execute the procedures on.
+ * @param p_manager the user manager.
+ *
+ * @return true if all the procedures were successfully executed.
+ */
+static bool j2k_exec (
+ opj_j2k_t * p_j2k,
+ opj_procedure_list_t * p_procedure_list,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ );
+/**
+ * Updates the rates of the tcp.
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_update_rates(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * The default encoding validation procedure without any extension.
+ *
+ * @param p_j2k the jpeg2000 codec to validate.
+ * @param p_stream the input stream to validate.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the parameters are correct.
+ */
+bool j2k_encoding_validation (
+ opj_j2k_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ );
+/**
+ * The read header procedure.
+ */
+bool j2k_read_header_procedure(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager);
+
+/**
+ * The default decoding validation procedure without any extension.
+ *
+ * @param p_j2k the jpeg2000 codec to validate.
+ * @param p_stream the input stream to validate.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the parameters are correct.
+ */
+bool j2k_decoding_validation (
+ opj_j2k_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ );
+/**
+ * Reads the tiles.
+ */
+bool j2k_decode_tiles (
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager);
+
+/**
+ * The mct encoding validation procedure.
+ *
+ * @param p_j2k the jpeg2000 codec to validate.
+ * @param p_stream the input stream to validate.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the parameters are correct.
+ */
+bool j2k_mct_validation (
+ opj_j2k_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ );
+/**
+ * Builds the tcd decoder to use to decode tile.
+ */
+bool j2k_build_decoder (
+ opj_j2k_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ );
+/**
+ * Builds the tcd encoder to use to encode tile.
+ */
+bool j2k_build_encoder (
+ opj_j2k_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ );
+/**
+ * Copies the decoding tile parameters onto all the tile parameters.
+ * Creates also the tile decoder.
+ */
+bool j2k_copy_default_tcp_and_create_tcd(
+ opj_j2k_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ );
+/**
+ * Destroys the memory associated with the decoding of headers.
+ */
+bool j2k_destroy_header_memory (
+ opj_j2k_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ );
+
+/**
+ * Sets up the procedures to do on writting header. Developpers wanting to extend the library can add their own writting procedures.
+ */
+void j2k_setup_header_writting (opj_j2k_t *p_j2k);
+
+/**
+ * Sets up the procedures to do on reading header. Developpers wanting to extend the library can add their own reading procedures.
+ */
+void j2k_setup_header_reading (opj_j2k_t *p_j2k);
+
+/**
+ * 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.
+ */
+static bool j2k_post_write_tile (
+ opj_j2k_t * p_j2k,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 p_data_size,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ );
+
+static bool j2k_pre_write_tile (
+ opj_j2k_t * p_j2k,
+ OPJ_UINT32 p_tile_index,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ );
+static bool j2k_update_image_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data);
+
+static bool j2k_add_mct(opj_tcp_t * p_tcp,opj_image_t * p_image, OPJ_UINT32 p_index);
+/**
+ * Gets the offset of the header.
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+static bool j2k_get_end_header(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ );
+
+static void j2k_read_int16_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_read_int32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_read_float32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_read_float64_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+
+static void j2k_read_int16_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_read_int32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_read_float32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_read_float64_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+
+static void j2k_write_float_to_int16 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_write_float_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_write_float_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_write_float_to_float64 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+
+
+
+/*@}*/
+
+/*@}*/
+
+/* ----------------------------------------------------------------------- */
+
+
+
+/****************************************************************************
+ ********************* CONSTANTS ********************************************
+ ****************************************************************************/
+
+
+
+
+/**
+ * List of progression orders.
+ */
+const j2k_prog_order_t j2k_prog_order_list [] =
+{
+ {CPRL, "CPRL"},
+ {LRCP, "LRCP"},
+ {PCRL, "PCRL"},
+ {RLCP, "RLCP"},
+ {RPCL, "RPCL"},
+ {-1, ""}
+};
+
+const OPJ_UINT32 MCT_ELEMENT_SIZE [] =
+{
+ 2,
+ 4,
+ 4,
+ 8
+};
+
+typedef void (* j2k_mct_function) (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+
+const j2k_mct_function j2k_mct_read_functions_to_float [] =
+{
+ j2k_read_int16_to_float,
+ j2k_read_int32_to_float,
+ j2k_read_float32_to_float,
+ j2k_read_float64_to_float
+};
+
+const j2k_mct_function j2k_mct_read_functions_to_int32 [] =
+{
+ j2k_read_int16_to_int32,
+ j2k_read_int32_to_int32,
+ j2k_read_float32_to_int32,
+ j2k_read_float64_to_int32
+};
+
+const j2k_mct_function j2k_mct_write_functions_from_float [] =
+{
+ j2k_write_float_to_int16,
+ j2k_write_float_to_int32,
+ j2k_write_float_to_float,
+ j2k_write_float_to_float64
+};
+
+
+
+
+/*const opj_dec_stream_marker_handler_t j2k_stream_marker_handler_tab[] =
+{
+ {J2K_MS_SOC, J2K_DEC_STATE_MHSOC, j2k_read_soc},
+ {J2K_MS_SOD, J2K_DEC_STATE_TPH, j2k_read_sod},
+ {J2K_MS_EOC, J2K_DEC_STATE_TPHSOT, j2k_read_eoc},
+ {J2K_MS_SOP, 0, 0},
+#ifdef USE_JPWL
+ {J2K_MS_EPC, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_epc},
+ {J2K_MS_EPB, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_epb},
+ {J2K_MS_ESD, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_esd},
+ {J2K_MS_RED, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_red},
+#endif
+#ifdef USE_JPSEC
+ {J2K_MS_SEC, J2K_DEC_STATE_MH, j2k_read_sec},
+ {J2K_MS_INSEC, 0, j2k_read_insec},
+#endif
+
+ {0, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_unk}
+};*/
+
+const opj_dec_memory_marker_handler_t j2k_memory_marker_handler_tab [] =
+{
+ {J2K_MS_SOT, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPHSOT, j2k_read_sot},
+ {J2K_MS_COD, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_cod},
+ {J2K_MS_COC, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_coc},
+ {J2K_MS_RGN, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_rgn},
+ {J2K_MS_QCD, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_qcd},
+ {J2K_MS_QCC, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_qcc},
+ {J2K_MS_POC, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_poc},
+ {J2K_MS_SIZ, J2K_DEC_STATE_MHSIZ , j2k_read_siz},
+ {J2K_MS_TLM, J2K_DEC_STATE_MH, j2k_read_tlm},
+ {J2K_MS_PLM, J2K_DEC_STATE_MH, j2k_read_plm},
+ {J2K_MS_PLT, J2K_DEC_STATE_TPH, j2k_read_plt},
+ {J2K_MS_PPM, J2K_DEC_STATE_MH, j2k_read_ppm},
+ {J2K_MS_PPT, J2K_DEC_STATE_TPH, j2k_read_ppt},
+ {J2K_MS_SOP, 0, 0},
+ {J2K_MS_CRG, J2K_DEC_STATE_MH, j2k_read_crg},
+ {J2K_MS_COM, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_com},
+ {J2K_MS_MCT, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_mct},
+ {J2K_MS_CBD, J2K_DEC_STATE_MH , j2k_read_cbd},
+ {J2K_MS_MCC, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_mcc},
+ {J2K_MS_MCO, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_mco}
+#ifdef USE_JPWL
+ {J2K_MS_EPC, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_epc},
+ {J2K_MS_EPB, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_epb},
+ {J2K_MS_ESD, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_esd},
+ {J2K_MS_RED, J2K_DEC_STATE_MH | J2K_DEC_STATE_TPH, j2k_read_red},
+#endif /* USE_JPWL */
+#ifdef USE_JPSEC
+ {J2K_MS_SEC, J2K_DEC_STATE_MH, j2k_read_sec},
+ {J2K_MS_INSEC, 0, j2k_read_insec}
+#endif /* USE_JPSEC */
+};
+
+void j2k_read_int16_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+{
+ OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
+ OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_temp;
+
+ for
+ (i=0;i<p_nb_elem;++i)
+ {
+ opj_read_bytes(l_src_data,&l_temp,2);
+ l_src_data+=sizeof(OPJ_INT16);
+ *(l_dest_data++) = (OPJ_FLOAT32) l_temp;
+ }
+}
+
+void j2k_read_int32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+{
+ OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
+ OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_temp;
+
+ for
+ (i=0;i<p_nb_elem;++i)
+ {
+ opj_read_bytes(l_src_data,&l_temp,4);
+ l_src_data+=sizeof(OPJ_INT32);
+ *(l_dest_data++) = (OPJ_FLOAT32) l_temp;
+ }
+}
+void j2k_read_float32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+{
+ OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
+ OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
+ OPJ_UINT32 i;
+ OPJ_FLOAT32 l_temp;
+
+ for
+ (i=0;i<p_nb_elem;++i)
+ {
+ opj_read_float(l_src_data,&l_temp);
+ l_src_data+=sizeof(OPJ_FLOAT32);
+ *(l_dest_data++) = l_temp;
+ }
+}
+
+void j2k_read_float64_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+{
+ OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
+ OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data;
+ OPJ_UINT32 i;
+ OPJ_FLOAT64 l_temp;
+
+ for
+ (i=0;i<p_nb_elem;++i)
+ {
+ opj_read_double(l_src_data,&l_temp);
+ l_src_data+=sizeof(OPJ_FLOAT64);
+ *(l_dest_data++) = (OPJ_FLOAT32) l_temp;
+ }
+
+}
+
+void j2k_read_int16_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+{
+ OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
+ OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_temp;
+
+ for
+ (i=0;i<p_nb_elem;++i)
+ {
+ opj_read_bytes(l_src_data,&l_temp,2);
+ l_src_data+=sizeof(OPJ_INT16);
+ *(l_dest_data++) = (OPJ_INT32) l_temp;
+ }
+}
+
+void j2k_read_int32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+{
+ OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
+ OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_temp;
+
+ for
+ (i=0;i<p_nb_elem;++i)
+ {
+ opj_read_bytes(l_src_data,&l_temp,4);
+ l_src_data+=sizeof(OPJ_INT32);
+ *(l_dest_data++) = (OPJ_INT32) l_temp;
+ }
+}
+void j2k_read_float32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+{
+ OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
+ OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
+ OPJ_UINT32 i;
+ OPJ_FLOAT32 l_temp;
+
+ for
+ (i=0;i<p_nb_elem;++i)
+ {
+ opj_read_float(l_src_data,&l_temp);
+ l_src_data+=sizeof(OPJ_FLOAT32);
+ *(l_dest_data++) = (OPJ_INT32) l_temp;
+ }
+}
+
+void j2k_read_float64_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+{
+ OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data;
+ OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data;
+ OPJ_UINT32 i;
+ OPJ_FLOAT64 l_temp;
+
+ for
+ (i=0;i<p_nb_elem;++i)
+ {
+ opj_read_double(l_src_data,&l_temp);
+ l_src_data+=sizeof(OPJ_FLOAT64);
+ *(l_dest_data++) = (OPJ_INT32) l_temp;
+ }
+
+}
+
+void j2k_write_float_to_int16 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+{
+ OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
+ OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_temp;
+
+ for
+ (i=0;i<p_nb_elem;++i)
+ {
+ l_temp = (OPJ_UINT32) *(l_src_data++);
+ opj_write_bytes(l_dest_data,l_temp,sizeof(OPJ_INT16));
+ l_dest_data+=sizeof(OPJ_INT16);
+ }
+}
+
+void j2k_write_float_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+{
+ OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
+ OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_temp;
+
+ for
+ (i=0;i<p_nb_elem;++i)
+ {
+ l_temp = (OPJ_UINT32) *(l_src_data++);
+ opj_write_bytes(l_dest_data,l_temp,sizeof(OPJ_INT32));
+ l_dest_data+=sizeof(OPJ_INT32);
+ }
+}
+
+void j2k_write_float_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+{
+ OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
+ OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
+ OPJ_UINT32 i;
+ OPJ_FLOAT32 l_temp;
+
+ for
+ (i=0;i<p_nb_elem;++i)
+ {
+ l_temp = (OPJ_FLOAT32) *(l_src_data++);
+ opj_write_float(l_dest_data,l_temp);
+ l_dest_data+=sizeof(OPJ_FLOAT32);
+ }
+
+}
+
+void j2k_write_float_to_float64 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem)
+{
+ OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data;
+ OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data;
+ OPJ_UINT32 i;
+ OPJ_FLOAT64 l_temp;
+ for
+ (i=0;i<p_nb_elem;++i)
+ {
+ l_temp = (OPJ_FLOAT64) *(l_src_data++);
+ opj_write_double(l_dest_data,l_temp);
+ l_dest_data+=sizeof(OPJ_FLOAT64);
+ }
+}
+
+
+
+
+/**
+ * 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 OPJ_CHAR * j2k_convert_progression_order(OPJ_PROG_ORDER p_prg_order)
+{
+ const j2k_prog_order_t *po;
+ for
+ (po = j2k_prog_order_list; po->enum_prog != -1; ++po )
+ {
+ if
+ (po->enum_prog == p_prg_order)
+ {
+ return po->str_prog;
+ }
+ }
+ return po->str_prog;
+}
+
+
+
+
+
+
+
+/**
+ * Checks the progression order changes values. Tells if the poc given as input are valid.
+ *
+ * @param p_pocs the progression order changes.
+ * @param p_nb_pocs the number of progression order changes.
+ * @param p_nb_resolutions the number of resolutions.
+ * @param numcomps the number of components
+ * @param numlayers the number of layers.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the pocs are valid.
+ */
+bool j2k_check_poc_val(const opj_poc_t *p_pocs, OPJ_UINT32 p_nb_pocs, OPJ_UINT32 p_nb_resolutions, OPJ_UINT32 p_num_comps, OPJ_UINT32 p_num_layers, opj_event_mgr_t * p_manager)
+{
+ OPJ_UINT32* packet_array;
+ OPJ_UINT32 index , resno, compno, layno;
+ OPJ_UINT32 i;
+ OPJ_UINT32 step_c = 1;
+ OPJ_UINT32 step_r = p_num_comps * step_c;
+ OPJ_UINT32 step_l = p_nb_resolutions * step_r;
+ bool loss = false;
+ OPJ_UINT32 layno0 = 0;
+
+ packet_array = (OPJ_UINT32*) opj_calloc(step_l * p_num_layers, sizeof(OPJ_UINT32));
+ if
+ (packet_array == 00)
+ {
+ opj_event_msg(p_manager , EVT_ERROR, "Not enough memory for checking the poc values.\n");
+ return false;
+ }
+ memset(packet_array,0,step_l * p_num_layers* sizeof(OPJ_UINT32));
+ if
+ (p_nb_pocs == 0)
+ {
+ return true;
+ }
+
+ index = step_r * p_pocs->resno0;
+ // take each resolution for each poc
+ for
+ (resno = p_pocs->resno0 ; resno < p_pocs->resno1 ; ++resno)
+ {
+ OPJ_UINT32 res_index = index + p_pocs->compno0 * step_c;
+ // take each comp of each resolution for each poc
+ for
+ (compno = p_pocs->compno0 ; compno < p_pocs->compno1 ; ++compno)
+ {
+ OPJ_UINT32 comp_index = res_index + layno0 * step_l;
+ // and finally take each layer of each res of ...
+ for
+ (layno = layno0; layno < p_pocs->layno1 ; ++layno)
+ {
+ //index = step_r * resno + step_c * compno + step_l * layno;
+ packet_array[comp_index] = 1;
+ comp_index += step_l;
+ }
+ res_index += step_c;
+ }
+ index += step_r;
+ }
+ ++p_pocs;
+ // iterate through all the pocs
+ for
+ (i = 1; i < p_nb_pocs ; ++i)
+ {
+ OPJ_UINT32 l_last_layno1 = (p_pocs-1)->layno1 ;
+ layno0 = (p_pocs->layno1 > l_last_layno1)? l_last_layno1 : 0;
+ index = step_r * p_pocs->resno0;
+ // take each resolution for each poc
+ for
+ (resno = p_pocs->resno0 ; resno < p_pocs->resno1 ; ++resno)
+ {
+ OPJ_UINT32 res_index = index + p_pocs->compno0 * step_c;
+ // take each comp of each resolution for each poc
+ for
+ (compno = p_pocs->compno0 ; compno < p_pocs->compno1 ; ++compno)
+ {
+ OPJ_UINT32 comp_index = res_index + layno0 * step_l;
+ // and finally take each layer of each res of ...
+ for
+ (layno = layno0; layno < p_pocs->layno1 ; ++layno)
+ {
+ //index = step_r * resno + step_c * compno + step_l * layno;
+ packet_array[comp_index] = 1;
+ comp_index += step_l;
+ }
+ res_index += step_c;
+ }
+ index += step_r;
+ }
+ ++p_pocs;
+ }
+
+ index = 0;
+ for
+ (layno = 0; layno < p_num_layers ; ++layno)
+ {
+ for
+ (resno = 0; resno < p_nb_resolutions; ++resno)
+ {
+ for
+ (compno = 0; compno < p_num_comps; ++compno)
+ {
+ loss |= (packet_array[index]!=1);
+ //index = step_r * resno + step_c * compno + step_l * layno;
+ index += step_c;
+ }
+ }
+ }
+ if
+ (loss)
+ {
+ opj_event_msg(p_manager , EVT_ERROR, "Missing packets possible loss of data\n");
+ }
+ opj_free(packet_array);
+ return !loss;
+}
+
+
+/* ----------------------------------------------------------------------- */
+
+/**
+ * Gets the number of tile parts used for the given change of progression (if any) and the given tile.
+ *
+ * @param cp the coding parameters.
+ * @param pino the offset of the given poc (i.e. its position in the coding parameter).
+ * @param tileno the given tile.
+ *
+ * @return the number of tile parts.
+ */
+OPJ_UINT32 j2k_get_num_tp(opj_cp_t *cp,OPJ_UINT32 pino,OPJ_UINT32 tileno)
+{
+ const OPJ_CHAR *prog = 00;
+ OPJ_UINT32 i;
+ OPJ_UINT32 tpnum = 1;
+ opj_tcp_t *tcp = 00;
+ opj_poc_t * l_current_poc = 00;
+
+ // preconditions only in debug
+ assert(tileno < (cp->tw * cp->th));
+ assert(pino < (cp->tcps[tileno].numpocs + 1));
+
+ // get the given tile coding parameter
+ tcp = &cp->tcps[tileno];
+ assert(tcp != 00);
+ l_current_poc = &(tcp->pocs[pino]);
+ assert(l_current_poc != 0);
+
+ // get the progression order as a character string
+ prog = j2k_convert_progression_order(tcp->prg);
+ assert(strlen(prog) > 0);
+
+ if
+ (cp->m_specific_param.m_enc.m_tp_on == 1)
+ {
+ for
+ (i=0;i<4;++i)
+ {
+ switch
+ (prog[i])
+ {
+ // component wise
+ case 'C':
+ tpnum *= l_current_poc->compE;
+ break;
+ // resolution wise
+ case 'R':
+ tpnum *= l_current_poc->resE;
+ break;
+ // precinct wise
+ case 'P':
+ tpnum *= l_current_poc->prcE;
+ break;
+ // layer wise
+ case 'L':
+ tpnum *= l_current_poc->layE;
+ break;
+ }
+ // whould we split here ?
+ if
+ ( cp->m_specific_param.m_enc.m_tp_flag == prog[i] )
+ {
+ cp->m_specific_param.m_enc.m_tp_pos=i;
+ break;
+ }
+ }
+ }
+ else
+ {
+ tpnum=1;
+ }
+ return tpnum;
+}
+
+/**
+ * Calculates the total number of tile parts needed by the encoder to
+ * encode such an image. If not enough memory is available, then the function return false.
+ *
+ * @param p_nb_tiles pointer that will hold the number of tile parts.
+ * @param cp the coding parameters for the image.
+ * @param image the image to encode.
+ * @param p_j2k the p_j2k encoder.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the function was successful, false else.
+ */
+bool j2k_calculate_tp(
+ opj_j2k_t *p_j2k,
+ opj_cp_t *cp,
+ OPJ_UINT32 * p_nb_tiles,
+ opj_image_t *image,
+ opj_event_mgr_t * p_manager)
+{
+ OPJ_UINT32 pino,tileno;
+ OPJ_UINT32 l_nb_tiles;
+ opj_tcp_t *tcp;
+
+ // preconditions
+ assert(p_nb_tiles != 00);
+ assert(cp != 00);
+ assert(image != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_nb_tiles = cp->tw * cp->th;
+ * p_nb_tiles = 0;
+ tcp = cp->tcps;
+
+ /* INDEX >> */
+ if
+ (p_j2k->cstr_info)
+ {
+ opj_tile_info_t * l_info_tile_ptr = p_j2k->cstr_info->tile;
+ for
+ (tileno = 0; tileno < l_nb_tiles; ++tileno)
+ {
+ OPJ_UINT32 cur_totnum_tp = 0;
+ pi_update_encoding_parameters(image,cp,tileno);
+ for
+ (pino = 0; pino <= tcp->numpocs; ++pino)
+ {
+ OPJ_UINT32 tp_num = j2k_get_num_tp(cp,pino,tileno);
+ *p_nb_tiles = *p_nb_tiles + tp_num;
+ cur_totnum_tp += tp_num;
+ }
+ tcp->m_nb_tile_parts = cur_totnum_tp;
+ l_info_tile_ptr->tp = (opj_tp_info_t *) opj_malloc(cur_totnum_tp * sizeof(opj_tp_info_t));
+ if
+ (l_info_tile_ptr->tp == 00)
+ {
+ return false;
+ }
+ memset(l_info_tile_ptr->tp,0,cur_totnum_tp * sizeof(opj_tp_info_t));
+ l_info_tile_ptr->num_tps = cur_totnum_tp;
+ ++l_info_tile_ptr;
+ ++tcp;
+ }
+ }
+ else
+ {
+ for
+ (tileno = 0; tileno < l_nb_tiles; ++tileno)
+ {
+ OPJ_UINT32 cur_totnum_tp = 0;
+ pi_update_encoding_parameters(image,cp,tileno);
+ for
+ (pino = 0; pino <= tcp->numpocs; ++pino)
+ {
+ OPJ_UINT32 tp_num=0;
+ tp_num = j2k_get_num_tp(cp,pino,tileno);
+ *p_nb_tiles = *p_nb_tiles + tp_num;
+ cur_totnum_tp += tp_num;
+ }
+ tcp->m_nb_tile_parts = cur_totnum_tp;
+ ++tcp;
+ }
+ }
+ return true;
+}
+
+/**
+ * Writes the SOC marker (Start Of Codestream)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+
+bool j2k_write_soc(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ /* 2 bytes will be written */
+ OPJ_BYTE * l_start_stream = 00;
+
+ // preconditions
+ assert(p_stream != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_start_stream = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
+
+ /* write SOC identifier */
+ opj_write_bytes(l_start_stream,J2K_MS_SOC,2);
+ if
+ (opj_stream_write_data(p_stream,l_start_stream,2,p_manager) != 2)
+ {
+ return false;
+ }
+/* UniPG>> */
+#ifdef USE_JPWL
+ /* update markers struct */
+ j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOC, p_stream_tell(p_stream) - 2, 2);
+#endif /* USE_JPWL */
+ return true;
+/* <<UniPG */
+}
+
+/**
+ * Reads a SOC marker (Start of Codestream)
+ * @param p_header_data the data contained in the SOC box.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_header_size the size of the data contained in the SOC marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_soc(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+
+{
+ OPJ_BYTE l_data [2];
+ OPJ_UINT32 l_marker;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+ if
+ (opj_stream_read_data(p_stream,l_data,2,p_manager) != 2)
+ {
+ return false;
+ }
+ opj_read_bytes(l_data,&l_marker,2);
+ if
+ (l_marker != J2K_MS_SOC)
+ {
+ return false;
+ }
+ /* assure length of data is correct (0) */
+ p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_MHSIZ;
+ /* Index */
+ if
+ (p_j2k->cstr_info)
+ {
+ //TODO p_j2k->cstr_info->main_head_start = opj_stream_tell(p_stream) - 2; // why - 2 ?
+ p_j2k->cstr_info->codestream_size = 0;/*p_stream_numbytesleft(p_j2k->p_stream) + 2 - p_j2k->cstr_info->main_head_start*/;
+ }
+ return true;
+}
+
+/**
+ * Writes the SIZ marker (image and tile size)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_siz(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_size_len;
+ OPJ_BYTE * l_current_ptr;
+ opj_image_t * l_image = 00;
+ opj_cp_t *cp = 00;
+ opj_image_comp_t * l_img_comp = 00;
+
+ // preconditions
+ assert(p_stream != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_image = p_j2k->m_image;
+ cp = &(p_j2k->m_cp);
+ l_size_len = 40 + 3 * l_image->numcomps;
+ l_img_comp = l_image->comps;
+
+ if
+ (l_size_len > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
+ {
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data
+ = opj_realloc(
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data,
+ l_size_len);
+ if
+ (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_size_len;
+ }
+
+ l_current_ptr = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
+
+ /* write SOC identifier */
+ opj_write_bytes(l_current_ptr,J2K_MS_SIZ,2); /* SIZ */
+ l_current_ptr+=2;
+ opj_write_bytes(l_current_ptr,l_size_len-2,2); /* L_SIZ */
+ l_current_ptr+=2;
+ opj_write_bytes(l_current_ptr, cp->rsiz, 2); /* Rsiz (capabilities) */
+ l_current_ptr+=2;
+ opj_write_bytes(l_current_ptr, l_image->x1, 4); /* Xsiz */
+ l_current_ptr+=4;
+ opj_write_bytes(l_current_ptr, l_image->y1, 4); /* Ysiz */
+ l_current_ptr+=4;
+ opj_write_bytes(l_current_ptr, l_image->x0, 4); /* X0siz */
+ l_current_ptr+=4;
+ opj_write_bytes(l_current_ptr, l_image->y0, 4); /* Y0siz */
+ l_current_ptr+=4;
+ opj_write_bytes(l_current_ptr, cp->tdx, 4); /* XTsiz */
+ l_current_ptr+=4;
+ opj_write_bytes(l_current_ptr, cp->tdy, 4); /* YTsiz */
+ l_current_ptr+=4;
+ opj_write_bytes(l_current_ptr, cp->tx0, 4); /* XT0siz */
+ l_current_ptr+=4;
+ opj_write_bytes(l_current_ptr, cp->ty0, 4); /* YT0siz */
+ l_current_ptr+=4;
+ opj_write_bytes(l_current_ptr, l_image->numcomps, 2); /* Csiz */
+ l_current_ptr+=2;
+ for
+ (i = 0; i < l_image->numcomps; ++i)
+ {
+ // TODO here with MCT ?
+ opj_write_bytes(l_current_ptr, l_img_comp->prec - 1 + (l_img_comp->sgnd << 7), 1); /* Ssiz_i */
+ ++l_current_ptr;
+ opj_write_bytes(l_current_ptr, l_img_comp->dx, 1); /* XRsiz_i */
+ ++l_current_ptr;
+ opj_write_bytes(l_current_ptr, l_img_comp->dy, 1); /* YRsiz_i */
+ ++l_current_ptr;
+ ++l_img_comp;
+ }
+ if
+ (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_size_len,p_manager) != l_size_len)
+ {
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Reads a SIZ marker (image and tile size)
+ * @param p_header_data the data contained in the SIZ box.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_header_size the size of the data contained in the SIZ marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_siz (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 l_size, i;
+ OPJ_UINT32 l_nb_comp;
+ OPJ_UINT32 l_nb_comp_remain;
+ OPJ_UINT32 l_remaining_size;
+ OPJ_UINT32 l_nb_tiles;
+ OPJ_UINT32 l_tmp;
+ opj_image_t *l_image = 00;
+ opj_cp_t *l_cp = 00;
+ opj_image_comp_t * l_img_comp = 00;
+ opj_tcp_t * l_current_tile_param = 00;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_header_data != 00);
+
+ l_image = p_j2k->m_image;
+ l_cp = &(p_j2k->m_cp);
+ if
+ (p_header_size < 36)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n");
+ return false;
+ }
+ l_remaining_size = p_header_size - 36;
+
+ l_nb_comp = l_remaining_size / 3;
+ l_nb_comp_remain = l_remaining_size % 3;
+ if
+ (l_nb_comp_remain != 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n");
+ return false;
+ }
+ l_size = p_header_size + 2; /* Lsiz */
+
+ opj_read_bytes(p_header_data,&l_tmp ,2); /* Rsiz (capabilities) */
+ p_header_data+=2;
+ l_cp->rsiz = (OPJ_RSIZ_CAPABILITIES) l_tmp;
+ opj_read_bytes(p_header_data,(OPJ_UINT32 *) (&l_image->x1) ,4); /* Xsiz */
+ p_header_data+=4;
+ opj_read_bytes(p_header_data,(OPJ_UINT32*) (&l_image->y1),4); /* Ysiz */
+ p_header_data+=4;
+ opj_read_bytes(p_header_data,(OPJ_UINT32*) &l_image->x0,4); /* X0siz */
+ p_header_data+=4;
+ opj_read_bytes(p_header_data,(OPJ_UINT32*) &l_image->y0,4); /* Y0siz */
+ p_header_data+=4;
+ opj_read_bytes(p_header_data, (&l_cp->tdx),4); /* XTsiz */
+ p_header_data+=4;
+ opj_read_bytes(p_header_data,&l_cp->tdy,4); /* YTsiz */
+ p_header_data+=4;
+ opj_read_bytes(p_header_data,(OPJ_UINT32 *) (&l_cp->tx0),4); /* XT0siz */
+ p_header_data+=4;
+ opj_read_bytes(p_header_data,(OPJ_UINT32 *) (&l_cp->ty0),4); /* YT0siz */
+ p_header_data+=4;
+ opj_read_bytes(p_header_data,(&l_image->numcomps),2); /* Csiz */
+ p_header_data+=2;
+ if
+ (l_image->numcomps != l_nb_comp)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n");
+ return false;
+ }
+
+#ifdef USE_JPWL
+ if (p_j2k->m_cp->correct) {
+ /* if JPWL is on, we check whether TX errors have damaged
+ too much the SIZ parameters */
+ if (!(image->x1 * image->y1)) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR,
+ "JPWL: bad image size (%d x %d)\n",
+ image->x1, image->y1);
+ if (!JPWL_ASSUME || JPWL_ASSUME) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+ return;
+ }
+ }
+ if (image->numcomps != ((len - 38) / 3)) {
+ opj_event_msg(p_j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
+ "JPWL: Csiz is %d => space in SIZ only for %d comps.!!!\n",
+ image->numcomps, ((len - 38) / 3));
+ if (!JPWL_ASSUME) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+ return;
+ }
+ /* we try to correct */
+ opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- trying to adjust this\n");
+ if (image->numcomps < ((len - 38) / 3)) {
+ len = 38 + 3 * image->numcomps;
+ opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- setting Lsiz to %d => HYPOTHESIS!!!\n",
+ len);
+ } else {
+ image->numcomps = ((len - 38) / 3);
+ opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- setting Csiz to %d => HYPOTHESIS!!!\n",
+ image->numcomps);
+ }
+ }
+
+ /* update components number in the jpwl_exp_comps filed */
+ cp->exp_comps = image->numcomps;
+ }
+#endif /* USE_JPWL */
+
+ l_image->comps = (opj_image_comp_t*) opj_calloc(l_image->numcomps, sizeof(opj_image_comp_t));
+ if
+ (l_image->comps == 00)
+ {
+ l_image->numcomps = 0;
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
+ return false;
+ }
+ memset(l_image->comps,0,l_image->numcomps * sizeof(opj_image_comp_t));
+ l_img_comp = l_image->comps;
+ for
+ (i = 0; i < l_image->numcomps; ++i)
+ {
+ OPJ_UINT32 tmp;
+ opj_read_bytes(p_header_data,&tmp,1); /* Ssiz_i */
+ ++p_header_data;
+ l_img_comp->prec = (tmp & 0x7f) + 1;
+ l_img_comp->sgnd = tmp >> 7;
+ opj_read_bytes(p_header_data,&l_img_comp->dx,1); /* XRsiz_i */
+ ++p_header_data;
+ opj_read_bytes(p_header_data,&l_img_comp->dy,1); /* YRsiz_i */
+ ++p_header_data;
+#ifdef USE_JPWL
+ if (p_j2k->m_cp->correct) {
+ /* if JPWL is on, we check whether TX errors have damaged
+ too much the SIZ parameters, again */
+ if (!(image->comps[i].dx * image->comps[i].dy)) {
+ opj_event_msg(p_j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
+ "JPWL: bad XRsiz_%d/YRsiz_%d (%d x %d)\n",
+ i, i, image->comps[i].dx, image->comps[i].dy);
+ if (!JPWL_ASSUME) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+ return;
+ }
+ /* we try to correct */
+ opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- trying to adjust them\n");
+ if (!image->comps[i].dx) {
+ image->comps[i].dx = 1;
+ opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- setting XRsiz_%d to %d => HYPOTHESIS!!!\n",
+ i, image->comps[i].dx);
+ }
+ if (!image->comps[i].dy) {
+ image->comps[i].dy = 1;
+ opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- setting YRsiz_%d to %d => HYPOTHESIS!!!\n",
+ i, image->comps[i].dy);
+ }
+ }
+
+ }
+#endif /* USE_JPWL */
+ l_img_comp->resno_decoded = 0; /* number of resolution decoded */
+ l_img_comp->factor = l_cp->m_specific_param.m_dec.m_reduce; /* reducing factor per component */
+ ++l_img_comp;
+ }
+
+ l_cp->tw = int_ceildiv(l_image->x1 - l_cp->tx0, l_cp->tdx);
+ l_cp->th = int_ceildiv(l_image->y1 - l_cp->ty0, l_cp->tdy);
+ l_nb_tiles = l_cp->tw * l_cp->th;
+ if
+ (p_j2k->m_specific_param.m_decoder.m_discard_tiles)
+ {
+ p_j2k->m_specific_param.m_decoder.m_start_tile_x = (p_j2k->m_specific_param.m_decoder.m_start_tile_x - l_cp->tx0) / l_cp->tdx;
+ p_j2k->m_specific_param.m_decoder.m_start_tile_y = (p_j2k->m_specific_param.m_decoder.m_start_tile_y - l_cp->ty0) / l_cp->tdy;
+ p_j2k->m_specific_param.m_decoder.m_end_tile_x = int_ceildiv((p_j2k->m_specific_param.m_decoder.m_end_tile_x - l_cp->tx0), l_cp->tdx);
+ p_j2k->m_specific_param.m_decoder.m_end_tile_y = int_ceildiv((p_j2k->m_specific_param.m_decoder.m_end_tile_y - l_cp->ty0), l_cp->tdy);
+ }
+ else
+ {
+ p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0;
+ p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0;
+ p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw;
+ p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th;
+ }
+
+#ifdef USE_JPWL
+ if (p_j2k->m_cp->correct) {
+ /* if JPWL is on, we check whether TX errors have damaged
+ too much the SIZ parameters */
+ if ((cp->tw < 1) || (cp->th < 1) || (cp->tw > cp->max_tiles) || (cp->th > cp->max_tiles)) {
+ opj_event_msg(p_j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
+ "JPWL: bad number of tiles (%d x %d)\n",
+ cp->tw, cp->th);
+ if (!JPWL_ASSUME) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+ return;
+ }
+ /* we try to correct */
+ opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- trying to adjust them\n");
+ if (cp->tw < 1) {
+ cp->tw= 1;
+ opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- setting %d tiles in x => HYPOTHESIS!!!\n",
+ cp->tw);
+ }
+ if (cp->tw > cp->max_tiles) {
+ cp->tw= 1;
+ opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- too large x, increase expectance of %d\n"
+ "- setting %d tiles in x => HYPOTHESIS!!!\n",
+ cp->max_tiles, cp->tw);
+ }
+ if (cp->th < 1) {
+ cp->th= 1;
+ opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- setting %d tiles in y => HYPOTHESIS!!!\n",
+ cp->th);
+ }
+ if (cp->th > cp->max_tiles) {
+ cp->th= 1;
+ opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- too large y, increase expectance of %d to continue\n",
+ "- setting %d tiles in y => HYPOTHESIS!!!\n",
+ cp->max_tiles, cp->th);
+ }
+ }
+ }
+#endif /* USE_JPWL */
+ /* memory allocations */
+ l_cp->tcps = (opj_tcp_t*) opj_calloc(l_nb_tiles, sizeof(opj_tcp_t));
+ if
+ (l_cp->tcps == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
+ return false;
+ }
+ memset(l_cp->tcps,0,l_nb_tiles*sizeof(opj_tcp_t));
+
+#ifdef USE_JPWL
+ if (p_j2k->m_cp->correct) {
+ if (!cp->tcps) {
+ opj_event_msg(p_j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
+ "JPWL: could not alloc tcps field of cp\n");
+ if (!JPWL_ASSUME || JPWL_ASSUME) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+ return;
+ }
+ }
+ }
+#endif /* USE_JPWL */
+
+ p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps = (opj_tccp_t*) opj_calloc(l_image->numcomps, sizeof(opj_tccp_t));
+ if
+ (p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
+ return false;
+ }
+ memset(p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps ,0,l_image->numcomps*sizeof(opj_tccp_t));
+
+ p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records = opj_malloc(J2K_MCT_DEFAULT_NB_RECORDS * sizeof(opj_mct_data_t));
+ if
+ (! p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
+ return false;
+ }
+ memset(p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records,0,J2K_MCT_DEFAULT_NB_RECORDS * sizeof(opj_mct_data_t));
+ p_j2k->m_specific_param.m_decoder.m_default_tcp->m_nb_max_mct_records = J2K_MCT_DEFAULT_NB_RECORDS;
+
+ p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records = opj_malloc(J2K_MCC_DEFAULT_NB_RECORDS * sizeof(opj_simple_mcc_decorrelation_data_t));
+ if
+ (! p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
+ return false;
+ }
+ memset(p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records,0,J2K_MCC_DEFAULT_NB_RECORDS * sizeof(opj_simple_mcc_decorrelation_data_t));
+ p_j2k->m_specific_param.m_decoder.m_default_tcp->m_nb_max_mcc_records = J2K_MCC_DEFAULT_NB_RECORDS;
+
+ /* set up default dc level shift */
+ for
+ (i=0;i<l_image->numcomps;++i)
+ {
+ if
+ (! l_image->comps[i].sgnd)
+ {
+ p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps[i].m_dc_level_shift = 1 << (l_image->comps[i].prec - 1);
+ }
+ }
+
+ l_current_tile_param = l_cp->tcps;
+ for
+ (i = 0; i < l_nb_tiles; ++i)
+ {
+ l_current_tile_param->tccps = (opj_tccp_t*) opj_malloc(l_image->numcomps * sizeof(opj_tccp_t));
+ if
+ (l_current_tile_param->tccps == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
+ return false;
+ }
+ memset(l_current_tile_param->tccps,0,l_image->numcomps * sizeof(opj_tccp_t));
+
+ ++l_current_tile_param;
+
+ }
+ p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_MH;
+ opj_image_comp_update(l_image,l_cp);
+
+ /* Index */
+ if
+ (p_j2k->cstr_info)
+ {
+ opj_codestream_info_t *cstr_info = p_j2k->cstr_info;
+ cstr_info->image_w = l_image->x1 - l_image->x0;
+ cstr_info->image_h = l_image->y1 - l_image->y0;
+ cstr_info->numcomps = l_image->numcomps;
+ cstr_info->tw = l_cp->tw;
+ cstr_info->th = l_cp->th;
+ cstr_info->tile_x = l_cp->tdx;
+ cstr_info->tile_y = l_cp->tdy;
+ cstr_info->tile_Ox = l_cp->tx0;
+ cstr_info->tile_Oy = l_cp->ty0;
+ cstr_info->tile = (opj_tile_info_t*) opj_calloc(l_nb_tiles, sizeof(opj_tile_info_t));
+ if
+ (cstr_info->tile == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
+ return false;
+ }
+ memset(cstr_info->tile,0,l_nb_tiles * sizeof(opj_tile_info_t));
+ }
+ return true;
+}
+
+/**
+ * Writes the COM marker (comment)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_com(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 l_comment_size;
+ OPJ_UINT32 l_total_com_size;
+ const OPJ_CHAR *l_comment;
+ OPJ_BYTE * l_current_ptr = 00;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_stream != 00);
+ assert(p_manager != 00);
+
+ l_comment = p_j2k->m_cp.comment;
+ l_comment_size = strlen(l_comment);
+ l_total_com_size = l_comment_size + 6;
+
+ if
+ (l_total_com_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
+ {
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data
+ = opj_realloc(
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data,
+ l_total_com_size);
+ if
+ (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_total_com_size;
+ }
+ l_current_ptr = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
+ opj_write_bytes(l_current_ptr,J2K_MS_COM , 2); /* COM */
+ l_current_ptr+=2;
+ opj_write_bytes(l_current_ptr,l_total_com_size - 2 , 2); /* L_COM */
+ l_current_ptr+=2;
+ opj_write_bytes(l_current_ptr,1 , 2); /* General use (IS 8859-15:1999 (Latin) values) */
+ l_current_ptr+=2,
+ memcpy( l_current_ptr,l_comment,l_comment_size);
+ if
+ (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_total_com_size,p_manager) != l_total_com_size)
+ {
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Reads a COM marker (comments)
+ * @param p_header_data the data contained in the COM box.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_header_size the size of the data contained in the COM marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_com (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_header_data != 00);
+ return true;
+}
+
+/**
+ * Gets the size taken by writting a SPCod or SPCoc for the given tile and component.
+ *
+ * @param p_tile_no the tile indix.
+ * @param p_comp_no the component being outputted.
+ * @param p_j2k the J2K codec.
+ *
+ * @return the number of bytes taken by the SPCod element.
+ */
+OPJ_UINT32 j2k_get_SPCod_SPCoc_size (
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_tile_no,
+ OPJ_UINT32 p_comp_no
+ )
+{
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ opj_tccp_t *l_tccp = 00;
+
+ // preconditions
+ assert(p_j2k != 00);
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = &l_cp->tcps[p_tile_no];
+ l_tccp = &l_tcp->tccps[p_comp_no];
+
+ // preconditions again
+ assert(p_tile_no < (l_cp->tw * l_cp->th));
+ assert(p_comp_no < p_j2k->m_image->numcomps);
+
+ if
+ (l_tccp->csty & J2K_CCP_CSTY_PRT)
+ {
+ return 5 + l_tccp->numresolutions;
+ }
+ else
+ {
+ return 5;
+ }
+}
+
+
+/**
+ * Writes a SPCod or SPCoc element, i.e. the coding style of a given component of a tile.
+ *
+ * @param p_comp_no the component number to output.
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+ *
+*/
+bool j2k_write_SPCod_SPCoc(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_tile_no,
+ OPJ_UINT32 p_comp_no,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 i;
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ opj_tccp_t *l_tccp = 00;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_header_size != 00);
+ assert(p_manager != 00);
+ assert(p_data != 00);
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = &l_cp->tcps[p_tile_no];
+ l_tccp = &l_tcp->tccps[p_comp_no];
+
+ // preconditions again
+ assert(p_tile_no < (l_cp->tw * l_cp->th));
+ assert(p_comp_no <(p_j2k->m_image->numcomps));
+
+ if
+ (*p_header_size < 5)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error writting SPCod SPCoc element\n");
+ return false;
+ }
+
+ opj_write_bytes(p_data,l_tccp->numresolutions - 1, 1); /* SPcoc (D) */
+ ++p_data;
+ opj_write_bytes(p_data,l_tccp->cblkw - 2, 1); /* SPcoc (E) */
+ ++p_data;
+ opj_write_bytes(p_data,l_tccp->cblkh - 2, 1); /* SPcoc (F) */
+ ++p_data;
+ opj_write_bytes(p_data,l_tccp->cblksty, 1); /* SPcoc (G) */
+ ++p_data;
+ opj_write_bytes(p_data,l_tccp->qmfbid, 1); /* SPcoc (H) */
+ ++p_data;
+
+ *p_header_size = *p_header_size - 5;
+ if
+ (l_tccp->csty & J2K_CCP_CSTY_PRT)
+ {
+ if
+ (*p_header_size < l_tccp->numresolutions)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error writting SPCod SPCoc element\n");
+ return false;
+ }
+ for
+ (i = 0; i < l_tccp->numresolutions; ++i)
+ {
+ opj_write_bytes(p_data,l_tccp->prcw[i] + (l_tccp->prch[i] << 4), 1); /* SPcoc (I_i) */
+ ++p_data;
+ }
+ *p_header_size = *p_header_size - l_tccp->numresolutions;
+
+ }
+ return true;
+}
+
+
+/**
+ * Reads a SPCod or SPCoc element, i.e. the coding style of a given component of a tile.
+ * @param p_header_data the data contained in the COM box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the COM marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_SPCod_SPCoc(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 compno,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 * p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ // loop
+ OPJ_UINT32 i;
+
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ opj_tccp_t *l_tccp = 00;
+ OPJ_BYTE * l_current_ptr = 00;
+ OPJ_UINT32 l_tmp;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_header_data != 00);
+
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
+
+ // precondition again
+ assert(compno < p_j2k->m_image->numcomps);
+ l_tccp = &l_tcp->tccps[compno];
+ l_current_ptr = p_header_data;
+
+
+ // make sure room is sufficient
+ if
+ (* p_header_size < 5)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading SPCod SPCoc element\n");
+ return false;
+ }
+ opj_read_bytes(l_current_ptr, &l_tccp->numresolutions ,1); /* SPcox (D) */
+ ++l_tccp->numresolutions; /* tccp->numresolutions = read() + 1 */
+ ++l_current_ptr;
+
+ // If user wants to remove more resolutions than the codestream contains, return error
+ if
+ (l_cp->m_specific_param.m_dec.m_reduce >= l_tccp->numresolutions)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error decoding component %d.\nThe number of resolutions to remove is higher than the number "
+ "of resolutions of this component\nModify the cp_reduce parameter.\n\n", compno);
+ p_j2k->m_specific_param.m_decoder.m_state |= J2K_DEC_STATE_ERR;
+ return false;
+ }
+
+ opj_read_bytes(l_current_ptr,&l_tccp->cblkw ,1); /* SPcoc (E) */
+ ++l_current_ptr;
+ l_tccp->cblkw += 2;
+
+ opj_read_bytes(l_current_ptr,&l_tccp->cblkh ,1); /* SPcoc (F) */
+ ++l_current_ptr;
+ l_tccp->cblkh += 2;
+
+ opj_read_bytes(l_current_ptr,&l_tccp->cblksty ,1); /* SPcoc (G) */
+ ++l_current_ptr;
+
+ opj_read_bytes(l_current_ptr,&l_tccp->qmfbid ,1); /* SPcoc (H) */
+ ++l_current_ptr;
+
+ * p_header_size = * p_header_size - 5;
+
+ // use custom precinct size ?
+ if
+ (l_tccp->csty & J2K_CCP_CSTY_PRT)
+ {
+ if
+ (* p_header_size < l_tccp->numresolutions)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading SPCod SPCoc element\n");
+ return false;
+ }
+ for
+ (i = 0; i < l_tccp->numresolutions; ++i)
+ {
+ opj_read_bytes(l_current_ptr,&l_tmp ,1); /* SPcoc (I_i) */
+ ++l_current_ptr;
+ l_tccp->prcw[i] = l_tmp & 0xf;
+ l_tccp->prch[i] = l_tmp >> 4;
+ }
+ * p_header_size = * p_header_size - l_tccp->numresolutions;
+ }
+ else
+ {
+ /* set default size for the precinct width and height */
+ for
+ (i = 0; i < l_tccp->numresolutions; ++i)
+ {
+ l_tccp->prcw[i] = 15;
+ l_tccp->prch[i] = 15;
+ }
+ }
+
+ /* INDEX >> */
+ if
+ (p_j2k->cstr_info && compno == 0)
+ {
+ OPJ_UINT32 l_data_size = l_tccp->numresolutions * sizeof(OPJ_UINT32);
+ memcpy(p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].pdx,l_tccp->prcw, l_data_size);
+ memcpy(p_j2k->cstr_info->tile[p_j2k->m_current_tile_number].pdy,l_tccp->prch, l_data_size);
+ }
+ /* << INDEX */
+ return true;
+}
+
+/**
+ * Copies the tile component parameters of all the component from the first tile component.
+ *
+ * @param p_j2k the J2k codec.
+ */
+void j2k_copy_tile_component_parameters(
+ opj_j2k_t *p_j2k
+ )
+{
+ // loop
+ OPJ_UINT32 i;
+
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ opj_tccp_t *l_ref_tccp = 00;
+ opj_tccp_t *l_copied_tccp = 00;
+ OPJ_UINT32 l_prc_size;
+ // preconditions
+ assert(p_j2k != 00);
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
+
+ l_ref_tccp = &l_tcp->tccps[0];
+ l_copied_tccp = l_ref_tccp + 1;
+ l_prc_size = l_ref_tccp->numresolutions * sizeof(OPJ_UINT32);
+
+ for
+ (i=1;i<p_j2k->m_image->numcomps;++i)
+ {
+ l_copied_tccp->numresolutions = l_ref_tccp->numresolutions;
+ l_copied_tccp->cblkw = l_ref_tccp->cblkw;
+ l_copied_tccp->cblkh = l_ref_tccp->cblkh;
+ l_copied_tccp->cblksty = l_ref_tccp->cblksty;
+ l_copied_tccp->qmfbid = l_ref_tccp->qmfbid;
+ memcpy(l_copied_tccp->prcw,l_ref_tccp->prcw,l_prc_size);
+ memcpy(l_copied_tccp->prch,l_ref_tccp->prch,l_prc_size);
+ ++l_copied_tccp;
+ }
+}
+
+
+
+/**
+ * Writes the COD marker (Coding style default)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_cod(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ OPJ_UINT32 l_code_size,l_remaining_size;
+ OPJ_BYTE * l_current_data = 00;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
+ l_code_size = 9 + j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,0);
+ l_remaining_size = l_code_size;
+
+ if
+ (l_code_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
+ {
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data
+ = opj_realloc(
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data,
+ l_code_size);
+ if
+ (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_code_size;
+ }
+
+ l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
+
+ opj_write_bytes(l_current_data,J2K_MS_COD,2); /* COD */
+ l_current_data += 2;
+
+ opj_write_bytes(l_current_data,l_code_size-2,2); /* L_COD */
+ l_current_data += 2;
+
+ opj_write_bytes(l_current_data,l_tcp->csty,1); /* Scod */
+ ++l_current_data;
+
+ opj_write_bytes(l_current_data,l_tcp->prg,1); /* SGcod (A) */
+ ++l_current_data;
+
+ opj_write_bytes(l_current_data,l_tcp->numlayers,2); /* SGcod (B) */
+ l_current_data+=2;
+
+ opj_write_bytes(l_current_data,l_tcp->mct,1); /* SGcod (C) */
+ ++l_current_data;
+
+ l_remaining_size -= 9;
+
+ if
+ (! j2k_write_SPCod_SPCoc(p_j2k,p_j2k->m_current_tile_number,0,l_current_data,&l_remaining_size,p_manager))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error writting COD marker\n");
+ return false;
+ }
+ if
+ (l_remaining_size != 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error writting COD marker\n");
+ return false;
+ }
+
+ if
+ (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_code_size,p_manager) != l_code_size)
+ {
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Reads a COD marker (Coding Styke defaults)
+ * @param p_header_data the data contained in the COD box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the COD marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_cod (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ // loop
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_tmp;
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ opj_image_t *l_image = 00;
+
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH) ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
+ l_image = p_j2k->m_image;
+
+ // make sure room is sufficient
+ if
+ (p_header_size < 5)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n");
+ return false;
+ }
+
+ opj_read_bytes(p_header_data,&l_tcp->csty,1); /* Scod */
+ ++p_header_data;
+ opj_read_bytes(p_header_data,&l_tmp,1); /* SGcod (A) */
+ ++p_header_data;
+ l_tcp->prg = (OPJ_PROG_ORDER) l_tmp;
+ opj_read_bytes(p_header_data,&l_tcp->numlayers,2); /* SGcod (B) */
+ p_header_data+=2;
+ if
+ (l_cp->m_specific_param.m_dec.m_layer)
+ {
+ l_tcp->num_layers_to_decode = l_cp->m_specific_param.m_dec.m_layer;
+ }
+ else
+ {
+ l_tcp->num_layers_to_decode = l_tcp->numlayers;
+ }
+
+ opj_read_bytes(p_header_data,&l_tcp->mct,1); /* SGcod (C) */
+ ++p_header_data;
+
+ p_header_size -= 5;
+ for
+ (i = 0; i < l_image->numcomps; ++i)
+ {
+ l_tcp->tccps[i].csty = l_tcp->csty & J2K_CCP_CSTY_PRT;
+ }
+
+ if
+ (! j2k_read_SPCod_SPCoc(p_j2k,0,p_header_data,&p_header_size,p_manager))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n");
+ return false;
+ }
+ if
+ (p_header_size != 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n");
+ return false;
+ }
+ j2k_copy_tile_component_parameters(p_j2k);
+
+
+ /* Index */
+ if
+ (p_j2k->cstr_info)
+ {
+ opj_codestream_info_t *l_cstr_info = p_j2k->cstr_info;
+ l_cstr_info->prog = l_tcp->prg;
+ l_cstr_info->numlayers = l_tcp->numlayers;
+ l_cstr_info->numdecompos = (OPJ_INT32*) opj_malloc(l_image->numcomps * sizeof(OPJ_UINT32));
+ for
+ (i = 0; i < l_image->numcomps; ++i)
+ {
+ l_cstr_info->numdecompos[i] = l_tcp->tccps[i].numresolutions - 1;
+ }
+ }
+ return true;
+}
+
+/**
+ * Writes the COC marker (Coding style component)
+ *
+ * @param p_comp_no the index of the component to output.
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_coc(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_comp_no,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 l_coc_size,l_remaining_size;
+ OPJ_UINT32 l_comp_room;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_comp_room = (p_j2k->m_image->numcomps <= 256) ? 1 : 2;
+
+ l_coc_size = 5 + l_comp_room + j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
+ if
+ (l_coc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
+ {
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data
+ = opj_realloc(
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data,
+ l_coc_size);
+ if
+ (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_coc_size;
+ }
+
+ j2k_write_coc_in_memory(p_j2k,p_comp_no,p_j2k->m_specific_param.m_encoder.m_header_tile_data,&l_remaining_size,p_manager);
+
+ if
+ (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_coc_size,p_manager) != l_coc_size)
+ {
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Gets the maximum size taken by a coc.
+ *
+ * @param p_j2k the jpeg2000 codec to use.
+ */
+OPJ_UINT32 j2k_get_max_coc_size(opj_j2k_t *p_j2k)
+{
+ OPJ_UINT32 i,j;
+ OPJ_UINT32 l_nb_comp;
+ OPJ_UINT32 l_nb_tiles;
+ OPJ_UINT32 l_max = 0;
+
+ // preconditions
+
+ l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th ;
+ l_nb_comp = p_j2k->m_image->numcomps;
+
+ for
+ (i=0;i<l_nb_tiles;++i)
+ {
+ for
+ (j=0;j<l_nb_comp;++j)
+ {
+ l_max = uint_max(l_max,j2k_get_SPCod_SPCoc_size(p_j2k,i,j));
+ }
+ }
+ return 6 + l_max;
+}
+
+/**
+ * Gets the maximum size taken by the toc headers of all the tile parts of any given tile.
+ */
+OPJ_UINT32 j2k_get_max_toc_size (opj_j2k_t *p_j2k)
+{
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_nb_tiles;
+ OPJ_UINT32 l_max = 0;
+ opj_tcp_t * l_tcp = 00;
+ // preconditions
+
+ l_tcp = p_j2k->m_cp.tcps;
+ l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th ;
+
+ for
+ (i=0;i<l_nb_tiles;++i)
+ {
+ l_max = uint_max(l_max,l_tcp->m_nb_tile_parts);
+ ++l_tcp;
+ }
+ return 12 * l_max;
+}
+
+
+/**
+ * Gets the maximum size taken by the headers of the SOT.
+ *
+ * @param p_j2k the jpeg2000 codec to use.
+ */
+OPJ_UINT32 j2k_get_specific_header_sizes(opj_j2k_t *p_j2k)
+{
+ OPJ_UINT32 l_nb_bytes = 0;
+ OPJ_UINT32 l_nb_comps;
+ OPJ_UINT32 l_coc_bytes,l_qcc_bytes;
+
+
+ l_nb_comps = p_j2k->m_image->numcomps - 1;
+ l_nb_bytes += j2k_get_max_toc_size(p_j2k);
+ if
+ (p_j2k->m_cp.m_specific_param.m_enc.m_cinema == 0)
+ {
+ l_coc_bytes = j2k_get_max_coc_size(p_j2k);
+ l_nb_bytes += l_nb_comps * l_coc_bytes;
+ l_qcc_bytes = j2k_get_max_qcc_size(p_j2k);
+ l_nb_bytes += l_nb_comps * l_qcc_bytes;
+ }
+ l_nb_bytes += j2k_get_max_poc_size(p_j2k);
+ /*** DEVELOPER CORNER, Add room for your headers ***/
+
+
+ return l_nb_bytes;
+}
+
+
+/**
+ * Writes the COC marker (Coding style component)
+ *
+ * @param p_comp_no the index of the component to output.
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+void j2k_write_coc_in_memory(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_comp_no,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_data_written,
+ struct opj_event_mgr * p_manager
+ )
+{
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ OPJ_UINT32 l_coc_size,l_remaining_size;
+ OPJ_BYTE * l_current_data = 00;
+ opj_image_t *l_image = 00;
+ OPJ_UINT32 l_comp_room;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
+ l_image = p_j2k->m_image;
+ l_comp_room = (l_image->numcomps <= 256) ? 1 : 2;
+
+ l_coc_size = 5 + l_comp_room + j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
+ l_remaining_size = l_coc_size;
+
+ l_current_data = p_data;
+
+ opj_write_bytes(l_current_data,J2K_MS_COC,2); /* COC */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,l_coc_size-2,2); /* L_COC */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,p_comp_no, l_comp_room); /* Ccoc */
+ l_current_data+=l_comp_room;
+ opj_write_bytes(l_current_data, l_tcp->tccps[p_comp_no].csty, 1); /* Scoc */
+ ++l_current_data;
+ l_remaining_size -= (5 + l_comp_room);
+ j2k_write_SPCod_SPCoc(p_j2k,p_j2k->m_current_tile_number,0,l_current_data,&l_remaining_size,p_manager);
+ * p_data_written = l_coc_size;
+}
+
+
+/**
+ * Reads a COC marker (Coding Style Component)
+ * @param p_header_data the data contained in the COC box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the COC marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_coc (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ opj_image_t *l_image = 00;
+ OPJ_UINT32 l_comp_room;
+ OPJ_UINT32 l_comp_no;
+
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH) ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
+ l_image = p_j2k->m_image;
+
+ l_comp_room = l_image->numcomps <= 256 ? 1 : 2;
+ // make sure room is sufficient
+ if
+ (p_header_size < l_comp_room + 1)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n");
+ return false;
+ }
+ p_header_size -= l_comp_room + 1;
+
+ opj_read_bytes(p_header_data,&l_comp_no,l_comp_room); /* Ccoc */
+ p_header_data += l_comp_room;
+ if
+ (l_comp_no >= l_image->numcomps)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker (bad number of components)\n");
+ return false;
+ }
+ opj_read_bytes(p_header_data,&l_tcp->tccps[l_comp_no].csty,1); /* Scoc */
+ ++p_header_data ;
+
+ if
+ (! j2k_read_SPCod_SPCoc(p_j2k,l_comp_no,p_header_data,&p_header_size,p_manager))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n");
+ return false;
+ }
+ if
+ (p_header_size != 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n");
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Gets the size taken by writting SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC.
+ *
+ * @param p_tile_no the tile indix.
+ * @param p_comp_no the component being outputted.
+ * @param p_j2k the J2K codec.
+ *
+ * @return the number of bytes taken by the SPCod element.
+ */
+OPJ_UINT32 j2k_get_SQcd_SQcc_size (
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_tile_no,
+ OPJ_UINT32 p_comp_no
+ )
+{
+ OPJ_UINT32 l_num_bands;
+
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ opj_tccp_t *l_tccp = 00;
+
+ // preconditions
+ assert(p_j2k != 00);
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = &l_cp->tcps[p_tile_no];
+ l_tccp = &l_tcp->tccps[p_comp_no];
+
+ // preconditions again
+ assert(p_tile_no < l_cp->tw * l_cp->th);
+ assert(p_comp_no < p_j2k->m_image->numcomps);
+
+ l_num_bands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 : (l_tccp->numresolutions * 3 - 2);
+
+ if
+ (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT)
+ {
+ return 1 + l_num_bands;
+ }
+ else
+ {
+ return 1 + 2*l_num_bands;
+ }
+}
+
+/**
+ * Writes a SQcd or SQcc element, i.e. the quantization values of a band.
+ *
+ * @param p_tile_no the tile to output.
+ * @param p_comp_no the component number to output.
+ * @param p_data the data buffer.
+ * @param p_header_size pointer to the size of the data buffer, it is changed by the function.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+ *
+*/
+bool j2k_write_SQcd_SQcc(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_tile_no,
+ OPJ_UINT32 p_comp_no,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 l_header_size;
+ OPJ_UINT32 l_band_no, l_num_bands;
+ OPJ_UINT32 l_expn,l_mant;
+
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ opj_tccp_t *l_tccp = 00;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_header_size != 00);
+ assert(p_manager != 00);
+ assert(p_data != 00);
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = &l_cp->tcps[p_tile_no];
+ l_tccp = &l_tcp->tccps[p_comp_no];
+
+ // preconditions again
+ assert(p_tile_no < l_cp->tw * l_cp->th);
+ assert(p_comp_no <p_j2k->m_image->numcomps);
+
+ l_num_bands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 : (l_tccp->numresolutions * 3 - 2);
+
+ if
+ (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT)
+ {
+ l_header_size = 1 + l_num_bands;
+ if
+ (*p_header_size < l_header_size)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error writting SQcd SQcc element\n");
+ return false;
+ }
+ opj_write_bytes(p_data,l_tccp->qntsty + (l_tccp->numgbits << 5), 1); /* Sqcx */
+ ++p_data;
+ for
+ (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no)
+ {
+ l_expn = l_tccp->stepsizes[l_band_no].expn;
+ opj_write_bytes(p_data, l_expn << 3, 1); /* SPqcx_i */
+ ++p_data;
+ }
+ }
+ else
+ {
+ l_header_size = 1 + 2*l_num_bands;
+ if
+ (*p_header_size < l_header_size)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error writting SQcd SQcc element\n");
+ return false;
+ }
+ opj_write_bytes(p_data,l_tccp->qntsty + (l_tccp->numgbits << 5), 1); /* Sqcx */
+ ++p_data;
+ for
+ (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no)
+ {
+ l_expn = l_tccp->stepsizes[l_band_no].expn;
+ l_mant = l_tccp->stepsizes[l_band_no].mant;
+ opj_write_bytes(p_data, (l_expn << 11) + l_mant, 2); /* SPqcx_i */
+ p_data += 2;
+ }
+ }
+ *p_header_size = *p_header_size - l_header_size;
+ return true;
+}
+
+/**
+ * Reads a SQcd or SQcc element, i.e. the quantization values of a band.
+ *
+ * @param p_comp_no the component being targeted.
+ * @param p_header_data the data contained in the COM box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the COM marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_SQcd_SQcc(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_comp_no,
+ OPJ_BYTE* p_header_data,
+ OPJ_UINT32 * p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ // loop
+ OPJ_UINT32 l_band_no;
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ opj_tccp_t *l_tccp = 00;
+ OPJ_BYTE * l_current_ptr = 00;
+ OPJ_UINT32 l_tmp;
+ OPJ_UINT32 l_num_band;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_header_data != 00);
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
+ // precondition again
+ assert(p_comp_no < p_j2k->m_image->numcomps);
+ l_tccp = &l_tcp->tccps[p_comp_no];
+ l_current_ptr = p_header_data;
+
+ if
+ (* p_header_size < 1)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading SQcd or SQcc element\n");
+ return false;
+ }
+ * p_header_size -= 1;
+
+ opj_read_bytes(l_current_ptr, &l_tmp ,1); /* Sqcx */
+ ++l_current_ptr;
+
+ l_tccp->qntsty = l_tmp & 0x1f;
+ l_tccp->numgbits = l_tmp >> 5;
+ if
+ (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT)
+ {
+ l_num_band = 1;
+ }
+ else
+ {
+ l_num_band = (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) ? (*p_header_size) : (*p_header_size) / 2;
+ }
+
+#ifdef USE_JPWL
+ if (p_j2k->m_cp->correct) {
+
+ /* if JPWL is on, we check whether there are too many subbands */
+ if ((numbands < 0) || (numbands >= J2K_MAXBANDS)) {
+ opj_event_msg(p_j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
+ "JPWL: bad number of subbands in Sqcx (%d)\n",
+ numbands);
+ if (!JPWL_ASSUME) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+ return;
+ }
+ /* we try to correct */
+ numbands = 1;
+ opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- trying to adjust them\n"
+ "- setting number of bands to %d => HYPOTHESIS!!!\n",
+ numbands);
+ };
+
+ };
+#endif /* USE_JPWL */
+ if
+ (l_tccp->qntsty == J2K_CCP_QNTSTY_NOQNT)
+ {
+ for
+ (l_band_no = 0; l_band_no < l_num_band; l_band_no++)
+ {
+ opj_read_bytes(l_current_ptr, &l_tmp ,1); /* SPqcx_i */
+ ++l_current_ptr;
+ l_tccp->stepsizes[l_band_no].expn = l_tmp>>3;
+ l_tccp->stepsizes[l_band_no].mant = 0;
+ }
+ * p_header_size = * p_header_size - l_num_band;
+ }
+ else
+ {
+ for
+ (l_band_no = 0; l_band_no < l_num_band; l_band_no++)
+ {
+ opj_read_bytes(l_current_ptr, &l_tmp ,2); /* SPqcx_i */
+ l_current_ptr+=2;
+ l_tccp->stepsizes[l_band_no].expn = l_tmp >> 11;
+ l_tccp->stepsizes[l_band_no].mant = l_tmp & 0x7ff;
+ }
+ * p_header_size = * p_header_size - 2*l_num_band;
+ }
+
+ /* Add Antonin : if scalar_derived -> compute other stepsizes */
+ if
+ (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT)
+ {
+ for
+ (l_band_no = 1; l_band_no < J2K_MAXBANDS; l_band_no++)
+ {
+ l_tccp->stepsizes[l_band_no].expn =
+ ((l_tccp->stepsizes[0].expn) - ((l_band_no - 1) / 3) > 0) ?
+ (l_tccp->stepsizes[0].expn) - ((l_band_no - 1) / 3) : 0;
+ l_tccp->stepsizes[l_band_no].mant = l_tccp->stepsizes[0].mant;
+ }
+
+ }
+ return true;
+}
+
+
+
+/**
+ * Copies the tile component parameters of all the component from the first tile component.
+ *
+ * @param p_j2k the J2k codec.
+ */
+void j2k_copy_tile_quantization_parameters(
+ opj_j2k_t *p_j2k
+ )
+{
+ // loop
+ OPJ_UINT32 i;
+
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ opj_tccp_t *l_ref_tccp = 00;
+ opj_tccp_t *l_copied_tccp = 00;
+ OPJ_UINT32 l_size;
+ // preconditions
+ assert(p_j2k != 00);
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
+ // precondition again
+ l_ref_tccp = &l_tcp->tccps[0];
+ l_copied_tccp = l_ref_tccp + 1;
+ l_size = J2K_MAXBANDS * sizeof(opj_stepsize_t);
+
+ for
+ (i=1;i<p_j2k->m_image->numcomps;++i)
+ {
+ l_copied_tccp->qntsty = l_ref_tccp->qntsty;
+ l_copied_tccp->numgbits = l_ref_tccp->numgbits;
+ memcpy(l_copied_tccp->stepsizes,l_ref_tccp->stepsizes,l_size);
+ ++l_copied_tccp;
+ }
+}
+
+
+
+/**
+ * Writes the QCD marker (quantization default)
+ *
+ * @param p_comp_number the index of the component to output.
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_qcd(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ OPJ_UINT32 l_qcd_size,l_remaining_size;
+ OPJ_BYTE * l_current_data = 00;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
+ l_qcd_size = 4 + j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,0);
+ l_remaining_size = l_qcd_size;
+
+ if
+ (l_qcd_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
+ {
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data
+ = opj_realloc(
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data,
+ l_qcd_size);
+ if
+ (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_qcd_size;
+ }
+ l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
+
+ opj_write_bytes(l_current_data,J2K_MS_QCD,2); /* QCD */
+ l_current_data += 2;
+
+ opj_write_bytes(l_current_data,l_qcd_size-2,2); /* L_QCD */
+ l_current_data += 2;
+
+ l_remaining_size -= 4;
+
+ if
+ (! j2k_write_SQcd_SQcc(p_j2k,p_j2k->m_current_tile_number,0,l_current_data,&l_remaining_size,p_manager))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error writting QCD marker\n");
+ return false;
+ }
+ if
+ (l_remaining_size != 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error writting QCD marker\n");
+ return false;
+ }
+
+ if
+ (opj_stream_write_data(p_stream, p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_qcd_size,p_manager) != l_qcd_size)
+ {
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Reads a QCD marker (Quantization defaults)
+ * @param p_header_data the data contained in the QCD box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the QCD marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_qcd (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ if
+ (! j2k_read_SQcd_SQcc(p_j2k,0,p_header_data,&p_header_size,p_manager))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading QCD marker\n");
+ return false;
+ }
+ if
+ (p_header_size != 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading QCD marker\n");
+ return false;
+ }
+ j2k_copy_tile_quantization_parameters(p_j2k);
+ return true;
+}
+
+
+/**
+ * Writes the QCC marker (quantization component)
+ *
+ * @param p_comp_no the index of the component to output.
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_qcc(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_comp_no,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 l_qcc_size,l_remaining_size;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_qcc_size = 6 + j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
+ l_remaining_size = l_qcc_size;
+ if
+ (l_qcc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
+ {
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data
+ = opj_realloc(
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data,
+ l_qcc_size);
+ if
+ (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_qcc_size;
+ }
+ j2k_write_qcc_in_memory(p_j2k,p_comp_no,p_j2k->m_specific_param.m_encoder.m_header_tile_data,&l_remaining_size,p_manager);
+
+ if
+ (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_qcc_size,p_manager) != l_qcc_size)
+ {
+ return false;
+ }
+ return true;
+}
+
+
+/**
+ * Writes the QCC marker (quantization component)
+ *
+ * @param p_comp_no the index of the component to output.
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+void j2k_write_qcc_in_memory(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_comp_no,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_data_written,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 l_qcc_size,l_remaining_size;
+ OPJ_BYTE * l_current_data = 00;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_qcc_size = 6 + j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no);
+ l_remaining_size = l_qcc_size;
+
+ l_current_data = p_data;
+
+ opj_write_bytes(l_current_data,J2K_MS_QCC,2); /* QCC */
+ l_current_data += 2;
+
+ if
+ (p_j2k->m_image->numcomps <= 256)
+ {
+ --l_qcc_size;
+ opj_write_bytes(l_current_data,l_qcc_size-2,2); /* L_QCC */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data, p_comp_no, 1); /* Cqcc */
+ ++l_current_data;
+ // in the case only one byte is sufficient the last byte allocated is useless -> still do -6 for available
+ l_remaining_size -= 6;
+ }
+ else
+ {
+ opj_write_bytes(l_current_data,l_qcc_size-2,2); /* L_QCC */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data, p_comp_no, 2); /* Cqcc */
+ l_current_data+=2;
+ l_remaining_size -= 6;
+ }
+ j2k_write_SQcd_SQcc(p_j2k,p_j2k->m_current_tile_number,p_comp_no,l_current_data,&l_remaining_size,p_manager);
+ * p_data_written = l_qcc_size;
+}
+
+/**
+ * Gets the maximum size taken by a qcc.
+ */
+OPJ_UINT32 j2k_get_max_qcc_size (opj_j2k_t *p_j2k)
+{
+ return j2k_get_max_coc_size(p_j2k);
+}
+
+/**
+ * Reads a QCC marker (Quantization component)
+ * @param p_header_data the data contained in the QCC box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the QCC marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_qcc(
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager)
+{
+ OPJ_UINT32 l_num_comp,l_comp_no;
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_num_comp = p_j2k->m_image->numcomps;
+
+#ifdef USE_JPWL
+ if (p_j2k->m_cp->correct) {
+
+ static OPJ_UINT32 backup_compno = 0;
+
+ /* compno is negative or larger than the number of components!!! */
+ if ((compno < 0) || (compno >= numcomp)) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR,
+ "JPWL: bad component number in QCC (%d out of a maximum of %d)\n",
+ compno, numcomp);
+ if (!JPWL_ASSUME) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+ return;
+ }
+ /* we try to correct */
+ compno = backup_compno % numcomp;
+ opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- trying to adjust this\n"
+ "- setting component number to %d\n",
+ compno);
+ }
+
+ /* keep your private count of tiles */
+ backup_compno++;
+ };
+#endif /* USE_JPWL */
+ if
+ (l_num_comp <= 256)
+ {
+ if
+ (p_header_size < 1)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
+ return false;
+ }
+ opj_read_bytes(p_header_data,&l_comp_no,1);
+ ++p_header_data;
+ --p_header_size;
+ }
+ else
+ {
+ if
+ (p_header_size < 2)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
+ return false;
+ }
+ opj_read_bytes(p_header_data,&l_comp_no,2);
+ p_header_data+=2;
+ p_header_size-=2;
+ }
+ if
+ (! j2k_read_SQcd_SQcc(p_j2k,l_comp_no,p_header_data,&p_header_size,p_manager))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
+ return false;
+ }
+ if
+ (p_header_size != 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n");
+ return false;
+ }
+ return true;
+
+}
+
+
+/**
+ * Writes the CBD marker (Component bit depth definition)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_cbd(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_cbd_size;
+ OPJ_BYTE * l_current_data = 00;
+ opj_image_t *l_image = 00;
+ opj_image_comp_t * l_comp = 00;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_image = p_j2k->m_image;
+ l_cbd_size = 6 + p_j2k->m_image->numcomps;
+
+ if
+ (l_cbd_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
+ {
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data
+ = opj_realloc(
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data,
+ l_cbd_size);
+ if
+ (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_cbd_size;
+ }
+
+ l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
+ opj_write_bytes(l_current_data,J2K_MS_CBD,2); /* CBD */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,l_cbd_size-2,2); /* L_CBD */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,l_image->numcomps, 2); /* Ncbd */
+ l_current_data+=2;
+ l_comp = l_image->comps;
+ for
+ (i=0;i<l_image->numcomps;++i)
+ {
+ opj_write_bytes(l_current_data, (l_comp->sgnd << 7) | (l_comp->prec - 1), 1); /* Component bit depth */
+ ++l_current_data;
+ ++l_comp;
+ }
+ if
+ (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_cbd_size,p_manager) != l_cbd_size)
+ {
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Reads a CBD marker (Component bit depth definition)
+ * @param p_header_data the data contained in the CBD box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the CBD marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_cbd (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager)
+{
+ OPJ_UINT32 l_nb_comp,l_num_comp;
+ OPJ_UINT32 l_comp_def;
+ OPJ_UINT32 i;
+ opj_image_comp_t * l_comp = 00;
+
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_num_comp = p_j2k->m_image->numcomps;
+
+ if
+ (p_header_size != (p_j2k->m_image->numcomps + 2))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Crror reading CBD marker\n");
+ return false;
+ }
+ opj_read_bytes(p_header_data,&l_nb_comp,2); /* Ncbd */
+ p_header_data+=2;
+ if
+ (l_nb_comp != l_num_comp)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Crror reading CBD marker\n");
+ return false;
+ }
+
+ l_comp = p_j2k->m_image->comps;
+ for
+ (i=0;i<l_num_comp;++i)
+ {
+ opj_read_bytes(p_header_data,&l_comp_def,1); /* Component bit depth */
+ ++p_header_data;
+ l_comp->sgnd = (l_comp_def>>7) & 1;
+ l_comp->prec = (l_comp_def&0x7f) + 1;
+ ++l_comp;
+ }
+ return true;
+}
+
+/**
+ * Writes the MCC marker (Multiple Component Collection)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_mcc_record(
+ opj_j2k_t *p_j2k,
+ struct opj_simple_mcc_decorrelation_data * p_mcc_record,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_mcc_size;
+ OPJ_BYTE * l_current_data = 00;
+ OPJ_UINT32 l_nb_bytes_for_comp;
+ OPJ_UINT32 l_mask;
+ OPJ_UINT32 l_tmcc;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ if
+ (p_mcc_record->m_nb_comps > 255 )
+ {
+ l_nb_bytes_for_comp = 2;
+ l_mask = 0x8000;
+ }
+ else
+ {
+ l_nb_bytes_for_comp = 1;
+ l_mask = 0;
+ }
+
+ l_mcc_size = p_mcc_record->m_nb_comps * 2 * l_nb_bytes_for_comp + 19;
+ if
+ (l_mcc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
+ {
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data
+ = opj_realloc(
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data,
+ l_mcc_size);
+ if
+ (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_mcc_size;
+ }
+ l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
+ opj_write_bytes(l_current_data,J2K_MS_MCC,2); /* MCC */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,l_mcc_size-2,2); /* Lmcc */
+ l_current_data += 2;
+
+ /* first marker */
+ opj_write_bytes(l_current_data,0,2); /* Zmcc */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,p_mcc_record->m_index,1); /* Imcc -> no need for other values, take the first */
+ ++l_current_data;
+ /* only one marker atm */
+ opj_write_bytes(l_current_data,0,2); /* Ymcc */
+ l_current_data+=2;
+ opj_write_bytes(l_current_data,1,2); /* Qmcc -> number of collections -> 1 */
+ l_current_data+=2;
+ opj_write_bytes(l_current_data,0x1,1); /* Xmcci type of component transformation -> array based decorrelation */
+ ++l_current_data;
+
+ opj_write_bytes(l_current_data,p_mcc_record->m_nb_comps | l_mask,2); /* Nmcci number of input components involved and size for each component offset = 8 bits */
+ l_current_data+=2;
+
+ for
+ (i=0;i<p_mcc_record->m_nb_comps;++i)
+ {
+ opj_write_bytes(l_current_data,i,l_nb_bytes_for_comp); /* Cmccij Component offset*/
+ l_current_data+=l_nb_bytes_for_comp;
+ }
+
+ opj_write_bytes(l_current_data,p_mcc_record->m_nb_comps|l_mask,2); /* Mmcci number of output components involved and size for each component offset = 8 bits */
+ l_current_data+=2;
+ for
+ (i=0;i<p_mcc_record->m_nb_comps;++i)
+ {
+ opj_write_bytes(l_current_data,i,l_nb_bytes_for_comp); /* Wmccij Component offset*/
+ l_current_data+=l_nb_bytes_for_comp;
+ }
+ l_tmcc = ((!p_mcc_record->m_is_irreversible)&1)<<16;
+ if
+ (p_mcc_record->m_decorrelation_array)
+ {
+ l_tmcc |= p_mcc_record->m_decorrelation_array->m_index;
+ }
+ if
+ (p_mcc_record->m_offset_array)
+ {
+ l_tmcc |= ((p_mcc_record->m_offset_array->m_index)<<8);
+ }
+ opj_write_bytes(l_current_data,l_tmcc,3); /* Tmcci : use MCT defined as number 1 and irreversible array based. */
+ l_current_data+=3;
+ if
+ (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_mcc_size,p_manager) != l_mcc_size)
+ {
+ return false;
+ }
+ return true;
+}
+
+
+/**
+ * Reads a MCC marker (Multiple Component Collection)
+ *
+ * @param p_header_data the data contained in the MCC box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the MCC marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_mcc (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 i,j;
+ OPJ_UINT32 l_tmp;
+ OPJ_UINT32 l_indix;
+ opj_tcp_t * l_tcp;
+ opj_simple_mcc_decorrelation_data_t * l_mcc_record;
+ opj_mct_data_t * l_mct_data;
+ OPJ_UINT32 l_nb_collections;
+ OPJ_UINT32 l_nb_comps;
+ OPJ_UINT32 l_nb_bytes_by_comp;
+
+
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH ? &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
+
+ if
+ (p_header_size < 2)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return false;
+ }
+
+ /* first marker */
+ opj_read_bytes(p_header_data,&l_tmp,2); /* Zmcc */
+ p_header_data += 2;
+ if
+ (l_tmp != 0)
+ {
+ opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple data spanning\n");
+ return true;
+ }
+ if
+ (p_header_size < 7)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return false;
+ }
+ opj_read_bytes(p_header_data,&l_indix,1); /* Imcc -> no need for other values, take the first */
+ ++p_header_data;
+
+ l_mcc_record = l_tcp->m_mcc_records;
+ for
+ (i=0;i<l_tcp->m_nb_mcc_records;++i)
+ {
+ if
+ (l_mcc_record->m_index == l_indix)
+ {
+ break;
+ }
+ ++l_mcc_record;
+ }
+ /** NOT FOUND */
+ if
+ (i == l_tcp->m_nb_mcc_records)
+ {
+ if
+ (l_tcp->m_nb_mcc_records == l_tcp->m_nb_max_mcc_records)
+ {
+ l_tcp->m_nb_max_mcc_records += J2K_MCC_DEFAULT_NB_RECORDS;
+ l_tcp->m_mcc_records = opj_realloc(l_tcp->m_mcc_records,l_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t));
+ if
+ (! l_tcp->m_mcc_records)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return false;
+ }
+ l_mcc_record = l_tcp->m_mcc_records + l_tcp->m_nb_mcc_records;
+ memset(l_mcc_record,0,(l_tcp->m_nb_max_mcc_records-l_tcp->m_nb_mcc_records) * sizeof(opj_simple_mcc_decorrelation_data_t));
+ }
+ l_mcc_record = l_tcp->m_mcc_records + l_tcp->m_nb_mcc_records;
+ }
+ l_mcc_record->m_index = l_indix;
+
+ /* only one marker atm */
+ opj_read_bytes(p_header_data,&l_tmp,2); /* Ymcc */
+ p_header_data+=2;
+ if
+ (l_tmp != 0)
+ {
+ opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple data spanning\n");
+ return true;
+ }
+ opj_read_bytes(p_header_data,&l_nb_collections,2); /* Qmcc -> number of collections -> 1 */
+ p_header_data+=2;
+ if
+ (l_nb_collections > 1)
+ {
+ opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple collections\n");
+ return true;
+ }
+ p_header_size -= 7;
+ for
+ (i=0;i<l_nb_collections;++i)
+ {
+ if
+ (p_header_size < 3)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return false;
+ }
+ opj_read_bytes(p_header_data,&l_tmp,1); /* Xmcci type of component transformation -> array based decorrelation */
+ ++p_header_data;
+ if
+ (l_tmp != 1)
+ {
+ opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections other than array decorrelation\n");
+ return true;
+ }
+ opj_read_bytes(p_header_data,&l_nb_comps,2);
+ p_header_data+=2;
+ p_header_size-=3;
+ l_nb_bytes_by_comp = 1 + (l_nb_comps>>15);
+ l_mcc_record->m_nb_comps = l_nb_comps & 0x7fff;
+ if
+ (p_header_size < (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 2))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return false;
+ }
+ p_header_size -= (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 2);
+ for
+ (j=0;j<l_mcc_record->m_nb_comps;++j)
+ {
+ opj_read_bytes(p_header_data,&l_tmp,l_nb_bytes_by_comp); /* Cmccij Component offset*/
+ p_header_data+=l_nb_bytes_by_comp;
+ if
+ (l_tmp != j)
+ {
+ opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections with indix shuffle\n");
+ return true;
+ }
+ }
+ opj_read_bytes(p_header_data,&l_nb_comps,2);
+ p_header_data+=2;
+ l_nb_bytes_by_comp = 1 + (l_nb_comps>>15);
+ l_nb_comps &= 0x7fff;
+ if
+ (l_nb_comps != l_mcc_record->m_nb_comps)
+ {
+ opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections without same number of indixes\n");
+ return true;
+ }
+ if
+ (p_header_size < (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 3))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return false;
+ }
+ p_header_size -= (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 3);
+ for
+ (j=0;j<l_mcc_record->m_nb_comps;++j)
+ {
+ opj_read_bytes(p_header_data,&l_tmp,l_nb_bytes_by_comp); /* Wmccij Component offset*/
+ p_header_data+=l_nb_bytes_by_comp;
+ if
+ (l_tmp != j)
+ {
+ opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections with indix shuffle\n");
+ return true;
+ }
+ }
+ opj_read_bytes(p_header_data,&l_tmp,3); /* Wmccij Component offset*/
+ p_header_data += 3;
+ l_mcc_record->m_is_irreversible = ! ((l_tmp>>16) & 1);
+ l_mcc_record->m_decorrelation_array = 00;
+ l_mcc_record->m_offset_array = 00;
+ l_indix = l_tmp & 0xff;
+ if
+ (l_indix != 0)
+ {
+ l_mct_data = l_tcp->m_mct_records;
+ for
+ (j=0;j<l_tcp->m_nb_mct_records;++j)
+ {
+ if
+ (l_mct_data->m_index == l_indix)
+ {
+ l_mcc_record->m_decorrelation_array = l_mct_data;
+ break;
+ }
+ ++l_mct_data;
+ }
+ if
+ (l_mcc_record->m_decorrelation_array == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return false;
+ }
+ }
+ l_indix = (l_tmp >> 8) & 0xff;
+ if
+ (l_indix != 0)
+ {
+ l_mct_data = l_tcp->m_mct_records;
+ for
+ (j=0;j<l_tcp->m_nb_mct_records;++j)
+ {
+ if
+ (l_mct_data->m_index == l_indix)
+ {
+ l_mcc_record->m_offset_array = l_mct_data;
+ break;
+ }
+ ++l_mct_data;
+ }
+ if
+ (l_mcc_record->m_offset_array == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return false;
+ }
+ }
+ }
+ if
+ (p_header_size != 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return false;
+ }
+ ++l_tcp->m_nb_mcc_records;
+ return true;
+}
+
+/**
+ * Writes the MCT marker (Multiple Component Transform)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_mct_record(
+ opj_j2k_t *p_j2k,
+ opj_mct_data_t * p_mct_record,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 l_mct_size;
+ OPJ_BYTE * l_current_data = 00;
+ OPJ_UINT32 l_tmp;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_mct_size = 10 + p_mct_record->m_data_size;
+ if
+ (l_mct_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
+ {
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data
+ = opj_realloc(
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data,
+ l_mct_size);
+ if
+ (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_mct_size;
+ }
+
+ l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
+
+ opj_write_bytes(l_current_data,J2K_MS_MCT,2); /* MCT */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,l_mct_size-2,2); /* Lmct */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,0,2); /* Zmct */
+ l_current_data += 2;
+ /* only one marker atm */
+ l_tmp = (p_mct_record->m_index & 0xff) | (p_mct_record->m_array_type << 8) | (p_mct_record->m_element_type << 10);
+ opj_write_bytes(l_current_data,l_tmp,2);
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,0,2); /* Ymct */
+ l_current_data+=2;
+
+ memcpy(l_current_data,p_mct_record->m_data,p_mct_record->m_data_size);
+ if
+ (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_mct_size,p_manager) != l_mct_size)
+ {
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Reads a MCT marker (Multiple Component Transform)
+ *
+ * @param p_header_data the data contained in the MCT box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the MCT marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_mct (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 i;
+ opj_tcp_t *l_tcp = 00;
+ OPJ_UINT32 l_tmp;
+ OPJ_UINT32 l_indix;
+ opj_mct_data_t * l_mct_data;
+
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+
+ l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH ? &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
+
+ if
+ (p_header_size < 2)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
+ return false;
+ }
+ /* first marker */
+ opj_read_bytes(p_header_data,&l_tmp,2); /* Zmct */
+ p_header_data += 2;
+ if
+ (l_tmp != 0)
+ {
+ opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge mct data within multiple MCT records\n");
+ return true;
+ }
+ if
+ (p_header_size <= 6)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
+ return false;
+ }
+ opj_read_bytes(p_header_data,&l_tmp,2); /* Imct -> no need for other values, take the first, type is double with decorrelation x0000 1101 0000 0000*/
+ p_header_data += 2;
+
+ l_indix = l_tmp & 0xff;
+ l_mct_data = l_tcp->m_mct_records;
+ for
+ (i=0;i<l_tcp->m_nb_mct_records;++i)
+ {
+ if
+ (l_mct_data->m_index == l_indix)
+ {
+ break;
+ }
+ ++l_mct_data;
+ }
+ /* NOT FOUND */
+ if
+ (i == l_tcp->m_nb_mct_records)
+ {
+ if
+ (l_tcp->m_nb_mct_records == l_tcp->m_nb_max_mct_records)
+ {
+ l_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS;
+ l_tcp->m_mct_records = opj_realloc(l_tcp->m_mct_records,l_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
+ if
+ (! l_tcp->m_mct_records)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
+ return false;
+ }
+ l_mct_data = l_tcp->m_mct_records + l_tcp->m_nb_mct_records;
+ memset(l_mct_data ,0,(l_tcp->m_nb_max_mct_records - l_tcp->m_nb_mct_records) * sizeof(opj_mct_data_t));
+ }
+ l_mct_data = l_tcp->m_mct_records + l_tcp->m_nb_mct_records;
+ }
+ if
+ (l_mct_data->m_data)
+ {
+ opj_free(l_mct_data->m_data);
+ l_mct_data->m_data = 00;
+ }
+ l_mct_data->m_index = l_indix;
+ l_mct_data->m_array_type = (l_tmp >> 8) & 3;
+ l_mct_data->m_element_type = (l_tmp >> 10) & 3;
+
+ opj_read_bytes(p_header_data,&l_tmp,2); /* Ymct */
+ p_header_data+=2;
+ if
+ (l_tmp != 0)
+ {
+ opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple MCT markers\n");
+ return true;
+ }
+ p_header_size -= 6;
+ l_mct_data->m_data = opj_malloc(p_header_size);
+ if
+ (! l_mct_data->m_data)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n");
+ return false;
+ }
+ memcpy(l_mct_data->m_data,p_header_data,p_header_size);
+ l_mct_data->m_data_size = p_header_size;
+ ++l_tcp->m_nb_mct_records;
+ return true;
+}
+
+bool j2k_setup_mct_encoding (opj_tcp_t * p_tcp,opj_image_t * p_image)
+{
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_indix = 1;
+ opj_mct_data_t * l_mct_deco_data = 00,* l_mct_offset_data = 00;
+ opj_simple_mcc_decorrelation_data_t * l_mcc_data;
+ OPJ_UINT32 l_mct_size,l_nb_elem;
+ OPJ_FLOAT32 * l_data, * l_current_data;
+ opj_tccp_t * l_tccp;
+
+ // preconditions
+ assert(p_tcp != 00);
+
+ if
+ (p_tcp->mct != 2)
+ {
+ return true;
+ }
+
+ if
+ (p_tcp->m_mct_decoding_matrix)
+ {
+ if
+ (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records)
+ {
+ p_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS;
+ p_tcp->m_mct_records = opj_realloc(p_tcp->m_mct_records,p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
+ if
+ (! p_tcp->m_mct_records)
+ {
+ return false;
+ }
+ l_mct_deco_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
+ memset(l_mct_deco_data ,0,(p_tcp->m_nb_max_mct_records - p_tcp->m_nb_mct_records) * sizeof(opj_mct_data_t));
+ }
+ l_mct_deco_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
+
+ if
+ (l_mct_deco_data->m_data)
+ {
+ opj_free(l_mct_deco_data->m_data);
+ l_mct_deco_data->m_data = 00;
+ }
+ l_mct_deco_data->m_index = l_indix++;
+ l_mct_deco_data->m_array_type = MCT_TYPE_DECORRELATION;
+ l_mct_deco_data->m_element_type = MCT_TYPE_FLOAT;
+ l_nb_elem = p_image->numcomps * p_image->numcomps;
+ l_mct_size = l_nb_elem * MCT_ELEMENT_SIZE[l_mct_deco_data->m_element_type];
+ l_mct_deco_data->m_data = opj_malloc(l_mct_size );
+ if
+ (! l_mct_deco_data->m_data)
+ {
+ return false;
+ }
+ j2k_mct_write_functions_from_float[l_mct_deco_data->m_element_type](p_tcp->m_mct_decoding_matrix,l_mct_deco_data->m_data,l_nb_elem);
+ l_mct_deco_data->m_data_size = l_mct_size;
+ ++p_tcp->m_nb_mct_records;
+ }
+
+ if
+ (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records)
+ {
+ p_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS;
+ p_tcp->m_mct_records = opj_realloc(p_tcp->m_mct_records,p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
+ if
+ (! p_tcp->m_mct_records)
+ {
+ return false;
+ }
+ l_mct_offset_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
+ memset(l_mct_offset_data ,0,(p_tcp->m_nb_max_mct_records - p_tcp->m_nb_mct_records) * sizeof(opj_mct_data_t));
+ if
+ (l_mct_deco_data)
+ {
+ l_mct_deco_data = l_mct_offset_data - 1;
+ }
+ }
+ l_mct_offset_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
+ if
+ (l_mct_offset_data->m_data)
+ {
+ opj_free(l_mct_offset_data->m_data);
+ l_mct_offset_data->m_data = 00;
+ }
+
+ l_mct_offset_data->m_index = l_indix++;
+ l_mct_offset_data->m_array_type = MCT_TYPE_OFFSET;
+ l_mct_offset_data->m_element_type = MCT_TYPE_FLOAT;
+ l_nb_elem = p_image->numcomps;
+ l_mct_size = l_nb_elem * MCT_ELEMENT_SIZE[l_mct_offset_data->m_element_type];
+ l_mct_offset_data->m_data = opj_malloc(l_mct_size );
+ if
+ (! l_mct_offset_data->m_data)
+ {
+ return false;
+ }
+ l_data = opj_malloc(l_nb_elem * sizeof(OPJ_FLOAT32));
+ if
+ (! l_data)
+ {
+ opj_free(l_mct_offset_data->m_data);
+ l_mct_offset_data->m_data = 00;
+ return false;
+ }
+ l_tccp = p_tcp->tccps;
+ l_current_data = l_data;
+ for
+ (i=0;i<l_nb_elem;++i)
+ {
+ *(l_current_data++) = (OPJ_FLOAT32) (l_tccp->m_dc_level_shift);
+ ++l_tccp;
+ }
+ j2k_mct_write_functions_from_float[l_mct_offset_data->m_element_type](l_data,l_mct_offset_data->m_data,l_nb_elem);
+ opj_free(l_data);
+ l_mct_offset_data->m_data_size = l_mct_size;
+ ++p_tcp->m_nb_mct_records;
+
+ if
+ (p_tcp->m_nb_mcc_records == p_tcp->m_nb_max_mcc_records)
+ {
+ p_tcp->m_nb_max_mcc_records += J2K_MCT_DEFAULT_NB_RECORDS;
+ p_tcp->m_mcc_records = opj_realloc(p_tcp->m_mcc_records,p_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t));
+ if
+ (! p_tcp->m_mcc_records)
+ {
+ return false;
+ }
+ l_mcc_data = p_tcp->m_mcc_records + p_tcp->m_nb_mcc_records;
+ memset(l_mcc_data ,0,(p_tcp->m_nb_max_mcc_records - p_tcp->m_nb_mcc_records) * sizeof(opj_simple_mcc_decorrelation_data_t));
+
+ }
+ l_mcc_data = p_tcp->m_mcc_records + p_tcp->m_nb_mcc_records;
+ l_mcc_data->m_decorrelation_array = l_mct_deco_data;
+ l_mcc_data->m_is_irreversible = 1;
+ l_mcc_data->m_nb_comps = p_image->numcomps;
+ l_mcc_data->m_index = l_indix++;
+ l_mcc_data->m_offset_array = l_mct_offset_data;
+ ++p_tcp->m_nb_mcc_records;
+ return true;
+}
+
+/**
+ * Writes the MCO marker (Multiple component transformation ordering)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_mco(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_BYTE * l_current_data = 00;
+ OPJ_UINT32 l_mco_size;
+ opj_tcp_t * l_tcp = 00;
+ opj_simple_mcc_decorrelation_data_t * l_mcc_record;
+ OPJ_UINT32 i;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_tcp =&(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
+ l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
+ l_mco_size = 5 + l_tcp->m_nb_mcc_records;
+ if
+ (l_mco_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
+ {
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data
+ = opj_realloc(
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data,
+ l_mco_size);
+ if
+ (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_mco_size;
+ }
+
+ opj_write_bytes(l_current_data,J2K_MS_MCO,2); /* MCO */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,l_mco_size-2,2); /* Lmco */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,l_tcp->m_nb_mcc_records,1); /* Nmco : only one tranform stage*/
+ ++l_current_data;
+
+ l_mcc_record = l_tcp->m_mcc_records;
+ for
+ (i=0;i<l_tcp->m_nb_mcc_records;++i)
+ {
+ opj_write_bytes(l_current_data,l_mcc_record->m_index,1); /* Imco -> use the mcc indicated by 1*/
+ ++l_current_data;
+ ++l_mcc_record;
+ }
+
+ if
+ (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_mco_size,p_manager) != l_mco_size)
+ {
+ return false;
+ }
+ return true;
+}
+/**
+ * Reads a MCO marker (Multiple Component Transform Ordering)
+ *
+ * @param p_header_data the data contained in the MCO box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the MCO marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_mco (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 l_tmp, i;
+ OPJ_UINT32 l_nb_stages;
+ opj_tcp_t * l_tcp;
+ opj_tccp_t * l_tccp;
+ opj_image_t * l_image;
+ opj_image_comp_t * l_img_comp;
+
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_image = p_j2k->m_image;
+ l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH ? &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
+ if
+ (p_header_size < 1)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading MCO marker\n");
+ return false;
+ }
+
+ opj_read_bytes(p_header_data,&l_nb_stages,1); /* Nmco : only one tranform stage*/
+ ++p_header_data;
+ if
+ (l_nb_stages > 1)
+ {
+ opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple transformation stages.\n");
+ return true;
+ }
+ if
+ (p_header_size != l_nb_stages + 1)
+ {
+ opj_event_msg(p_manager, EVT_WARNING, "Error reading MCO marker\n");
+ return false;
+ }
+
+ l_tccp = l_tcp->tccps;
+ l_img_comp = l_image->comps;
+ for
+ (i=0;i<l_image->numcomps;++i)
+ {
+ l_tccp->m_dc_level_shift = 0;
+ ++l_tccp;
+ }
+ if
+ (l_tcp->m_mct_decoding_matrix)
+ {
+ opj_free(l_tcp->m_mct_decoding_matrix);
+ l_tcp->m_mct_decoding_matrix = 00;
+ }
+
+ for
+ (i=0;i<l_nb_stages;++i)
+ {
+ opj_read_bytes(p_header_data,&l_tmp,1);
+ ++p_header_data;
+ if
+ (! j2k_add_mct(l_tcp,p_j2k->m_image,l_tmp))
+ {
+ return false;
+ }
+ }
+ return true;
+}
+
+bool j2k_add_mct(opj_tcp_t * p_tcp,opj_image_t * p_image, OPJ_UINT32 p_index)
+{
+ OPJ_UINT32 i;
+ opj_simple_mcc_decorrelation_data_t * l_mcc_record;
+ opj_mct_data_t * l_deco_array, * l_offset_array;
+ OPJ_UINT32 l_data_size,l_mct_size, l_offset_size;
+ OPJ_UINT32 l_nb_elem;
+ OPJ_UINT32 * l_offset_data, * l_current_offset_data;
+ opj_tccp_t * l_tccp;
+
+
+ // preconditions
+ assert(p_tcp != 00);
+
+ l_mcc_record = p_tcp->m_mcc_records;
+ for
+ (i=0;i<p_tcp->m_nb_mcc_records;++i)
+ {
+ if
+ (l_mcc_record->m_index == p_index)
+ {
+ break;
+ }
+ }
+ if
+ (i==p_tcp->m_nb_mcc_records)
+ {
+ /** element discarded **/
+ return true;
+ }
+ if
+ (l_mcc_record->m_nb_comps != p_image->numcomps)
+ {
+ /** do not support number of comps != image */
+ return true;
+ }
+ l_deco_array = l_mcc_record->m_decorrelation_array;
+ if
+ (l_deco_array)
+ {
+ l_data_size = MCT_ELEMENT_SIZE[l_deco_array->m_element_type] * p_image->numcomps * p_image->numcomps;
+ if
+ (l_deco_array->m_data_size != l_data_size)
+ {
+ return false;
+ }
+ l_nb_elem = p_image->numcomps * p_image->numcomps;
+ l_mct_size = l_nb_elem * sizeof(OPJ_FLOAT32);
+ p_tcp->m_mct_decoding_matrix = opj_malloc(l_mct_size);
+ if
+ (! p_tcp->m_mct_decoding_matrix )
+ {
+ return false;
+ }
+ j2k_mct_read_functions_to_float[l_deco_array->m_element_type](l_deco_array->m_data,p_tcp->m_mct_decoding_matrix,l_nb_elem);
+ }
+ l_offset_array = l_mcc_record->m_offset_array;
+ if
+ (l_offset_array)
+ {
+ l_data_size = MCT_ELEMENT_SIZE[l_offset_array->m_element_type] * p_image->numcomps;
+ if
+ (l_offset_array->m_data_size != l_data_size)
+ {
+ return false;
+ }
+ l_nb_elem = p_image->numcomps;
+ l_offset_size = l_nb_elem * sizeof(OPJ_UINT32);
+ l_offset_data = opj_malloc(l_offset_size);
+ if
+ (! l_offset_data )
+ {
+ return false;
+ }
+ j2k_mct_read_functions_to_int32[l_offset_array->m_element_type](l_offset_array->m_data,l_offset_data,l_nb_elem);
+ l_tccp = p_tcp->tccps;
+ l_current_offset_data = l_offset_data;
+ for
+ (i=0;i<p_image->numcomps;++i)
+ {
+ l_tccp->m_dc_level_shift = *(l_current_offset_data++);
+ ++l_tccp;
+ }
+ opj_free(l_offset_data);
+ }
+ return true;
+}
+
+/**
+ * Writes the MCT marker (Multiple Component Transform)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_mct_data_group(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 i;
+ opj_simple_mcc_decorrelation_data_t * l_mcc_record;
+ opj_mct_data_t * l_mct_record;
+ opj_tcp_t * l_tcp;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_stream != 00);
+ assert(p_manager != 00);
+
+ if
+ (! j2k_write_cbd(p_j2k,p_stream,p_manager))
+ {
+ return false;
+ }
+ l_tcp = &(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
+ l_mct_record = l_tcp->m_mct_records;
+ for
+ (i=0;i<l_tcp->m_nb_mct_records;++i)
+ {
+ if
+ (! j2k_write_mct_record(p_j2k,l_mct_record,p_stream,p_manager))
+ {
+ return false;
+ }
+ ++l_mct_record;
+ }
+ l_mcc_record = l_tcp->m_mcc_records;
+ for
+ (i=0;i<l_tcp->m_nb_mcc_records;++i)
+ {
+ if
+ (! j2k_write_mcc_record(p_j2k,l_mcc_record,p_stream,p_manager))
+ {
+ return false;
+ }
+ ++l_mcc_record;
+ }
+ if
+ (! j2k_write_mco(p_j2k,p_stream,p_manager))
+ {
+ return false;
+ }
+ return true;
+}
+
+
+/**
+ * Writes the POC marker (Progression Order Change)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_poc(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 l_nb_comp;
+ OPJ_UINT32 l_nb_poc;
+ OPJ_UINT32 l_poc_size;
+ OPJ_UINT32 l_written_size = 0;
+ opj_tcp_t *l_tcp = 00;
+ opj_tccp_t *l_tccp = 00;
+ OPJ_UINT32 l_poc_room;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_tcp = &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number];
+ l_tccp = &l_tcp->tccps[0];
+ l_nb_comp = p_j2k->m_image->numcomps;
+ l_nb_poc = 1 + l_tcp->numpocs;
+ if
+ (l_nb_comp <= 256)
+ {
+ l_poc_room = 1;
+ }
+ else
+ {
+ l_poc_room = 2;
+ }
+ l_poc_size = 4 + (5 + 2 * l_poc_room) * l_nb_poc;
+ if
+ (l_poc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
+ {
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data
+ = opj_realloc(
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data,
+ l_poc_size);
+ if
+ (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_poc_size;
+ }
+
+ j2k_write_poc_in_memory(p_j2k,p_j2k->m_specific_param.m_encoder.m_header_tile_data,&l_written_size,p_manager);
+
+ if
+ (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_poc_size,p_manager) != l_poc_size)
+ {
+ return false;
+ }
+ return true;
+}
+
+
+/**
+ * Writes EPC ????
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_epc(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ opj_codestream_info_t * l_info = 00;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_info = p_j2k->cstr_info;
+ if
+ (l_info)
+ {
+ l_info->codestream_size = opj_stream_tell(p_stream);
+ /* UniPG>> */
+ /* The following adjustment is done to adjust the codestream size */
+ /* if SOD is not at 0 in the buffer. Useful in case of JP2, where */
+ /* the first bunch of bytes is not in the codestream */
+ l_info->codestream_size -= l_info->main_head_start;
+ /* <<UniPG */
+ }
+
+#ifdef USE_JPWL
+ /*
+ preparation of JPWL marker segments
+ */
+ if(cp->epc_on) {
+
+ /* encode according to JPWL */
+ jpwl_encode(p_j2k, p_stream, image);
+
+ }
+#endif /* USE_JPWL */
+ return true;
+}
+
+
+/**
+ * Gets the maximum size taken by the writting of a POC.
+ */
+OPJ_UINT32 j2k_get_max_poc_size(opj_j2k_t *p_j2k)
+{
+ opj_tcp_t * l_tcp = 00;
+ OPJ_UINT32 l_nb_tiles = 0;
+ OPJ_UINT32 l_max_poc = 0;
+ OPJ_UINT32 i;
+
+ l_tcp = p_j2k->m_cp.tcps;
+ l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
+
+ for
+ (i=0;i<l_nb_tiles;++i)
+ {
+ l_max_poc = uint_max(l_max_poc,l_tcp->numpocs);
+ ++l_tcp;
+ }
+ ++l_max_poc;
+ return 4 + 9 * l_max_poc;
+}
+
+
+/**
+ * Writes the POC marker (Progression Order Change)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+void j2k_write_poc_in_memory(
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_data_written,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 i;
+ OPJ_BYTE * l_current_data = 00;
+ OPJ_UINT32 l_nb_comp;
+ OPJ_UINT32 l_nb_poc;
+ OPJ_UINT32 l_poc_size;
+ opj_image_t *l_image = 00;
+ opj_tcp_t *l_tcp = 00;
+ opj_tccp_t *l_tccp = 00;
+ opj_poc_t *l_current_poc = 00;
+ OPJ_UINT32 l_poc_room;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_tcp = &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number];
+ l_tccp = &l_tcp->tccps[0];
+ l_image = p_j2k->m_image;
+ l_nb_comp = l_image->numcomps;
+ l_nb_poc = 1 + l_tcp->numpocs;
+ if
+ (l_nb_comp <= 256)
+ {
+ l_poc_room = 1;
+ }
+ else
+ {
+ l_poc_room = 2;
+ }
+ l_poc_size = 4 + (5 + 2 * l_poc_room) * l_nb_poc;
+
+ l_current_data = p_data;
+
+ opj_write_bytes(l_current_data,J2K_MS_POC,2); /* POC */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,l_poc_size-2,2); /* Lpoc */
+ l_current_data += 2;
+
+ l_current_poc = l_tcp->pocs;
+ for
+ (i = 0; i < l_nb_poc; ++i)
+ {
+ opj_write_bytes(l_current_data,l_current_poc->resno0,1); /* RSpoc_i */
+ ++l_current_data;
+ opj_write_bytes(l_current_data,l_current_poc->compno0,l_poc_room); /* CSpoc_i */
+ l_current_data+=l_poc_room;
+ opj_write_bytes(l_current_data,l_current_poc->layno1,2); /* LYEpoc_i */
+ l_current_data+=2;
+ opj_write_bytes(l_current_data,l_current_poc->resno1,1); /* REpoc_i */
+ ++l_current_data;
+ opj_write_bytes(l_current_data,l_current_poc->compno1,l_poc_room); /* CEpoc_i */
+ l_current_data+=l_poc_room;
+ opj_write_bytes(l_current_data,l_current_poc->prg,1); /* Ppoc_i */
+ ++l_current_data;
+
+ /* change the value of the max layer according to the actual number of layers in the file, components and resolutions*/
+ l_current_poc->layno1 = int_min(l_current_poc->layno1, l_tcp->numlayers);
+ l_current_poc->resno1 = int_min(l_current_poc->resno1, l_tccp->numresolutions);
+ l_current_poc->compno1 = int_min(l_current_poc->compno1, l_nb_comp);
+ ++l_current_poc;
+ }
+ * p_data_written = l_poc_size;
+}
+
+
+/**
+ * Reads a POC marker (Progression Order Change)
+ *
+ * @param p_header_data the data contained in the POC box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the POC marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_poc (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_nb_comp;
+ opj_image_t * l_image = 00;
+ OPJ_UINT32 l_old_poc_nb,l_current_poc_nb,l_current_poc_remaining;
+ OPJ_UINT32 l_chunk_size;
+ OPJ_UINT32 l_tmp;
+
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ opj_poc_t *l_current_poc = 00;
+ OPJ_UINT32 l_comp_room;
+
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_image = p_j2k->m_image;
+ l_nb_comp = l_image->numcomps;
+ if
+ (l_nb_comp <= 256)
+ {
+ l_comp_room = 1;
+ }
+ else
+ {
+ l_comp_room = 2;
+ }
+ l_chunk_size = 5 + 2 * l_comp_room;
+ l_current_poc_nb = p_header_size / l_chunk_size;
+ l_current_poc_remaining = p_header_size % l_chunk_size;
+
+ if
+ ((l_current_poc_nb <= 0) || (l_current_poc_remaining != 0))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading POC marker\n");
+ return false;
+ }
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH) ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
+ l_old_poc_nb = l_tcp->POC ? l_tcp->numpocs + 1 : 0;
+ l_current_poc_nb += l_old_poc_nb;
+ assert(l_current_poc_nb < 32);
+
+ /* now poc is in use.*/
+ l_tcp->POC = 1;
+
+ l_current_poc = &l_tcp->pocs[l_old_poc_nb];
+ for
+ (i = l_old_poc_nb; i < l_current_poc_nb; ++i)
+ {
+ opj_read_bytes(p_header_data,&(l_current_poc->resno0),1); /* RSpoc_i */
+ ++p_header_data;
+ opj_read_bytes(p_header_data,&(l_current_poc->compno0),l_comp_room); /* CSpoc_i */
+ p_header_data+=l_comp_room;
+ opj_read_bytes(p_header_data,&(l_current_poc->layno1),2); /* LYEpoc_i */
+ p_header_data+=2;
+ opj_read_bytes(p_header_data,&(l_current_poc->resno1),1); /* REpoc_i */
+ ++p_header_data;
+ opj_read_bytes(p_header_data,&(l_current_poc->compno1),l_comp_room); /* CEpoc_i */
+ p_header_data+=l_comp_room;
+ opj_read_bytes(p_header_data,&l_tmp,1); /* Ppoc_i */
+ ++p_header_data;
+ l_current_poc->prg = (OPJ_PROG_ORDER) l_tmp;
+ /* make sure comp is in acceptable bounds */
+ l_current_poc->compno1 = uint_min(l_current_poc->compno1, l_nb_comp);
+ ++l_current_poc;
+ }
+ l_tcp->numpocs = l_current_poc_nb - 1;
+ return true;
+}
+
+/**
+ * Writes the RGN marker (Region Of Interest)
+ *
+ * @param p_tile_no the tile to output
+ * @param p_comp_no the component to output
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_rgn(
+ opj_j2k_t *p_j2k,
+ OPJ_UINT32 p_tile_no,
+ OPJ_UINT32 p_comp_no,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_BYTE * l_current_data = 00;
+ OPJ_UINT32 l_nb_comp;
+ OPJ_UINT32 l_rgn_size;
+ opj_image_t *l_image = 00;
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ opj_tccp_t *l_tccp = 00;
+ OPJ_UINT32 l_comp_room;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = &l_cp->tcps[p_tile_no];
+ l_tccp = &l_tcp->tccps[p_comp_no];
+
+ l_nb_comp = l_image->numcomps;
+
+ if
+ (l_nb_comp <= 256)
+ {
+ l_comp_room = 1;
+ }
+ else
+ {
+ l_comp_room = 2;
+ }
+ l_rgn_size = 6 + l_comp_room;
+
+ l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
+
+ opj_write_bytes(l_current_data,J2K_MS_RGN,2); /* RGN */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,l_rgn_size-2,2); /* Lrgn */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,p_comp_no,l_comp_room); /* Crgn */
+ l_current_data+=l_comp_room;
+ opj_write_bytes(l_current_data, 0,1); /* Srgn */
+ ++l_current_data;
+ opj_write_bytes(l_current_data, l_tccp->roishift,1); /* SPrgn */
+ ++l_current_data;
+
+ if
+ (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_rgn_size,p_manager) != l_rgn_size)
+ {
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Reads a RGN marker (Region Of Interest)
+ *
+ * @param p_header_data the data contained in the POC box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the POC marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_rgn (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 l_nb_comp;
+ opj_image_t * l_image = 00;
+
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ OPJ_UINT32 l_comp_room;
+ OPJ_UINT32 l_comp_no;
+ OPJ_UINT32 l_roi_sty;
+
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_image = p_j2k->m_image;
+ l_nb_comp = l_image->numcomps;
+ if
+ (l_nb_comp <= 256)
+ {
+ l_comp_room = 1;
+ }
+ else
+ {
+ l_comp_room = 2;
+ }
+ if
+ (p_header_size != 2 + l_comp_room)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading RGN marker\n");
+ return false;
+ }
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_TPH) ? &l_cp->tcps[p_j2k->m_current_tile_number] : p_j2k->m_specific_param.m_decoder.m_default_tcp;
+
+ opj_read_bytes(p_header_data,&l_comp_no,l_comp_room); /* Crgn */
+ p_header_data+=l_comp_room;
+ opj_read_bytes(p_header_data,&l_roi_sty,1); /* Srgn */
+ ++p_header_data;
+
+#ifdef USE_JPWL
+ if (p_j2k->m_cp->correct) {
+ /* totlen is negative or larger than the bytes left!!! */
+ if (compno >= numcomps) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR,
+ "JPWL: bad component number in RGN (%d when there are only %d)\n",
+ compno, numcomps);
+ if (!JPWL_ASSUME || JPWL_ASSUME) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+ return;
+ }
+ }
+ };
+#endif /* USE_JPWL */
+
+ opj_read_bytes(p_header_data,(OPJ_UINT32 *) (&(l_tcp->tccps[l_comp_no].roishift)),1); /* SPrgn */
+ ++p_header_data;
+ return true;
+
+}
+
+/**
+ * Writes the TLM marker (Tile Length Marker)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_tlm(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_BYTE * l_current_data = 00;
+ OPJ_UINT32 l_tlm_size;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_tlm_size = 6 + (5*p_j2k->m_specific_param.m_encoder.m_total_tile_parts);
+ if
+ (l_tlm_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size)
+ {
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data
+ = opj_realloc(
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data,
+ l_tlm_size);
+ if
+ (! p_j2k->m_specific_param.m_encoder.m_header_tile_data)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_tlm_size;
+ }
+ l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
+
+ /* change the way data is written to avoid seeking if possible */
+ // TODO
+ p_j2k->m_specific_param.m_encoder.m_tlm_start = opj_stream_tell(p_stream);
+
+ opj_write_bytes(l_current_data,J2K_MS_TLM,2); /* TLM */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,l_tlm_size-2,2); /* Lpoc */
+ l_current_data += 2;
+ opj_write_bytes(l_current_data,0,1); /* Ztlm=0*/
+ ++l_current_data;
+ opj_write_bytes(l_current_data,0x50,1); /* Stlm ST=1(8bits-255 tiles max),SP=1(Ptlm=32bits) */
+ ++l_current_data;
+ /* do nothing on the 5 * l_j2k->m_specific_param.m_encoder.m_total_tile_parts remaining data */
+
+ if
+ (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_tlm_size,p_manager) != l_tlm_size)
+ {
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Reads a TLM marker (Tile Length Marker)
+ *
+ * @param p_header_data the data contained in the TLM box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the TLM marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_tlm (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 l_Ztlm, l_Stlm, l_ST, l_SP, l_tot_num_tp, l_tot_num_tp_remaining, l_quotient, l_Ptlm_size;
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ if
+ (p_header_size < 2)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading TLM marker\n");
+ return false;
+ }
+ p_header_size -= 2;
+
+
+ opj_read_bytes(p_header_data,&l_Ztlm,1); /* Ztlm */
+ ++p_header_data;
+ opj_read_bytes(p_header_data,&l_Stlm,1); /* Stlm */
+ ++p_header_data;
+
+ l_ST = ((l_Stlm >> 4) & 0x3);
+ l_SP = (l_Stlm >> 6) & 0x1;
+
+ l_Ptlm_size = (l_SP + 1) * 2;
+ l_quotient = l_Ptlm_size + l_ST;
+
+ l_tot_num_tp = p_header_size / l_quotient;
+ l_tot_num_tp_remaining = p_header_size % l_quotient;
+ if
+ (l_tot_num_tp_remaining != 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading TLM marker\n");
+ return false;
+ }
+ /* Do not care of this at the moment since only local variables are set here */
+ /*
+ for
+ (i = 0; i < l_tot_num_tp; ++i)
+ {
+ opj_read_bytes(p_header_data,&l_Ttlm_i,l_ST); // Ttlm_i
+ p_header_data += l_ST;
+ opj_read_bytes(p_header_data,&l_Ptlm_i,l_Ptlm_size); // Ptlm_i
+ p_header_data += l_Ptlm_size;
+ }*/
+ return true;
+}
+
+/**
+ * Reads a CRG marker (Component registration)
+ *
+ * @param p_header_data the data contained in the TLM box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the TLM marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_crg (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 l_nb_comp;
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_nb_comp = p_j2k->m_image->numcomps;
+
+ if
+ (p_header_size != l_nb_comp *4)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading CRG marker\n");
+ return false;
+ }
+ /* Do not care of this at the moment since only local variables are set here */
+ /*
+ for
+ (i = 0; i < l_nb_comp; ++i)
+ {
+ opj_read_bytes(p_header_data,&l_Xcrg_i,2); // Xcrg_i
+ p_header_data+=2;
+ opj_read_bytes(p_header_data,&l_Ycrg_i,2); // Xcrg_i
+ p_header_data+=2;
+ }
+ */
+ return true;
+}
+
+/**
+ * Reads a PLM marker (Packet length, main header marker)
+ *
+ * @param p_header_data the data contained in the TLM box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the TLM marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_plm (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ if
+ (p_header_size < 1)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
+ return false;
+ }
+ /* Do not care of this at the moment since only local variables are set here */
+ /*
+ opj_read_bytes(p_header_data,&l_Zplm,1); // Zplm
+ ++p_header_data;
+ --p_header_size;
+
+ while
+ (p_header_size > 0)
+ {
+ opj_read_bytes(p_header_data,&l_Nplm,1); // Nplm
+ ++p_header_data;
+ p_header_size -= (1+l_Nplm);
+ if
+ (p_header_size < 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
+ return false;
+ }
+ for
+ (i = 0; i < l_Nplm; ++i)
+ {
+ opj_read_bytes(p_header_data,&l_tmp,1); // Iplm_ij
+ ++p_header_data;
+ // take only the last seven bytes
+ l_packet_len |= (l_tmp & 0x7f);
+ if
+ (l_tmp & 0x80)
+ {
+ l_packet_len <<= 7;
+ }
+ else
+ {
+ // store packet length and proceed to next packet
+ l_packet_len = 0;
+ }
+ }
+ if
+ (l_packet_len != 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
+ return false;
+ }
+ }
+ */
+ return true;
+}
+
+/**
+ * Reads a PLT marker (Packet length, tile-part header)
+ *
+ * @param p_header_data the data contained in the PLT box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the PLT marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_plt (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 l_Zplt, l_tmp, l_packet_len = 0, i;
+
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ if
+ (p_header_size < 1)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
+ return false;
+ }
+
+ opj_read_bytes(p_header_data,&l_Zplt,1); // Zplt
+ ++p_header_data;
+ --p_header_size;
+ for
+ (i = 0; i < p_header_size; ++i)
+ {
+ opj_read_bytes(p_header_data,&l_tmp,1); // Iplm_ij
+ ++p_header_data;
+ // take only the last seven bytes
+ l_packet_len |= (l_tmp & 0x7f);
+ if
+ (l_tmp & 0x80)
+ {
+ l_packet_len <<= 7;
+ }
+ else
+ {
+ // store packet length and proceed to next packet
+ l_packet_len = 0;
+ }
+ }
+ if
+ (l_packet_len != 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n");
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Reads a PPM marker (Packed packet headers, main header)
+ *
+ * @param p_header_data the data contained in the POC box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the POC marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_ppm (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+
+ opj_cp_t *l_cp = 00;
+ OPJ_UINT32 l_remaining_data, l_Z_ppm, l_N_ppm;
+
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ if
+ (p_header_size < 1)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading RGN marker\n");
+ return false;
+ }
+ l_cp = &(p_j2k->m_cp);
+ l_cp->ppm = 1;
+
+ opj_read_bytes(p_header_data,&l_Z_ppm,1); /* Z_ppm */
+ ++p_header_data;
+ --p_header_size;
+
+ // first PPM marker
+ if
+ (l_Z_ppm == 0)
+ {
+ if
+ (p_header_size < 4)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n");
+ return false;
+ }
+ // read a N_ppm
+ opj_read_bytes(p_header_data,&l_N_ppm,4); /* N_ppm */
+ p_header_data+=4;
+ p_header_size-=4;
+ /* First PPM marker */
+ l_cp->ppm_len = l_N_ppm;
+ l_cp->ppm_data_size = 0;
+ l_cp->ppm_buffer = (OPJ_BYTE *) opj_malloc(l_cp->ppm_len);
+ l_cp->ppm_data = l_cp->ppm_buffer;
+ if
+ (l_cp->ppm_buffer == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory reading ppm marker\n");
+ return false;
+ }
+ memset(l_cp->ppm_buffer,0,l_cp->ppm_len);
+ }
+
+ while
+ (true)
+ {
+ if
+ (l_cp->ppm_data_size == l_cp->ppm_len)
+ {
+ if
+ (p_header_size >= 4)
+ {
+ // read a N_ppm
+ opj_read_bytes(p_header_data,&l_N_ppm,4); /* N_ppm */
+ p_header_data+=4;
+ p_header_size-=4;
+ l_cp->ppm_len += l_N_ppm ;
+ l_cp->ppm_buffer = (OPJ_BYTE *) opj_realloc(l_cp->ppm_buffer, l_cp->ppm_len);
+ l_cp->ppm_data = l_cp->ppm_buffer;
+ if
+ (l_cp->ppm_buffer == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory reading ppm marker\n");
+ return false;
+ }
+ memset(l_cp->ppm_buffer+l_cp->ppm_data_size,0,l_N_ppm);
+ }
+ else
+ {
+ return false;
+ }
+ }
+ l_remaining_data = l_cp->ppm_len - l_cp->ppm_data_size;
+ if
+ (l_remaining_data <= p_header_size)
+ {
+ /* we must store less information than available in the packet */
+ memcpy(l_cp->ppm_buffer + l_cp->ppm_data_size , p_header_data , l_remaining_data);
+ l_cp->ppm_data_size = l_cp->ppm_len;
+ p_header_size -= l_remaining_data;
+ p_header_data += l_remaining_data;
+ }
+ else
+ {
+ memcpy(l_cp->ppm_buffer + l_cp->ppm_data_size , p_header_data , p_header_size);
+ l_cp->ppm_data_size += p_header_size;
+ p_header_data += p_header_size;
+ p_header_size = 0;
+ break;
+ }
+ }
+ return true;
+}
+
+/**
+ * Reads a PPT marker (Packed packet headers, tile-part header)
+ *
+ * @param p_header_data the data contained in the PPT box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the PPT marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_ppt (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ OPJ_UINT32 l_Z_ppt;
+
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ if
+ (p_header_size < 1)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading PPT marker\n");
+ return false;
+ }
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = &(l_cp->tcps[p_j2k->m_current_tile_number]);
+ l_tcp->ppt = 1;
+
+ opj_read_bytes(p_header_data,&l_Z_ppt,1); /* Z_ppt */
+ ++p_header_data;
+ --p_header_size;
+
+ // first PPM marker
+ if
+ (l_Z_ppt == 0)
+ {
+ /* First PPM marker */
+ l_tcp->ppt_len = p_header_size;
+ l_tcp->ppt_data_size = 0;
+ l_tcp->ppt_buffer = (OPJ_BYTE *) opj_malloc(l_tcp->ppt_len);
+ l_tcp->ppt_data = l_tcp->ppt_buffer;
+ if
+ (l_tcp->ppt_buffer == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory reading PPT marker\n");
+ return false;
+ }
+ memset(l_tcp->ppt_buffer,0,l_tcp->ppt_len);
+ }
+ else
+ {
+ l_tcp->ppt_len += p_header_size;
+ l_tcp->ppt_buffer = (OPJ_BYTE *) opj_realloc(l_tcp->ppt_buffer,l_tcp->ppt_len);
+ if
+ (l_tcp->ppt_buffer == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory reading PPT marker\n");
+ return false;
+ }
+ l_tcp->ppt_data = l_tcp->ppt_buffer;
+ memset(l_tcp->ppt_buffer+l_tcp->ppt_data_size,0,p_header_size);
+ }
+ memcpy(l_tcp->ppt_buffer+l_tcp->ppt_data_size,p_header_data,p_header_size);
+ l_tcp->ppt_data_size += p_header_size;
+ return true;
+}
+
+/**
+ * Writes the SOT marker (Start of tile-part)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_sot(
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_data_written,
+ const struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ opj_write_bytes(p_data,J2K_MS_SOT,2); /* SOT */
+ p_data += 2;
+
+ opj_write_bytes(p_data,10,2); /* Lsot */
+ p_data += 2;
+
+ opj_write_bytes(p_data, p_j2k->m_current_tile_number,2); /* Isot */
+ p_data += 2;
+
+ /* Psot */
+ p_data += 4;
+
+ opj_write_bytes(p_data, p_j2k->m_specific_param.m_encoder.m_current_tile_part_number,1); /* TPsot */
+ ++p_data;
+
+ opj_write_bytes(p_data, p_j2k->m_cp.tcps[p_j2k->m_current_tile_number].m_nb_tile_parts,1); /* TNsot */
+ ++p_data;
+ /* UniPG>> */
+#ifdef USE_JPWL
+ /* update markers struct */
+ j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOT, p_j2k->sot_start, len + 2);
+#endif /* USE_JPWL */
+
+ * p_data_written = 12;
+ return true;
+}
+
+/**
+ * Reads a PPT marker (Packed packet headers, tile-part header)
+ *
+ * @param p_header_data the data contained in the PPT box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the PPT marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_sot (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager
+ )
+{
+
+ opj_cp_t *l_cp = 00;
+ opj_tcp_t *l_tcp = 00;
+ OPJ_UINT32 l_tot_len, l_num_parts = 0;
+ OPJ_UINT32 l_current_part;
+ OPJ_UINT32 l_tile_x,l_tile_y;
+
+ // preconditions
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ if
+ (p_header_size != 8)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error reading SOT marker\n");
+ return false;
+ }
+ l_cp = &(p_j2k->m_cp);
+ opj_read_bytes(p_header_data,&(p_j2k->m_current_tile_number),2); /* Isot */
+ p_header_data+=2;
+
+
+ l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
+ l_tile_x = p_j2k->m_current_tile_number % l_cp->tw;
+ l_tile_y = p_j2k->m_current_tile_number / l_cp->tw;
+
+#ifdef USE_JPWL
+ if (p_j2k->m_cp->correct) {
+
+ static int backup_tileno = 0;
+
+ /* tileno is negative or larger than the number of tiles!!! */
+ if ((tileno < 0) || (tileno > (cp->tw * cp->th))) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR,
+ "JPWL: bad tile number (%d out of a maximum of %d)\n",
+ tileno, (cp->tw * cp->th));
+ if (!JPWL_ASSUME) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+ return;
+ }
+ /* we try to correct */
+ tileno = backup_tileno;
+ opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- trying to adjust this\n"
+ "- setting tile number to %d\n",
+ tileno);
+ }
+
+ /* keep your private count of tiles */
+ backup_tileno++;
+ };
+#endif /* USE_JPWL */
+
+ /* look for the tile in the list of already processed tile (in parts). */
+ /* Optimization possible here with a more complex data structure and with the removing of tiles */
+ /* since the time taken by this function can only grow at the time */
+
+ opj_read_bytes(p_header_data,&l_tot_len,4); /* Psot */
+ p_header_data+=4;
+
+#ifdef USE_JPWL
+ if (p_j2k->m_cp->correct) {
+
+ /* totlen is negative or larger than the bytes left!!! */
+ if ((totlen < 0) || (totlen > (p_stream_numbytesleft(p_stream) + 8))) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR,
+ "JPWL: bad tile byte size (%d bytes against %d bytes left)\n",
+ totlen, p_stream_numbytesleft(p_stream) + 8);
+ if (!JPWL_ASSUME) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR, "JPWL: giving up\n");
+ return;
+ }
+ /* we try to correct */
+ totlen = 0;
+ opj_event_msg(p_j2k->cinfo, EVT_WARNING, "- trying to adjust this\n"
+ "- setting Psot to %d => assuming it is the last tile\n",
+ totlen);
+ }
+
+ };
+#endif /* USE_JPWL */
+
+ if
+ (!l_tot_len)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Cannot read data with no size known, giving up\n");
+ return false;
+ }
+
+ opj_read_bytes(p_header_data,&l_current_part ,1); /* Psot */
+ ++p_header_data;
+
+ opj_read_bytes(p_header_data,&l_num_parts ,1); /* Psot */
+ ++p_header_data;
+
+ if
+ (l_num_parts != 0)
+ {
+ l_tcp->m_nb_tile_parts = l_num_parts;
+ }
+ if
+ (l_tcp->m_nb_tile_parts)
+ {
+ if
+ (l_tcp->m_nb_tile_parts == (l_current_part + 1))
+ {
+ p_j2k->m_specific_param.m_decoder.m_can_decode = 1;
+ }
+ }
+ p_j2k->m_specific_param.m_decoder.m_sot_length = l_tot_len - 12;
+ p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_TPH;
+ p_j2k->m_specific_param.m_decoder.m_skip_data =
+ (l_tile_x < p_j2k->m_specific_param.m_decoder.m_start_tile_x)
+ || (l_tile_x >= p_j2k->m_specific_param.m_decoder.m_end_tile_x)
+ || (l_tile_y < p_j2k->m_specific_param.m_decoder.m_start_tile_y)
+ || (l_tile_y >= p_j2k->m_specific_param.m_decoder.m_end_tile_y);
+ /* Index */
+
+ /* move this onto a separate method to call before reading any SOT */
+ /*if
+ TODO
+ (p_j2k->cstr_info)
+ {
+ if
+ (l_tcp->first)
+ {
+ if
+ (tileno == 0)
+ {
+ p_j2k->cstr_info->main_head_end = p_stream_tell(p_stream) - 13;
+ }
+ p_j2k->cstr_info->tile[tileno].tileno = tileno;
+ p_j2k->cstr_info->tile[tileno].start_pos = p_stream_tell(p_stream) - 12;
+ p_j2k->cstr_info->tile[tileno].end_pos = p_j2k->cstr_info->tile[tileno].start_pos + totlen - 1;
+ p_j2k->cstr_info->tile[tileno].num_tps = numparts;
+ if
+ (numparts)
+ {
+ p_j2k->cstr_info->tile[tileno].tp = (opj_tp_info_t *) opj_malloc(numparts * sizeof(opj_tp_info_t));
+ }
+ else
+ {
+ p_j2k->cstr_info->tile[tileno].tp = (opj_tp_info_t *) opj_malloc(10 * sizeof(opj_tp_info_t)); // Fixme (10)
+ }
+ }
+ else
+ {
+ p_j2k->cstr_info->tile[tileno].end_pos += totlen;
+ }
+ p_j2k->cstr_info->tile[tileno].tp[partno].tp_start_pos = p_stream_tell(p_stream) - 12;
+ p_j2k->cstr_info->tile[tileno].tp[partno].tp_end_pos =
+ p_j2k->cstr_info->tile[tileno].tp[partno].tp_start_pos + totlen - 1;
+ }*/
+ return true;
+}
+
+/**
+ * Writes the SOD marker (Start of data)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_sod(
+ opj_j2k_t *p_j2k,
+ struct opj_tcd * p_tile_coder,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_data_written,
+ OPJ_UINT32 p_total_data_size,
+ const struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ opj_tcp_t *l_tcp = 00;
+ opj_codestream_info_t *l_cstr_info = 00;
+ opj_cp_t *l_cp = 00;
+
+ OPJ_UINT32 l_size_tile;
+ OPJ_UINT32 l_remaining_data;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ opj_write_bytes(p_data,J2K_MS_SOD,2); /* SOD */
+ p_data += 2;
+
+ /* make room for the EOF marker */
+ l_remaining_data = p_total_data_size - 4;
+
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number];
+ l_cstr_info = p_j2k->cstr_info;
+
+ /* update tile coder */
+ p_tile_coder->tp_num = p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number ;
+ p_tile_coder->cur_tp_num = p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
+ l_size_tile = l_cp->th * l_cp->tw;
+
+ /* INDEX >> */
+ if
+ (l_cstr_info)
+ {
+ if
+ (!p_j2k->m_specific_param.m_encoder.m_current_tile_part_number )
+ {
+ //TODO cstr_info->tile[p_j2k->m_current_tile_number].end_header = p_stream_tell(p_stream) + p_j2k->pos_correction - 1;
+ l_cstr_info->tile[p_j2k->m_current_tile_number].tileno = p_j2k->m_current_tile_number;
+ }
+ else
+ {
+ /*
+ TODO
+ if
+ (cstr_info->tile[p_j2k->m_current_tile_number].packet[cstr_info->packno - 1].end_pos < p_stream_tell(p_stream))
+ {
+ cstr_info->tile[p_j2k->m_current_tile_number].packet[cstr_info->packno].start_pos = p_stream_tell(p_stream);
+ }*/
+
+ }
+ /* UniPG>> */
+#ifdef USE_JPWL
+ /* update markers struct */
+ j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOD, p_j2k->sod_start, 2);
+#endif /* USE_JPWL */
+ /* <<UniPG */
+ }
+ /* << INDEX */
+
+ if
+ (p_j2k->m_specific_param.m_encoder.m_current_tile_part_number == 0)
+ {
+ p_tile_coder->tcd_image->tiles->packno = 0;
+ if
+ (l_cstr_info)
+ {
+ l_cstr_info->packno = 0;
+ }
+ }
+ *p_data_written = 0;
+ if
+ (! tcd_encode_tile(p_tile_coder, p_j2k->m_current_tile_number, p_data, p_data_written, l_remaining_data , l_cstr_info))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Cannot encode tile\n");
+ return false;
+ }
+ *p_data_written += 2;
+ return true;
+}
+
+/**
+ * Updates the Tile Length Marker.
+ */
+void j2k_update_tlm (
+ opj_j2k_t * p_j2k,
+ OPJ_UINT32 p_tile_part_size
+ )
+{
+ opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,p_j2k->m_current_tile_number,1); /* PSOT */
+ ++p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current;
+ opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,p_tile_part_size,4); /* PSOT */
+ p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current += 4;
+}
+
+
+/**
+ * Reads a SOD marker (Start Of Data)
+ *
+ * @param p_header_data the data contained in the SOD box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the SOD marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_sod (
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 l_current_read_size;
+ opj_codestream_info_t * l_cstr_info = 00;
+ OPJ_BYTE ** l_current_data = 00;
+ opj_tcp_t * l_tcp = 00;
+ OPJ_UINT32 * l_tile_len = 00;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_tcp = &(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
+ p_j2k->m_specific_param.m_decoder.m_sot_length -= 2;
+ l_cstr_info = p_j2k->cstr_info;
+
+ l_current_data = &(l_tcp->m_data);
+ l_tile_len = &l_tcp->m_data_size;
+
+ if
+ (! *l_current_data)
+ {
+ *l_current_data = (OPJ_BYTE*) my_opj_malloc(p_j2k->m_specific_param.m_decoder.m_sot_length);
+ }
+ else
+ {
+ *l_current_data = (OPJ_BYTE*) my_opj_realloc(*l_current_data, *l_tile_len + p_j2k->m_specific_param.m_decoder.m_sot_length);
+ }
+ if
+ (*l_current_data == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile\n");
+ return false;
+ }
+
+ /* Index */
+ if
+ (l_cstr_info)
+ {
+ OPJ_SIZE_T l_current_pos = opj_stream_tell(p_stream)-1;
+ l_cstr_info->tile[p_j2k->m_current_tile_number].tp[p_j2k->m_specific_param.m_encoder.m_current_tile_part_number].tp_end_header = l_current_pos;
+ if
+ (p_j2k->m_specific_param.m_encoder.m_current_tile_part_number == 0)
+ {
+ l_cstr_info->tile[p_j2k->m_current_tile_number].end_header = l_current_pos;
+ }
+ l_cstr_info->packno = 0;
+ }
+ l_current_read_size = opj_stream_read_data(p_stream, *l_current_data + *l_tile_len , p_j2k->m_specific_param.m_decoder.m_sot_length,p_manager);
+ if
+ (l_current_read_size != p_j2k->m_specific_param.m_decoder.m_sot_length)
+ {
+ p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_NEOC;
+ }
+ else
+ {
+ p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_TPHSOT;
+ }
+ *l_tile_len += l_current_read_size;
+ return true;
+}
+
+/**
+ * Writes the EOC marker (End of Codestream)
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_eoc(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_header_tile_data,J2K_MS_EOC,2); /* EOC */
+
+
+/* UniPG>> */
+#ifdef USE_JPWL
+ /* update markers struct */
+ j2k_add_marker(p_j2k->cstr_info, J2K_MS_EOC, p_stream_tell(p_stream) - 2, 2);
+#endif /* USE_JPWL */
+
+ if
+ (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,2,p_manager) != 2)
+ {
+ return false;
+ }
+ if
+ (! opj_stream_flush(p_stream,p_manager))
+ {
+ return false;
+ }
+ return true;
+}
+
+
+/**
+ * Inits the Info
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_init_info(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ opj_codestream_info_t * l_cstr_info = 00;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+ l_cstr_info = p_j2k->cstr_info;
+
+ if
+ (l_cstr_info)
+ {
+ OPJ_UINT32 compno;
+ l_cstr_info->tile = (opj_tile_info_t *) opj_malloc(p_j2k->m_cp.tw * p_j2k->m_cp.th * sizeof(opj_tile_info_t));
+ l_cstr_info->image_w = p_j2k->m_image->x1 - p_j2k->m_image->x0;
+ l_cstr_info->image_h = p_j2k->m_image->y1 - p_j2k->m_image->y0;
+ l_cstr_info->prog = (&p_j2k->m_cp.tcps[0])->prg;
+ l_cstr_info->tw = p_j2k->m_cp.tw;
+ l_cstr_info->th = p_j2k->m_cp.th;
+ l_cstr_info->tile_x = p_j2k->m_cp.tdx; /* new version parser */
+ l_cstr_info->tile_y = p_j2k->m_cp.tdy; /* new version parser */
+ l_cstr_info->tile_Ox = p_j2k->m_cp.tx0; /* new version parser */
+ l_cstr_info->tile_Oy = p_j2k->m_cp.ty0; /* new version parser */
+ l_cstr_info->numcomps = p_j2k->m_image->numcomps;
+ l_cstr_info->numlayers = (&p_j2k->m_cp.tcps[0])->numlayers;
+ l_cstr_info->numdecompos = (OPJ_INT32*) opj_malloc(p_j2k->m_image->numcomps * sizeof(OPJ_INT32));
+ for (compno=0; compno < p_j2k->m_image->numcomps; compno++) {
+ l_cstr_info->numdecompos[compno] = (&p_j2k->m_cp.tcps[0])->tccps->numresolutions - 1;
+ }
+ l_cstr_info->D_max = 0.0; /* ADD Marcela */
+ l_cstr_info->main_head_start = opj_stream_tell(p_stream); /* position of SOC */
+ l_cstr_info->maxmarknum = 100;
+ l_cstr_info->marker = (opj_marker_info_t *) opj_malloc(l_cstr_info->maxmarknum * sizeof(opj_marker_info_t));
+ l_cstr_info->marknum = 0;
+ }
+ return j2k_calculate_tp(p_j2k,&(p_j2k->m_cp),&p_j2k->m_specific_param.m_encoder.m_total_tile_parts,p_j2k->m_image,p_manager);
+}
+
+/**
+ * Creates a tile-coder decoder.
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_create_tcd(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ p_j2k->m_tcd = tcd_create(false);
+ if
+ (! p_j2k->m_tcd)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to create Tile Coder\n");
+ return false;
+ }
+ if
+ (! tcd_init(p_j2k->m_tcd,p_j2k->m_image,&p_j2k->m_cp))
+ {
+ tcd_destroy(p_j2k->m_tcd);
+ p_j2k->m_tcd = 00;
+ return false;
+ }
+ return true;
+}
+
+OPJ_FLOAT32 get_tp_stride (opj_tcp_t * p_tcp)
+{
+ return (OPJ_FLOAT32) ((p_tcp->m_nb_tile_parts - 1) * 14);
+}
+
+OPJ_FLOAT32 get_default_stride (opj_tcp_t * p_tcp)
+{
+ return 0;
+}
+
+/**
+ * Updates the rates of the tcp.
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_update_rates(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ opj_cp_t * l_cp = 00;
+ opj_image_t * l_image = 00;
+ opj_tcp_t * l_tcp = 00;
+ opj_image_comp_t * l_img_comp = 00;
+
+ OPJ_UINT32 i,j,k;
+ OPJ_INT32 l_x0,l_y0,l_x1,l_y1;
+ OPJ_FLOAT32 * l_rates = 0;
+ OPJ_FLOAT32 l_sot_remove;
+ OPJ_UINT32 l_bits_empty, l_size_pixel;
+ OPJ_UINT32 l_tile_size = 0;
+ OPJ_UINT32 l_last_res;
+ OPJ_FLOAT32 (* l_tp_stride_func)(opj_tcp_t *) = 00;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+
+ l_cp = &(p_j2k->m_cp);
+ l_image = p_j2k->m_image;
+ l_tcp = l_cp->tcps;
+
+ l_bits_empty = 8 * l_image->comps->dx * l_image->comps->dy;
+ l_size_pixel = l_image->numcomps * l_image->comps->prec;
+ l_sot_remove = ((OPJ_FLOAT32) opj_stream_tell(p_stream)) / (l_cp->th * l_cp->tw);
+
+ if
+ (l_cp->m_specific_param.m_enc.m_tp_on)
+ {
+ l_tp_stride_func = get_tp_stride;
+ }
+ else
+ {
+ l_tp_stride_func = get_default_stride;
+ }
+
+ for
+ (i=0;i<l_cp->th;++i)
+ {
+ for
+ (j=0;j<l_cp->tw;++j)
+ {
+ OPJ_FLOAT32 l_offset = ((*l_tp_stride_func)(l_tcp)) / l_tcp->numlayers;
+ /* 4 borders of the tile rescale on the image if necessary */
+ l_x0 = int_max(l_cp->tx0 + j * l_cp->tdx, l_image->x0);
+ l_y0 = int_max(l_cp->ty0 + i * l_cp->tdy, l_image->y0);
+ l_x1 = int_min(l_cp->tx0 + (j + 1) * l_cp->tdx, l_image->x1);
+ l_y1 = int_min(l_cp->ty0 + (i + 1) * l_cp->tdy, l_image->y1);
+ l_rates = l_tcp->rates;
+
+ /* Modification of the RATE >> */
+ if
+ (*l_rates)
+ {
+ *l_rates = (( (float) (l_size_pixel * (l_x1 - l_x0) * (l_y1 - l_y0)))
+ /
+ ((*l_rates) * l_bits_empty)
+ )
+ -
+ l_offset;
+ }
+ ++l_rates;
+ for
+ (k = 1; k < l_tcp->numlayers; ++k)
+ {
+ if
+ (*l_rates)
+ {
+ *l_rates = (( (OPJ_FLOAT32) (l_size_pixel * (l_x1 - l_x0) * (l_y1 - l_y0)))
+ /
+ ((*l_rates) * l_bits_empty)
+ )
+ -
+ l_offset;
+ }
+ ++l_rates;
+ }
+ ++l_tcp;
+ }
+ }
+
+ l_tcp = l_cp->tcps;
+ for
+ (i=0;i<l_cp->th;++i)
+ {
+ for
+ (j=0;j<l_cp->tw;++j)
+ {
+ l_rates = l_tcp->rates;
+ if
+ (*l_rates)
+ {
+ *l_rates -= l_sot_remove;
+ if
+ (*l_rates < 30)
+ {
+ *l_rates = 30;
+ }
+ }
+ ++l_rates;
+ l_last_res = l_tcp->numlayers - 1;
+ for
+ (k = 1; k < l_last_res; ++k)
+ {
+ if
+ (*l_rates)
+ {
+ *l_rates -= l_sot_remove;
+ if
+ (*l_rates < *(l_rates - 1) + 10)
+ {
+ *l_rates = (*(l_rates - 1)) + 20;
+ }
+ }
+ ++l_rates;
+ }
+ if
+ (*l_rates)
+ {
+ *l_rates -= (l_sot_remove + 2.f);
+ if
+ (*l_rates < *(l_rates - 1) + 10)
+ {
+ *l_rates = (*(l_rates - 1)) + 20;
+ }
+ }
+ ++l_tcp;
+ }
+ }
+
+ l_img_comp = l_image->comps;
+ l_tile_size = 0;
+ for
+ (i=0;i<l_image->numcomps;++i)
+ {
+ l_tile_size += ( uint_ceildiv(l_cp->tdx,l_img_comp->dx)
+ *
+ uint_ceildiv(l_cp->tdy,l_img_comp->dy)
+ *
+ l_img_comp->prec
+ );
+ ++l_img_comp;
+ }
+
+ l_tile_size = (OPJ_UINT32) (l_tile_size * 0.1625); /* 1.3/8 = 0.1625 */
+ l_tile_size += j2k_get_specific_header_sizes(p_j2k);
+
+ p_j2k->m_specific_param.m_encoder.m_encoded_tile_size = l_tile_size;
+ p_j2k->m_specific_param.m_encoder.m_encoded_tile_data = (OPJ_BYTE *) my_opj_malloc(p_j2k->m_specific_param.m_encoder.m_encoded_tile_size);
+ if
+ (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data == 00)
+ {
+ return false;
+ }
+ if
+ (l_cp->m_specific_param.m_enc.m_cinema)
+ {
+ p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer = (OPJ_BYTE *) opj_malloc(5*p_j2k->m_specific_param.m_encoder.m_total_tile_parts);
+ if
+ (! p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current = p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer;
+ }
+ return true;
+}
+
+/**
+ * Reads a EOC marker (End Of Codestream)
+ *
+ * @param p_header_data the data contained in the SOD box.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_header_size the size of the data contained in the SOD marker.
+ * @param p_manager the user event manager.
+*/
+bool j2k_read_eoc (
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 i;
+ opj_tcd_t * l_tcd = 00;
+ OPJ_UINT32 l_nb_tiles;
+ opj_tcp_t * l_tcp = 00;
+ bool l_success;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
+ l_tcp = p_j2k->m_cp.tcps;
+
+ l_tcd = tcd_create(true);
+ if
+ (l_tcd == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
+ return false;
+ }
+
+
+
+ for
+ (i = 0; i < l_nb_tiles; ++i)
+ {
+ if
+ (l_tcp->m_data)
+ {
+ if
+ (! tcd_init_decode_tile(l_tcd, i))
+ {
+ tcd_destroy(l_tcd);
+ opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
+ return false;
+ }
+ l_success = tcd_decode_tile(l_tcd, l_tcp->m_data, l_tcp->m_data_size, i, p_j2k->cstr_info);
+ /* cleanup */
+ if
+ (! l_success)
+ {
+ p_j2k->m_specific_param.m_decoder.m_state |= J2K_DEC_STATE_ERR;
+ break;
+ }
+ }
+ j2k_tcp_destroy(l_tcp);
+ ++l_tcp;
+ }
+ tcd_destroy(l_tcd);
+ return true;
+}
+
+/**
+ * Writes the image components.
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_image_components(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 compno;
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ for
+ (compno = 1; compno < p_j2k->m_image->numcomps; ++compno)
+ {
+ if
+ (! j2k_write_coc(p_j2k,compno,p_stream, p_manager))
+ {
+ return false;
+ }
+ if
+ (! j2k_write_qcc(p_j2k,compno,p_stream, p_manager))
+ {
+ return false;
+ }
+ }
+ return true;
+}
+
+/**
+ * Writes regions of interests.
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_regions(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 compno;
+ const opj_tccp_t *l_tccp = 00;
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_tccp = p_j2k->m_cp.tcps->tccps;
+ for
+ (compno = 0; compno < p_j2k->m_image->numcomps; ++compno)
+ {
+ if
+ (l_tccp->roishift)
+ {
+ if
+ (! j2k_write_rgn(p_j2k,0,compno,p_stream,p_manager))
+ {
+ return false;
+ }
+ }
+ ++l_tccp;
+ }
+ return true;
+}
+/**
+ * Writes the updated tlm.
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_write_updated_tlm(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 l_tlm_size;
+ OPJ_SIZE_T l_tlm_position, l_current_position;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_tlm_size = 5 * p_j2k->m_specific_param.m_encoder.m_total_tile_parts;
+ l_tlm_position = 6 + p_j2k->m_specific_param.m_encoder.m_tlm_start;
+ l_current_position = opj_stream_tell(p_stream);
+
+ if
+ (! opj_stream_seek(p_stream,l_tlm_position,p_manager))
+ {
+ return false;
+ }
+ if
+ (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer,l_tlm_size,p_manager) != l_tlm_size)
+ {
+ return false;
+ }
+ if
+ (! opj_stream_seek(p_stream,l_current_position,p_manager))
+ {
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Ends the encoding, i.e. frees memory.
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_end_encoding(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ tcd_destroy(p_j2k->m_tcd);
+ p_j2k->m_tcd = 00;
+
+ if
+ (p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer)
+ {
+ opj_free(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer);
+ p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer = 0;
+ p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current = 0;
+ }
+ if
+ (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data)
+ {
+ opj_free(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
+ p_j2k->m_specific_param.m_encoder.m_encoded_tile_data = 0;
+ }
+ p_j2k->m_specific_param.m_encoder.m_encoded_tile_size = 0;
+
+ return true;
+}
+
+/**
+ * Gets the offset of the header.
+ *
+ * @param p_stream the stream to write data to.
+ * @param p_j2k J2K codec.
+ * @param p_manager the user event manager.
+*/
+bool j2k_get_end_header(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ p_j2k->cstr_info->main_head_end = opj_stream_tell(p_stream);
+ return true;
+}
+
+
+
+
+/**
+ * Reads an unknown marker
+ *
+ * @param p_stream the stream object to read from.
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the marker could be deduced.
+*/
+bool j2k_read_unk (
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_BYTE l_data [2];
+ OPJ_UINT32 l_unknown_size;
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ opj_event_msg(p_manager, EVT_WARNING, "Unknown marker\n");
+
+#ifdef USE_JPWL
+ if (p_j2k->m_cp->correct) {
+ OPJ_INT32 m = 0, id, i;
+ OPJ_INT32 min_id = 0, min_dist = 17, cur_dist = 0, tmp_id;
+ p_stream_seek(p_j2k->p_stream, p_stream_tell(p_j2k->p_stream) - 2);
+ id = p_stream_read(p_j2k->p_stream, 2);
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR,
+ "JPWL: really don't know this marker %x\n",
+ id);
+ if (!JPWL_ASSUME) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR,
+ "- possible synch loss due to uncorrectable codestream errors => giving up\n");
+ return;
+ }
+ /* OK, activate this at your own risk!!! */
+ /* we look for the marker at the minimum hamming distance from this */
+ while (j2k_dec_mstab[m].id) {
+
+ /* 1's where they differ */
+ tmp_id = j2k_dec_mstab[m].id ^ id;
+
+ /* compute the hamming distance between our id and the current */
+ cur_dist = 0;
+ for (i = 0; i < 16; i++) {
+ if ((tmp_id >> i) & 0x0001) {
+ cur_dist++;
+ }
+ }
+
+ /* if current distance is smaller, set the minimum */
+ if (cur_dist < min_dist) {
+ min_dist = cur_dist;
+ min_id = j2k_dec_mstab[m].id;
+ }
+
+ /* jump to the next marker */
+ m++;
+ }
+
+ /* do we substitute the marker? */
+ if (min_dist < JPWL_MAXIMUM_HAMMING) {
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR,
+ "- marker %x is at distance %d from the read %x\n",
+ min_id, min_dist, id);
+ opj_event_msg(p_j2k->cinfo, EVT_ERROR,
+ "- trying to substitute in place and crossing fingers!\n");
+ p_stream_seek(p_j2k->p_stream, p_stream_tell(p_j2k->p_stream) - 2);
+ p_stream_write(p_j2k->p_stream, min_id, 2);
+
+ /* rewind */
+ p_stream_seek(p_j2k->p_stream, p_stream_tell(p_j2k->p_stream) - 2);
+
+ }
+
+ };
+#endif /* USE_JPWL */
+ if
+ (opj_stream_read_data(p_stream,l_data,2,p_manager) != 2)
+ {
+ opj_event_msg(p_manager, EVT_WARNING, "Unknown marker\n");
+ return false;
+ }
+ opj_read_bytes(l_data,&l_unknown_size,2);
+ if
+ (l_unknown_size < 2)
+ {
+ return false;
+ }
+ l_unknown_size-=2;
+
+ if
+ (opj_stream_skip(p_stream,l_unknown_size,p_manager) != l_unknown_size)
+ {
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Reads the lookup table containing all the marker, status and action, and returns the handler associated
+ * with the marker value.
+ * @param p_id Marker value to look up
+ *
+ * @return the handler associated with the id.
+*/
+const opj_dec_memory_marker_handler_t * j2k_get_marker_handler (OPJ_UINT32 p_id)
+{
+ const opj_dec_memory_marker_handler_t *e;
+ for
+ (e = j2k_memory_marker_handler_tab; e->id != 0; ++e)
+ {
+ if
+ (e->id == p_id)
+ {
+ break;
+ }
+ }
+ return e;
+}
+
+/**
+ * Destroys a tile coding parameter structure.
+ *
+ * @param p_tcp the tile coding parameter to destroy.
+ */
+void j2k_tcp_destroy (opj_tcp_t *p_tcp)
+{
+ if
+ (p_tcp == 00)
+ {
+ return;
+ }
+ if
+ (p_tcp->ppt_buffer != 00)
+ {
+ opj_free(p_tcp->ppt_buffer);
+ p_tcp->ppt_buffer = 00;
+ }
+ if
+ (p_tcp->tccps != 00)
+ {
+ opj_free(p_tcp->tccps);
+ p_tcp->tccps = 00;
+ }
+ if
+ (p_tcp->m_mct_coding_matrix != 00)
+ {
+ opj_free(p_tcp->m_mct_coding_matrix);
+ p_tcp->m_mct_coding_matrix = 00;
+ }
+ if
+ (p_tcp->m_mct_decoding_matrix != 00)
+ {
+ opj_free(p_tcp->m_mct_decoding_matrix);
+ p_tcp->m_mct_decoding_matrix = 00;
+ }
+ if
+ (p_tcp->m_mcc_records)
+ {
+ opj_free(p_tcp->m_mcc_records);
+ p_tcp->m_mcc_records = 00;
+ p_tcp->m_nb_max_mcc_records = 0;
+ p_tcp->m_nb_mcc_records = 0;
+ }
+ if
+ (p_tcp->m_mct_records)
+ {
+ opj_mct_data_t * l_mct_data = p_tcp->m_mct_records;
+ OPJ_UINT32 i;
+ for
+ (i=0;i<p_tcp->m_nb_mct_records;++i)
+ {
+ if
+ (l_mct_data->m_data)
+ {
+ opj_free(l_mct_data->m_data);
+ l_mct_data->m_data = 00;
+ }
+ ++l_mct_data;
+ }
+ opj_free(p_tcp->m_mct_records);
+ p_tcp->m_mct_records = 00;
+ }
+
+ if
+ (p_tcp->mct_norms != 00)
+ {
+ opj_free(p_tcp->mct_norms);
+ p_tcp->mct_norms = 00;
+ }
+ if
+ (p_tcp->m_data)
+ {
+ opj_free(p_tcp->m_data);
+ p_tcp->m_data = 00;
+ }
+}
+
+/**
+ * Destroys a coding parameter structure.
+ *
+ * @param p_cp the coding parameter to destroy.
+ */
+void j2k_cp_destroy (opj_cp_t *p_cp)
+{
+ OPJ_UINT32 l_nb_tiles;
+ opj_tcp_t * l_current_tile = 00;
+ OPJ_UINT32 i;
+
+ if
+ (p_cp == 00)
+ {
+ return;
+ }
+ if
+ (p_cp->tcps != 00)
+ {
+ l_current_tile = p_cp->tcps;
+ l_nb_tiles = p_cp->th * p_cp->tw;
+
+ for
+ (i = 0; i < l_nb_tiles; ++i)
+ {
+ j2k_tcp_destroy(l_current_tile);
+ ++l_current_tile;
+ }
+ opj_free(p_cp->tcps);
+ p_cp->tcps = 00;
+ }
+ if
+ (p_cp->ppm_buffer != 00)
+ {
+ opj_free(p_cp->ppm_buffer);
+ p_cp->ppm_buffer = 00;
+ }
+ if
+ (p_cp->comment != 00)
+ {
+ opj_free(p_cp->comment);
+ p_cp->comment = 00;
+ }
+ if
+ (! p_cp->m_is_decoder)
+ {
+ if
+ (p_cp->m_specific_param.m_enc.m_matrice)
+ {
+ opj_free(p_cp->m_specific_param.m_enc.m_matrice);
+ p_cp->m_specific_param.m_enc.m_matrice = 00;
+ }
+ }
+}
+
+/* ----------------------------------------------------------------------- */
+/* J2K / JPT decoder interface */
+/* ----------------------------------------------------------------------- */
+/**
+ * Creates a J2K decompression structure.
+ *
+ * @return a handle to a J2K decompressor if successful, NULL otherwise.
+*/
+opj_j2k_t* j2k_create_decompress()
+{
+ opj_j2k_t *l_j2k = (opj_j2k_t*) opj_malloc(sizeof(opj_j2k_t));
+ if
+ (!l_j2k)
+ {
+ return 00;
+ }
+ memset(l_j2k,0,sizeof(opj_j2k_t));
+ l_j2k->m_is_decoder = 1;
+ l_j2k->m_cp.m_is_decoder = 1;
+ l_j2k->m_specific_param.m_decoder.m_default_tcp = (opj_tcp_t*) opj_malloc(sizeof(opj_tcp_t));
+ if
+ (!l_j2k->m_specific_param.m_decoder.m_default_tcp)
+ {
+ opj_free(l_j2k);
+ return 00;
+ }
+ memset(l_j2k->m_specific_param.m_decoder.m_default_tcp,0,sizeof(opj_tcp_t));
+
+ l_j2k->m_specific_param.m_decoder.m_header_data = (OPJ_BYTE *) opj_malloc(J2K_DEFAULT_HEADER_SIZE);
+ if
+ (! l_j2k->m_specific_param.m_decoder.m_header_data)
+ {
+ j2k_destroy(l_j2k);
+ return 00;
+ }
+ l_j2k->m_specific_param.m_decoder.m_header_data_size = J2K_DEFAULT_HEADER_SIZE;
+
+ // validation list creation
+ l_j2k->m_validation_list = opj_procedure_list_create();
+ if
+ (! l_j2k->m_validation_list)
+ {
+ j2k_destroy(l_j2k);
+ return 00;
+ }
+
+ // execution list creation
+ l_j2k->m_procedure_list = opj_procedure_list_create();
+ if
+ (! l_j2k->m_procedure_list)
+ {
+ j2k_destroy(l_j2k);
+ return 00;
+ }
+ return l_j2k;
+}
+
+opj_j2k_t* j2k_create_compress()
+{
+ opj_j2k_t *l_j2k = (opj_j2k_t*) opj_malloc(sizeof(opj_j2k_t));
+ if
+ (!l_j2k)
+ {
+ return 00;
+ }
+ memset(l_j2k,0,sizeof(opj_j2k_t));
+ l_j2k->m_is_decoder = 0;
+ l_j2k->m_cp.m_is_decoder = 0;
+
+ l_j2k->m_specific_param.m_encoder.m_header_tile_data = (OPJ_BYTE *) opj_malloc(J2K_DEFAULT_HEADER_SIZE);
+ if
+ (! l_j2k->m_specific_param.m_encoder.m_header_tile_data)
+ {
+ j2k_destroy(l_j2k);
+ return 00;
+ }
+ l_j2k->m_specific_param.m_encoder.m_header_tile_data_size = J2K_DEFAULT_HEADER_SIZE;
+
+ // validation list creation
+ l_j2k->m_validation_list = opj_procedure_list_create();
+ if
+ (! l_j2k->m_validation_list)
+ {
+ j2k_destroy(l_j2k);
+ return 00;
+ }
+
+ // execution list creation
+ l_j2k->m_procedure_list = opj_procedure_list_create();
+ if
+ (! l_j2k->m_procedure_list)
+ {
+ j2k_destroy(l_j2k);
+ return 00;
+ }
+ return l_j2k;
+}
+
+
+/**
+ * Destroys a jpeg2000 codec.
+ *
+ * @param p_j2k the jpeg20000 structure to destroy.
+ */
+void j2k_destroy (opj_j2k_t *p_j2k)
+{
+ if
+ (p_j2k == 00)
+ {
+ return;
+ }
+
+ if
+ (p_j2k->m_is_decoder)
+ {
+ if
+ (p_j2k->m_specific_param.m_decoder.m_default_tcp != 00)
+ {
+ j2k_tcp_destroy(p_j2k->m_specific_param.m_decoder.m_default_tcp);
+ opj_free(p_j2k->m_specific_param.m_decoder.m_default_tcp);
+ p_j2k->m_specific_param.m_decoder.m_default_tcp = 00;
+ }
+ if
+ (p_j2k->m_specific_param.m_decoder.m_header_data != 00)
+ {
+ opj_free(p_j2k->m_specific_param.m_decoder.m_header_data);
+ p_j2k->m_specific_param.m_decoder.m_header_data = 00;
+ p_j2k->m_specific_param.m_decoder.m_header_data_size = 0;
+ }
+
+ }
+ else
+ {
+ if
+ (p_j2k->m_specific_param.m_encoder.m_encoded_tile_data)
+ {
+ opj_free(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
+ p_j2k->m_specific_param.m_encoder.m_encoded_tile_data = 00;
+ }
+ if
+ (p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer)
+ {
+ opj_free(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer);
+ p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer = 00;
+ p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current = 00;
+ }
+ if
+ (p_j2k->m_specific_param.m_encoder.m_header_tile_data)
+ {
+ opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data = 00;
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
+ }
+ }
+ tcd_destroy(p_j2k->m_tcd);
+
+ j2k_cp_destroy(&(p_j2k->m_cp));
+ memset(&(p_j2k->m_cp),0,sizeof(opj_cp_t));
+
+ opj_procedure_list_destroy(p_j2k->m_procedure_list);
+ p_j2k->m_procedure_list = 00;
+
+ opj_procedure_list_destroy(p_j2k->m_validation_list);
+ p_j2k->m_procedure_list = 00;
+
+ opj_free(p_j2k);
+}
+
+/**
+ * Starts a compression scheme, i.e. validates the codec parameters, writes the header.
+ *
+ * @param p_j2k the jpeg2000 codec.
+ * @param p_stream 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,
+ opj_stream_private_t *p_stream,
+ opj_image_t * p_image,
+ opj_event_mgr_t * p_manager)
+{
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_stream != 00);
+ assert(p_manager != 00);
+ p_j2k->m_image = p_image;
+
+
+ /* customization of the validation */
+ j2k_setup_encoding_validation (p_j2k);
+
+ /* validation of the parameters codec */
+ if
+ (! j2k_exec(p_j2k,p_j2k->m_validation_list,p_stream,p_manager))
+ {
+ return false;
+ }
+
+ /* customization of the encoding */
+ j2k_setup_header_writting(p_j2k);
+
+ /* write header */
+ if
+ (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager))
+ {
+ return false;
+ }
+ return true;
+}
+/**
+ * Sets up the procedures to do on reading header. Developpers wanting to extend the library can add their own reading procedures.
+ */
+void j2k_setup_header_reading (opj_j2k_t *p_j2k)
+{
+ // preconditions
+ assert(p_j2k != 00);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_read_header_procedure);
+
+ /* DEVELOPER CORNER, add your custom procedures */
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_copy_default_tcp_and_create_tcd);
+
+}
+
+/**
+ * Sets up the procedures to do on decoding data. Developpers wanting to extend the library can add their own reading procedures.
+ */
+void j2k_setup_decoding (opj_j2k_t *p_j2k)
+{
+ // preconditions
+ assert(p_j2k != 00);
+
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_decode_tiles);
+ /* DEVELOPER CORNER, add your custom procedures */
+
+}
+
+/**
+ * Sets up the procedures to do on writting header. Developpers wanting to extend the library can add their own writting procedures.
+ */
+void j2k_setup_header_writting (opj_j2k_t *p_j2k)
+{
+ // preconditions
+ assert(p_j2k != 00);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_init_info );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_soc );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_siz );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_cod );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_qcd );
+
+
+ if
+ (p_j2k->m_cp.m_specific_param.m_enc.m_cinema)
+ {
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_image_components );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_tlm );
+ if
+ (p_j2k->m_cp.m_specific_param.m_enc.m_cinema == CINEMA4K_24)
+ {
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_poc );
+ }
+ }
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_regions);
+
+ if
+ (p_j2k->m_cp.comment != 00)
+ {
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_com);
+ }
+
+ /* DEVELOPER CORNER, insert your custom procedures */
+ if
+ (p_j2k->m_cp.rsiz & MCT)
+ {
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_mct_data_group );
+ }
+ /* End of Developer Corner */
+
+ if
+ (p_j2k->cstr_info)
+ {
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_get_end_header );
+ }
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_create_tcd);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_update_rates);
+}
+
+/**
+ * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
+ * are valid. Developpers wanting to extend the library can add their own validation procedures.
+ */
+void j2k_setup_end_compress (opj_j2k_t *p_j2k)
+{
+ // preconditions
+ assert(p_j2k != 00);
+
+ /* DEVELOPER CORNER, insert your custom procedures */
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_eoc );
+ if
+ (p_j2k->m_cp.m_specific_param.m_enc.m_cinema)
+ {
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_updated_tlm);
+ }
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_write_epc );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_end_encoding );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,j2k_destroy_header_memory);
+}
+
+
+
+/**
+ * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
+ * are valid. Developpers wanting to extend the library can add their own validation procedures.
+ */
+void j2k_setup_encoding_validation (opj_j2k_t *p_j2k)
+{
+ // preconditions
+ assert(p_j2k != 00);
+ opj_procedure_list_add_procedure(p_j2k->m_validation_list, j2k_build_encoder);
+ opj_procedure_list_add_procedure(p_j2k->m_validation_list, j2k_encoding_validation);
+
+
+ /* DEVELOPER CORNER, add your custom validation procedure */
+ opj_procedure_list_add_procedure(p_j2k->m_validation_list, j2k_mct_validation);
+}
+
+/**
+ * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
+ * are valid. Developpers wanting to extend the library can add their own validation procedures.
+ */
+void j2k_setup_decoding_validation (opj_j2k_t *p_j2k)
+{
+ // preconditions
+ assert(p_j2k != 00);
+ opj_procedure_list_add_procedure(p_j2k->m_validation_list, j2k_build_decoder);
+ opj_procedure_list_add_procedure(p_j2k->m_validation_list, j2k_decoding_validation);
+ /* DEVELOPER CORNER, add your custom validation procedure */
+
+}
+
+
+/**
+ * Excutes the given procedures on the given codec.
+ *
+ * @param p_procedure_list the list of procedures to execute
+ * @param p_j2k the jpeg2000 codec to execute the procedures on.
+ * @param p_stream the stream to execute the procedures on.
+ * @param p_manager the user manager.
+ *
+ * @return true if all the procedures were successfully executed.
+ */
+bool j2k_exec (
+ opj_j2k_t * p_j2k,
+ opj_procedure_list_t * p_procedure_list,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ bool (** l_procedure) (opj_j2k_t * ,opj_stream_private_t *,opj_event_mgr_t *) = 00;
+ bool l_result = true;
+ OPJ_UINT32 l_nb_proc, i;
+
+ // preconditions
+ assert(p_procedure_list != 00);
+ assert(p_j2k != 00);
+ assert(p_stream != 00);
+ assert(p_manager != 00);
+
+ l_nb_proc = opj_procedure_list_get_nb_procedures(p_procedure_list);
+ l_procedure = (bool (**) (opj_j2k_t * ,opj_stream_private_t *,opj_event_mgr_t *)) opj_procedure_list_get_first_procedure(p_procedure_list);
+ for
+ (i=0;i<l_nb_proc;++i)
+ {
+ l_result = l_result && ((*l_procedure) (p_j2k,p_stream,p_manager));
+ ++l_procedure;
+ }
+ // and clear the procedure list at the end.
+ opj_procedure_list_clear(p_procedure_list);
+ return l_result;
+}
+
+/**
+ * The default encoding validation procedure without any extension.
+ *
+ * @param p_j2k the jpeg2000 codec to validate.
+ * @param p_stream the input stream to validate.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the parameters are correct.
+ */
+bool j2k_encoding_validation (
+ opj_j2k_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ bool l_is_valid = true;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_stream != 00);
+ assert(p_manager != 00);
+
+ /* STATE checking */
+ /* make sure the state is at 0 */
+ l_is_valid &= (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_NONE);
+
+ /* POINTER validation */
+ /* make sure a p_j2k codec is present */
+ l_is_valid &= (p_j2k->m_procedure_list != 00);
+ /* make sure a validation list is present */
+ l_is_valid &= (p_j2k->m_validation_list != 00);
+
+ if
+ ((p_j2k->m_cp.tdx) < (OPJ_UINT32) (1 << p_j2k->m_cp.tcps->tccps->numresolutions))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Number of resolutions is too high in comparison to the size of tiles\n");
+ return false;
+ }
+ if
+ ((p_j2k->m_cp.tdy) < (OPJ_UINT32) (1 << p_j2k->m_cp.tcps->tccps->numresolutions))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Number of resolutions is too high in comparison to the size of tiles\n");
+ return false;
+ }
+
+ /* PARAMETER VALIDATION */
+ return l_is_valid;
+}
+
+/**
+ * The default decoding validation procedure without any extension.
+ *
+ * @param p_j2k the jpeg2000 codec to validate.
+ * @param p_stream the input stream to validate.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the parameters are correct.
+ */
+bool j2k_decoding_validation (
+ opj_j2k_t *p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ bool l_is_valid = true;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_stream != 00);
+ assert(p_manager != 00);
+
+ /* STATE checking */
+ /* make sure the state is at 0 */
+ l_is_valid &= (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_NONE);
+
+ /* POINTER validation */
+ /* make sure a p_j2k codec is present */
+ /* make sure a procedure list is present */
+ l_is_valid &= (p_j2k->m_procedure_list != 00);
+ /* make sure a validation list is present */
+ l_is_valid &= (p_j2k->m_validation_list != 00);
+
+ /* PARAMETER VALIDATION */
+ return l_is_valid;
+}
+
+/**
+ * The mct encoding validation procedure.
+ *
+ * @param p_j2k the jpeg2000 codec to validate.
+ * @param p_stream the input stream to validate.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the parameters are correct.
+ */
+bool j2k_mct_validation (
+ opj_j2k_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ bool l_is_valid = true;
+ OPJ_UINT32 i,j;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_stream != 00);
+ assert(p_manager != 00);
+
+ if
+ ((p_j2k->m_cp.rsiz & 0x8200) == 0x8200)
+ {
+ OPJ_UINT32 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
+ opj_tcp_t * l_tcp = p_j2k->m_cp.tcps;
+ for
+ (i=0;i<l_nb_tiles;++i)
+ {
+ if
+ (l_tcp->mct == 2)
+ {
+ opj_tccp_t * l_tccp = l_tcp->tccps;
+ l_is_valid &= (l_tcp->m_mct_coding_matrix != 00);
+ for
+ (j=0;j<p_j2k->m_image->numcomps;++j)
+ {
+ l_is_valid &= ! (l_tccp->qmfbid & 1);
+ ++l_tccp;
+ }
+ }
+ ++l_tcp;
+ }
+ }
+ return l_is_valid;
+}
+
+/**
+ * Builds the cp decoder parameters to use to decode tile.
+ */
+bool j2k_build_decoder (
+ opj_j2k_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ // add here initialization of cp
+ // copy paste of setup_decoder
+ return true;
+}
+
+/**
+ * Builds the cp encoder parameters to use to encode tile.
+ */
+bool j2k_build_encoder (
+ opj_j2k_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ // add here initialization of cp
+ // copy paste of setup_encoder
+ return true;
+}
+
+bool j2k_copy_default_tcp_and_create_tcd
+ (
+ opj_j2k_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ opj_tcp_t * l_tcp = 00;
+ opj_tcp_t * l_default_tcp = 00;
+ OPJ_UINT32 l_nb_tiles;
+ OPJ_UINT32 i,j;
+ opj_tccp_t *l_current_tccp = 00;
+ OPJ_UINT32 l_tccp_size;
+ OPJ_UINT32 l_mct_size;
+ opj_image_t * l_image;
+ OPJ_UINT32 l_mcc_records_size,l_mct_records_size;
+ opj_mct_data_t * l_src_mct_rec, *l_dest_mct_rec;
+ opj_simple_mcc_decorrelation_data_t * l_src_mcc_rec, *l_dest_mcc_rec;
+ OPJ_UINT32 l_offset;
+
+ // preconditions in debug
+ assert(p_j2k != 00);
+ assert(p_stream != 00);
+ assert(p_manager != 00);
+
+ l_image = p_j2k->m_image;
+ l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
+ l_tcp = p_j2k->m_cp.tcps;
+ l_tccp_size = l_image->numcomps * sizeof(opj_tccp_t);
+ l_default_tcp = p_j2k->m_specific_param.m_decoder.m_default_tcp;
+ l_mct_size = l_image->numcomps * l_image->numcomps * sizeof(OPJ_FLOAT32);
+ for
+ (i=0;i<l_nb_tiles;++i)
+ {
+ l_current_tccp = l_tcp->tccps;
+ memcpy(l_tcp,l_default_tcp, sizeof(opj_tcp_t));
+ l_tcp->ppt = 0;
+ l_tcp->ppt_data = 00;
+ l_tcp->tccps = l_current_tccp;
+ if
+ (l_default_tcp->m_mct_decoding_matrix)
+ {
+ l_tcp->m_mct_decoding_matrix = opj_malloc(l_mct_size);
+ if
+ (! l_tcp->m_mct_decoding_matrix )
+ {
+ return false;
+ }
+ memcpy(l_tcp->m_mct_decoding_matrix,l_default_tcp->m_mct_decoding_matrix,l_mct_size);
+ }
+ l_mct_records_size = l_default_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t);
+ l_tcp->m_mct_records = opj_malloc(l_mct_records_size);
+ if
+ (! l_tcp->m_mct_records)
+ {
+ return false;
+ }
+ memcpy(l_tcp->m_mct_records, l_default_tcp->m_mct_records,l_mct_records_size);
+ l_src_mct_rec = l_default_tcp->m_mct_records;
+ l_dest_mct_rec = l_tcp->m_mct_records;
+ for
+ (j=0;j<l_default_tcp->m_nb_mct_records;++j)
+ {
+ if
+ (l_src_mct_rec->m_data)
+ {
+ l_dest_mct_rec->m_data = opj_malloc(l_src_mct_rec->m_data_size);
+ if
+ (! l_dest_mct_rec->m_data)
+ {
+ return false;
+ }
+ memcpy(l_dest_mct_rec->m_data,l_src_mct_rec->m_data,l_src_mct_rec->m_data_size);
+ }
+ ++l_src_mct_rec;
+ ++l_dest_mct_rec;
+ }
+ l_mcc_records_size = l_default_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t);
+ l_tcp->m_mcc_records = opj_malloc(l_mcc_records_size);
+ if
+ (! l_tcp->m_mcc_records)
+ {
+ return false;
+ }
+ memcpy(l_tcp->m_mcc_records,l_default_tcp->m_mcc_records,l_mcc_records_size);
+ l_src_mcc_rec = l_default_tcp->m_mcc_records;
+ l_dest_mcc_rec = l_tcp->m_mcc_records;
+ for
+ (j=0;j<l_default_tcp->m_nb_max_mcc_records;++j)
+ {
+ if
+ (l_src_mcc_rec->m_decorrelation_array)
+ {
+ l_offset = l_src_mcc_rec->m_decorrelation_array - l_default_tcp->m_mct_records;
+ l_dest_mcc_rec->m_decorrelation_array = l_tcp->m_mct_records + l_offset;
+ }
+ if
+ (l_src_mcc_rec->m_offset_array)
+ {
+ l_offset = l_src_mcc_rec->m_offset_array - l_default_tcp->m_mct_records;
+ l_dest_mcc_rec->m_offset_array = l_tcp->m_mct_records + l_offset;
+ }
+ ++l_src_mcc_rec;
+ ++l_dest_mcc_rec;
+ }
+ memcpy(l_current_tccp,l_default_tcp->tccps,l_tccp_size);
+ ++l_tcp;
+ }
+ p_j2k->m_tcd = tcd_create(true);
+ if
+ (! p_j2k->m_tcd )
+ {
+ return false;
+ }
+ if
+ (! tcd_init(p_j2k->m_tcd, l_image, &(p_j2k->m_cp)))
+ {
+ tcd_destroy(p_j2k->m_tcd);
+ p_j2k->m_tcd = 00;
+ opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Destroys the memory associated with the decoding of headers.
+ */
+bool j2k_destroy_header_memory (
+ opj_j2k_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ // preconditions in debug
+ assert(p_j2k != 00);
+ assert(p_stream != 00);
+ assert(p_manager != 00);
+
+ if
+ (p_j2k->m_specific_param.m_encoder.m_header_tile_data)
+ {
+ opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data);
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data = 0;
+ }
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0;
+ return true;
+}
+
+/**
+ * Sets up the decoder decoding parameters using user parameters.
+ * Decoding parameters are stored in p_j2k->m_cp.
+ *
+ * @param p_j2k J2K codec
+ * @param p_parameters decompression parameters
+ * @deprecated
+*/
+void j2k_setup_decoder(
+ opj_j2k_t *p_j2k,
+ opj_dparameters_t *p_parameters
+ )
+{
+ if
+ (p_j2k && p_parameters)
+ {
+ /* create and initialize the coding parameters structure */
+ p_j2k->m_cp.m_specific_param.m_dec.m_reduce = p_parameters->cp_reduce;
+ p_j2k->m_cp.m_specific_param.m_dec.m_layer = p_parameters->cp_layer;
+ p_j2k->m_specific_param.m_decoder.m_discard_tiles = p_parameters->m_use_restrict_decode;
+ if
+ (p_parameters->m_use_restrict_decode)
+ {
+ p_j2k->m_specific_param.m_decoder.m_start_tile_x = p_parameters->m_decode_start_x;
+ p_j2k->m_specific_param.m_decoder.m_start_tile_y = p_parameters->m_decode_start_y;
+ p_j2k->m_specific_param.m_decoder.m_end_tile_x = p_parameters->m_decode_end_x;
+ p_j2k->m_specific_param.m_decoder.m_end_tile_y = p_parameters->m_decode_end_y;
+ }
+
+#ifdef USE_JPWL
+ cp->correct = parameters->jpwl_correct;
+ cp->exp_comps = parameters->jpwl_exp_comps;
+ cp->max_tiles = parameters->jpwl_max_tiles;
+#endif /* USE_JPWL */
+ }
+}
+
+void j2k_setup_encoder(opj_j2k_t *p_j2k, opj_cparameters_t *parameters, opj_image_t *image, struct opj_event_mgr * p_manager) {
+ OPJ_UINT32 i, j, tileno, numpocs_tile;
+ opj_cp_t *cp = 00;
+ bool l_res;
+ if(!p_j2k || !parameters || ! image) {
+ return;
+ }
+
+ /* keep a link to cp so that we can destroy it later in j2k_destroy_compress */
+ cp = &(p_j2k->m_cp);
+
+ /* set default values for cp */
+ cp->tw = 1;
+ cp->th = 1;
+
+ /*
+ copy user encoding parameters
+ */
+ cp->m_specific_param.m_enc.m_cinema = parameters->cp_cinema;
+ cp->m_specific_param.m_enc.m_max_comp_size = parameters->max_comp_size;
+ cp->rsiz = parameters->cp_rsiz;
+ cp->m_specific_param.m_enc.m_disto_alloc = parameters->cp_disto_alloc;
+ cp->m_specific_param.m_enc.m_fixed_alloc = parameters->cp_fixed_alloc;
+ cp->m_specific_param.m_enc.m_fixed_quality = parameters->cp_fixed_quality;
+
+ /* mod fixed_quality */
+ if
+ (parameters->cp_matrice)
+ {
+ size_t array_size = parameters->tcp_numlayers * parameters->numresolution * 3 * sizeof(OPJ_INT32);
+ cp->m_specific_param.m_enc.m_matrice = (OPJ_INT32 *) opj_malloc(array_size);
+ memcpy(cp->m_specific_param.m_enc.m_matrice, parameters->cp_matrice, array_size);
+ }
+
+ /* tiles */
+ cp->tdx = parameters->cp_tdx;
+ cp->tdy = parameters->cp_tdy;
+
+ /* tile offset */
+ cp->tx0 = parameters->cp_tx0;
+ cp->ty0 = parameters->cp_ty0;
+
+ /* comment string */
+ if(parameters->cp_comment) {
+ cp->comment = (char*)opj_malloc(strlen(parameters->cp_comment) + 1);
+ if(cp->comment) {
+ strcpy(cp->comment, parameters->cp_comment);
+ }
+ }
+
+ /*
+ calculate other encoding parameters
+ */
+
+ if (parameters->tile_size_on) {
+ cp->tw = int_ceildiv(image->x1 - cp->tx0, cp->tdx);
+ cp->th = int_ceildiv(image->y1 - cp->ty0, cp->tdy);
+ } else {
+ cp->tdx = image->x1 - cp->tx0;
+ cp->tdy = image->y1 - cp->ty0;
+ }
+
+ if
+ (parameters->tp_on)
+ {
+ cp->m_specific_param.m_enc.m_tp_flag = parameters->tp_flag;
+ cp->m_specific_param.m_enc.m_tp_on = 1;
+ }
+
+#ifdef USE_JPWL
+ /*
+ calculate JPWL encoding parameters
+ */
+
+ if (parameters->jpwl_epc_on) {
+ OPJ_INT32 i;
+
+ /* set JPWL on */
+ cp->epc_on = true;
+ cp->info_on = false; /* no informative technique */
+
+ /* set EPB on */
+ if ((parameters->jpwl_hprot_MH > 0) || (parameters->jpwl_hprot_TPH[0] > 0)) {
+ cp->epb_on = true;
+
+ cp->hprot_MH = parameters->jpwl_hprot_MH;
+ for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
+ cp->hprot_TPH_tileno[i] = parameters->jpwl_hprot_TPH_tileno[i];
+ cp->hprot_TPH[i] = parameters->jpwl_hprot_TPH[i];
+ }
+ /* if tile specs are not specified, copy MH specs */
+ if (cp->hprot_TPH[0] == -1) {
+ cp->hprot_TPH_tileno[0] = 0;
+ cp->hprot_TPH[0] = parameters->jpwl_hprot_MH;
+ }
+ for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
+ cp->pprot_tileno[i] = parameters->jpwl_pprot_tileno[i];
+ cp->pprot_packno[i] = parameters->jpwl_pprot_packno[i];
+ cp->pprot[i] = parameters->jpwl_pprot[i];
+ }
+ }
+
+ /* set ESD writing */
+ if ((parameters->jpwl_sens_size == 1) || (parameters->jpwl_sens_size == 2)) {
+ cp->esd_on = true;
+
+ cp->sens_size = parameters->jpwl_sens_size;
+ cp->sens_addr = parameters->jpwl_sens_addr;
+ cp->sens_range = parameters->jpwl_sens_range;
+
+ cp->sens_MH = parameters->jpwl_sens_MH;
+ for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
+ cp->sens_TPH_tileno[i] = parameters->jpwl_sens_TPH_tileno[i];
+ cp->sens_TPH[i] = parameters->jpwl_sens_TPH[i];
+ }
+ }
+
+ /* always set RED writing to false: we are at the encoder */
+ cp->red_on = false;
+
+ } else {
+ cp->epc_on = false;
+ }
+#endif /* USE_JPWL */
+
+
+ /* initialize the mutiple tiles */
+ /* ---------------------------- */
+ cp->tcps = (opj_tcp_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tcp_t));
+ if
+ (parameters->numpocs)
+ {
+ /* initialisation of POC */
+ l_res = j2k_check_poc_val(parameters->POC,parameters->numpocs, parameters->numresolution, image->numcomps, parameters->tcp_numlayers, p_manager);
+ // TODO
+ }
+ for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
+ opj_tcp_t *tcp = &cp->tcps[tileno];
+ tcp->numlayers = parameters->tcp_numlayers;
+ for (j = 0; j < tcp->numlayers; j++) {
+ if(cp->m_specific_param.m_enc.m_cinema){
+ if (cp->m_specific_param.m_enc.m_fixed_quality) {
+ tcp->distoratio[j] = parameters->tcp_distoratio[j];
+ }
+ tcp->rates[j] = parameters->tcp_rates[j];
+ }else{
+ if (cp->m_specific_param.m_enc.m_fixed_quality) { /* add fixed_quality */
+ tcp->distoratio[j] = parameters->tcp_distoratio[j];
+ } else {
+ tcp->rates[j] = parameters->tcp_rates[j];
+ }
+ }
+ }
+ tcp->csty = parameters->csty;
+ tcp->prg = parameters->prog_order;
+ tcp->mct = parameters->tcp_mct;
+
+
+
+ numpocs_tile = 0;
+ tcp->POC = 0;
+ if
+ (parameters->numpocs)
+ {
+ /* initialisation of POC */
+ tcp->POC = 1;
+ // TODO
+ for (i = 0; i < (unsigned int) parameters->numpocs; i++) {
+ if((tileno == parameters->POC[i].tile - 1) || (parameters->POC[i].tile == -1)) {
+ opj_poc_t *tcp_poc = &tcp->pocs[numpocs_tile];
+ tcp_poc->resno0 = parameters->POC[numpocs_tile].resno0;
+ tcp_poc->compno0 = parameters->POC[numpocs_tile].compno0;
+ tcp_poc->layno1 = parameters->POC[numpocs_tile].layno1;
+ tcp_poc->resno1 = parameters->POC[numpocs_tile].resno1;
+ tcp_poc->compno1 = parameters->POC[numpocs_tile].compno1;
+ tcp_poc->prg1 = parameters->POC[numpocs_tile].prg1;
+ tcp_poc->tile = parameters->POC[numpocs_tile].tile;
+ numpocs_tile++;
+ }
+ }
+ tcp->numpocs = numpocs_tile -1 ;
+ }else{
+ tcp->numpocs = 0;
+ }
+
+ tcp->tccps = (opj_tccp_t*) opj_calloc(image->numcomps, sizeof(opj_tccp_t));
+ if
+ (parameters->mct_data)
+ {
+ OPJ_UINT32 lMctSize = image->numcomps * image->numcomps * sizeof(OPJ_FLOAT32);
+ OPJ_FLOAT32 * lTmpBuf = opj_malloc(lMctSize);
+ OPJ_INT32 * l_dc_shift = (OPJ_INT32 *) ((OPJ_BYTE *) parameters->mct_data + lMctSize);
+ tcp->mct = 2;
+ tcp->m_mct_coding_matrix = opj_malloc(lMctSize);
+ memcpy(tcp->m_mct_coding_matrix,parameters->mct_data,lMctSize);
+ memcpy(lTmpBuf,parameters->mct_data,lMctSize);
+ tcp->m_mct_decoding_matrix = opj_malloc(lMctSize);
+ assert(opj_matrix_inversion_f(lTmpBuf,(tcp->m_mct_decoding_matrix),image->numcomps));
+ tcp->mct_norms = opj_malloc(image->numcomps * sizeof(OPJ_FLOAT64));
+ opj_calculate_norms(tcp->mct_norms,image->numcomps,tcp->m_mct_decoding_matrix);
+ opj_free(lTmpBuf);
+ for
+ (i = 0; i < image->numcomps; i++)
+ {
+ opj_tccp_t *tccp = &tcp->tccps[i];
+ tccp->m_dc_level_shift = l_dc_shift[i];
+ }
+ j2k_setup_mct_encoding(tcp,image);
+ }
+ else
+ {
+ for
+ (i = 0; i < image->numcomps; i++)
+ {
+ opj_tccp_t *tccp = &tcp->tccps[i];
+ opj_image_comp_t * l_comp = &(image->comps[i]);
+ if
+ (! l_comp->sgnd)
+ {
+ tccp->m_dc_level_shift = 1 << (l_comp->prec - 1);
+ }
+ }
+ }
+
+
+ for (i = 0; i < image->numcomps; i++) {
+ opj_tccp_t *tccp = &tcp->tccps[i];
+ tccp->csty = parameters->csty & 0x01; /* 0 => one precinct || 1 => custom precinct */
+ tccp->numresolutions = parameters->numresolution;
+ tccp->cblkw = int_floorlog2(parameters->cblockw_init);
+ tccp->cblkh = int_floorlog2(parameters->cblockh_init);
+ tccp->cblksty = parameters->mode;
+ tccp->qmfbid = parameters->irreversible ? 0 : 1;
+ tccp->qntsty = parameters->irreversible ? J2K_CCP_QNTSTY_SEQNT : J2K_CCP_QNTSTY_NOQNT;
+ tccp->numgbits = 2;
+ if (i == parameters->roi_compno) {
+ tccp->roishift = parameters->roi_shift;
+ } else {
+ tccp->roishift = 0;
+ }
+
+ if(parameters->cp_cinema)
+ {
+ //Precinct size for lowest frequency subband=128
+ tccp->prcw[0] = 7;
+ tccp->prch[0] = 7;
+ //Precinct size at all other resolutions = 256
+ for (j = 1; j < tccp->numresolutions; j++) {
+ tccp->prcw[j] = 8;
+ tccp->prch[j] = 8;
+ }
+ }else{
+ if (parameters->csty & J2K_CCP_CSTY_PRT) {
+ int p = 0;
+ for (j = tccp->numresolutions - 1; j >= 0; j--) {
+ if (p < parameters->res_spec) {
+
+ if (parameters->prcw_init[p] < 1) {
+ tccp->prcw[j] = 1;
+ } else {
+ tccp->prcw[j] = int_floorlog2(parameters->prcw_init[p]);
+ }
+
+ if (parameters->prch_init[p] < 1) {
+ tccp->prch[j] = 1;
+ }else {
+ tccp->prch[j] = int_floorlog2(parameters->prch_init[p]);
+ }
+
+ } else {
+ int res_spec = parameters->res_spec;
+ int size_prcw = parameters->prcw_init[res_spec - 1] >> (p - (res_spec - 1));
+ int size_prch = parameters->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 for level %d : %d,%d\n", j,tccp->prcw[j], tccp->prch[j]); */
+ } //end for
+ } else {
+ for (j = 0; j < tccp->numresolutions; j++) {
+ tccp->prcw[j] = 15;
+ tccp->prch[j] = 15;
+ }
+ }
+ }
+
+ dwt_calc_explicit_stepsizes(tccp, image->comps[i].prec);
+ }
+ }
+ if
+ (parameters->mct_data)
+ {
+ opj_free(parameters->mct_data);
+ parameters->mct_data = 00;
+ }
+}
+
+bool j2k_write_first_tile_part (
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_data_written,
+ OPJ_UINT32 p_total_data_size,
+ opj_stream_private_t *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 compno;
+ OPJ_UINT32 l_nb_bytes_written = 0;
+ OPJ_UINT32 l_current_nb_bytes_written;
+ OPJ_BYTE * l_begin_data = 00;
+
+ opj_tcp_t *l_tcp = 00;
+ opj_tcd_t * l_tcd = 00;
+ opj_cp_t * l_cp = 00;
+
+ l_tcd = p_j2k->m_tcd;
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = l_cp->tcps + p_j2k->m_current_tile_number;
+
+ l_tcd->cur_pino = 0;
+ /*Get number of tile parts*/
+
+ p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = 0;
+ /* INDEX >> */
+
+ /* << INDEX */
+ l_current_nb_bytes_written = 0;
+ l_begin_data = p_data;
+ if
+ (! j2k_write_sot(p_j2k,p_data,&l_current_nb_bytes_written,p_stream,p_manager))
+ {
+ return false;
+ }
+ l_nb_bytes_written += l_current_nb_bytes_written;
+ p_data += l_current_nb_bytes_written;
+ p_total_data_size -= l_current_nb_bytes_written;
+
+ if
+ (l_cp->m_specific_param.m_enc.m_cinema == 0)
+ {
+ for
+ (compno = 1; compno < p_j2k->m_image->numcomps; compno++)
+ {
+ l_current_nb_bytes_written = 0;
+ j2k_write_coc_in_memory(p_j2k,compno,p_data,&l_current_nb_bytes_written,p_manager);
+ l_nb_bytes_written += l_current_nb_bytes_written;
+ p_data += l_current_nb_bytes_written;
+ p_total_data_size -= l_current_nb_bytes_written;
+
+ l_current_nb_bytes_written = 0;
+ j2k_write_qcc_in_memory(p_j2k,compno,p_data,&l_current_nb_bytes_written,p_manager);
+ l_nb_bytes_written += l_current_nb_bytes_written;
+ p_data += l_current_nb_bytes_written;
+ p_total_data_size -= l_current_nb_bytes_written;
+ }
+ if
+ (l_cp->tcps[p_j2k->m_current_tile_number].numpocs)
+ {
+ l_current_nb_bytes_written = 0;
+ j2k_write_poc_in_memory(p_j2k,p_data,&l_current_nb_bytes_written,p_manager);
+ l_nb_bytes_written += l_current_nb_bytes_written;
+ p_data += l_current_nb_bytes_written;
+ p_total_data_size -= l_current_nb_bytes_written;
+ }
+ }
+ l_current_nb_bytes_written = 0;
+ if
+ (! j2k_write_sod(p_j2k,l_tcd,p_data,&l_current_nb_bytes_written,p_total_data_size,p_stream,p_manager))
+ {
+ return false;
+ }
+ l_nb_bytes_written += l_current_nb_bytes_written;
+ * p_data_written = l_nb_bytes_written;
+
+ /* Writing Psot in SOT marker */
+ opj_write_bytes(l_begin_data + 6,l_nb_bytes_written,4); /* PSOT */
+ if
+ (l_cp->m_specific_param.m_enc.m_cinema)
+ {
+ j2k_update_tlm(p_j2k,l_nb_bytes_written);
+ }
+ return true;
+}
+
+bool j2k_write_all_tile_parts(
+ opj_j2k_t *p_j2k,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_data_written,
+ OPJ_UINT32 p_total_data_size,
+ opj_stream_private_t *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ OPJ_UINT32 tilepartno=0;
+ OPJ_UINT32 l_nb_bytes_written = 0;
+ OPJ_UINT32 l_current_nb_bytes_written;
+ OPJ_UINT32 l_part_tile_size;
+ OPJ_UINT32 tot_num_tp;
+ OPJ_UINT32 pino;
+
+ OPJ_BYTE * l_begin_data;
+ opj_tcp_t *l_tcp = 00;
+ opj_tcd_t * l_tcd = 00;
+ opj_cp_t * l_cp = 00;
+
+
+ l_tcd = p_j2k->m_tcd;
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = l_cp->tcps + p_j2k->m_current_tile_number;
+
+ /*Get number of tile parts*/
+ tot_num_tp = j2k_get_num_tp(l_cp,0,p_j2k->m_current_tile_number);
+ for
+ (tilepartno = 1; tilepartno < tot_num_tp ; ++tilepartno)
+ {
+ p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = tilepartno;
+ l_current_nb_bytes_written = 0;
+ l_part_tile_size = 0;
+ l_begin_data = p_data;
+ if
+ (! j2k_write_sot(p_j2k,p_data,&l_current_nb_bytes_written,p_stream,p_manager))
+ {
+ return false;
+ }
+ l_nb_bytes_written += l_current_nb_bytes_written;
+ p_data += l_current_nb_bytes_written;
+ p_total_data_size -= l_current_nb_bytes_written;
+ l_part_tile_size += l_nb_bytes_written;
+
+ l_current_nb_bytes_written = 0;
+ if
+ (! j2k_write_sod(p_j2k,l_tcd,p_data,&l_current_nb_bytes_written,p_total_data_size,p_stream,p_manager))
+ {
+ return false;
+ }
+ p_data += l_current_nb_bytes_written;
+ l_nb_bytes_written += l_current_nb_bytes_written;
+ p_total_data_size -= l_current_nb_bytes_written;
+ l_part_tile_size += l_nb_bytes_written;
+
+ /* Writing Psot in SOT marker */
+ opj_write_bytes(l_begin_data + 6,l_part_tile_size,4); /* PSOT */
+
+ if
+ (l_cp->m_specific_param.m_enc.m_cinema)
+ {
+ j2k_update_tlm(p_j2k,l_part_tile_size);
+ }
+ ++p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
+ }
+ for
+ (pino = 1; pino <= l_tcp->numpocs; ++pino)
+ {
+ l_tcd->cur_pino = pino;
+ /*Get number of tile parts*/
+ tot_num_tp = j2k_get_num_tp(l_cp,pino,p_j2k->m_current_tile_number);
+ for
+ (tilepartno = 0; tilepartno < tot_num_tp ; ++tilepartno)
+ {
+ p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = tilepartno;
+ l_current_nb_bytes_written = 0;
+ l_part_tile_size = 0;
+ l_begin_data = p_data;
+ if
+ (! j2k_write_sot(p_j2k,p_data,&l_current_nb_bytes_written,p_stream,p_manager))
+ {
+ return false;
+ }
+ l_nb_bytes_written += l_current_nb_bytes_written;
+ p_data += l_current_nb_bytes_written;
+ p_total_data_size -= l_current_nb_bytes_written;
+ l_part_tile_size += l_current_nb_bytes_written;
+
+ l_current_nb_bytes_written = 0;
+ if
+ (! j2k_write_sod(p_j2k,l_tcd,p_data,&l_current_nb_bytes_written,p_total_data_size,p_stream,p_manager))
+ {
+ return false;
+ }
+ l_nb_bytes_written += l_current_nb_bytes_written;
+ p_data += l_current_nb_bytes_written;
+ p_total_data_size -= l_current_nb_bytes_written;
+ l_part_tile_size += l_current_nb_bytes_written;
+
+ /* Writing Psot in SOT marker */
+ opj_write_bytes(l_begin_data + 6,l_part_tile_size,4); /* PSOT */
+
+ if
+ (l_cp->m_specific_param.m_enc.m_cinema)
+ {
+ j2k_update_tlm(p_j2k,l_part_tile_size);
+ }
+ ++p_j2k->m_specific_param.m_encoder.m_current_tile_part_number;
+ }
+ }
+ *p_data_written = l_nb_bytes_written;
+ return true;
+}
+
+
+bool j2k_pre_write_tile (
+ opj_j2k_t * p_j2k,
+ OPJ_UINT32 p_tile_index,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ if
+ (p_tile_index != p_j2k->m_current_tile_number)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "The given tile index does not match." );
+ return false;
+ }
+
+ opj_event_msg(p_manager, EVT_INFO, "tile number %d / %d\n", p_j2k->m_current_tile_number + 1, p_j2k->m_cp.tw * p_j2k->m_cp.th);
+
+ p_j2k->m_specific_param.m_encoder.m_current_tile_part_number = 0;
+ p_j2k->m_tcd->cur_totnum_tp = p_j2k->m_cp.tcps[p_tile_index].m_nb_tile_parts;
+ p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = 0;
+ /* initialisation before tile encoding */
+ if
+ (! tcd_init_encode_tile(p_j2k->m_tcd, p_j2k->m_current_tile_number))
+ {
+ return false;
+ }
+ return true;
+}
+
+/**
+ * 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,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ if
+ (! j2k_pre_write_tile(p_j2k,p_tile_index,p_stream,p_manager))
+ {
+ return false;
+ }
+ return j2k_post_write_tile(p_j2k,p_data,p_data_size,p_stream,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_post_write_tile (
+ opj_j2k_t * p_j2k,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 p_data_size,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ opj_tcd_t * l_tcd = 00;
+ opj_cp_t * l_cp = 00;
+ opj_tcp_t * l_tcp = 00;
+ OPJ_UINT32 l_nb_bytes_written;
+ OPJ_BYTE * l_current_data = 00;
+ OPJ_UINT32 l_tile_size = 0;
+ OPJ_UINT32 l_available_data;
+
+ assert(p_j2k->m_specific_param.m_encoder.m_encoded_tile_data);
+
+ l_tcd = p_j2k->m_tcd;
+ l_cp = &(p_j2k->m_cp);
+ l_tcp = l_cp->tcps + p_j2k->m_current_tile_number;
+
+ l_tile_size = p_j2k->m_specific_param.m_encoder.m_encoded_tile_size;
+ l_available_data = l_tile_size;
+ l_current_data = p_j2k->m_specific_param.m_encoder.m_encoded_tile_data;
+ if
+ (! tcd_copy_tile_data(l_tcd,p_data,p_data_size))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Size mismtach between tile data and sent data." );
+ return false;
+ }
+
+ l_nb_bytes_written = 0;
+ if
+ (! j2k_write_first_tile_part(p_j2k,l_current_data,&l_nb_bytes_written,l_available_data,p_stream,p_manager))
+ {
+ return false;
+ }
+ l_current_data += l_nb_bytes_written;
+ l_available_data -= l_nb_bytes_written;
+
+ l_nb_bytes_written = 0;
+ if
+ (! j2k_write_all_tile_parts(p_j2k,l_current_data,&l_nb_bytes_written,l_available_data,p_stream,p_manager))
+ {
+ return false;
+ }
+
+ l_available_data -= l_nb_bytes_written;
+ l_nb_bytes_written = l_tile_size - l_available_data;
+
+ if
+ (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_encoded_tile_data,l_nb_bytes_written,p_manager) != l_nb_bytes_written)
+ {
+ return false;
+ }
+ ++p_j2k->m_current_tile_number;
+ return true;
+}
+
+/**
+ * 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,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ OPJ_UINT32 l_current_marker = J2K_MS_SOT;
+ OPJ_UINT32 l_marker_size;
+ const opj_dec_memory_marker_handler_t * l_marker_handler = 00;
+ opj_tcp_t * l_tcp = 00;
+ OPJ_UINT32 l_nb_tiles;
+
+ // preconditions
+ assert(p_stream != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ if
+ (p_j2k->m_specific_param.m_decoder.m_state == J2K_DEC_STATE_EOC)
+ {
+ l_current_marker = J2K_MS_EOC;
+ }
+ else if
+ (p_j2k->m_specific_param.m_decoder.m_state != J2K_DEC_STATE_TPHSOT)
+ {
+ return false;
+ }
+
+ while
+ (! p_j2k->m_specific_param.m_decoder.m_can_decode && l_current_marker != J2K_MS_EOC)
+ {
+ while
+ (l_current_marker != J2K_MS_SOD)
+ {
+ if
+ (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
+ return false;
+ }
+ opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_marker_size,2);
+ if
+ (p_j2k->m_specific_param.m_decoder.m_state & J2K_DEC_STATE_TPH)
+ {
+ p_j2k->m_specific_param.m_decoder.m_sot_length -= (l_marker_size + 2);
+ }
+ l_marker_size -= 2;
+
+ l_marker_handler = j2k_get_marker_handler(l_current_marker);
+ // Check if the marker is known
+ if
+ (! (p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states) )
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Marker is not compliant with its position\n");
+ return false;
+ }
+ if
+ (l_marker_size > p_j2k->m_specific_param.m_decoder.m_header_data_size)
+ {
+ p_j2k->m_specific_param.m_decoder.m_header_data = opj_realloc(p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size);
+ if
+ (p_j2k->m_specific_param.m_decoder.m_header_data == 00)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_decoder.m_header_data_size = l_marker_size;
+
+ }
+ if
+ (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager) != l_marker_size)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
+ return false;
+ }
+ if
+ (! (*(l_marker_handler->handler))(p_j2k,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Marker is not compliant with its position\n");
+ return false;
+ }
+ if
+ (p_j2k->m_specific_param.m_decoder.m_skip_data)
+ {
+ if
+ (opj_stream_skip(p_stream,p_j2k->m_specific_param.m_decoder.m_sot_length,p_manager) != p_j2k->m_specific_param.m_decoder.m_sot_length)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
+ return false;
+ }
+ l_current_marker = J2K_MS_SOD;
+ }
+ else
+ {
+ if
+ (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
+ return false;
+ }
+ opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2);
+ }
+ }
+
+ if
+ (! p_j2k->m_specific_param.m_decoder.m_skip_data)
+ {
+ if
+ (! j2k_read_sod(p_j2k,p_stream,p_manager))
+ {
+ return false;
+ }
+ }
+ else
+ {
+ p_j2k->m_specific_param.m_decoder.m_skip_data = 0;
+ p_j2k->m_specific_param.m_decoder.m_can_decode = 0;
+ p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_TPHSOT;
+ if
+ (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
+ return false;
+ }
+ opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2);
+ }
+ }
+
+ if
+ (l_current_marker == J2K_MS_EOC)
+ {
+ if
+ (p_j2k->m_specific_param.m_decoder.m_state != J2K_DEC_STATE_EOC)
+ {
+ p_j2k->m_current_tile_number = 0;
+ p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_EOC;
+ }
+ }
+ if
+ ( ! p_j2k->m_specific_param.m_decoder.m_can_decode)
+ {
+ l_tcp = p_j2k->m_cp.tcps + p_j2k->m_current_tile_number;
+ l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
+ while
+ (
+ (p_j2k->m_current_tile_number < l_nb_tiles)
+ && (l_tcp->m_data == 00)
+ )
+ {
+ ++p_j2k->m_current_tile_number;
+ ++l_tcp;
+ }
+ if
+ (p_j2k->m_current_tile_number == l_nb_tiles)
+ {
+ *p_go_on = false;
+ return true;
+ }
+ }
+ if
+ (! tcd_init_decode_tile(p_j2k->m_tcd, p_j2k->m_current_tile_number))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n");
+ return false;
+ }
+ *p_tile_index = p_j2k->m_current_tile_number;
+ *p_go_on = true;
+ *p_data_size = tcd_get_decoded_tile_size(p_j2k->m_tcd);
+ * p_tile_x0 = p_j2k->m_tcd->tcd_image->tiles->x0;
+ * p_tile_y0 = p_j2k->m_tcd->tcd_image->tiles->y0;
+ * p_tile_x1 = p_j2k->m_tcd->tcd_image->tiles->x1;
+ * p_tile_y1 = p_j2k->m_tcd->tcd_image->tiles->y1;
+ * p_nb_comps = p_j2k->m_tcd->tcd_image->tiles->numcomps;
+ p_j2k->m_specific_param.m_decoder.m_state |= J2K_DEC_STATE_DATA;
+ return true;
+}
+
+bool j2k_decode_tile (
+ opj_j2k_t * p_j2k,
+ OPJ_UINT32 p_tile_index,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 p_data_size,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ OPJ_UINT32 l_current_marker;
+ OPJ_BYTE l_data [2];
+ opj_tcp_t * l_tcp;
+
+ // preconditions
+ assert(p_stream != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ if
+ (! (p_j2k->m_specific_param.m_decoder.m_state & J2K_DEC_STATE_DATA) || p_tile_index != p_j2k->m_current_tile_number)
+ {
+ return false;
+ }
+ l_tcp = &(p_j2k->m_cp.tcps[p_tile_index]);
+ if
+ (! l_tcp->m_data)
+ {
+ j2k_tcp_destroy(&(p_j2k->m_cp.tcps[p_tile_index]));
+ return false;
+ }
+ if
+ (! tcd_decode_tile(p_j2k->m_tcd, l_tcp->m_data, l_tcp->m_data_size, p_tile_index, p_j2k->cstr_info))
+ {
+ j2k_tcp_destroy(l_tcp);
+ p_j2k->m_specific_param.m_decoder.m_state |= J2K_DEC_STATE_ERR;
+ return false;
+ }
+ if
+ (! tcd_update_tile_data(p_j2k->m_tcd,p_data,p_data_size))
+ {
+ return false;
+ }
+ j2k_tcp_destroy(l_tcp);
+ p_j2k->m_tcd->tcp = 0;
+
+ p_j2k->m_specific_param.m_decoder.m_can_decode = 0;
+ p_j2k->m_specific_param.m_decoder.m_state &= (~J2K_DEC_STATE_DATA);
+ if
+ (p_j2k->m_specific_param.m_decoder.m_state != J2K_DEC_STATE_EOC)
+ {
+ if
+ (opj_stream_read_data(p_stream,l_data,2,p_manager) != 2)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
+ return false;
+ }
+ opj_read_bytes(l_data,&l_current_marker,2);
+ if
+ (l_current_marker == J2K_MS_EOC)
+ {
+ p_j2k->m_current_tile_number = 0;
+ p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_EOC;
+ }
+ else if
+ (l_current_marker != J2K_MS_SOT)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Stream too short, expected SOT\n");
+ return false;
+ }
+ }
+ return true;
+}
+
+
+/**
+ * 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 *p_stream, struct opj_event_mgr * p_manager)
+{
+ /* customization of the encoding */
+ j2k_setup_end_compress(p_j2k);
+
+ if
+ (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager))
+ {
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Reads a jpeg2000 codestream header structure.
+ *
+ * @param p_stream 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 *p_stream,
+ struct opj_event_mgr * p_manager
+ )
+{
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_stream != 00);
+ assert(p_manager != 00);
+
+ *p_image = 00;
+ /* create an empty image */
+ p_j2k->m_image = opj_image_create0();
+ if
+ (! p_j2k->m_image)
+ {
+ return false;
+ }
+
+ /* customization of the validation */
+ j2k_setup_decoding_validation (p_j2k);
+
+ /* validation of the parameters codec */
+ if
+ (! j2k_exec(p_j2k,p_j2k->m_validation_list,p_stream,p_manager))
+ {
+ opj_image_destroy(p_j2k->m_image);
+ p_j2k->m_image = 00;
+ return false;
+ }
+
+ /* customization of the encoding */
+ j2k_setup_header_reading(p_j2k);
+
+ /* read header */
+ if
+ (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager))
+ {
+ opj_image_destroy(p_j2k->m_image);
+ p_j2k->m_image = 00;
+ return false;
+ }
+ *p_image = p_j2k->m_image;
+ * p_tile_x0 = p_j2k->m_cp.tx0;
+ * p_tile_y0 = p_j2k->m_cp.ty0;
+ * p_tile_width = p_j2k->m_cp.tdx;
+ * p_tile_height = p_j2k->m_cp.tdy;
+ * p_nb_tiles_x = p_j2k->m_cp.tw;
+ * p_nb_tiles_y = p_j2k->m_cp.th;
+ return true;
+}
+
+/**
+ * The read header procedure.
+ */
+bool j2k_read_header_procedure(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager)
+{
+ OPJ_UINT32 l_current_marker;
+ OPJ_UINT32 l_marker_size;
+ const opj_dec_memory_marker_handler_t * l_marker_handler = 00;
+
+ // preconditions
+ assert(p_stream != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_MHSOC;
+
+ if
+ (! j2k_read_soc(p_j2k,p_stream,p_manager))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Expected a SOC marker \n");
+ return false;
+ }
+ if
+ (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
+ return false;
+ }
+ opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2);
+
+ while
+ (l_current_marker != J2K_MS_SOT)
+ {
+ if
+ (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
+ return false;
+ }
+ opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_marker_size,2);
+ l_marker_size -= 2;
+ /*if
+ (l_current_marker < 0xff00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "%.8x: expected a marker instead of %x\n", opj_stream_tell(p_stream) - 2, l_current_marker);
+ return 0;
+ }
+ */
+ l_marker_handler = j2k_get_marker_handler(l_current_marker);
+ // Check if the marker is known
+ if
+ (! (p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states) )
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Marker is not compliant with its position\n");
+ return false;
+ }
+ if
+ (l_marker_size > p_j2k->m_specific_param.m_decoder.m_header_data_size)
+ {
+ p_j2k->m_specific_param.m_decoder.m_header_data = opj_realloc(p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size);
+ if
+ (p_j2k->m_specific_param.m_decoder.m_header_data == 00)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_decoder.m_header_data_size = l_marker_size;
+ }
+ if
+ (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager) != l_marker_size)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
+ return false;
+ }
+ if
+ (! (*(l_marker_handler->handler))(p_j2k,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Marker is not compliant with its position\n");
+ return false;
+ }
+ if
+ (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n");
+ return false;
+ }
+ opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2);
+ }
+ p_j2k->m_specific_param.m_decoder.m_state = J2K_DEC_STATE_TPHSOT;
+ return true;
+}
+
+
+
+/**
+ * Reads the tiles.
+ */
+bool j2k_decode_tiles (
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager)
+{
+ bool l_go_on = true;
+ OPJ_UINT32 l_current_tile_no;
+ OPJ_UINT32 l_data_size,l_max_data_size;
+ OPJ_INT32 l_tile_x0,l_tile_y0,l_tile_x1,l_tile_y1;
+ OPJ_UINT32 l_nb_comps;
+ OPJ_BYTE * l_current_data;
+
+ l_current_data = opj_malloc(1000);
+ if
+ (! l_current_data)
+ {
+ return false;
+ }
+ l_max_data_size = 1000;
+
+ while
+ (true)
+ {
+ if
+ (! j2k_read_tile_header(
+ p_j2k,&l_current_tile_no,
+ &l_data_size,
+ &l_tile_x0,
+ &l_tile_y0,
+ &l_tile_x1,
+ &l_tile_y1,
+ &l_nb_comps,
+ &l_go_on,
+ p_stream,
+ p_manager))
+ {
+ return false;
+ }
+ if
+ (! l_go_on)
+ {
+ break;
+ }
+ if
+ (l_data_size > l_max_data_size)
+ {
+ l_current_data = opj_realloc(l_current_data,l_data_size);
+ if
+ (! l_current_data)
+ {
+ return false;
+ }
+ l_max_data_size = l_data_size;
+ }
+ if
+ (! j2k_decode_tile(p_j2k,l_current_tile_no,l_current_data,l_data_size,p_stream,p_manager))
+ {
+ opj_free(l_current_data);
+ return false;
+ }
+ if
+ (! j2k_update_image_data(p_j2k->m_tcd,l_current_data))
+ {
+ opj_free(l_current_data);
+ return false;
+ }
+
+ }
+ opj_free(l_current_data);
+ return true;
+}
+
+
+
+
+
+
+/**
+ * Decodes the tiles of the stream.
+ */
+opj_image_t * j2k_decode(
+ opj_j2k_t * p_j2k,
+ opj_stream_private_t * p_stream,
+ opj_event_mgr_t * p_manager)
+{
+ /* customization of the encoding */
+ j2k_setup_decoding(p_j2k);
+
+ /* write header */
+ if
+ (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager))
+ {
+ opj_image_destroy(p_j2k->m_image);
+ p_j2k->m_image = 00;
+ }
+ return p_j2k->m_image;
+}
+
+/**
+ * Encodes all the tiles in a row.
+ */
+bool j2k_encode(
+ opj_j2k_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_nb_tiles;
+ OPJ_UINT32 l_max_tile_size, l_current_tile_size;
+ OPJ_BYTE * l_current_data;
+
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_stream != 00);
+ assert(p_manager != 00);
+
+ l_current_data = opj_malloc(1000);
+ if
+ (! l_current_data)
+ {
+ return false;
+ }
+ l_max_tile_size = 1000;
+
+ l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
+ for
+ (i=0;i<l_nb_tiles;++i)
+ {
+ if
+ (! j2k_pre_write_tile(p_j2k,i,p_stream,p_manager))
+ {
+ opj_free(l_current_data);
+ return false;
+ }
+ l_current_tile_size = tcd_get_encoded_tile_size(p_j2k->m_tcd);
+ if
+ (l_current_tile_size > l_max_tile_size)
+ {
+ l_current_data = opj_realloc(l_current_data,l_current_tile_size);
+ if
+ (! l_current_data)
+ {
+ return false;
+ }
+ l_max_tile_size = l_current_tile_size;
+ }
+ j2k_get_tile_data(p_j2k->m_tcd,l_current_data);
+ if
+ (! j2k_post_write_tile (p_j2k,l_current_data,l_current_tile_size,p_stream,p_manager))
+ {
+ return false;
+ }
+ }
+ opj_free(l_current_data);
+ return true;
+}
+
+
+
+/**
+ * Ends the decompression procedures and possibiliy add data to be read after the
+ * codestream.
+ */
+bool j2k_end_decompress(
+ opj_j2k_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager)
+{
+ return true;
+}
+
+
+
+void j2k_get_tile_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data)
+{
+ OPJ_UINT32 i,j,k = 0;
+ OPJ_UINT32 l_width,l_height,l_stride, l_offset_x,l_offset_y, l_image_width;
+ opj_image_comp_t * l_img_comp = 00;
+ opj_tcd_tilecomp_t * l_tilec = 00;
+ opj_image_t * l_image = 00;
+ OPJ_UINT32 l_size_comp, l_remaining;
+ OPJ_INT32 * l_src_ptr;
+ l_tilec = p_tcd->tcd_image->tiles->comps;
+ l_image = p_tcd->image;
+ l_img_comp = l_image->comps;
+ for
+ (i=0;i<p_tcd->image->numcomps;++i)
+ {
+ l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/
+ l_remaining = l_img_comp->prec & 7; /* (%8) */
+ if
+ (l_remaining)
+ {
+ ++l_size_comp;
+ }
+ if
+ (l_size_comp == 3)
+ {
+ l_size_comp = 4;
+ }
+ l_width = (l_tilec->x1 - l_tilec->x0);
+ l_height = (l_tilec->y1 - l_tilec->y0);
+ l_offset_x = int_ceildiv(l_image->x0, l_img_comp->dx);
+ l_offset_y = int_ceildiv(l_image->y0, l_img_comp->dy);
+ l_image_width = int_ceildiv(l_image->x1 - l_image->x0, l_img_comp->dx);
+ l_stride = l_image_width - l_width;
+ l_src_ptr = l_img_comp->data + (l_tilec->x0 - l_offset_x) + (l_tilec->y0 - l_offset_y) * l_image_width;
+
+ switch
+ (l_size_comp)
+ {
+ case 1:
+ {
+ OPJ_CHAR * l_dest_ptr = (OPJ_CHAR*) p_data;
+ if
+ (l_img_comp->sgnd)
+ {
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (k=0;k<l_width;++k)
+ {
+ *(l_dest_ptr) = (OPJ_CHAR) (*l_src_ptr);
+ ++l_dest_ptr;
+ ++l_src_ptr;
+ }
+ l_src_ptr += l_stride;
+ }
+ }
+ else
+ {
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (k=0;k<l_width;++k)
+ {
+ *(l_dest_ptr) = (*l_src_ptr)&0xff;
+ ++l_dest_ptr;
+ ++l_src_ptr;
+ }
+ l_src_ptr += l_stride;
+ }
+ }
+ p_data = (OPJ_BYTE*) l_dest_ptr;
+ }
+ break;
+ case 2:
+ {
+ OPJ_INT16 * l_dest_ptr = (OPJ_INT16 *) p_data;
+ if
+ (l_img_comp->sgnd)
+ {
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (k=0;k<l_width;++k)
+ {
+ *(l_dest_ptr++) = (OPJ_INT16) (*(l_src_ptr++));
+ }
+ l_src_ptr += l_stride;
+ }
+ }
+ else
+ {
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (k=0;k<l_width;++k)
+ {
+ *(l_dest_ptr++) = (*(l_src_ptr++))&0xffff;
+ }
+ l_src_ptr += l_stride;
+ }
+ }
+ p_data = (OPJ_BYTE*) l_dest_ptr;
+ }
+ break;
+ case 4:
+ {
+ OPJ_INT32 * l_dest_ptr = (OPJ_INT32 *) p_data;
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (k=0;k<l_width;++k)
+ {
+ *(l_dest_ptr++) = *(l_src_ptr++);
+ }
+ l_src_ptr += l_stride;
+ }
+ p_data = (OPJ_BYTE*) l_dest_ptr;
+ }
+ break;
+ }
+ ++l_img_comp;
+ ++l_tilec;
+ }
+}
+
+bool j2k_update_image_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data)
+{
+ OPJ_UINT32 i,j,k = 0;
+ OPJ_UINT32 l_width,l_height,l_offset_x,l_offset_y;
+ opj_image_comp_t * l_img_comp = 00;
+ opj_tcd_tilecomp_t * l_tilec = 00;
+ opj_image_t * l_image = 00;
+ OPJ_UINT32 l_size_comp, l_remaining;
+ OPJ_UINT32 l_dest_stride;
+ OPJ_INT32 * l_dest_ptr;
+ opj_tcd_resolution_t* l_res= 00;
+
+
+ l_tilec = p_tcd->tcd_image->tiles->comps;
+ l_image = p_tcd->image;
+ l_img_comp = l_image->comps;
+ for
+ (i=0;i<p_tcd->image->numcomps;++i)
+ {
+ if
+ (!l_img_comp->data)
+ {
+ l_img_comp->data = (OPJ_INT32*) opj_malloc(l_img_comp->w * l_img_comp->h * sizeof(OPJ_INT32));
+ if
+ (! l_img_comp->data)
+ {
+ return false;
+ }
+ memset(l_img_comp->data,0,l_img_comp->w * l_img_comp->h * sizeof(OPJ_INT32));
+ }
+
+ l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/
+ l_remaining = l_img_comp->prec & 7; /* (%8) */
+ l_res = l_tilec->resolutions + l_img_comp->resno_decoded;
+
+ if
+ (l_remaining)
+ {
+ ++l_size_comp;
+ }
+ if
+ (l_size_comp == 3)
+ {
+ l_size_comp = 4;
+ }
+ l_width = (l_res->x1 - l_res->x0);
+ l_height = (l_res->y1 - l_res->y0);
+ l_dest_stride = (l_img_comp->w) - l_width;
+ l_offset_x = int_ceildivpow2(l_img_comp->x0, l_img_comp->factor);
+ l_offset_y = int_ceildivpow2(l_img_comp->y0, l_img_comp->factor);
+ l_dest_ptr = l_img_comp->data + (l_res->x0 - l_offset_x) + (l_res->y0 - l_offset_y) * l_img_comp->w;
+
+ switch
+ (l_size_comp)
+ {
+ case 1:
+ {
+ OPJ_CHAR * l_src_ptr = (OPJ_CHAR*) p_data;
+ if
+ (l_img_comp->sgnd)
+ {
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (k=0;k<l_width;++k)
+ {
+ *(l_dest_ptr++) = (OPJ_INT32) (*(l_src_ptr++));
+ }
+ l_dest_ptr += l_dest_stride;
+ }
+
+ }
+ else
+ {
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (k=0;k<l_width;++k)
+ {
+ *(l_dest_ptr++) = (OPJ_INT32) ((*(l_src_ptr++))&0xff);
+ }
+ l_dest_ptr += l_dest_stride;
+ }
+ }
+ p_data = (OPJ_BYTE*) l_src_ptr;
+ }
+ break;
+ case 2:
+ {
+ OPJ_INT16 * l_src_ptr = (OPJ_INT16 *) p_data;
+ if
+ (l_img_comp->sgnd)
+ {
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (k=0;k<l_width;++k)
+ {
+ *(l_dest_ptr++) = *(l_src_ptr++);
+ }
+ l_dest_ptr += l_dest_stride;
+ }
+ }
+ else
+ {
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (k=0;k<l_width;++k)
+ {
+ *(l_dest_ptr++) = (*(l_src_ptr++))&0xffff;
+ }
+ l_dest_ptr += l_dest_stride;
+ }
+ }
+ p_data = (OPJ_BYTE*) l_src_ptr;
+ }
+ break;
+ case 4:
+ {
+ OPJ_INT32 * l_src_ptr = (OPJ_INT32 *) p_data;
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (k=0;k<l_width;++k)
+ {
+ *(l_dest_ptr++) = (*(l_src_ptr++));
+ }
+ l_dest_ptr += l_dest_stride;
+ }
+ p_data = (OPJ_BYTE*) l_src_ptr;
+ }
+ break;
+ }
+ ++l_img_comp;
+ ++l_tilec;
+ }
+ return true;
+}
+
+/**
+ * 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
+ )
+{
+ opj_cp_t * l_cp = &(p_j2k->m_cp);
+
+ if
+ (p_j2k->m_specific_param.m_decoder.m_state != J2K_DEC_STATE_TPHSOT)
+ {
+ return false;
+ }
+ p_j2k->m_specific_param.m_decoder.m_start_tile_x = (p_start_x - l_cp->tx0) / l_cp->tdx;
+ p_j2k->m_specific_param.m_decoder.m_start_tile_y = (p_start_y - l_cp->ty0) / l_cp->tdy;
+ p_j2k->m_specific_param.m_decoder.m_end_tile_x = int_ceildiv((p_end_x - l_cp->tx0), l_cp->tdx);
+ p_j2k->m_specific_param.m_decoder.m_end_tile_y = int_ceildiv((p_end_y - l_cp->ty0), l_cp->tdy);
+ p_j2k->m_specific_param.m_decoder.m_discard_tiles = 1;
+ return true;
+}
diff --git a/v2/libopenjpeg/j2k.h b/v2/libopenjpeg/j2k.h new file mode 100755 index 00000000..ccb31e33 --- /dev/null +++ b/v2/libopenjpeg/j2k.h @@ -0,0 +1,736 @@ +/*
+ * 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.
+ */
+#ifndef __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.
+*/
+
+#include "openjpeg.h"
+
+struct opj_dparameters;
+struct opj_stream_private;
+struct opj_event_mgr;
+/** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */
+/*@{*/
+
+#define J2K_CP_CSTY_PRT 0x01
+#define J2K_CP_CSTY_SOP 0x02
+#define J2K_CP_CSTY_EPH 0x04
+#define J2K_CCP_CSTY_PRT 0x01
+#define J2K_CCP_CBLKSTY_LAZY 0x01
+#define J2K_CCP_CBLKSTY_RESET 0x02
+#define J2K_CCP_CBLKSTY_TERMALL 0x04
+#define J2K_CCP_CBLKSTY_VSC 0x08
+#define J2K_CCP_CBLKSTY_PTERM 0x10
+#define J2K_CCP_CBLKSTY_SEGSYM 0x20
+#define J2K_CCP_QNTSTY_NOQNT 0
+#define J2K_CCP_QNTSTY_SIQNT 1
+#define J2K_CCP_QNTSTY_SEQNT 2
+
+/* ----------------------------------------------------------------------- */
+
+#define J2K_MS_SOC 0xff4f /**< SOC marker value */
+#define J2K_MS_SOT 0xff90 /**< SOT marker value */
+#define J2K_MS_SOD 0xff93 /**< SOD marker value */
+#define J2K_MS_EOC 0xffd9 /**< EOC marker value */
+#define J2K_MS_SIZ 0xff51 /**< SIZ marker value */
+#define J2K_MS_COD 0xff52 /**< COD marker value */
+#define J2K_MS_COC 0xff53 /**< COC marker value */
+#define J2K_MS_RGN 0xff5e /**< RGN marker value */
+#define J2K_MS_QCD 0xff5c /**< QCD marker value */
+#define J2K_MS_QCC 0xff5d /**< QCC marker value */
+#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>> */
+#ifdef USE_JPWL
+#define J2K_MS_EPC 0xff68 /**< EPC marker value (Part 11: JPEG 2000 for Wireless) */
+#define J2K_MS_EPB 0xff66 /**< EPB marker value (Part 11: JPEG 2000 for Wireless) */
+#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 */
+
+
+/* ----------------------------------------------------------------------- */
+
+/**
+Values that specify the status of the decoding process when decoding the main header.
+These values may be combined with a | operator.
+*/
+typedef enum
+{
+ 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;
+
+/**
+Values that specify the status of the decoding process when decoding the main header.
+These values may be combined with a | operator.
+*/
+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;
+
+/**
+ * Type of data for storing the MCT data
+ */
+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;
+
+
+/* ----------------------------------------------------------------------- */
+
+
+
+/**
+Quantization stepsize
+*/
+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();
+
+/**
+ * Destroys a jpeg2000 codec.
+ *
+ * @param p_j2k the jpeg20000 structure to destroy.
+ */
+void j2k_destroy (opj_j2k_t *p_j2k);
+
+/**
+ * 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
+ );
+
+
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __J2K_H */
diff --git a/v2/libopenjpeg/j2k_lib.c b/v2/libopenjpeg/j2k_lib.c new file mode 100755 index 00000000..84d07dd6 --- /dev/null +++ b/v2/libopenjpeg/j2k_lib.c @@ -0,0 +1,65 @@ +/*
+ * Copyright (c) 2005, Hervé 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;
+}
+
diff --git a/v2/libopenjpeg/j2k_lib.h b/v2/libopenjpeg/j2k_lib.h new file mode 100755 index 00000000..d44d3d86 --- /dev/null +++ b/v2/libopenjpeg/j2k_lib.h @@ -0,0 +1,54 @@ +/*
+ * Copyright (c) 2005, Hervé 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.
+ */
+#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 "openjpeg.h"
+/** @defgroup MISC MISC - Miscellaneous internal functions */
+/*@{*/
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+
+/**
+Difference in successive opj_clock() calls tells you the elapsed time
+@return Returns time in seconds
+*/
+OPJ_FLOAT64 opj_clock(void);
+
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __J2K_LIB_H */
+
diff --git a/v2/libopenjpeg/jp2.c b/v2/libopenjpeg/jp2.c new file mode 100755 index 00000000..0d288d5d --- /dev/null +++ b/v2/libopenjpeg/jp2.c @@ -0,0 +1,2229 @@ +/*
+ * 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) 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 "jp2.h"
+#include "cio.h"
+#include "opj_malloc.h"
+#include "event.h"
+#include "j2k.h"
+#include "function_list.h"
+#include "assert.h"
+
+/** @defgroup JP2 JP2 - JPEG-2000 file format reader/writer */
+/*@{*/
+
+#define BOX_SIZE 1024
+
+
+
+/** @name Local static functions */
+/*@{*/
+
+
+
+/**
+ * Writes the Jpeg2000 file Header box - JP2 Header box (warning, this is a super box).
+ *
+ * @param cio the stream to write data to.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_manager user event manager.
+ *
+ * @return true if writting was successful.
+*/
+bool jp2_write_jp2h(
+ opj_jp2_t *jp2,
+ struct opj_stream_private *cio,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Skips the Jpeg2000 Codestream Header box - JP2C Header box.
+ *
+ * @param cio the stream to write data to.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_manager user event manager.
+ *
+ * @return true if writting was successful.
+*/
+bool jp2_skip_jp2c(
+ opj_jp2_t *jp2,
+ struct opj_stream_private *cio,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Reads the Jpeg2000 file Header box - JP2 Header box (warning, this is a super box).
+ *
+ * @param p_header_data the data contained in the file header box.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_header_size the size of the data contained in the file header box.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the JP2 Header box was successfully reconized.
+*/
+bool jp2_read_jp2h(
+ opj_jp2_t *jp2,
+ unsigned char * p_header_data,
+ unsigned int p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Writes the Jpeg2000 codestream Header box - JP2C Header box. This function must be called AFTER the coding has been done.
+ *
+ * @param cio the stream to write data to.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_manager user event manager.
+ *
+ * @return true if writting was successful.
+*/
+static bool jp2_write_jp2c(
+ opj_jp2_t *jp2,
+ struct opj_stream_private *cio,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Reads a box header. The box is the way data is packed inside a jpeg2000 file structure.
+ *
+ * @param cio the input stream to read data from.
+ * @param box the box structure to fill.
+ * @param p_number_bytes_read pointer to an int that will store the number of bytes read from the stream (shoul usually be 2).
+ * @param p_manager user event manager.
+ *
+ * @return true if the box is reconized, false otherwise
+*/
+static bool jp2_read_boxhdr(
+ opj_jp2_box_t *box,
+ OPJ_UINT32 * p_number_bytes_read,
+ struct opj_stream_private *cio,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Reads a box header. The box is the way data is packed inside a jpeg2000 file structure. Data is read from a character string
+ *
+ * @param p_data the character string to read data from.
+ * @param box the box structure to fill.
+ * @param p_number_bytes_read pointer to an int that will store the number of bytes read from the stream (shoul usually be 2).
+ * @param p_box_max_size the maximum number of bytes in the box.
+ *
+ * @return true if the box is reconized, false otherwise
+*/
+static bool jp2_read_boxhdr_char(
+ opj_jp2_box_t *box,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_number_bytes_read,
+ OPJ_UINT32 p_box_max_size,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Reads a jpeg2000 file signature box.
+ *
+ * @param p_header_data the data contained in the signature box.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_header_size the size of the data contained in the signature box.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the file signature box is valid.
+ */
+static bool jp2_read_jp(
+ opj_jp2_t *jp2,
+ unsigned char * p_header_data,
+ unsigned int p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Writes a jpeg2000 file signature box.
+ *
+ * @param cio the stream to write data to.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_manager the user event manager.
+ *
+ * @return true if writting was successful.
+ */
+static bool jp2_write_jp(
+ opj_jp2_t *jp2,
+ struct opj_stream_private *cio,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Writes a FTYP box - File type box
+ *
+ * @param cio the stream to write data to.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_manager the user event manager.
+ *
+ * @return true if writting was successful.
+ */
+static bool jp2_write_ftyp(
+ opj_jp2_t *jp2,
+ struct opj_stream_private *cio,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Reads a a FTYP box - File type box
+ *
+ * @param p_header_data the data contained in the FTYP box.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_header_size the size of the data contained in the FTYP box.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the FTYP box is valid.
+ */
+static bool jp2_read_ftyp(
+ opj_jp2_t *jp2,
+ unsigned char * p_header_data,
+ unsigned int p_header_size,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Reads a IHDR box - Image Header box
+ *
+ * @param p_image_header_data pointer to actual data (already read from file)
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_image_header_size the size of the image header
+ * @param p_manager the user event manager.
+ *
+ * @return true if the image header is valid, fale else.
+ */
+static bool jp2_read_ihdr(
+ opj_jp2_t *jp2,
+ unsigned char * p_image_header_data,
+ unsigned int p_image_header_size,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Writes the Image Header box - Image Header box.
+ *
+ * @param jp2 jpeg2000 file codec.
+ * @param p_nb_bytes_written pointer to store the nb of bytes written by the function.
+ *
+ * @return the data being copied.
+*/
+static unsigned char * jp2_write_ihdr(
+ opj_jp2_t *jp2,
+ unsigned int * p_nb_bytes_written
+ );
+
+/**
+ * Reads a Bit per Component box.
+ *
+ * @param p_bpc_header_data pointer to actual data (already read from file)
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_bpc_header_size the size of the bpc header
+ * @param p_manager the user event manager.
+ *
+ * @return true if the bpc header is valid, fale else.
+ */
+static bool jp2_read_bpcc(
+ opj_jp2_t *jp2,
+ unsigned char * p_bpc_header_data,
+ unsigned int p_bpc_header_size,
+ struct opj_event_mgr * p_manager
+ );
+
+
+/**
+ * Writes the Bit per Component box.
+ *
+ * @param jp2 jpeg2000 file codec.
+ * @param p_nb_bytes_written pointer to store the nb of bytes written by the function.
+ *
+ * @return the data being copied.
+*/
+static unsigned char * jp2_write_bpcc(
+ opj_jp2_t *jp2,
+ unsigned int * p_nb_bytes_written
+ );
+
+/**
+ * Reads the Colour Specification box.
+ *
+ * @param p_colr_header_data pointer to actual data (already read from file)
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_colr_header_size the size of the color header
+ * @param p_manager the user event manager.
+ *
+ * @return true if the bpc header is valid, fale else.
+*/
+static bool jp2_read_colr(
+ opj_jp2_t *jp2,
+ unsigned char * p_colr_header_data,
+ unsigned int p_colr_header_size,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Writes the Colour Specification box.
+ *
+ * @param jp2 jpeg2000 file codec.
+ * @param p_nb_bytes_written pointer to store the nb of bytes written by the function.
+ *
+ * @return the data being copied.
+*/
+static unsigned char *jp2_write_colr(
+ opj_jp2_t *jp2,
+ unsigned int * p_nb_bytes_written
+ );
+
+
+/**
+ * Reads a jpeg2000 file header structure.
+ *
+ * @param cio the stream to read data from.
+ * @param jp2 the jpeg2000 file header structure.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the box is valid.
+ */
+bool jp2_read_header_procedure(
+ opj_jp2_t *jp2,
+ struct opj_stream_private *cio,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Excutes the given procedures on the given codec.
+ *
+ * @param p_procedure_list the list of procedures to execute
+ * @param jp2 the jpeg2000 file codec to execute the procedures on.
+ * @param cio the stream to execute the procedures on.
+ * @param p_manager the user manager.
+ *
+ * @return true if all the procedures were successfully executed.
+ */
+static bool jp2_exec (
+ opj_jp2_t * jp2,
+ struct opj_procedure_list * p_procedure_list,
+ struct opj_stream_private *cio,
+ struct opj_event_mgr * p_manager
+ );
+/**
+ * Finds the execution function related to the given box id.
+ *
+ * @param p_id the id of the handler to fetch.
+ *
+ * @return the given handler or NULL if it could not be found.
+ */
+static const opj_jp2_header_handler_t * jp2_find_handler (int p_id);
+
+/**
+ * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
+ * are valid. Developpers wanting to extend the library can add their own validation procedures.
+ */
+static void jp2_setup_encoding_validation (opj_jp2_t *jp2);
+
+/**
+ * Sets up the procedures to do on writting header. Developpers wanting to extend the library can add their own writting procedures.
+ */
+static void jp2_setup_header_writting (opj_jp2_t *jp2);
+
+/**
+ * The default validation procedure without any extension.
+ *
+ * @param jp2 the jpeg2000 codec to validate.
+ * @param cio the input stream to validate.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the parameters are correct.
+ */
+bool jp2_default_validation (
+ opj_jp2_t * jp2,
+ struct opj_stream_private *cio,
+ struct opj_event_mgr * p_manager
+ );
+
+/**
+ * Finds the execution function related to the given box id.
+ *
+ * @param p_id the id of the handler to fetch.
+ *
+ * @return the given handler or NULL if it could not be found.
+ */
+static const opj_jp2_header_handler_t * jp2_find_handler (
+ int p_id
+ );
+
+/**
+ * Finds the image execution function related to the given box id.
+ *
+ * @param p_id the id of the handler to fetch.
+ *
+ * @return the given handler or NULL if it could not be found.
+ */
+static const opj_jp2_header_handler_t * jp2_img_find_handler (
+ int p_id
+ );
+
+/**
+ * Sets up the procedures to do on writting header after the codestream.
+ * Developpers wanting to extend the library can add their own writting procedures.
+ */
+static void jp2_setup_end_header_writting (opj_jp2_t *jp2);
+
+/**
+ * Sets up the procedures to do on reading header after the codestream.
+ * Developpers wanting to extend the library can add their own writting procedures.
+ */
+static void jp2_setup_end_header_reading (opj_jp2_t *jp2);
+
+/**
+ * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
+ * are valid. Developpers wanting to extend the library can add their own validation procedures.
+ */
+static void jp2_setup_decoding_validation (opj_jp2_t *jp2);
+
+/**
+ * Sets up the procedures to do on reading header.
+ * Developpers wanting to extend the library can add their own writting procedures.
+ */
+static void jp2_setup_header_reading (opj_jp2_t *jp2);
+/*@}*/
+
+/*@}*/
+
+/* ----------------------------------------------------------------------- */
+const opj_jp2_header_handler_t jp2_header [] =
+{
+ {JP2_JP,jp2_read_jp},
+ {JP2_FTYP,jp2_read_ftyp},
+ {JP2_JP2H,jp2_read_jp2h}
+};
+
+const opj_jp2_header_handler_t jp2_img_header [] =
+{
+ {JP2_IHDR,jp2_read_ihdr},
+ {JP2_COLR,jp2_read_colr},
+ {JP2_BPCC,jp2_read_bpcc}
+};
+/**
+ * Finds the execution function related to the given box id.
+ *
+ * @param p_id the id of the handler to fetch.
+ *
+ * @return the given handler or 00 if it could not be found.
+ */
+const opj_jp2_header_handler_t * jp2_find_handler (
+ int p_id
+ )
+{
+ unsigned int i, l_handler_size = sizeof(jp2_header) / sizeof(opj_jp2_header_handler_t);
+ for
+ (i=0;i<l_handler_size;++i)
+ {
+ if
+ (jp2_header[i].id == p_id)
+ {
+ return &jp2_header[i];
+ }
+ }
+ return 00;
+}
+
+/**
+ * Finds the image execution function related to the given box id.
+ *
+ * @param p_id the id of the handler to fetch.
+ *
+ * @return the given handler or 00 if it could not be found.
+ */
+static const opj_jp2_header_handler_t * jp2_img_find_handler (
+ int p_id
+ )
+{
+ unsigned int i, l_handler_size = sizeof(jp2_img_header) / sizeof(opj_jp2_header_handler_t);
+ for
+ (i=0;i<l_handler_size;++i)
+ {
+ if
+ (jp2_img_header[i].id == p_id)
+ {
+ return &jp2_img_header[i];
+ }
+ }
+ return 00;
+
+}
+
+/**
+ * Reads a jpeg2000 file header structure.
+ *
+ * @param cio the stream to read data from.
+ * @param jp2 the jpeg2000 file header structure.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the box is valid.
+ */
+bool jp2_read_header_procedure(
+ opj_jp2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager)
+{
+ opj_jp2_box_t box;
+ unsigned int l_nb_bytes_read;
+ const opj_jp2_header_handler_t * l_current_handler;
+ unsigned int l_last_data_size = BOX_SIZE;
+ unsigned int l_current_data_size;
+ unsigned char * l_current_data = 00;
+
+ // preconditions
+ assert(cio != 00);
+ assert(jp2 != 00);
+ assert(p_manager != 00);
+
+ l_current_data = opj_malloc(l_last_data_size);
+
+ if
+ (l_current_data == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to handle jpeg2000 file header\n");
+ return false;
+ }
+ memset(l_current_data, 0 , l_last_data_size);
+ while
+ (jp2_read_boxhdr(&box,&l_nb_bytes_read,cio,p_manager))
+ {
+ // is it the codestream box ?
+ if
+ (box.type == JP2_JP2C)
+ {
+ if
+ (jp2->jp2_state & JP2_STATE_HEADER)
+ {
+ jp2->jp2_state |= JP2_STATE_CODESTREAM;
+ return true;
+ }
+ else
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "bad placed jpeg codestream\n");
+ return false;
+ }
+ }
+ else if
+ (box.length == 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Cannot handle box of undefined sizes\n");
+ return false;
+ }
+
+ l_current_handler = jp2_find_handler(box.type);
+ l_current_data_size = box.length - l_nb_bytes_read;
+
+ if
+ (l_current_handler != 00)
+ {
+ if
+ (l_current_data_size > l_last_data_size)
+ {
+ l_current_data = opj_realloc(l_current_data,l_current_data_size);
+ l_last_data_size = l_current_data_size;
+ }
+ l_nb_bytes_read = opj_stream_read_data(cio,l_current_data,l_current_data_size,p_manager);
+ if
+ (l_nb_bytes_read != l_current_data_size)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Problem with reading JPEG2000 box, stream error\n");
+ return false;
+ }
+ if
+ (! l_current_handler->handler(jp2,l_current_data,l_current_data_size,p_manager))
+ {
+ return false;
+ }
+ }
+ else
+ {
+ jp2->jp2_state |= JP2_STATE_UNKNOWN;
+ if
+ (opj_stream_skip(cio,l_current_data_size,p_manager) != l_current_data_size)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Problem with skipping JPEG2000 box, stream error\n");
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+/**
+ * Reads a box header. The box is the way data is packed inside a jpeg2000 file structure.
+ *
+ * @param cio the input stream to read data from.
+ * @param box the box structure to fill.
+ * @param p_number_bytes_read pointer to an int that will store the number of bytes read from the stream (should usually be 8).
+ * @param p_manager user event manager.
+ *
+ * @return true if the box is reconized, false otherwise
+*/
+bool jp2_read_boxhdr(opj_jp2_box_t *box, OPJ_UINT32 * p_number_bytes_read,opj_stream_private_t *cio, opj_event_mgr_t * p_manager)
+{
+ /* read header from file */
+ unsigned char l_data_header [8];
+
+ // preconditions
+ assert(cio != 00);
+ assert(box != 00);
+ assert(p_number_bytes_read != 00);
+ assert(p_manager != 00);
+
+ *p_number_bytes_read = opj_stream_read_data(cio,l_data_header,8,p_manager);
+ if
+ (*p_number_bytes_read != 8)
+ {
+ return false;
+ }
+ /* process read data */
+ opj_read_bytes(l_data_header,&(box->length), 4);
+ opj_read_bytes(l_data_header+4,&(box->type), 4);
+
+ // do we have a "special very large box ?"
+ // read then the XLBox
+ if
+ (box->length == 1)
+ {
+ OPJ_UINT32 l_xl_part_size;
+ OPJ_UINT32 l_nb_bytes_read = opj_stream_read_data(cio,l_data_header,8,p_manager);
+ if
+ (l_nb_bytes_read != 8)
+ {
+ if
+ (l_nb_bytes_read > 0)
+ {
+ *p_number_bytes_read += l_nb_bytes_read;
+ }
+ return false;
+ }
+ opj_read_bytes(l_data_header,&l_xl_part_size, 4);
+ if
+ (l_xl_part_size != 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Cannot handle box sizes higher than 2^32\n");
+ return false;
+ }
+ opj_read_bytes(l_data_header,&(box->length), 4);
+ }
+ return true;
+}
+
+/**
+ * Reads a box header. The box is the way data is packed inside a jpeg2000 file structure. Data is read from a character string
+ *
+ * @param p_data the character string to read data from.
+ * @param box the box structure to fill.
+ * @param p_number_bytes_read pointer to an int that will store the number of bytes read from the stream (shoul usually be 2).
+ * @param p_box_max_size the maximum number of bytes in the box.
+ *
+ * @return true if the box is reconized, false otherwise
+*/
+static bool jp2_read_boxhdr_char(
+ opj_jp2_box_t *box,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 * p_number_bytes_read,
+ OPJ_UINT32 p_box_max_size,
+ opj_event_mgr_t * p_manager
+ )
+{
+ // preconditions
+ assert(p_data != 00);
+ assert(box != 00);
+ assert(p_number_bytes_read != 00);
+ assert(p_manager != 00);
+
+ if
+ (p_box_max_size < 8)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Cannot handle box of less than 8 bytes\n");
+ return false;
+ }
+ /* process read data */
+ opj_read_bytes(p_data,&(box->length), 4);
+ p_data += 4;
+ opj_read_bytes(p_data,&(box->type), 4);
+ p_data += 4;
+ *p_number_bytes_read = 8;
+
+ // do we have a "special very large box ?"
+ // read then the XLBox
+ if
+ (box->length == 1)
+ {
+ unsigned int l_xl_part_size;
+ if
+ (p_box_max_size < 16)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Cannot handle XL box of less than 16 bytes\n");
+ return false;
+ }
+
+ opj_read_bytes(p_data,&l_xl_part_size, 4);
+ p_data += 4;
+ *p_number_bytes_read += 4;
+ if
+ (l_xl_part_size != 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Cannot handle box sizes higher than 2^32\n");
+ return false;
+ }
+ opj_read_bytes(p_data,&(box->length), 4);
+ *p_number_bytes_read += 4;
+ if
+ (box->length == 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Cannot handle box of undefined sizes\n");
+ return false;
+ }
+
+ }
+ else if
+ (box->length == 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Cannot handle box of undefined sizes\n");
+ return false;
+ }
+ return true;
+}
+
+
+/**
+ * Reads a jpeg2000 file signature box.
+ *
+ * @param p_header_data the data contained in the signature box.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_header_size the size of the data contained in the signature box.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the file signature box is valid.
+ */
+bool jp2_read_jp(
+ opj_jp2_t *jp2,
+ unsigned char * p_header_data,
+ unsigned int p_header_size,
+ opj_event_mgr_t * p_manager
+ )
+{
+ unsigned int l_magic_number;
+
+ // preconditions
+ assert(p_header_data != 00);
+ assert(jp2 != 00);
+ assert(p_manager != 00);
+
+ if
+ (jp2->jp2_state != JP2_STATE_NONE)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "The signature box must be the first box in the file.\n");
+ return false;
+ }
+
+
+ /* assure length of data is correct (4 -> magic number) */
+ if
+ (p_header_size != 4)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error with JP signature Box size\n");
+ return false;
+ }
+
+ // rearrange data
+ opj_read_bytes(p_header_data,&l_magic_number,4);
+ if
+ (l_magic_number != 0x0d0a870a )
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error with JP Signature : bad magic number\n");
+ return false;
+ }
+ jp2->jp2_state |= JP2_STATE_SIGNATURE;
+ return true;
+}
+
+/**
+ * Reads a a FTYP box - File type box
+ *
+ * @param p_header_data the data contained in the FTYP box.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_header_size the size of the data contained in the FTYP box.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the FTYP box is valid.
+ */
+bool jp2_read_ftyp(
+ opj_jp2_t *jp2,
+ unsigned char * p_header_data,
+ unsigned int p_header_size,
+ opj_event_mgr_t * p_manager
+ )
+{
+ unsigned int i;
+ unsigned int l_remaining_bytes;
+
+ // preconditions
+ assert(p_header_data != 00);
+ assert(jp2 != 00);
+ assert(p_manager != 00);
+
+ if
+ (jp2->jp2_state != JP2_STATE_SIGNATURE)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "The ftyp box must be the second box in the file.\n");
+ return false;
+ }
+
+ /* assure length of data is correct */
+ if
+ (p_header_size < 8)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error with FTYP signature Box size\n");
+ return false;
+ }
+
+ opj_read_bytes(p_header_data,&jp2->brand,4); /* BR */
+ p_header_data += 4;
+
+ opj_read_bytes(p_header_data,&jp2->minversion,4); /* MinV */
+ p_header_data += 4;
+
+ l_remaining_bytes = p_header_size - 8;
+
+ /* the number of remaining bytes should be a multiple of 4 */
+ if
+ ((l_remaining_bytes & 0x3) != 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error with FTYP signature Box size\n");
+ return false;
+ }
+ /* div by 4 */
+ jp2->numcl = l_remaining_bytes >> 2;
+ if
+ (jp2->numcl)
+ {
+ jp2->cl = (unsigned int *) opj_malloc(jp2->numcl * sizeof(unsigned int));
+ if
+ (jp2->cl == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory with FTYP Box\n");
+ return false;
+ }
+ memset(jp2->cl,0,jp2->numcl * sizeof(unsigned int));
+ }
+
+
+ for
+ (i = 0; i < jp2->numcl; ++i)
+ {
+ opj_read_bytes(p_header_data,&jp2->cl[i],4); /* CLi */
+ p_header_data += 4;
+
+ }
+ jp2->jp2_state |= JP2_STATE_FILE_TYPE;
+ return true;
+}
+
+/**
+ * Writes a jpeg2000 file signature box.
+ *
+ * @param cio the stream to write data to.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_manager the user event manager.
+ *
+ * @return true if writting was successful.
+ */
+bool jp2_write_jp (
+ opj_jp2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager
+ )
+{
+ /* 12 bytes will be read */
+ unsigned char l_signature_data [12];
+
+ // preconditions
+ assert(cio != 00);
+ assert(jp2 != 00);
+ assert(p_manager != 00);
+
+
+ /* write box length */
+ opj_write_bytes(l_signature_data,12,4);
+ /* writes box type */
+ opj_write_bytes(l_signature_data+4,JP2_JP,4);
+ /* writes magic number*/
+ opj_write_bytes(l_signature_data+8,0x0d0a870a,4);
+ if
+ (opj_stream_write_data(cio,l_signature_data,12,p_manager) != 12)
+ {
+ return false;
+ }
+ return true;
+}
+
+
+/**
+ * Writes a FTYP box - File type box
+ *
+ * @param cio the stream to write data to.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_manager the user event manager.
+ *
+ * @return true if writting was successful.
+ */
+bool jp2_write_ftyp(
+ opj_jp2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager
+ )
+{
+ unsigned int i;
+ unsigned int l_ftyp_size = 16 + 4 * jp2->numcl;
+ unsigned char * l_ftyp_data, * l_current_data_ptr;
+ bool l_result;
+
+ // preconditions
+ assert(cio != 00);
+ assert(jp2 != 00);
+ assert(p_manager != 00);
+
+ l_ftyp_data = (unsigned char *) opj_malloc(l_ftyp_size);
+
+ if
+ (l_ftyp_data == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to handle ftyp data\n");
+ return false;
+ }
+ memset(l_ftyp_data,0,l_ftyp_size);
+
+ l_current_data_ptr = l_ftyp_data;
+
+ opj_write_bytes(l_current_data_ptr, l_ftyp_size,4); /* box size */
+ l_current_data_ptr += 4;
+
+ opj_write_bytes(l_current_data_ptr, JP2_FTYP,4); /* FTYP */
+ l_current_data_ptr += 4;
+
+ opj_write_bytes(l_current_data_ptr, jp2->brand,4); /* BR */
+ l_current_data_ptr += 4;
+
+ opj_write_bytes(l_current_data_ptr, jp2->minversion,4); /* MinV */
+ l_current_data_ptr += 4;
+
+ for
+ (i = 0; i < jp2->numcl; i++)
+ {
+ opj_write_bytes(l_current_data_ptr, jp2->cl[i],4); /* CL */
+ }
+
+ l_result = (opj_stream_write_data(cio,l_ftyp_data,l_ftyp_size,p_manager) == l_ftyp_size);
+ if
+ (! l_result)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Error while writting ftyp data to stream\n");
+ }
+ opj_free(l_ftyp_data);
+ return l_result;
+}
+
+/**
+ * Writes the Jpeg2000 file Header box - JP2 Header box (warning, this is a super box).
+ *
+ * @param cio the stream to write data to.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_manager user event manager.
+ *
+ * @return true if writting was successful.
+*/
+bool jp2_write_jp2h(
+ opj_jp2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager
+ )
+{
+ opj_jp2_img_header_writer_handler_t l_writers [3];
+ opj_jp2_img_header_writer_handler_t * l_current_writer;
+
+ int i, l_nb_pass;
+ /* size of data for super box*/
+ int l_jp2h_size = 8;
+ bool l_result = true;
+
+ /* to store the data of the super box */
+ unsigned char l_jp2h_data [8];
+
+ // preconditions
+ assert(cio != 00);
+ assert(jp2 != 00);
+ assert(p_manager != 00);
+
+ memset(l_writers,0,sizeof(l_writers));
+
+ if
+ (jp2->bpc == 255)
+ {
+ l_nb_pass = 3;
+ l_writers[0].handler = jp2_write_ihdr;
+ l_writers[1].handler = jp2_write_bpcc;
+ l_writers[2].handler = jp2_write_colr;
+ }
+ else
+ {
+ l_nb_pass = 2;
+ l_writers[0].handler = jp2_write_ihdr;
+ l_writers[1].handler = jp2_write_colr;
+ }
+
+ /* write box header */
+ /* write JP2H type */
+ opj_write_bytes(l_jp2h_data+4,JP2_JP2H,4);
+
+ l_current_writer = l_writers;
+ for
+ (i=0;i<l_nb_pass;++i)
+ {
+ l_current_writer->m_data = l_current_writer->handler(jp2,&(l_current_writer->m_size));
+ if
+ (l_current_writer->m_data == 00)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to hold JP2 Header data\n");
+ l_result = false;
+ break;
+ }
+ l_jp2h_size += l_current_writer->m_size;
+ ++l_current_writer;
+ }
+
+ if
+ (! l_result)
+ {
+ l_current_writer = l_writers;
+ for
+ (i=0;i<l_nb_pass;++i)
+ {
+ if
+ (l_current_writer->m_data != 00)
+ {
+ opj_free(l_current_writer->m_data );
+ }
+ ++l_current_writer;
+ }
+ return false;
+ }
+
+ /* write super box size */
+ opj_write_bytes(l_jp2h_data,l_jp2h_size,4);
+
+ /* write super box data on stream */
+ if
+ (opj_stream_write_data(cio,l_jp2h_data,8,p_manager) != 8)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Stream error while writting JP2 Header box\n");
+ l_result = false;
+ }
+
+ if
+ (l_result)
+ {
+ l_current_writer = l_writers;
+ for
+ (i=0;i<l_nb_pass;++i)
+ {
+ if
+ (opj_stream_write_data(cio,l_current_writer->m_data,l_current_writer->m_size,p_manager) != l_current_writer->m_size)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Stream error while writting JP2 Header box\n");
+ l_result = false;
+ break;
+ }
+ ++l_current_writer;
+ }
+ }
+ l_current_writer = l_writers;
+ /* cleanup */
+ for
+ (i=0;i<l_nb_pass;++i)
+ {
+ if
+ (l_current_writer->m_data != 00)
+ {
+ opj_free(l_current_writer->m_data );
+ }
+ ++l_current_writer;
+ }
+ return l_result;
+}
+
+/**
+ * Reads the Jpeg2000 file Header box - JP2 Header box (warning, this is a super box).
+ *
+ * @param p_header_data the data contained in the file header box.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_header_size the size of the data contained in the file header box.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the JP2 Header box was successfully reconized.
+*/
+bool jp2_read_jp2h(
+ opj_jp2_t *jp2,
+ unsigned char * p_header_data,
+ unsigned int p_header_size,
+ opj_event_mgr_t * p_manager
+ )
+{
+ unsigned int l_box_size=0, l_current_data_size = 0;
+ opj_jp2_box_t box;
+ const opj_jp2_header_handler_t * l_current_handler;
+
+ // preconditions
+ assert(p_header_data != 00);
+ assert(jp2 != 00);
+ assert(p_manager != 00);
+
+ /* make sure the box is well placed */
+ if
+ ((jp2->jp2_state & JP2_STATE_FILE_TYPE) != JP2_STATE_FILE_TYPE )
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "The box must be the first box in the file.\n");
+ return false;
+ }
+ jp2->jp2_img_state = JP2_IMG_STATE_NONE;
+
+ /* iterate while remaining data */
+ while
+ (p_header_size > 0)
+ {
+ if
+ (! jp2_read_boxhdr_char(&box,p_header_data,&l_box_size,p_header_size, p_manager))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Stream error while reading JP2 Header box\n");
+ return false;
+ }
+ if
+ (box.length > p_header_size)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Stream error while reading JP2 Header box\n");
+ return false;
+ }
+ l_current_handler = jp2_img_find_handler(box.type);
+
+ l_current_data_size = box.length - l_box_size;
+ p_header_data += l_box_size;
+
+ if
+ (l_current_handler != 00)
+ {
+ if
+ (! l_current_handler->handler(jp2,p_header_data,l_current_data_size,p_manager))
+ {
+ return false;
+ }
+ }
+ else
+ {
+ jp2->jp2_img_state |= JP2_IMG_STATE_UNKNOWN;
+ }
+ p_header_data += l_current_data_size;
+ p_header_size -= box.length;
+ }
+ jp2->jp2_state |= JP2_STATE_HEADER;
+ return true;
+}
+
+/**
+ * Reads a IHDR box - Image Header box
+ *
+ * @param p_image_header_data pointer to actual data (already read from file)
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_image_header_size the size of the image header
+ * @param p_image_header_max_size maximum size of the header, any size bigger than this value should result the function to output false.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the image header is valid, fale else.
+ */
+bool jp2_read_ihdr(
+ opj_jp2_t *jp2,
+ unsigned char * p_image_header_data,
+ unsigned int p_image_header_size,
+ opj_event_mgr_t * p_manager
+ )
+{
+ // preconditions
+ assert(p_image_header_data != 00);
+ assert(jp2 != 00);
+ assert(p_manager != 00);
+
+ if
+ (p_image_header_size != 14)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Bad image header box (bad size)\n");
+ return false;
+ }
+ opj_read_bytes(p_image_header_data,&(jp2->h),4); /* HEIGHT */
+ p_image_header_data += 4;
+ opj_read_bytes(p_image_header_data,&(jp2->w),4); /* WIDTH */
+ p_image_header_data += 4;
+ opj_read_bytes(p_image_header_data,&(jp2->numcomps),2); /* NC */
+ p_image_header_data += 2;
+
+ /* allocate memory for components */
+ jp2->comps = (opj_jp2_comps_t*) opj_malloc(jp2->numcomps * sizeof(opj_jp2_comps_t));
+ if
+ (jp2->comps == 0)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to handle image header (ihdr)\n");
+ return false;
+ }
+ memset(jp2->comps,0,jp2->numcomps * sizeof(opj_jp2_comps_t));
+
+ opj_read_bytes(p_image_header_data,&(jp2->bpc),1); /* BPC */
+ ++ p_image_header_data;
+ opj_read_bytes(p_image_header_data,&(jp2->C),1); /* C */
+ ++ p_image_header_data;
+ opj_read_bytes(p_image_header_data,&(jp2->UnkC),1); /* UnkC */
+ ++ p_image_header_data;
+ opj_read_bytes(p_image_header_data,&(jp2->IPR),1); /* IPR */
+ ++ p_image_header_data;
+ return true;
+}
+
+/**
+ * Writes the Image Header box - Image Header box.
+ *
+ * @param jp2 jpeg2000 file codec.
+ * @param p_nb_bytes_written pointer to store the nb of bytes written by the function.
+ *
+ * @return the data being copied.
+*/
+static unsigned char * jp2_write_ihdr(
+ opj_jp2_t *jp2,
+ unsigned int * p_nb_bytes_written
+ )
+{
+ unsigned char * l_ihdr_data,* l_current_ihdr_ptr;
+
+ // preconditions
+ assert(jp2 != 00);
+ assert(p_nb_bytes_written != 00);
+
+ /* default image header is 22 bytes wide */
+ l_ihdr_data = (unsigned char *) opj_malloc(22);
+ if
+ (l_ihdr_data == 00)
+ {
+ return 00;
+ }
+ memset(l_ihdr_data,0,22);
+
+ l_current_ihdr_ptr = l_ihdr_data;
+
+ opj_write_bytes(l_current_ihdr_ptr,22,4); /* write box size */
+ l_current_ihdr_ptr+=4;
+ opj_write_bytes(l_current_ihdr_ptr,JP2_IHDR, 4); /* IHDR */
+ l_current_ihdr_ptr+=4;
+ opj_write_bytes(l_current_ihdr_ptr,jp2->h, 4); /* HEIGHT */
+ l_current_ihdr_ptr+=4;
+ opj_write_bytes(l_current_ihdr_ptr, jp2->w, 4); /* WIDTH */
+ l_current_ihdr_ptr+=4;
+ opj_write_bytes(l_current_ihdr_ptr, jp2->numcomps, 2); /* NC */
+ l_current_ihdr_ptr+=2;
+ opj_write_bytes(l_current_ihdr_ptr, jp2->bpc, 1); /* BPC */
+ ++l_current_ihdr_ptr;
+ opj_write_bytes(l_current_ihdr_ptr, jp2->C, 1); /* C : Always 7 */
+ ++l_current_ihdr_ptr;
+ opj_write_bytes(l_current_ihdr_ptr, jp2->UnkC, 1); /* UnkC, colorspace unknown */
+ ++l_current_ihdr_ptr;
+ opj_write_bytes(l_current_ihdr_ptr, jp2->IPR, 1); /* IPR, no intellectual property */
+ ++l_current_ihdr_ptr;
+ *p_nb_bytes_written = 22;
+ return l_ihdr_data;
+}
+
+/**
+ * Writes the Bit per Component box.
+ *
+ * @param jp2 jpeg2000 file codec.
+ * @param p_nb_bytes_written pointer to store the nb of bytes written by the function.
+ *
+ * @return the data being copied.
+*/
+unsigned char * jp2_write_bpcc(
+ opj_jp2_t *jp2,
+ unsigned int * p_nb_bytes_written
+ )
+{
+ unsigned int i;
+ /* room for 8 bytes for box and 1 byte for each component */
+ int l_bpcc_size = 8 + jp2->numcomps;
+ unsigned char * l_bpcc_data,* l_current_bpcc_ptr;
+
+ // preconditions
+ assert(jp2 != 00);
+ assert(p_nb_bytes_written != 00);
+
+ l_bpcc_data = (unsigned char *) opj_malloc(l_bpcc_size);
+ if
+ (l_bpcc_data == 00)
+ {
+ return 00;
+ }
+ memset(l_bpcc_data,0,l_bpcc_size);
+
+ l_current_bpcc_ptr = l_bpcc_data;
+
+ opj_write_bytes(l_current_bpcc_ptr,l_bpcc_size,4); /* write box size */
+ l_current_bpcc_ptr += 4;
+ opj_write_bytes(l_current_bpcc_ptr,JP2_BPCC,4); /* BPCC */
+ l_current_bpcc_ptr += 4;
+
+ for
+ (i = 0; i < jp2->numcomps; ++i)
+ {
+ opj_write_bytes(l_current_bpcc_ptr, jp2->comps[i].bpcc, 1); /* write each component information */
+ ++l_current_bpcc_ptr;
+ }
+ *p_nb_bytes_written = l_bpcc_size;
+ return l_bpcc_data;
+}
+
+/**
+ * Reads a Bit per Component box.
+ *
+ * @param p_bpc_header_data pointer to actual data (already read from file)
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_bpc_header_size pointer that will hold the size of the bpc header
+ * @param p_bpc_header_max_size maximum size of the header, any size bigger than this value should result the function to output false.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the bpc header is valid, fale else.
+ */
+bool jp2_read_bpcc(
+ opj_jp2_t *jp2,
+ unsigned char * p_bpc_header_data,
+ unsigned int p_bpc_header_size,
+ opj_event_mgr_t * p_manager
+ )
+{
+ unsigned int i;
+
+ // preconditions
+ assert(p_bpc_header_data != 00);
+ assert(jp2 != 00);
+ assert(p_manager != 00);
+
+ // and length is relevant
+ if
+ (p_bpc_header_size != jp2->numcomps)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Bad BPCC header box (bad size)\n");
+ return false;
+ }
+
+ // read info for each component
+ for
+ (i = 0; i < jp2->numcomps; ++i)
+ {
+ opj_read_bytes(p_bpc_header_data,&jp2->comps[i].bpcc ,1); /* read each BPCC component */
+ ++p_bpc_header_data;
+ }
+ return true;
+}
+
+/**
+ * Writes the Colour Specification box.
+ *
+ * @param jp2 jpeg2000 file codec.
+ * @param p_nb_bytes_written pointer to store the nb of bytes written by the function.
+ *
+ * @return the data being copied.
+*/
+unsigned char *jp2_write_colr(
+ opj_jp2_t *jp2,
+ unsigned int * p_nb_bytes_written
+ )
+{
+ /* room for 8 bytes for box 3 for common data and variable upon profile*/
+ unsigned int l_colr_size = 11;
+ unsigned char * l_colr_data,* l_current_colr_ptr;
+
+ // preconditions
+ assert(jp2 != 00);
+ assert(p_nb_bytes_written != 00);
+
+ switch
+ (jp2->meth)
+ {
+ case 1 :
+ l_colr_size += 4;
+ break;
+ case 2 :
+ ++l_colr_size;
+ break;
+ default :
+ return 00;
+ }
+
+ l_colr_data = (unsigned char *) opj_malloc(l_colr_size);
+ if
+ (l_colr_data == 00)
+ {
+ return 00;
+ }
+ memset(l_colr_data,0,l_colr_size);
+ l_current_colr_ptr = l_colr_data;
+
+ opj_write_bytes(l_current_colr_ptr,l_colr_size,4); /* write box size */
+ l_current_colr_ptr += 4;
+ opj_write_bytes(l_current_colr_ptr,JP2_COLR,4); /* BPCC */
+ l_current_colr_ptr += 4;
+
+ opj_write_bytes(l_current_colr_ptr, jp2->meth,1); /* METH */
+ ++l_current_colr_ptr;
+ opj_write_bytes(l_current_colr_ptr, jp2->precedence,1); /* PRECEDENCE */
+ ++l_current_colr_ptr;
+ opj_write_bytes(l_current_colr_ptr, jp2->approx,1); /* APPROX */
+ ++l_current_colr_ptr;
+
+ if
+ (jp2->meth == 1)
+ {
+ opj_write_bytes(l_current_colr_ptr, jp2->enumcs,4); /* EnumCS */
+ }
+ else
+ {
+ opj_write_bytes(l_current_colr_ptr, 0, 1); /* PROFILE (??) */
+ }
+ *p_nb_bytes_written = l_colr_size;
+ return l_colr_data;
+}
+
+/**
+ * Reads the Colour Specification box.
+ *
+ * @param p_colr_header_data pointer to actual data (already read from file)
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_colr_header_size pointer that will hold the size of the color header
+ * @param p_colr_header_max_size maximum size of the header, any size bigger than this value should result the function to output false.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the bpc header is valid, fale else.
+*/
+bool jp2_read_colr(
+ opj_jp2_t * jp2,
+ unsigned char * p_colr_header_data,
+ unsigned int p_colr_header_size,
+ opj_event_mgr_t * p_manager
+ )
+{
+ // preconditions
+ assert(jp2 != 00);
+ assert(p_colr_header_data != 00);
+ assert(p_manager != 00);
+
+ if
+ (p_colr_header_size < 3)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Bad BPCC header box (bad size)\n");
+ return false;
+ }
+
+ opj_read_bytes(p_colr_header_data,&jp2->meth ,1); /* METH */
+ ++p_colr_header_data;
+
+ opj_read_bytes(p_colr_header_data,&jp2->precedence ,1); /* PRECEDENCE */
+ ++p_colr_header_data;
+
+ opj_read_bytes(p_colr_header_data,&jp2->approx ,1); /* APPROX */
+ ++p_colr_header_data;
+
+
+ if
+ (jp2->meth == 1)
+ {
+ if
+ (p_colr_header_size != 7)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Bad BPCC header box (bad size)\n");
+ return false;
+ }
+ opj_read_bytes(p_colr_header_data,&jp2->enumcs ,4); /* EnumCS */
+ }
+ /*else
+ {
+ // do not care with profiles.
+ }*/
+ return true;
+}
+
+/**
+ * Writes the Jpeg2000 codestream Header box - JP2C Header box.
+ *
+ * @param cio the stream to write data to.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_manager user event manager.
+ *
+ * @return true if writting was successful.
+*/
+bool jp2_write_jp2c(
+ opj_jp2_t *jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager
+ )
+{
+ unsigned int j2k_codestream_exit;
+ unsigned char l_data_header [8];
+
+ // preconditions
+ assert(jp2 != 00);
+ assert(cio != 00);
+ assert(p_manager != 00);
+ assert(opj_stream_has_seek(cio));
+
+ j2k_codestream_exit = opj_stream_tell(cio);
+ opj_write_bytes(l_data_header,j2k_codestream_exit - jp2->j2k_codestream_offset,4); /* size of codestream */
+ opj_write_bytes(l_data_header + 4,JP2_JP2C,4); /* JP2C */
+
+ if
+ (! opj_stream_seek(cio,jp2->j2k_codestream_offset,p_manager))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+ return false;
+ }
+
+ if
+ (opj_stream_write_data(cio,l_data_header,8,p_manager) != 8)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+ return false;
+ }
+
+ if
+ (! opj_stream_seek(cio,j2k_codestream_exit,p_manager))
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Destroys a jpeg2000 file decompressor.
+ *
+ * @param jp2 a jpeg2000 file decompressor.
+ */
+void jp2_destroy(opj_jp2_t *jp2)
+{
+ if
+ (jp2)
+ {
+ /* destroy the J2K codec */
+ j2k_destroy(jp2->j2k);
+ jp2->j2k = 00;
+ if
+ (jp2->comps)
+ {
+ opj_free(jp2->comps);
+ jp2->comps = 00;
+ }
+ if
+ (jp2->cl)
+ {
+ opj_free(jp2->cl);
+ jp2->cl = 00;
+ }
+ if
+ (jp2->m_validation_list)
+ {
+ opj_procedure_list_destroy(jp2->m_validation_list);
+ jp2->m_validation_list = 00;
+ }
+ if
+ (jp2->m_procedure_list)
+ {
+ opj_procedure_list_destroy(jp2->m_procedure_list);
+ jp2->m_procedure_list = 00;
+ }
+ opj_free(jp2);
+ }
+}
+
+
+
+
+
+/* ----------------------------------------------------------------------- */
+/* JP2 encoder interface */
+/* ----------------------------------------------------------------------- */
+
+opj_jp2_t* jp2_create(bool p_is_decoder)
+{
+ opj_jp2_t *jp2 = (opj_jp2_t*)opj_malloc(sizeof(opj_jp2_t));
+ if
+ (jp2)
+ {
+ memset(jp2,0,sizeof(opj_jp2_t));
+ /* create the J2K codec */
+ if
+ (! p_is_decoder)
+ {
+ jp2->j2k = j2k_create_compress();
+ }
+ else
+ {
+ jp2->j2k = j2k_create_decompress();
+ }
+ if
+ (jp2->j2k == 00)
+ {
+ jp2_destroy(jp2);
+ return 00;
+ }
+ // validation list creation
+ jp2->m_validation_list = opj_procedure_list_create();
+ if
+ (! jp2->m_validation_list)
+ {
+ jp2_destroy(jp2);
+ return 00;
+ }
+
+ // execution list creation
+ jp2->m_procedure_list = opj_procedure_list_create();
+ if
+ (! jp2->m_procedure_list)
+ {
+ jp2_destroy(jp2);
+ return 00;
+ }
+ }
+ return jp2;
+}
+
+/**
+ * Excutes the given procedures on the given codec.
+ *
+ * @param p_procedure_list the list of procedures to execute
+ * @param jp2 the jpeg2000 file codec to execute the procedures on.
+ * @param cio the stream to execute the procedures on.
+ * @param p_manager the user manager.
+ *
+ * @return true if all the procedures were successfully executed.
+ */
+bool jp2_exec (
+ opj_jp2_t * jp2,
+ opj_procedure_list_t * p_procedure_list,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager
+ )
+{
+ bool (** l_procedure) (opj_jp2_t * jp2,opj_stream_private_t *,opj_event_mgr_t *) = 00;
+ bool l_result = true;
+ unsigned int l_nb_proc, i;
+
+ // preconditions
+ assert(p_procedure_list != 00);
+ assert(jp2 != 00);
+ assert(cio != 00);
+ assert(p_manager != 00);
+
+ l_nb_proc = opj_procedure_list_get_nb_procedures(p_procedure_list);
+ l_procedure = (bool (**) (opj_jp2_t * jp2,opj_stream_private_t *,opj_event_mgr_t *)) opj_procedure_list_get_first_procedure(p_procedure_list);
+ for
+ (i=0;i<l_nb_proc;++i)
+ {
+ l_result = l_result && (*l_procedure) (jp2,cio,p_manager);
+ ++l_procedure;
+ }
+ // and clear the procedure list at the end.
+ opj_procedure_list_clear(p_procedure_list);
+ return l_result;
+}
+
+
+/**
+ * Starts a compression scheme, i.e. validates the codec parameters, writes the header.
+ *
+ * @param jp2 the jpeg2000 file codec.
+ * @param cio the stream object.
+ *
+ * @return true if the codec is valid.
+ */
+bool jp2_start_compress(opj_jp2_t *jp2, struct opj_stream_private *cio,opj_image_t * p_image, struct opj_event_mgr * p_manager)
+{
+ // preconditions
+ assert(jp2 != 00);
+ assert(cio != 00);
+ assert(p_manager != 00);
+
+ /* customization of the validation */
+ jp2_setup_encoding_validation (jp2);
+
+ /* validation of the parameters codec */
+ if
+ (! jp2_exec(jp2,jp2->m_validation_list,cio,p_manager))
+ {
+ return false;
+ }
+
+ /* customization of the encoding */
+ jp2_setup_header_writting(jp2);
+
+ /* write header */
+ if
+ (! jp2_exec (jp2,jp2->m_procedure_list,cio,p_manager))
+ {
+ return false;
+ }
+ return j2k_start_compress(jp2->j2k,cio,p_image,p_manager);
+}
+
+/**
+ * Reads a jpeg2000 file header structure.
+ *
+ * @param cio the stream to read data from.
+ * @param jp2 the jpeg2000 file header structure.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the box is valid.
+ */
+bool jp2_read_header(
+ opj_jp2_t *jp2,
+ 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,
+ struct opj_stream_private *cio,
+ struct opj_event_mgr * p_manager
+ )
+{
+ // preconditions
+ assert(jp2 != 00);
+ assert(cio != 00);
+ assert(p_manager != 00);
+
+ /* customization of the validation */
+ jp2_setup_decoding_validation (jp2);
+
+ /* customization of the encoding */
+ jp2_setup_header_reading(jp2);
+
+ /* validation of the parameters codec */
+ if
+ (! jp2_exec(jp2,jp2->m_validation_list,cio,p_manager))
+ {
+ return false;
+ }
+
+ /* read header */
+ if
+ (! jp2_exec (jp2,jp2->m_procedure_list,cio,p_manager))
+ {
+ return false;
+ }
+ return j2k_read_header(
+ jp2->j2k,
+ p_image,
+ p_tile_x0,
+ p_tile_y0,
+ p_tile_width,
+ p_tile_height,
+ p_nb_tiles_x,
+ p_nb_tiles_y,
+ cio,
+ p_manager);
+}
+
+/**
+ * Ends the decompression procedures and possibiliy add data to be read after the
+ * codestream.
+ */
+bool jp2_end_decompress(opj_jp2_t *jp2, opj_stream_private_t *cio, opj_event_mgr_t * p_manager)
+{
+ // preconditions
+ assert(jp2 != 00);
+ assert(cio != 00);
+ assert(p_manager != 00);
+
+ /* customization of the end encoding */
+ jp2_setup_end_header_reading(jp2);
+
+ /* write header */
+ if
+ (! jp2_exec (jp2,jp2->m_procedure_list,cio,p_manager))
+ {
+ return false;
+ }
+ return j2k_end_decompress(jp2->j2k, cio, p_manager);
+}
+
+
+/**
+ * Ends the compression procedures and possibiliy add data to be read after the
+ * codestream.
+ */
+bool jp2_end_compress(opj_jp2_t *jp2, opj_stream_private_t *cio, opj_event_mgr_t * p_manager)
+{
+ // preconditions
+ assert(jp2 != 00);
+ assert(cio != 00);
+ assert(p_manager != 00);
+
+ /* customization of the end encoding */
+ jp2_setup_end_header_writting(jp2);
+
+ if
+ (! j2k_end_compress(jp2->j2k,cio,p_manager))
+ {
+ return false;
+ }
+ /* write header */
+ return jp2_exec (jp2,jp2->m_procedure_list,cio,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 jp2_encode(opj_jp2_t *jp2, struct opj_stream_private *cio, struct opj_event_mgr * p_manager)
+{
+ return j2k_encode(jp2->j2k,cio,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 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
+ )
+{
+ return j2k_write_tile (p_jp2->j2k,p_tile_index,p_data,p_data_size,p_stream,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 jp2_decode_tile (
+ opj_jp2_t * p_jp2,
+ OPJ_UINT32 p_tile_index,
+ OPJ_BYTE * p_data,
+ OPJ_UINT32 p_data_size,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ return j2k_decode_tile (p_jp2->j2k,p_tile_index,p_data,p_data_size,p_stream,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_jp2,
+ 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,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager
+ )
+{
+ return j2k_read_tile_header (p_jp2->j2k,
+ p_tile_index,
+ p_data_size,
+ p_tile_x0,
+ p_tile_y0,
+ p_tile_x1,
+ p_tile_y1,
+ p_nb_comps,
+ p_go_on,
+ p_stream,
+ p_manager);
+}
+
+/**
+ * Sets up the procedures to do on writting header after the codestream.
+ * Developpers wanting to extend the library can add their own writting procedures.
+ */
+void jp2_setup_end_header_writting (opj_jp2_t *jp2)
+{
+ // preconditions
+ assert(jp2 != 00);
+
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,jp2_write_jp2c );
+ /* DEVELOPER CORNER, add your custom procedures */
+}
+
+/**
+ * Sets up the procedures to do on reading header.
+ * Developpers wanting to extend the library can add their own writting procedures.
+ */
+void jp2_setup_header_reading (opj_jp2_t *jp2)
+{
+ // preconditions
+ assert(jp2 != 00);
+
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,jp2_read_header_procedure );
+ /* DEVELOPER CORNER, add your custom procedures */
+}
+
+/**
+ * Sets up the procedures to do on reading header after the codestream.
+ * Developpers wanting to extend the library can add their own writting procedures.
+ */
+void jp2_setup_end_header_reading (opj_jp2_t *jp2)
+{
+ // preconditions
+ assert(jp2 != 00);
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,jp2_read_header_procedure );
+ /* DEVELOPER CORNER, add your custom procedures */
+}
+
+
+/**
+ * The default validation procedure without any extension.
+ *
+ * @param jp2 the jpeg2000 codec to validate.
+ * @param cio the input stream to validate.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the parameters are correct.
+ */
+bool jp2_default_validation (
+ opj_jp2_t * jp2,
+ opj_stream_private_t *cio,
+ opj_event_mgr_t * p_manager
+ )
+{
+ bool l_is_valid = true;
+ unsigned int i;
+
+ // preconditions
+ assert(jp2 != 00);
+ assert(cio != 00);
+ assert(p_manager != 00);
+ /* JPEG2000 codec validation */
+ /*TODO*/
+
+ /* STATE checking */
+ /* make sure the state is at 0 */
+ l_is_valid &= (jp2->jp2_state == JP2_STATE_NONE);
+ /* make sure not reading a jp2h ???? WEIRD */
+ l_is_valid &= (jp2->jp2_img_state == JP2_IMG_STATE_NONE);
+
+ /* POINTER validation */
+ /* make sure a j2k codec is present */
+ l_is_valid &= (jp2->j2k != 00);
+ /* make sure a procedure list is present */
+ l_is_valid &= (jp2->m_procedure_list != 00);
+ /* make sure a validation list is present */
+ l_is_valid &= (jp2->m_validation_list != 00);
+
+ /* PARAMETER VALIDATION */
+ /* number of components */
+ l_is_valid &= (jp2->numcl > 0);
+ /* width */
+ l_is_valid &= (jp2->h > 0);
+ /* height */
+ l_is_valid &= (jp2->w > 0);
+ /* precision */
+ for
+ (i = 0; i < jp2->numcomps; ++i)
+ {
+ l_is_valid &= (jp2->comps[i].bpcc > 0);
+ }
+ /* METH */
+ l_is_valid &= ((jp2->meth > 0) && (jp2->meth < 3));
+
+
+
+ /* stream validation */
+ /* back and forth is needed */
+ l_is_valid &= opj_stream_has_seek(cio);
+
+ return l_is_valid;
+
+}
+
+/**
+ * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
+ * are valid. Developpers wanting to extend the library can add their own validation procedures.
+ */
+void jp2_setup_encoding_validation (opj_jp2_t *jp2)
+{
+ // preconditions
+ assert(jp2 != 00);
+ opj_procedure_list_add_procedure(jp2->m_validation_list, jp2_default_validation);
+ /* DEVELOPER CORNER, add your custom validation procedure */
+}
+
+/**
+ * Sets up the validation ,i.e. adds the procedures to lauch to make sure the codec parameters
+ * are valid. Developpers wanting to extend the library can add their own validation procedures.
+ */
+void jp2_setup_decoding_validation (opj_jp2_t *jp2)
+{
+ // preconditions
+ assert(jp2 != 00);
+ /* DEVELOPER CORNER, add your custom validation procedure */
+}
+
+/**
+ * Sets up the procedures to do on writting header. Developpers wanting to extend the library can add their own writting procedures.
+ */
+void jp2_setup_header_writting (opj_jp2_t *jp2)
+{
+ // preconditions
+ assert(jp2 != 00);
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,jp2_write_jp );
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,jp2_write_ftyp );
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,jp2_write_jp2h );
+ opj_procedure_list_add_procedure(jp2->m_procedure_list,jp2_skip_jp2c );
+
+ /* DEVELOPER CORNER, insert your custom procedures */
+
+}
+
+
+/**
+ * Skips the Jpeg2000 Codestream Header box - JP2C Header box.
+ *
+ * @param cio the stream to write data to.
+ * @param jp2 the jpeg2000 file codec.
+ * @param p_manager user event manager.
+ *
+ * @return true if writting was successful.
+*/
+bool jp2_skip_jp2c(
+ opj_jp2_t *jp2,
+ struct opj_stream_private *cio,
+ struct opj_event_mgr * p_manager
+ )
+{
+ // preconditions
+ assert(jp2 != 00);
+ assert(cio != 00);
+ assert(p_manager != 00);
+
+ jp2->j2k_codestream_offset = opj_stream_tell(cio);
+ if
+ (opj_stream_skip(cio,8,p_manager) != 8)
+ {
+ return false;
+ }
+ return true;
+}
+
+struct opj_image * jp2_decode(opj_jp2_t *jp2, struct opj_stream_private *cio, struct opj_event_mgr * p_manager)
+{
+ /* J2K decoding */
+ struct opj_image * image = j2k_decode(jp2->j2k, cio, p_manager);
+ if
+ (!image)
+ {
+ opj_event_msg(p_manager, EVT_ERROR, "Failed to decode J2K image\n");
+ return false;
+ }
+
+ /* Set Image Color Space */
+ if (jp2->enumcs == 16)
+ image->color_space = CLRSPC_SRGB;
+ else if (jp2->enumcs == 17)
+ image->color_space = CLRSPC_GRAY;
+ else if (jp2->enumcs == 18)
+ image->color_space = CLRSPC_SYCC;
+ else
+ image->color_space = CLRSPC_UNKNOWN;
+ return image;
+}
+
+void jp2_setup_encoder(opj_jp2_t *jp2, opj_cparameters_t *parameters, opj_image_t *image,opj_event_mgr_t * p_manager)
+{
+ unsigned int i;
+ int depth_0, sign;
+
+ if(!jp2 || !parameters || !image)
+ return;
+
+ /* setup the J2K codec */
+ /* ------------------- */
+
+ /* Check if number of components respects standard */
+ if (image->numcomps < 1 || image->numcomps > 16384) {
+ opj_event_msg(p_manager, EVT_ERROR, "Invalid number of components specified while setting up JP2 encoder\n");
+ return;
+ }
+
+ j2k_setup_encoder(jp2->j2k, parameters, image,p_manager);
+
+ /* setup the JP2 codec */
+ /* ------------------- */
+
+ /* Profile box */
+
+ jp2->brand = JP2_JP2; /* BR */
+ jp2->minversion = 0; /* MinV */
+ jp2->numcl = 1;
+ jp2->cl = (unsigned int*) opj_malloc(jp2->numcl * sizeof(unsigned int));
+ jp2->cl[0] = JP2_JP2; /* CL0 : JP2 */
+
+ /* Image Header box */
+
+ jp2->numcomps = image->numcomps; /* NC */
+ jp2->comps = (opj_jp2_comps_t*) opj_malloc(jp2->numcomps * sizeof(opj_jp2_comps_t));
+ jp2->h = image->y1 - image->y0; /* HEIGHT */
+ jp2->w = image->x1 - image->x0; /* WIDTH */
+ /* BPC */
+ depth_0 = image->comps[0].prec - 1;
+ sign = image->comps[0].sgnd;
+ jp2->bpc = depth_0 + (sign << 7);
+ for (i = 1; i < image->numcomps; i++) {
+ int depth = image->comps[i].prec - 1;
+ sign = image->comps[i].sgnd;
+ if (depth_0 != depth)
+ jp2->bpc = 255;
+ }
+ jp2->C = 7; /* C : Always 7 */
+ jp2->UnkC = 0; /* UnkC, colorspace specified in colr box */
+ jp2->IPR = 0; /* IPR, no intellectual property */
+
+ /* BitsPerComponent box */
+
+ for (i = 0; i < image->numcomps; i++) {
+ jp2->comps[i].bpcc = image->comps[i].prec - 1 + (image->comps[i].sgnd << 7);
+ }
+
+ /* Colour Specification box */
+
+ if ((image->numcomps == 1 || image->numcomps == 3) && (jp2->bpc != 255)) {
+ jp2->meth = 1; /* METH: Enumerated colourspace */
+ } else {
+ jp2->meth = 2; /* METH: Restricted ICC profile */
+ }
+ if (jp2->meth == 1) {
+ if (image->color_space == 1)
+ jp2->enumcs = 16; /* sRGB as defined by IEC 61966–2–1 */
+ else if (image->color_space == 2)
+ jp2->enumcs = 17; /* greyscale */
+ else if (image->color_space == 3)
+ jp2->enumcs = 18; /* YUV */
+ } else {
+ jp2->enumcs = 0; /* PROFILE (??) */
+ }
+ jp2->precedence = 0; /* PRECEDENCE */
+ jp2->approx = 0; /* APPROX */
+
+}
+
+void jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters)
+{
+ if(!jp2 || !parameters)
+ return;
+
+ /* setup the J2K codec */
+ /* ------------------- */
+ j2k_setup_decoder(jp2->j2k, parameters);
+}
+/**
+ * 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.
+ * @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 jp2_set_decode_area(
+ 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
+ )
+{
+ return j2k_set_decode_area(p_jp2->j2k,p_start_x,p_start_y,p_end_x,p_end_y,p_manager);
+}
+
+#if 0
+
+
+
+
+
+static void jp2_write_url(opj_cio_t *cio, char *Idx_file) {
+ unsigned int i;
+ opj_jp2_box_t box;
+
+ box.init_pos = cio_tell(cio);
+ cio_skip(cio, 4);
+ cio_write(cio, JP2_URL, 4); /* DBTL */
+ cio_write(cio, 0, 1); /* VERS */
+ cio_write(cio, 0, 3); /* FLAG */
+
+ if(Idx_file) {
+ for (i = 0; i < strlen(Idx_file); i++) {
+ cio_write(cio, Idx_file[i], 1);
+ }
+ }
+
+ box.length = cio_tell(cio) - box.init_pos;
+ cio_seek(cio, box.init_pos);
+ cio_write(cio, box.length, 4); /* L */
+ cio_seek(cio, box.init_pos + box.length);
+}
+#endif
diff --git a/v2/libopenjpeg/jp2.h b/v2/libopenjpeg/jp2.h new file mode 100755 index 00000000..67d6edcc --- /dev/null +++ b/v2/libopenjpeg/jp2.h @@ -0,0 +1,342 @@ +/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * 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.
+ *
+ * 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 __JP2_H
+#define __JP2_H
+/**
+@file jp2.h
+@brief The JPEG-2000 file format Reader/Writer (JP2)
+
+*/
+#include "openjpeg.h"
+
+
+
+
+/**********************************************************************************
+ ********************************* 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;
+ unsigned int bpcc;
+}
+opj_jp2_comps_t;
+
+/**
+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;
+ /* height of image */
+ unsigned int h;
+ /* number of components in the image */
+ unsigned int numcomps;
+ unsigned int bpc;
+ unsigned int C;
+ unsigned int UnkC;
+ unsigned int IPR;
+ unsigned int meth;
+ unsigned int approx;
+ unsigned int enumcs;
+ unsigned int precedence;
+ unsigned int brand;
+ unsigned int minversion;
+ unsigned int numcl;
+ unsigned int *cl;
+ opj_jp2_comps_t *comps;
+ unsigned int j2k_codestream_offset;
+ unsigned int jp2_state;
+ unsigned int jp2_img_state;
+
+}
+opj_jp2_t;
+
+/**
+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.
+ */
+opj_jp2_t* jp2_create (bool p_is_decoder);
+
+/**
+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* 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.
+ * @param cio the stream object.
+ *
+ * @return true if the codec is valid.
+ */
+bool jp2_start_compress(opj_jp2_t *jp2, 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 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 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.
+ * @param jp2 the jpeg2000 file header structure.
+ * @param p_manager the user event manager.
+ *
+ * @return true if the box is valid.
+ */
+bool jp2_read_header(
+ opj_jp2_t *jp2,
+ 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.
+ * @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 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.
+ * @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 jp2_set_decode_area(
+ 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 */
+
diff --git a/v2/libopenjpeg/jpt.c b/v2/libopenjpeg/jpt.c new file mode 100755 index 00000000..f09b72d8 --- /dev/null +++ b/v2/libopenjpeg/jpt.c @@ -0,0 +1,249 @@ +/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * 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.
+ *
+ * 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 "jpt.h"
+#include "openjpeg.h"
+#include "cio.h"
+#include "event.h"
+/*
+ * Read the information contains in VBAS [JPP/JPT stream message header]
+ * 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)
+{
+ OPJ_BYTE l_elmt;
+ OPJ_UINT32 l_nb_bytes_read = 0;
+
+ // read data till the MSB of the current byte is 1.
+ // concatenate 7 bits of data, last bit is finish flag
+
+ // read data from the stream
+
+ 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;
+
+ // is the MSB equal to 1 ?
+ 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
+ *
+ */
+void jpt_init_msg_header(opj_jpt_msg_header_t * header)
+{
+ header->Id = 0; /* In-class Identifier */
+ header->last_byte = 0; /* Last byte information */
+ header->Class_Id = 0; /* Class Identifier */
+ header->CSn_Id = 0; /* CSn : index identifier */
+ header->Msg_offset = 0; /* Message offset */
+ header->Msg_length = 0; /* Message length */
+ header->Layer_nb = 0; /* Auxiliary for JPP case */
+}
+
+/*
+ * Re-initialize the value of the message header structure
+ *
+ * Only parameters always present in message header
+ *
+ */
+void jpt_reinit_msg_header(opj_jpt_msg_header_t * header)
+{
+ header->Id = 0; /* In-class Identifier */
+ header->last_byte = 0; /* Last byte information */
+ header->Msg_offset = 0; /* Message offset */
+ header->Msg_length = 0; /* Message length */
+}
+
+/*
+ * 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)
+{
+ OPJ_BYTE elmt, Class = 0, CSn = 0;
+ OPJ_UINT32 l_nb_bytes_read = 0;
+ OPJ_UINT32 l_last_nb_bytes_read;
+
+
+ jpt_reinit_msg_header(header);
+
+ /* ------------- */
+ /* VBAS : Bin-ID */
+ /* ------------- */
+ if
+ (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 */
+ switch ((elmt >> 5) & 0x03)
+ {
+ case 0:
+ opj_event_msg(p_manager, EVT_ERROR, "Error trying to read a byte of data!!!\n");
+ break;
+ case 1:
+ Class = 0;
+ CSn = 0;
+ break;
+ case 2:
+ Class = 1;
+ CSn = 0;
+ break;
+ case 3:
+ Class = 1;
+ CSn = 1;
+ break;
+ default:
+ break;
+ }
+
+ /* see information on bits 'c' [p 10 : A.2.1 general, ISO/IEC FCD 15444-9] */
+ if
+ (((elmt >> 4) & 0x01) == 1)
+ {
+ header->last_byte = 1;
+ }
+
+ /* In-class identifier */
+ header->Id |= (elmt & 0x0f);
+ if
+ ((elmt >> 7) == 1)
+ {
+ 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 */
+ /* ------------ */
+ if (Class == 1)
+ {
+ header->Class_Id = 0;
+ l_last_nb_bytes_read = 0;
+ 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 */
+ /* ---------- */
+ if (CSn == 1)
+ {
+ header->CSn_Id = 0;
+ l_last_nb_bytes_read = 0;
+ 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 */
+ /* ----------------- */
+ l_last_nb_bytes_read = 0;
+ 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 */
+ /* ----------------- */
+ l_last_nb_bytes_read = 0;
+ 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 */
+ /* ---------- */
+ if ((header->Class_Id & 0x01) == 1)
+ {
+ header->Layer_nb = 0;
+ if
+ (! 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;
+}
diff --git a/v2/libopenjpeg/jpt.h b/v2/libopenjpeg/jpt.h new file mode 100755 index 00000000..5e36d439 --- /dev/null +++ b/v2/libopenjpeg/jpt.h @@ -0,0 +1,83 @@ +/*
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
+ * 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.
+ *
+ * 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 __JPT_H
+#define __JPT_H
+/**
+@file jpt.h
+@brief JPT-stream reader (JPEG 2000, JPIP)
+
+JPT-stream functions are implemented in J2K.C.
+*/
+#include "openjpeg.h"
+struct opj_stream_private;
+struct opj_event_mgr;
+/**
+Message Header JPT stream structure
+*/
+typedef struct opj_jpt_msg_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
+ * @param p_cio stream handle
+ * @param header JPT Message header structure
+ * @param p_manager user event manager to display nice messages.
+*/
+bool jpt_read_msg_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
diff --git a/v2/libopenjpeg/mct.c b/v2/libopenjpeg/mct.c new file mode 100755 index 00000000..84356f34 --- /dev/null +++ b/v2/libopenjpeg/mct.c @@ -0,0 +1,304 @@ +/*
+ * 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) 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 "mct.h"
+#include "fix.h"
+#include "opj_malloc.h"
+
+/* <summary> */
+/* This table contains the norms of the basis function of the reversible MCT. */
+/* </summary> */
+static const OPJ_FLOAT64 mct_norms[3] = { 1.732, .8292, .8292 };
+
+/* <summary> */
+/* This table contains the norms of the basis function of the irreversible MCT. */
+/* </summary> */
+static const OPJ_FLOAT64 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> */
+/* Foward reversible MCT. */
+/* </summary> */
+void mct_encode(
+ OPJ_INT32* restrict c0,
+ OPJ_INT32* restrict c1,
+ OPJ_INT32* restrict c2,
+ OPJ_UINT32 n)
+{
+ OPJ_UINT32 i;
+ for(i = 0; i < n; ++i) {
+ OPJ_INT32 r = c0[i];
+ OPJ_INT32 g = c1[i];
+ OPJ_INT32 b = c2[i];
+ OPJ_INT32 y = (r + (g * 2) + b) >> 2;
+ OPJ_INT32 u = b - g;
+ OPJ_INT32 v = r - g;
+ c0[i] = y;
+ c1[i] = u;
+ c2[i] = v;
+ }
+}
+
+/* <summary> */
+/* Inverse reversible MCT. */
+/* </summary> */
+void mct_decode(
+ OPJ_INT32* restrict c0,
+ OPJ_INT32* restrict c1,
+ OPJ_INT32* restrict c2,
+ OPJ_UINT32 n)
+{
+ OPJ_UINT32 i;
+ for (i = 0; i < n; ++i) {
+ OPJ_INT32 y = c0[i];
+ OPJ_INT32 u = c1[i];
+ OPJ_INT32 v = c2[i];
+ OPJ_INT32 g = y - ((u + v) >> 2);
+ OPJ_INT32 r = v + g;
+ OPJ_INT32 b = u + g;
+ c0[i] = r;
+ c1[i] = g;
+ c2[i] = b;
+ }
+}
+
+/* <summary> */
+/* Get norm of basis function of reversible MCT. */
+/* </summary> */
+OPJ_FLOAT64 mct_getnorm(OPJ_UINT32 compno) {
+ return mct_norms[compno];
+}
+
+/* <summary> */
+/* Foward irreversible MCT. */
+/* </summary> */
+void mct_encode_real(
+ OPJ_INT32* restrict c0,
+ OPJ_INT32* restrict c1,
+ OPJ_INT32* restrict c2,
+ OPJ_UINT32 n)
+{
+ OPJ_UINT32 i;
+ for(i = 0; i < n; ++i) {
+ OPJ_INT32 r = c0[i];
+ OPJ_INT32 g = c1[i];
+ OPJ_INT32 b = c2[i];
+ OPJ_INT32 y = fix_mul(r, 2449) + fix_mul(g, 4809) + fix_mul(b, 934);
+ OPJ_INT32 u = -fix_mul(r, 1382) - fix_mul(g, 2714) + fix_mul(b, 4096);
+ OPJ_INT32 v = fix_mul(r, 4096) - fix_mul(g, 3430) - fix_mul(b, 666);
+ c0[i] = y;
+ c1[i] = u;
+ c2[i] = v;
+ }
+}
+
+/* <summary> */
+/* Inverse irreversible MCT. */
+/* </summary> */
+void mct_decode_real(
+ OPJ_FLOAT32* restrict c0,
+ OPJ_FLOAT32* restrict c1,
+ OPJ_FLOAT32* restrict c2,
+ OPJ_UINT32 n)
+{
+ OPJ_UINT32 i;
+ for(i = 0; i < n; ++i) {
+ OPJ_FLOAT32 y = c0[i];
+ OPJ_FLOAT32 u = c1[i];
+ OPJ_FLOAT32 v = c2[i];
+ OPJ_FLOAT32 r = y + (v * 1.402f);
+ OPJ_FLOAT32 g = y - (u * 0.34413f) - (v * (0.71414f));
+ OPJ_FLOAT32 b = y + (u * 1.772f);
+ c0[i] = r;
+ c1[i] = g;
+ c2[i] = b;
+ }
+}
+
+/* <summary> */
+/* Get norm of basis function of irreversible MCT. */
+/* </summary> */
+OPJ_FLOAT64 mct_getnorm_real(OPJ_UINT32 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]);
+ }
+}
+
diff --git a/v2/libopenjpeg/mct.h b/v2/libopenjpeg/mct.h new file mode 100755 index 00000000..41e608db --- /dev/null +++ b/v2/libopenjpeg/mct.h @@ -0,0 +1,130 @@ +/*
+ * 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) 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 __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.
+*/
+#include "openjpeg.h"
+/** @defgroup MCT MCT - Implementation of a multi-component transform */
+/*@{*/
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+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);
+/**
+Apply a reversible multi-component inverse transform to an image
+@param c0 Samples for luminance component
+@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);
+/**
+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)
+@return
+*/
+OPJ_FLOAT64 mct_getnorm(OPJ_UINT32 compno);
+
+/**
+Apply an irreversible 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_real(OPJ_INT32 *c0, OPJ_INT32 *c1, OPJ_INT32 *c2, OPJ_UINT32 n);
+/**
+Apply an irreversible multi-component inverse transform to an image
+@param c0 Samples for luminance component
+@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);
+/**
+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(
+ // 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 */
diff --git a/v2/libopenjpeg/mqc.c b/v2/libopenjpeg/mqc.c new file mode 100755 index 00000000..c899dfa9 --- /dev/null +++ b/v2/libopenjpeg/mqc.c @@ -0,0 +1,544 @@ +/*
+ * 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) 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 "mqc.h"
+#include "t1.h"
+#include "opj_malloc.h"
+
+/** @defgroup MQC MQC - Implementation of an MQ-Coder */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+/**
+Output a byte, doing bit-stuffing if necessary.
+After a 0xff byte, the next byte must be smaller than 0x90.
+@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> */
+/* This array defines all the possible states for a context. */
+/* </summary> */
+static opj_mqc_state_t mqc_states[47 * 2] = {
+ {0x5601, 0, &mqc_states[2], &mqc_states[3]},
+ {0x5601, 1, &mqc_states[3], &mqc_states[2]},
+ {0x3401, 0, &mqc_states[4], &mqc_states[12]},
+ {0x3401, 1, &mqc_states[5], &mqc_states[13]},
+ {0x1801, 0, &mqc_states[6], &mqc_states[18]},
+ {0x1801, 1, &mqc_states[7], &mqc_states[19]},
+ {0x0ac1, 0, &mqc_states[8], &mqc_states[24]},
+ {0x0ac1, 1, &mqc_states[9], &mqc_states[25]},
+ {0x0521, 0, &mqc_states[10], &mqc_states[58]},
+ {0x0521, 1, &mqc_states[11], &mqc_states[59]},
+ {0x0221, 0, &mqc_states[76], &mqc_states[66]},
+ {0x0221, 1, &mqc_states[77], &mqc_states[67]},
+ {0x5601, 0, &mqc_states[14], &mqc_states[13]},
+ {0x5601, 1, &mqc_states[15], &mqc_states[12]},
+ {0x5401, 0, &mqc_states[16], &mqc_states[28]},
+ {0x5401, 1, &mqc_states[17], &mqc_states[29]},
+ {0x4801, 0, &mqc_states[18], &mqc_states[28]},
+ {0x4801, 1, &mqc_states[19], &mqc_states[29]},
+ {0x3801, 0, &mqc_states[20], &mqc_states[28]},
+ {0x3801, 1, &mqc_states[21], &mqc_states[29]},
+ {0x3001, 0, &mqc_states[22], &mqc_states[34]},
+ {0x3001, 1, &mqc_states[23], &mqc_states[35]},
+ {0x2401, 0, &mqc_states[24], &mqc_states[36]},
+ {0x2401, 1, &mqc_states[25], &mqc_states[37]},
+ {0x1c01, 0, &mqc_states[26], &mqc_states[40]},
+ {0x1c01, 1, &mqc_states[27], &mqc_states[41]},
+ {0x1601, 0, &mqc_states[58], &mqc_states[42]},
+ {0x1601, 1, &mqc_states[59], &mqc_states[43]},
+ {0x5601, 0, &mqc_states[30], &mqc_states[29]},
+ {0x5601, 1, &mqc_states[31], &mqc_states[28]},
+ {0x5401, 0, &mqc_states[32], &mqc_states[28]},
+ {0x5401, 1, &mqc_states[33], &mqc_states[29]},
+ {0x5101, 0, &mqc_states[34], &mqc_states[30]},
+ {0x5101, 1, &mqc_states[35], &mqc_states[31]},
+ {0x4801, 0, &mqc_states[36], &mqc_states[32]},
+ {0x4801, 1, &mqc_states[37], &mqc_states[33]},
+ {0x3801, 0, &mqc_states[38], &mqc_states[34]},
+ {0x3801, 1, &mqc_states[39], &mqc_states[35]},
+ {0x3401, 0, &mqc_states[40], &mqc_states[36]},
+ {0x3401, 1, &mqc_states[41], &mqc_states[37]},
+ {0x3001, 0, &mqc_states[42], &mqc_states[38]},
+ {0x3001, 1, &mqc_states[43], &mqc_states[39]},
+ {0x2801, 0, &mqc_states[44], &mqc_states[38]},
+ {0x2801, 1, &mqc_states[45], &mqc_states[39]},
+ {0x2401, 0, &mqc_states[46], &mqc_states[40]},
+ {0x2401, 1, &mqc_states[47], &mqc_states[41]},
+ {0x2201, 0, &mqc_states[48], &mqc_states[42]},
+ {0x2201, 1, &mqc_states[49], &mqc_states[43]},
+ {0x1c01, 0, &mqc_states[50], &mqc_states[44]},
+ {0x1c01, 1, &mqc_states[51], &mqc_states[45]},
+ {0x1801, 0, &mqc_states[52], &mqc_states[46]},
+ {0x1801, 1, &mqc_states[53], &mqc_states[47]},
+ {0x1601, 0, &mqc_states[54], &mqc_states[48]},
+ {0x1601, 1, &mqc_states[55], &mqc_states[49]},
+ {0x1401, 0, &mqc_states[56], &mqc_states[50]},
+ {0x1401, 1, &mqc_states[57], &mqc_states[51]},
+ {0x1201, 0, &mqc_states[58], &mqc_states[52]},
+ {0x1201, 1, &mqc_states[59], &mqc_states[53]},
+ {0x1101, 0, &mqc_states[60], &mqc_states[54]},
+ {0x1101, 1, &mqc_states[61], &mqc_states[55]},
+ {0x0ac1, 0, &mqc_states[62], &mqc_states[56]},
+ {0x0ac1, 1, &mqc_states[63], &mqc_states[57]},
+ {0x09c1, 0, &mqc_states[64], &mqc_states[58]},
+ {0x09c1, 1, &mqc_states[65], &mqc_states[59]},
+ {0x08a1, 0, &mqc_states[66], &mqc_states[60]},
+ {0x08a1, 1, &mqc_states[67], &mqc_states[61]},
+ {0x0521, 0, &mqc_states[68], &mqc_states[62]},
+ {0x0521, 1, &mqc_states[69], &mqc_states[63]},
+ {0x0441, 0, &mqc_states[70], &mqc_states[64]},
+ {0x0441, 1, &mqc_states[71], &mqc_states[65]},
+ {0x02a1, 0, &mqc_states[72], &mqc_states[66]},
+ {0x02a1, 1, &mqc_states[73], &mqc_states[67]},
+ {0x0221, 0, &mqc_states[74], &mqc_states[68]},
+ {0x0221, 1, &mqc_states[75], &mqc_states[69]},
+ {0x0141, 0, &mqc_states[76], &mqc_states[70]},
+ {0x0141, 1, &mqc_states[77], &mqc_states[71]},
+ {0x0111, 0, &mqc_states[78], &mqc_states[72]},
+ {0x0111, 1, &mqc_states[79], &mqc_states[73]},
+ {0x0085, 0, &mqc_states[80], &mqc_states[74]},
+ {0x0085, 1, &mqc_states[81], &mqc_states[75]},
+ {0x0049, 0, &mqc_states[82], &mqc_states[76]},
+ {0x0049, 1, &mqc_states[83], &mqc_states[77]},
+ {0x0025, 0, &mqc_states[84], &mqc_states[78]},
+ {0x0025, 1, &mqc_states[85], &mqc_states[79]},
+ {0x0015, 0, &mqc_states[86], &mqc_states[80]},
+ {0x0015, 1, &mqc_states[87], &mqc_states[81]},
+ {0x0009, 0, &mqc_states[88], &mqc_states[82]},
+ {0x0009, 1, &mqc_states[89], &mqc_states[83]},
+ {0x0005, 0, &mqc_states[90], &mqc_states[84]},
+ {0x0005, 1, &mqc_states[91], &mqc_states[85]},
+ {0x0001, 0, &mqc_states[90], &mqc_states[86]},
+ {0x0001, 1, &mqc_states[91], &mqc_states[87]},
+ {0x5601, 0, &mqc_states[92], &mqc_states[92]},
+ {0x5601, 1, &mqc_states[93], &mqc_states[93]},
+};
+
+/*
+==========================================================
+ local functions
+==========================================================
+*/
+
+static void mqc_byteout(opj_mqc_t *mqc) {
+ if (*mqc->bp == 0xff) {
+ mqc->bp++;
+ *mqc->bp = mqc->c >> 20;
+ mqc->c &= 0xfffff;
+ mqc->ct = 7;
+ } else {
+ 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;
+ }
+ }
+ }
+}
+
+static void mqc_renorme(opj_mqc_t *mqc) {
+ do {
+ mqc->a <<= 1;
+ mqc->c <<= 1;
+ 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);
+ }
+}
+
+OPJ_UINT32 mqc_numbytes(opj_mqc_t *mqc) {
+ return mqc->bp - mqc->start;
+}
+
+void mqc_init_enc(opj_mqc_t *mqc, OPJ_BYTE *bp) {
+ mqc_setcurctx(mqc, 0);
+ mqc->a = 0x8000;
+ mqc->c = 0;
+ mqc->bp = bp - 1;
+ *(mqc->bp) = 0;
+ mqc->ct = 12;
+ /*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 {
+ mqc_codelps(mqc);
+ }
+}
+
+void mqc_flush(opj_mqc_t *mqc) {
+ mqc_setbits(mqc);
+ mqc->c <<= mqc->ct;
+ mqc_byteout(mqc);
+ mqc->c <<= mqc->ct;
+ mqc_byteout(mqc);
+
+ if (*mqc->bp != 0xff) {
+ mqc->bp++;
+ }
+}
+
+void mqc_bypass_init_enc(opj_mqc_t *mqc) {
+ mqc->c = 0;
+ mqc->ct = 8;
+ /*if (*mqc->bp == 0xff) {
+ mqc->ct = 7;
+ } */
+}
+
+void mqc_bypass_enc(opj_mqc_t *mqc, OPJ_UINT32 d) {
+ mqc->ct--;
+ 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;
+ }
+}
+
+OPJ_UINT32 mqc_bypass_flush_enc(opj_mqc_t *mqc) {
+ OPJ_BYTE bit_padding;
+
+ bit_padding = 0;
+
+ if (mqc->ct != 0) {
+ while (mqc->ct > 0) {
+ mqc->ct--;
+ mqc->c += bit_padding << mqc->ct;
+ bit_padding = (bit_padding + 1) & 0x01;
+ }
+ mqc->bp++;
+ *mqc->bp = mqc->c;
+ mqc->ct = 8;
+ mqc->c = 0;
+ }
+
+ return 1;
+}
+
+void mqc_reset_enc(opj_mqc_t *mqc) {
+ mqc_resetstates(mqc);
+ mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
+ mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
+ mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
+}
+
+OPJ_UINT32 mqc_restart_enc(opj_mqc_t *mqc) {
+ OPJ_UINT32 correction = 1;
+
+ /* <flush part> */
+ OPJ_INT32 n = 27 - 15 - mqc->ct;
+ mqc->c <<= mqc->ct;
+ while (n > 0) {
+ mqc_byteout(mqc);
+ n -= mqc->ct;
+ mqc->c <<= mqc->ct;
+ }
+ mqc_byteout(mqc);
+
+ return correction;
+}
+
+void mqc_restart_init_enc(opj_mqc_t *mqc) {
+ /* <Re-init part> */
+ mqc_setcurctx(mqc, 0);
+ mqc->a = 0x8000;
+ mqc->c = 0;
+ mqc->ct = 12;
+ mqc->bp--;
+ if (*mqc->bp == 0xff) {
+ mqc->ct = 13;
+ }
+}
+
+void mqc_erterm_enc(opj_mqc_t *mqc) {
+ OPJ_INT32 k = 11 - mqc->ct + 1;
+
+ while (k > 0) {
+ mqc->c <<= mqc->ct;
+ mqc->ct = 0;
+ mqc_byteout(mqc);
+ k -= mqc->ct;
+ }
+
+ if (*mqc->bp != 0xff) {
+ mqc_byteout(mqc);
+ }
+}
+
+void mqc_segmark_enc(opj_mqc_t *mqc) {
+ OPJ_UINT32 i;
+ mqc_setcurctx(mqc, 18);
+
+ for (i = 1; i < 5; i++) {
+ mqc_encode(mqc, i % 2);
+ }
+}
+
+void mqc_init_dec(opj_mqc_t *mqc, OPJ_BYTE *bp, OPJ_UINT32 len) {
+ mqc_setcurctx(mqc, 0);
+ mqc->start = bp;
+ mqc->end = bp + len;
+ mqc->bp = bp;
+ if (len==0) mqc->c = 0xff << 16;
+ else mqc->c = *mqc->bp << 16;
+ mqc_bytein(mqc);
+ 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 {
+ mqc->c -= (*mqc->curctx)->qeval << 16;
+ if ((mqc->a & 0x8000) == 0) {
+ d = mqc_mpsexchange(mqc);
+ mqc_renormd(mqc);
+ } else {
+ d = (*mqc->curctx)->mps;
+ }
+ }
+
+ return (OPJ_UINT32)d;
+}
+
+void mqc_resetstates(opj_mqc_t *mqc) {
+ OPJ_UINT32 i;
+ for (i = 0; i < MQC_NUMCTXS; i++) {
+ mqc->ctxs[i] = mqc_states;
+ }
+}
+
+void mqc_setstate(opj_mqc_t *mqc, OPJ_UINT32 ctxno, OPJ_UINT32 msb, OPJ_INT32 prob) {
+ mqc->ctxs[ctxno] = &mqc_states[msb + (prob << 1)];
+}
+
+
diff --git a/v2/libopenjpeg/mqc.h b/v2/libopenjpeg/mqc.h new file mode 100755 index 00000000..d4c5dd77 --- /dev/null +++ b/v2/libopenjpeg/mqc.h @@ -0,0 +1,198 @@ +/*
+ * 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) 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 __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.
+*/
+#include "openjpeg.h"
+/** @defgroup MQC MQC - Implementation of an MQ-Coder */
+/*@{*/
+
+/**
+This struct defines the state of a context.
+*/
+typedef struct opj_mqc_state {
+ /** 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
+
+/**
+MQ coder
+*/
+typedef struct opj_mqc {
+ 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 */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Create a new MQC handle
+@return Returns a new MQC handle if successful, returns NULL otherwise
+*/
+opj_mqc_t* mqc_create(void);
+/**
+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);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __MQC_H */
diff --git a/v2/libopenjpeg/openjpeg.c b/v2/libopenjpeg/openjpeg.c new file mode 100755 index 00000000..a635c78f --- /dev/null +++ b/v2/libopenjpeg/openjpeg.c @@ -0,0 +1,902 @@ +/*
+ * Copyright (c) 2005, Hervé 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 * ))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 * )) 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_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_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_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_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 * )) 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;
+/* 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 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_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
+ parameters->cp_rsiz |= 0x8100;
+ 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;
+}
diff --git a/v2/libopenjpeg/openjpeg.h b/v2/libopenjpeg/openjpeg.h new file mode 100755 index 00000000..e52bf41f --- /dev/null +++ b/v2/libopenjpeg/openjpeg.h @@ -0,0 +1,1079 @@ + /*
+ * 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.
+ */
+#ifndef OPENJPEG_H
+#define OPENJPEG_H
+
+#if defined(OPJ_STATIC) || !(defined(WIN32) || defined(__WIN32__))
+ #define OPJ_API
+ #define OPJ_CALLCONV
+#else
+ #define OPJ_CALLCONV __stdcall
+ #ifdef OPJ_EXPORTS
+ #define OPJ_API __declspec(dllexport)
+ #else
+ #define OPJ_API __declspec(dllimport)
+ #endif /* OPJ_EXPORTS */
+#endif /* !OPJ_STATIC || !WIN32 */
+
+#ifndef __cplusplus
+ #if defined(HAVE_STDBOOL_H)
+ #include <stdbool.h>
+ #else
+ #if !defined(bool)
+ #define bool int
+ #endif
+ #if !defined(true)
+ #define true 1
+ #endif
+ #if !defined(false)
+ #define false 0
+ #endif
+ #endif
+#endif /* __cplusplus */
+typedef unsigned int OPJ_UINT32;
+typedef int OPJ_INT32;
+typedef unsigned short OPJ_UINT16;
+typedef short OPJ_INT16;
+typedef char OPJ_CHAR;
+typedef unsigned char OPJ_BYTE;
+typedef unsigned int OPJ_SIZE_T;
+typedef double OPJ_FLOAT64;
+typedef float OPJ_FLOAT32;
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+ typedef __int64 OPJ_INT64;
+#else
+ typedef long long OPJ_INT64;
+#endif
+
+#define OPENJPEG_VERSION "1.2.0"
+/*
+==========================================================
+ Compiler directives
+==========================================================
+*/
+#include <stdio.h>
+
+
+
+
+
+/*
+==========================================================
+ Useful constant definitions
+==========================================================
+*/
+
+#define OPJ_PATH_LEN 4096 /**< Maximum allowed size for filenames */
+#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_DEFAULT_NB_SEGS 10
+#define J2K_STREAM_CHUNK_SIZE 0x100000 /** 1 mega by default */
+#define J2K_DEFAULT_HEADER_SIZE 1000
+#define J2K_MCC_DEFAULT_NB_RECORDS 10
+#define J2K_MCT_DEFAULT_NB_RECORDS 10
+
+/* UniPG>> */
+#define JPWL_MAX_NO_TILESPECS 16 /**< Maximum number of tile parts expected by JPWL: increase at your will */
+#define JPWL_MAX_NO_PACKSPECS 16 /**< Maximum number of packet parts expected by JPWL: increase at your will */
+#define JPWL_MAX_NO_MARKERS 512 /**< Maximum number of JPWL markers: increase at your will */
+#define JPWL_PRIVATEINDEX_NAME "jpwl_index_privatefilename" /**< index file name used when JPWL is on */
+#define JPWL_EXPECTED_COMPONENTS 3 /**< Expect this number of components, so you'll find better the first EPB */
+#define JPWL_MAXIMUM_TILES 8192 /**< Expect this maximum number of tiles, to avoid some crashes */
+#define JPWL_MAXIMUM_HAMMING 2 /**< Expect this maximum number of bit errors in marker id's */
+#define JPWL_MAXIMUM_EPB_ROOM 65450 /**< Expect this maximum number of bytes for composition of EPBs */
+/* <<UniPG */
+
+/*
+==========================================================
+ enum definitions
+==========================================================
+*/
+/**
+Rsiz Capabilities
+*/
+typedef enum RSIZ_CAPABILITIES {
+ STD_RSIZ = 0, /** Standard JPEG2000 profile*/
+ CINEMA2K = 3, /** Profile name for a 2K image*/
+ CINEMA4K = 4, /** Profile name for a 4K image*/
+ MCT = 0x8100
+} OPJ_RSIZ_CAPABILITIES;
+
+/**
+Digital cinema operation mode
+*/
+typedef enum CINEMA_MODE {
+ OFF = 0, /** Not Digital Cinema*/
+ CINEMA2K_24 = 1, /** 2K Digital Cinema at 24 fps*/
+ CINEMA2K_48 = 2, /** 2K Digital Cinema at 48 fps*/
+ CINEMA4K_24 = 3 /** 4K Digital Cinema at 24 fps*/
+}OPJ_CINEMA_MODE;
+
+/**
+Progression order
+*/
+typedef enum PROG_ORDER {
+ PROG_UNKNOWN = -1, /**< place-holder */
+ LRCP = 0, /**< layer-resolution-component-precinct order */
+ RLCP = 1, /**< resolution-layer-component-precinct order */
+ RPCL = 2, /**< resolution-precinct-component-layer order */
+ PCRL = 3, /**< precinct-component-resolution-layer order */
+ CPRL = 4 /**< component-precinct-resolution-layer order */
+} OPJ_PROG_ORDER;
+
+/**
+Supported image color spaces
+*/
+typedef enum COLOR_SPACE {
+ CLRSPC_UNKNOWN = -1, /**< place-holder */
+ CLRSPC_SRGB = 1, /**< sRGB */
+ CLRSPC_GRAY = 2, /**< grayscale */
+ CLRSPC_SYCC = 3 /**< YUV */
+} OPJ_COLOR_SPACE;
+
+/**
+Supported codec
+*/
+typedef enum CODEC_FORMAT {
+ CODEC_UNKNOWN = -1, /**< place-holder */
+ CODEC_J2K = 0, /**< JPEG-2000 codestream : read/write */
+ CODEC_JPT = 1, /**< JPT-stream (JPEG 2000, JPIP) : read only */
+ CODEC_JP2 = 2 /**< JPEG-2000 file format : read/write */
+} OPJ_CODEC_FORMAT;
+
+
+
+
+/*
+==========================================================
+ event manager typedef definitions
+==========================================================
+*/
+
+/**
+Callback function prototype for events
+@param msg Event message
+@param client_data
+*/
+typedef void (*opj_msg_callback) (const OPJ_CHAR *msg, void *client_data);
+
+
+
+
+/*
+==========================================================
+ codec typedef definitions
+==========================================================
+*/
+
+/**
+Progression order changes
+*/
+typedef struct opj_poc
+{
+ /** Resolution num start, Component num start, given by POC */
+ OPJ_UINT32 resno0, compno0;
+ /** Layer num end,Resolution num end, Component num end, given by POC */
+ OPJ_UINT32 layno1, resno1, compno1;
+ /** Layer num start,Precinct num start, Precinct num end */
+ OPJ_UINT32 layno0, precno0, precno1;
+ /** Progression order enum*/
+ OPJ_PROG_ORDER prg1,prg;
+ /** Progression order string*/
+ OPJ_CHAR progorder[5];
+ /** Tile number */
+ OPJ_UINT32 tile;
+ /** Start and end values for Tile width and height*/
+ OPJ_INT32 tx0,tx1,ty0,ty1;
+ /** Start value, initialised in pi_initialise_encode*/
+ OPJ_UINT32 layS, resS, compS, prcS;
+ /** End value, initialised in pi_initialise_encode */
+ OPJ_UINT32 layE, resE, compE, prcE;
+ /** Start and end values of Tile width and height, initialised in pi_initialise_encode*/
+ OPJ_UINT32 txS,txE,tyS,tyE,dx,dy;
+ /** Temporary values for Tile parts, initialised in pi_create_encode */
+ OPJ_UINT32 lay_t, res_t, comp_t, prc_t,tx0_t,ty0_t;
+} opj_poc_t;
+
+/**
+Compression parameters
+*/
+typedef struct opj_cparameters {
+ /** size of tile: tile_size_on = false (not in argument) or = true (in argument) */
+ bool tile_size_on;
+ /** XTOsiz */
+ int cp_tx0;
+ /** YTOsiz */
+ int cp_ty0;
+ /** XTsiz */
+ int cp_tdx;
+ /** YTsiz */
+ int cp_tdy;
+ /** allocation by rate/distortion */
+ int cp_disto_alloc;
+ /** allocation by fixed layer */
+ int cp_fixed_alloc;
+ /** add fixed_quality */
+ int cp_fixed_quality;
+ /** fixed layer */
+ int *cp_matrice;
+ /** comment for coding */
+ char *cp_comment;
+ /** csty : coding style */
+ int csty;
+ /** progression order (default LRCP) */
+ OPJ_PROG_ORDER prog_order;
+ /** progression order changes */
+ opj_poc_t POC[32];
+ /** number of progression order changes (POC), default to 0 */
+ int numpocs;
+ /** number of layers */
+ int tcp_numlayers;
+ /** rates of layers */
+ float tcp_rates[100];
+ /** different psnr for successive layers */
+ float tcp_distoratio[100];
+ /** number of resolutions */
+ int numresolution;
+ /** initial code block width, default to 64 */
+ int cblockw_init;
+ /** initial code block height, default to 64 */
+ int cblockh_init;
+ /** mode switch (cblk_style) */
+ int mode;
+ /** 1 : use the irreversible DWT 9-7, 0 : use lossless compression (default) */
+ int irreversible;
+ /** region of interest: affected component in [0..3], -1 means no ROI */
+ int roi_compno;
+ /** region of interest: upshift value */
+ int roi_shift;
+ /* number of precinct size specifications */
+ int res_spec;
+ /** initial precinct width */
+ int prcw_init[J2K_MAXRLVLS];
+ /** initial precinct height */
+ int prch_init[J2K_MAXRLVLS];
+
+ /**@name command line encoder parameters (not used inside the library) */
+ /*@{*/
+ /** input file name */
+ char infile[OPJ_PATH_LEN];
+ /** output file name */
+ char outfile[OPJ_PATH_LEN];
+ /** DEPRECATED. Index generation is now handeld with the opj_encode_with_info() function. Set to NULL */
+ int index_on;
+ /** DEPRECATED. Index generation is now handeld with the opj_encode_with_info() function. Set to NULL */
+ char index[OPJ_PATH_LEN];
+ /** subimage encoding: origin image offset in x direction */
+ int image_offset_x0;
+ /** subimage encoding: origin image offset in y direction */
+ int image_offset_y0;
+ /** subsampling value for dx */
+ int subsampling_dx;
+ /** subsampling value for dy */
+ int subsampling_dy;
+ /** input file format 0: PGX, 1: PxM, 2: BMP 3:TIF*/
+ int decod_format;
+ /** output file format 0: J2K, 1: JP2, 2: JPT */
+ int cod_format;
+ /*@}*/
+
+/* UniPG>> */
+ /**@name JPWL encoding parameters */
+ /*@{*/
+ /** enables writing of EPC in MH, thus activating JPWL */
+ bool jpwl_epc_on;
+ /** error protection method for MH (0,1,16,32,37-128) */
+ int jpwl_hprot_MH;
+ /** tile number of header protection specification (>=0) */
+ int jpwl_hprot_TPH_tileno[JPWL_MAX_NO_TILESPECS];
+ /** error protection methods for TPHs (0,1,16,32,37-128) */
+ int jpwl_hprot_TPH[JPWL_MAX_NO_TILESPECS];
+ /** tile number of packet protection specification (>=0) */
+ int jpwl_pprot_tileno[JPWL_MAX_NO_PACKSPECS];
+ /** packet number of packet protection specification (>=0) */
+ int jpwl_pprot_packno[JPWL_MAX_NO_PACKSPECS];
+ /** error protection methods for packets (0,1,16,32,37-128) */
+ int jpwl_pprot[JPWL_MAX_NO_PACKSPECS];
+ /** enables writing of ESD, (0=no/1/2 bytes) */
+ int jpwl_sens_size;
+ /** sensitivity addressing size (0=auto/2/4 bytes) */
+ int jpwl_sens_addr;
+ /** sensitivity range (0-3) */
+ int jpwl_sens_range;
+ /** sensitivity method for MH (-1=no,0-7) */
+ int jpwl_sens_MH;
+ /** tile number of sensitivity specification (>=0) */
+ int jpwl_sens_TPH_tileno[JPWL_MAX_NO_TILESPECS];
+ /** sensitivity methods for TPHs (-1=no,0-7) */
+ int jpwl_sens_TPH[JPWL_MAX_NO_TILESPECS];
+ /*@}*/
+/* <<UniPG */
+
+ /** Digital Cinema compliance 0-not compliant, 1-compliant*/
+ OPJ_CINEMA_MODE cp_cinema;
+ /** Maximum rate for each component. If == 0, component size limitation is not considered */
+ int max_comp_size;
+ /** Profile name*/
+ OPJ_RSIZ_CAPABILITIES cp_rsiz;
+ /** Tile part generation*/
+ char tp_on;
+ /** Flag for Tile part generation*/
+ char tp_flag;
+ /** MCT (multiple component transform) */
+ char tcp_mct;
+ /** Naive implementation of MCT restricted to a single reversible array based encoding without offset concerning all the components. */
+ void * mct_data;
+
+} opj_cparameters_t;
+
+/**
+Decompression parameters
+*/
+typedef struct opj_dparameters {
+ /**
+ Set the number of highest resolution levels to be discarded.
+ The image resolution is effectively divided by 2 to the power of the number of discarded levels.
+ The reduce factor is limited by the smallest total number of decomposition levels among tiles.
+ if != 0, then original dimension divided by 2^(reduce);
+ if == 0 or not used, image is decoded to the full resolution
+ */
+ int cp_reduce;
+ /**
+ Set the maximum number of quality layers to decode.
+ If there are less quality layers than the specified number, all the quality layers are decoded.
+ if != 0, then only the first "layer" layers are decoded;
+ if == 0 or not used, all the quality layers are decoded
+ */
+ int cp_layer;
+
+ /**
+ * Restrictive decoding parameters.
+ */
+ OPJ_INT32 m_decode_start_x;
+ OPJ_INT32 m_decode_start_y ;
+ OPJ_INT32 m_decode_end_x ;
+ OPJ_INT32 m_decode_end_y ;
+
+ /**@name command line encoder parameters (not used inside the library) */
+ /*@{*/
+ /** input file name */
+ char infile[OPJ_PATH_LEN];
+ /** output file name */
+ char outfile[OPJ_PATH_LEN];
+ /** input file format 0: J2K, 1: JP2, 2: JPT */
+ int decod_format;
+ /** output file format 0: PGX, 1: PxM, 2: BMP */
+ int cod_format;
+ /*@}*/
+
+/* UniPG>> */
+ /**@name JPWL decoding parameters */
+ /*@{*/
+ /** activates the JPWL correction capabilities */
+ bool jpwl_correct;
+ /** expected number of components */
+ int jpwl_exp_comps;
+ /** maximum number of tiles */
+ int jpwl_max_tiles;
+
+ /** use restrictive decoding ? */
+ OPJ_UINT32 m_use_restrict_decode : 1;
+ /*@}*/
+/* <<UniPG */
+
+} opj_dparameters_t;
+
+/**
+ * J2k codec.
+ */
+typedef void * opj_codec_t;
+
+
+/*
+==========================================================
+ I/O stream typedef definitions
+==========================================================
+*/
+
+/*
+ * Stream open flags.
+ */
+/** The stream was opened for reading. */
+#define OPJ_STREAM_READ 0x0001
+/** The stream was opened for writing. */
+#define OPJ_STREAM_WRITE 0x0002
+
+
+typedef OPJ_UINT32 (* opj_stream_read_fn) (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data) ;
+typedef OPJ_UINT32 (* opj_stream_write_fn) (void * p_buffer, OPJ_UINT32 p_nb_bytes, void * p_user_data) ;
+typedef OPJ_SIZE_T (* opj_stream_skip_fn) (OPJ_SIZE_T p_nb_bytes, void * p_user_data) ;
+typedef bool (* opj_stream_seek_fn) (OPJ_SIZE_T p_nb_bytes, void * p_user_data) ;
+
+
+typedef void * opj_stream_t;
+
+/*
+==========================================================
+ image typedef definitions
+==========================================================
+*/
+
+/**
+Defines a single image component
+*/
+typedef struct opj_image_comp {
+ /** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
+ OPJ_UINT32 dx;
+ /** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
+ OPJ_UINT32 dy;
+ /** data width */
+ OPJ_UINT32 w;
+ /** data height */
+ OPJ_UINT32 h;
+ /** x component offset compared to the whole image */
+ OPJ_INT32 x0;
+ /** y component offset compared to the whole image */
+ OPJ_INT32 y0;
+ /** precision */
+ OPJ_UINT32 prec;
+ /** number of decoded resolution */
+ OPJ_UINT32 resno_decoded;
+ /** number of division by 2 of the out image compared to the original size of image */
+ OPJ_UINT32 factor;
+ /** image component data */
+ int *data;
+ /** signed (1) / unsigned (0) */
+ OPJ_UINT32 sgnd : 1;
+
+} opj_image_comp_t;
+
+/**
+Defines image data and characteristics
+*/
+typedef struct opj_image
+{
+ /** XOsiz: horizontal offset from the origin of the reference grid to the left side of the image area */
+ OPJ_INT32 x0;
+ /** YOsiz: vertical offset from the origin of the reference grid to the top side of the image area */
+ OPJ_INT32 y0;
+ /** Xsiz: width of the reference grid */
+ OPJ_INT32 x1;
+ /** Ysiz: height of the reference grid */
+ OPJ_INT32 y1;
+ /** number of components in the image */
+ OPJ_UINT32 numcomps;
+ /** color space: sRGB, Greyscale or YUV */
+ OPJ_COLOR_SPACE color_space;
+ /** image components */
+ opj_image_comp_t *comps;
+} opj_image_t;
+
+/**
+Component parameters structure used by the opj_image_create function
+*/
+typedef struct opj_image_comptparm {
+ /** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
+ unsigned int dx;
+ /** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
+ unsigned int dy;
+ /** data width */
+ unsigned int w;
+ /** data height */
+ unsigned int h;
+ /** x component offset compared to the whole image */
+ int x0;
+ /** y component offset compared to the whole image */
+ int y0;
+ /** precision */
+ int prec;
+ /** image depth in bits */
+ int bpp;
+ /** signed (1) / unsigned (0) */
+ int sgnd;
+} opj_image_cmptparm_t;
+
+/*
+==========================================================
+ Information on the JPEG 2000 codestream
+==========================================================
+*/
+
+/**
+Index structure : Information concerning a packet inside tile
+*/
+typedef struct opj_packet_info {
+ /** packet start position (including SOP marker if it exists) */
+ int start_pos;
+ /** end of packet header position (including EPH marker if it exists)*/
+ int end_ph_pos;
+ /** packet end position */
+ int end_pos;
+ /** packet distorsion */
+ double disto;
+} opj_packet_info_t;
+
+/**
+Index structure : Information concerning tile-parts
+*/
+typedef struct opj_tp_info {
+ /** start position of tile part */
+ int tp_start_pos;
+ /** end position of tile part header */
+ int tp_end_header;
+ /** end position of tile part */
+ int tp_end_pos;
+ /** start packet of tile part */
+ int tp_start_pack;
+ /** number of packets of tile part */
+ int tp_numpacks;
+} opj_tp_info_t;
+
+/**
+Index structure : information regarding tiles
+*/
+typedef struct opj_tile_info {
+ /** value of thresh for each layer by tile cfr. Marcela */
+ double *thresh;
+ /** number of tile */
+ int tileno;
+ /** start position */
+ int start_pos;
+ /** end position of the header */
+ int end_header;
+ /** end position */
+ int end_pos;
+ /** precinct number for each resolution level (width) */
+ int pw[33];
+ /** precinct number for each resolution level (height) */
+ int ph[33];
+ /** precinct size (in power of 2), in X for each resolution level */
+ int pdx[33];
+ /** precinct size (in power of 2), in Y for each resolution level */
+ int pdy[33];
+ /** information concerning packets inside tile */
+ opj_packet_info_t *packet;
+ /** add fixed_quality */
+ int numpix;
+ /** add fixed_quality */
+ double distotile;
+ /** number of tile parts */
+ int num_tps;
+ /** information concerning tile parts */
+ opj_tp_info_t *tp;
+} opj_tile_info_t;
+
+/* UniPG>> */
+/**
+Marker structure
+*/
+typedef struct opj_marker_info_t {
+ /** marker type */
+ unsigned short int type;
+ /** position in codestream */
+ int pos;
+ /** length, marker val included */
+ int len;
+} opj_marker_info_t;
+/* <<UniPG */
+
+/**
+Index structure of the codestream
+*/
+typedef struct opj_codestream_info {
+ /** maximum distortion reduction on the whole image (add for Marcela) */
+ double D_max;
+ /** packet number */
+ int packno;
+ /** writing the packet in the index with t2_encode_packets */
+ int index_write;
+ /** image width */
+ int image_w;
+ /** image height */
+ int image_h;
+ /** progression order */
+ OPJ_PROG_ORDER prog;
+ /** tile size in x */
+ int tile_x;
+ /** tile size in y */
+ int tile_y;
+ /** */
+ int tile_Ox;
+ /** */
+ int tile_Oy;
+ /** number of tiles in X */
+ int tw;
+ /** number of tiles in Y */
+ int th;
+ /** component numbers */
+ int numcomps;
+ /** number of layer */
+ int numlayers;
+ /** number of decomposition for each component */
+ int *numdecompos;
+/* UniPG>> */
+ /** number of markers */
+ int marknum;
+ /** list of markers */
+ opj_marker_info_t *marker;
+ /** actual size of markers array */
+ int maxmarknum;
+/* <<UniPG */
+ /** main header position */
+ int main_head_start;
+ /** main header position */
+ int main_head_end;
+ /** codestream's size */
+ int codestream_size;
+ /** information regarding tiles inside image */
+ opj_tile_info_t *tile;
+} opj_codestream_info_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*
+==========================================================
+ openjpeg version
+==========================================================
+*/
+
+OPJ_API const OPJ_CHAR * OPJ_CALLCONV opj_version(void);
+
+/*
+==========================================================
+ image functions definitions
+==========================================================
+*/
+
+/**
+Create an image
+@param numcmpts number of components
+@param cmptparms components parameters
+@param clrspc image color space
+@return returns a new image structure if successful, returns NULL otherwise
+*/
+OPJ_API opj_image_t* OPJ_CALLCONV opj_image_create(OPJ_UINT32 numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc);
+
+/**
+ * Creates an image without allocating memory for the image (used in the new version of the library).
+ *
+ * @param p_num_cmpts the number of components
+ * @param p_cmpt_parms the components parameters
+ * @param p_clr_spc the image color space
+ *
+ * @return a new image structure if successful, NULL otherwise.
+*/
+OPJ_API opj_image_t* OPJ_CALLCONV opj_image_tile_create(OPJ_UINT32 numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc);
+
+/**
+Deallocate any resources associated with an image
+@param image image to be destroyed
+*/
+OPJ_API void OPJ_CALLCONV opj_image_destroy(opj_image_t *image);
+
+/*
+==========================================================
+ stream functions definitions
+==========================================================
+*/
+
+/**
+ * Creates an abstract stream. This function does nothing except allocating memory and initializing the abstract stream.
+ *
+ * @param l_is_reader if set to true then the stream will be an input stream, an output stream else.
+ *
+ * @return a stream object.
+*/
+OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_default_create(bool p_is_input);
+OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_create(OPJ_UINT32 p_size,bool p_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.
+ *
+ * @param p_stream the stream to destroy.
+ */
+OPJ_API void OPJ_CALLCONV opj_stream_destroy(opj_stream_t* p_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);
+
+/**
+ * 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);
+
+/**
+ * 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);
+
+/**
+ * Sets the given function to be used as a seek function, the stream is then seekable.
+ * @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_seek_function(opj_stream_t* p_stream, opj_stream_seek_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);
+
+/**
+ * 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_API opj_stream_t* OPJ_CALLCONV opj_stream_create_default_file_stream (FILE * p_file,bool p_is_read_stream);
+OPJ_API opj_stream_t* OPJ_CALLCONV opj_stream_create_file_stream (FILE * p_file,OPJ_UINT32 p_buffer_size, bool p_is_read_stream);
+
+
+
+/*
+==========================================================
+ event manager functions definitions
+==========================================================
+*/
+OPJ_API bool OPJ_CALLCONV opj_set_info_handler(opj_codec_t * p_codec, opj_msg_callback p_callback,void * p_user_data);
+OPJ_API bool OPJ_CALLCONV opj_set_warning_handler(opj_codec_t * p_codec, opj_msg_callback p_callback,void * p_user_data);
+OPJ_API bool OPJ_CALLCONV opj_set_error_handler(opj_codec_t * p_codec, opj_msg_callback p_callback,void * p_user_data);
+
+
+
+/*
+==========================================================
+ codec functions definitions
+==========================================================
+*/
+/**
+Creates a J2K/JPT/JP2 decompression structure
+@param format Decoder to select
+@return Returns a handle to a decompressor if successful, returns NULL otherwise
+*/
+OPJ_API opj_codec_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT format);
+
+/**
+Set decoding parameters to default values
+@param parameters Decompression parameters
+*/
+OPJ_API void OPJ_CALLCONV opj_set_default_decoder_parameters(opj_dparameters_t *parameters);
+
+#ifdef USE_OPJ_DEPRECATED
+#ifdef _MSC_VER
+#pragma message ( "warning, opj_setup_decoder is deprecated")
+#else
+#warning "warning, opj_setup_decoder is deprecated"
+#endif
+/**
+Setup the decoder decoding parameters using user parameters.
+Decoding parameters are returned in j2k->cp.
+@param dinfo decompressor handle
+@param parameters decompression parameters
+*/
+OPJ_API bool OPJ_CALLCONV opj_setup_decoder(opj_codec_t *dinfo, opj_dparameters_t *parameters);
+#endif
+
+/**
+Decode an image from a JPEG-2000 codestream
+@param dinfo decompressor handle
+@param cio Input buffer stream
+@return Returns a decoded image if successful, returns NULL otherwise
+*/
+OPJ_API opj_image_t* OPJ_CALLCONV opj_decode(opj_codec_t *p_decompressor, opj_stream_t * cio);
+
+/**
+ * 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.
+ *
+ * @return true if the data could be written.
+ */
+OPJ_API 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
+ );
+
+/**
+ * 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.
+ */
+OPJ_API 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);
+
+
+/**
+ * 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.
+ */
+OPJ_API 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
+ );
+
+/**
+ * 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.
+ */
+OPJ_API 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
+ );
+
+
+/**
+Decode an image from a JPEG-2000 codestream and extract the codestream information
+@param dinfo decompressor handle
+@param cio Input buffer stream
+@param cstr_info Codestream information structure if needed afterwards, NULL otherwise
+@return Returns a decoded image if successful, returns NULL otherwise
+*/
+//OPJ_API opj_image_t* OPJ_CALLCONV opj_decode_with_info(opj_dinfo_t *dinfo, opj_stream_t cio, opj_codestream_info_t *cstr_info);
+/**
+Creates a J2K/JP2 compression structure
+@param format Coder to select
+@return Returns a handle to a compressor if successful, returns NULL otherwise
+*/
+OPJ_API opj_codec_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT format);
+
+/**
+Destroy a decompressor handle
+@param dinfo decompressor handle to destroy
+*/
+OPJ_API void OPJ_CALLCONV opj_destroy_codec(opj_codec_t * p_codec);
+
+/**
+Set encoding parameters to default values, that means :
+<ul>
+<li>Lossless
+<li>1 tile
+<li>Size of precinct : 2^15 x 2^15 (means 1 precinct)
+<li>Size of code-block : 64 x 64
+<li>Number of resolutions: 6
+<li>No SOP marker in the codestream
+<li>No EPH marker in the codestream
+<li>No sub-sampling in x or y direction
+<li>No mode switch activated
+<li>Progression order: LRCP
+<li>No index file
+<li>No ROI upshifted
+<li>No offset of the origin of the image
+<li>No offset of the origin of the tiles
+<li>Reversible DWT 5-3
+</ul>
+@param parameters Compression parameters
+*/
+OPJ_API void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters);
+
+/**
+ * Sets the MCT matrix to use.
+ *
+ * @param parameters the parameters to change.
+ * @param pEncodingMatrix the encoding matrix.
+ * @param p_dc_shift the dc shift coefficients to use.
+ * @param pNbComp the number of components of the image.
+ *
+ * @return true if the parameters could be set.
+ */
+OPJ_API bool OPJ_CALLCONV opj_set_MCT(opj_cparameters_t *parameters,OPJ_FLOAT32 * pEncodingMatrix,OPJ_INT32 * p_dc_shift,OPJ_UINT32 pNbComp);
+
+/**
+ * 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);
+
+#ifdef USE_OPJ_DEPRECATED
+#ifdef _MSC_VER
+#pragma message ("warning, opj_setup_encoder is deprecated")
+#else
+#warning "warning, opj_setup_encoder is deprecated"
+#endif
+/**
+Setup the encoder parameters using the current image and using user parameters.
+@param cinfo Compressor handle
+@param parameters Compression parameters
+@param image Input filled image
+*/
+OPJ_API bool OPJ_CALLCONV opj_setup_encoder(opj_codec_t *cinfo, opj_cparameters_t *parameters, opj_image_t *image);
+#endif
+
+/**
+ * Decodes an image header.
+ *
+ * @param p_codec codec to use to decode the image.
+ * @param p_image pointer to a previously created image.
+ * @param p_tile_x0 pointer to a value that will hold the reference point x0 of the tiling grid.
+ * @param p_tile_y0 pointer to a value that will hold the reference point y0 of the tiling grid.
+ * @param p_tile_width pointer to a value that will hold the size in x of a tile in the grid.
+ * @param p_tile_height pointer to a value that will hold the size in y of a tile in the grid.
+ * @param p_nb_tiles_x pointer to a value that will hold the number of tiles in the x direction.
+ * @param p_nb_tiles_y pointer to a value that will hold the number of tiles in the y direction.
+ */
+OPJ_API 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);
+
+
+OPJ_API bool OPJ_CALLCONV opj_end_decompress (opj_codec_t *p_codec,opj_stream_t *p_cio);
+/**
+Encode an image into a JPEG-2000 codestream
+@param cinfo compressor handle
+@param cio Output buffer stream
+@param image Image to encode
+@param index Depreacted -> Set to NULL. To extract index, used opj_encode_wci()
+@return Returns true if successful, returns false otherwise
+*/
+OPJ_API bool OPJ_CALLCONV opj_encode(opj_codec_t *cinfo, opj_stream_t * cio);
+
+OPJ_API bool OPJ_CALLCONV opj_start_compress (opj_codec_t *p_codec,opj_image_t * p_image,opj_stream_t *p_cio);
+
+OPJ_API bool OPJ_CALLCONV opj_end_compress (opj_codec_t *p_codec,opj_stream_t *p_cio);
+/**
+Encode an image into a JPEG-2000 codestream and extract the codestream information
+@param cinfo compressor handle
+@param cio Output buffer stream
+@param image Image to encode
+@param cstr_info Codestream information structure if needed afterwards, NULL otherwise
+@return Returns true if successful, returns false otherwise
+*/
+//OPJ_API 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);
+/**
+Destroy Codestream information after compression or decompression
+@param cstr_info Codestream information structure
+*/
+OPJ_API void OPJ_CALLCONV opj_destroy_cstr_info(opj_codestream_info_t *cstr_info);
+
+//==============================================================================
+//==============================================================================
+/** profiling part */
+#ifdef _PROFILE
+void _ProfInit(void);
+void _ProfPrint(void);
+#define PROFINIT() _ProfInit();
+#define PROFSAVE(file) _ProfSave(file);
+#define PROFPRINT() _ProfPrint();
+#else
+#define PROFINIT()
+#define PROFSAVE(file)
+#define PROFPRINT()
+#endif // !_PROFILE
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OPENJPEG_H */
+
+
diff --git a/v2/libopenjpeg/opj_configure.h b/v2/libopenjpeg/opj_configure.h new file mode 100755 index 00000000..60058cbd --- /dev/null +++ b/v2/libopenjpeg/opj_configure.h @@ -0,0 +1,16 @@ +/* + * 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 */ diff --git a/v2/libopenjpeg/opj_includes.h b/v2/libopenjpeg/opj_includes.h new file mode 100755 index 00000000..371db8aa --- /dev/null +++ b/v2/libopenjpeg/opj_includes.h @@ -0,0 +1,104 @@ +/*
+ * Copyright (c) 2005, Hervé 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 does not have lrintf */
+#ifdef _MSC_VER
+static INLINE long lrintf(float f){
+ int i;
+
+ _asm{
+ fld f
+ fistp i
+ };
+
+ return i;
+}
+#endif
+
+#endif /* OPJ_INCLUDES_H */
diff --git a/v2/libopenjpeg/opj_malloc.h b/v2/libopenjpeg/opj_malloc.h new file mode 100755 index 00000000..0dd1bcdb --- /dev/null +++ b/v2/libopenjpeg/opj_malloc.h @@ -0,0 +1,145 @@ +/* + * 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 */ + diff --git a/v2/libopenjpeg/pi.c b/v2/libopenjpeg/pi.c new file mode 100755 index 00000000..f0dcd11e --- /dev/null +++ b/v2/libopenjpeg/pi.c @@ -0,0 +1,1999 @@ +/*
+ * 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 "pi.h"
+#include "int.h"
+#include "opj_malloc.h"
+#include "j2k.h"
+/** @defgroup PI PI - Implementation of a packet iterator */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+/**
+Get next packet in layer-resolution-component-precinct order.
+@param pi packet iterator to modify
+@return returns false if pi pointed to the last packet or else returns true
+*/
+static bool pi_next_lrcp(opj_pi_iterator_t * pi);
+/**
+Get next packet in resolution-layer-component-precinct order.
+@param pi packet iterator to modify
+@return returns false if pi pointed to the last packet or else returns true
+*/
+static bool pi_next_rlcp(opj_pi_iterator_t * pi);
+/**
+Get next packet in resolution-precinct-component-layer order.
+@param pi packet iterator to modify
+@return returns false if pi pointed to the last packet or else returns true
+*/
+static bool pi_next_rpcl(opj_pi_iterator_t * pi);
+/**
+Get next packet in precinct-component-resolution-layer order.
+@param pi packet iterator to modify
+@return returns false if pi pointed to the last packet or else returns true
+*/
+static bool pi_next_pcrl(opj_pi_iterator_t * pi);
+/**
+Get next packet in component-precinct-resolution-layer order.
+@param pi packet iterator to modify
+@return returns false if pi pointed to the last packet or else returns true
+*/
+static bool pi_next_cprl(opj_pi_iterator_t * pi);
+
+/**
+ * Updates the coding parameters if the encoding is used with Progression order changes and final (or cinema parameters are used).
+ *
+ * @param p_cp the coding parameters to modify
+ * @param p_tileno the tile index being concerned.
+ * @param p_tx0 X0 parameter for the tile
+ * @param p_tx1 X1 parameter for the tile
+ * @param p_ty0 Y0 parameter for the tile
+ * @param p_ty1 Y1 parameter for the tile
+ * @param p_max_prec the maximum precision for all the bands of the tile
+ * @param p_max_res the maximum number of resolutions for all the poc inside the tile.
+ * @param dx_min the minimum dx of all the components of all the resolutions for the tile.
+ * @param dy_min the minimum dy of all the components of all the resolutions for the tile.
+ */
+void pi_update_encode_poc_and_final (
+ opj_cp_t *p_cp,
+ OPJ_UINT32 p_tileno,
+ OPJ_INT32 p_tx0,
+ OPJ_INT32 p_tx1,
+ OPJ_INT32 p_ty0,
+ OPJ_INT32 p_ty1,
+ OPJ_UINT32 p_max_prec,
+ OPJ_UINT32 p_max_res,
+ OPJ_UINT32 p_dx_min,
+ OPJ_UINT32 p_dy_min);
+
+/**
+ * Updates the coding parameters if the encoding is not used with Progression order changes and final (and cinema parameters are used).
+ *
+ * @param p_cp the coding parameters to modify
+ * @param p_tileno the tile index being concerned.
+ * @param p_tx0 X0 parameter for the tile
+ * @param p_tx1 X1 parameter for the tile
+ * @param p_ty0 Y0 parameter for the tile
+ * @param p_ty1 Y1 parameter for the tile
+ * @param p_max_prec the maximum precision for all the bands of the tile
+ * @param p_max_res the maximum number of resolutions for all the poc inside the tile.
+ * @param dx_min the minimum dx of all the components of all the resolutions for the tile.
+ * @param dy_min the minimum dy of all the components of all the resolutions for the tile.
+ */
+void pi_update_encode_not_poc (
+ opj_cp_t *p_cp,
+ OPJ_UINT32 p_num_comps,
+ OPJ_UINT32 p_tileno,
+ OPJ_INT32 p_tx0,
+ OPJ_INT32 p_tx1,
+ OPJ_INT32 p_ty0,
+ OPJ_INT32 p_ty1,
+ OPJ_UINT32 p_max_prec,
+ OPJ_UINT32 p_max_res,
+ OPJ_UINT32 p_dx_min,
+ OPJ_UINT32 p_dy_min);
+
+/**
+ * Gets the encoding parameters needed to update the coding parameters and all the pocs.
+ *
+ * @param p_image the image being encoded.
+ * @param p_cp the coding parameters.
+ * @param tileno the tile index of the tile being encoded.
+ * @param p_tx0 pointer that will hold the X0 parameter for the tile
+ * @param p_tx1 pointer that will hold the X1 parameter for the tile
+ * @param p_ty0 pointer that will hold the Y0 parameter for the tile
+ * @param p_ty1 pointer that will hold the Y1 parameter for the tile
+ * @param p_max_prec pointer that will hold the the maximum precision for all the bands of the tile
+ * @param p_max_res pointer that will hold the the maximum number of resolutions for all the poc inside the tile.
+ * @param dx_min pointer that will hold the the minimum dx of all the components of all the resolutions for the tile.
+ * @param dy_min pointer that will hold the the minimum dy of all the components of all the resolutions for the tile.
+ */
+void get_encoding_parameters(
+ const opj_image_t *p_image,
+ const opj_cp_t *p_cp,
+ OPJ_UINT32 tileno,
+ OPJ_INT32 * p_tx0,
+ OPJ_INT32 * p_tx1,
+ OPJ_INT32 * p_ty0,
+ OPJ_INT32 * p_ty1,
+ OPJ_UINT32 * p_dx_min,
+ OPJ_UINT32 * p_dy_min,
+ OPJ_UINT32 * p_max_prec,
+ OPJ_UINT32 * p_max_res
+ );
+
+/**
+ * Gets the encoding parameters needed to update the coding parameters and all the pocs.
+ * The precinct widths, heights, dx and dy for each component at each resolution will be stored as well.
+ * the last parameter of the function should be an array of pointers of size nb components, each pointer leading
+ * to an area of size 4 * max_res. The data is stored inside this area with the following pattern :
+ * dx_compi_res0 , dy_compi_res0 , w_compi_res0, h_compi_res0 , dx_compi_res1 , dy_compi_res1 , w_compi_res1, h_compi_res1 , ...
+ *
+ * @param p_image the image being encoded.
+ * @param p_cp the coding parameters.
+ * @param tileno the tile index of the tile being encoded.
+ * @param p_tx0 pointer that will hold the X0 parameter for the tile
+ * @param p_tx1 pointer that will hold the X1 parameter for the tile
+ * @param p_ty0 pointer that will hold the Y0 parameter for the tile
+ * @param p_ty1 pointer that will hold the Y1 parameter for the tile
+ * @param p_max_prec pointer that will hold the the maximum precision for all the bands of the tile
+ * @param p_max_res pointer that will hold the the maximum number of resolutions for all the poc inside the tile.
+ * @param dx_min pointer that will hold the the minimum dx of all the components of all the resolutions for the tile.
+ * @param dy_min pointer that will hold the the minimum dy of all the components of all the resolutions for the tile.
+ * @param p_resolutions pointer to an area corresponding to the one described above.
+ */
+void get_all_encoding_parameters(
+ const opj_image_t *p_image,
+ const opj_cp_t *p_cp,
+ OPJ_UINT32 tileno,
+ OPJ_INT32 * p_tx0,
+ OPJ_INT32 * p_tx1,
+ OPJ_INT32 * p_ty0,
+ OPJ_INT32 * p_ty1,
+ OPJ_UINT32 * p_dx_min,
+ OPJ_UINT32 * p_dy_min,
+ OPJ_UINT32 * p_max_prec,
+ OPJ_UINT32 * p_max_res,
+ OPJ_UINT32 ** p_resolutions
+ );
+/**
+ * Allocates memory for a packet iterator. Data and data sizes are set by this operation.
+ * No other data is set. The include section of the packet iterator is not allocated.
+ *
+ * @param p_image the image used to initialize the packet iterator (in fact only the number of components is relevant.
+ * @param p_cp the coding parameters.
+ * @param p_tile_no the index of the tile from which creating the packet iterator.
+ */
+opj_pi_iterator_t * pi_create(
+ const opj_image_t *image,
+ const opj_cp_t *cp,
+ OPJ_UINT32 tileno
+ );
+void pi_update_decode_not_poc (opj_pi_iterator_t * p_pi,opj_tcp_t * p_tcp,OPJ_UINT32 p_max_precision,OPJ_UINT32 p_max_res);
+void pi_update_decode_poc (opj_pi_iterator_t * p_pi,opj_tcp_t * p_tcp,OPJ_UINT32 p_max_precision,OPJ_UINT32 p_max_res);
+
+
+/*@}*/
+
+/*@}*/
+
+/*
+==========================================================
+ local functions
+==========================================================
+*/
+
+static bool pi_next_lrcp(opj_pi_iterator_t * pi) {
+ opj_pi_comp_t *comp = 00;
+ opj_pi_resolution_t *res = 00;
+ OPJ_UINT32 index = 0;
+
+ if (!pi->first) {
+ comp = &pi->comps[pi->compno];
+ res = &comp->resolutions[pi->resno];
+ goto LABEL_SKIP;
+ } else {
+ pi->first = 0;
+ }
+
+ for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
+ for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1;
+ pi->resno++) {
+ for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
+ comp = &pi->comps[pi->compno];
+ if (pi->resno >= comp->numresolutions) {
+ continue;
+ }
+ res = &comp->resolutions[pi->resno];
+ if (!pi->tp_on){
+ pi->poc.precno1 = res->pw * res->ph;
+ }
+ for (pi->precno = pi->poc.precno0; pi->precno < pi->poc.precno1; pi->precno++) {
+ index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
+ if (!pi->include[index]) {
+ pi->include[index] = 1;
+ return true;
+ }
+LABEL_SKIP:;
+ }
+ }
+ }
+ }
+
+ return false;
+}
+
+static bool pi_next_rlcp(opj_pi_iterator_t * pi) {
+ opj_pi_comp_t *comp = 00;
+ opj_pi_resolution_t *res = 00;
+ OPJ_UINT32 index = 0;
+
+ if (!pi->first) {
+ comp = &pi->comps[pi->compno];
+ res = &comp->resolutions[pi->resno];
+ goto LABEL_SKIP;
+ } else {
+ pi->first = 0;
+ }
+
+ for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {
+ for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
+ for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
+ comp = &pi->comps[pi->compno];
+ if (pi->resno >= comp->numresolutions) {
+ continue;
+ }
+ res = &comp->resolutions[pi->resno];
+ if(!pi->tp_on){
+ pi->poc.precno1 = res->pw * res->ph;
+ }
+ for (pi->precno = pi->poc.precno0; pi->precno < pi->poc.precno1; pi->precno++) {
+ index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
+ if (!pi->include[index]) {
+ pi->include[index] = 1;
+ return true;
+ }
+LABEL_SKIP:;
+ }
+ }
+ }
+ }
+
+ return false;
+}
+
+static bool pi_next_rpcl(opj_pi_iterator_t * pi) {
+ opj_pi_comp_t *comp = 00;
+ opj_pi_resolution_t *res = 00;
+ OPJ_UINT32 index = 0;
+
+ if (!pi->first) {
+ goto LABEL_SKIP;
+ } else {
+ OPJ_UINT32 compno, resno;
+ pi->first = 0;
+ pi->dx = 0;
+ pi->dy = 0;
+ for (compno = 0; compno < pi->numcomps; compno++) {
+ comp = &pi->comps[compno];
+ for (resno = 0; resno < comp->numresolutions; resno++) {
+ OPJ_UINT32 dx, dy;
+ res = &comp->resolutions[resno];
+ dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
+ dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
+ pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
+ pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
+ }
+ }
+ }
+if (!pi->tp_on){
+ pi->poc.ty0 = pi->ty0;
+ pi->poc.tx0 = pi->tx0;
+ pi->poc.ty1 = pi->ty1;
+ pi->poc.tx1 = pi->tx1;
+ }
+ for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {
+ for (pi->y = pi->poc.ty0; pi->y < pi->poc.ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
+ for (pi->x = pi->poc.tx0; pi->x < pi->poc.tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
+ for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
+ OPJ_UINT32 levelno;
+ OPJ_INT32 trx0, try0;
+ OPJ_INT32 trx1, try1;
+ OPJ_UINT32 rpx, rpy;
+ OPJ_INT32 prci, prcj;
+ comp = &pi->comps[pi->compno];
+ if (pi->resno >= comp->numresolutions) {
+ continue;
+ }
+ res = &comp->resolutions[pi->resno];
+ levelno = comp->numresolutions - 1 - pi->resno;
+ trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
+ try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
+ trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);
+ try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
+ rpx = res->pdx + levelno;
+ rpy = res->pdy + levelno;
+ if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpx))))){
+ continue;
+ }
+ if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
+ continue;
+ }
+
+ if ((res->pw==0)||(res->ph==0)) continue;
+
+ if ((trx0==trx1)||(try0==try1)) continue;
+
+ prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno), res->pdx)
+ - int_floordivpow2(trx0, res->pdx);
+ prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy)
+ - int_floordivpow2(try0, res->pdy);
+ pi->precno = prci + prcj * res->pw;
+ for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
+ index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
+ if (!pi->include[index]) {
+ pi->include[index] = 1;
+ return true;
+ }
+LABEL_SKIP:;
+ }
+ }
+ }
+ }
+ }
+
+ return false;
+}
+
+static bool pi_next_pcrl(opj_pi_iterator_t * pi) {
+ opj_pi_comp_t *comp = 00;
+ opj_pi_resolution_t *res = 00;
+ OPJ_UINT32 index = 0;
+
+ if (!pi->first) {
+ comp = &pi->comps[pi->compno];
+ goto LABEL_SKIP;
+ } else {
+ OPJ_UINT32 compno, resno;
+ pi->first = 0;
+ pi->dx = 0;
+ pi->dy = 0;
+ for (compno = 0; compno < pi->numcomps; compno++) {
+ comp = &pi->comps[compno];
+ for (resno = 0; resno < comp->numresolutions; resno++) {
+ OPJ_UINT32 dx, dy;
+ res = &comp->resolutions[resno];
+ dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
+ dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
+ pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
+ pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
+ }
+ }
+ }
+ if (!pi->tp_on){
+ pi->poc.ty0 = pi->ty0;
+ pi->poc.tx0 = pi->tx0;
+ pi->poc.ty1 = pi->ty1;
+ pi->poc.tx1 = pi->tx1;
+ }
+ for (pi->y = pi->poc.ty0; pi->y < pi->poc.ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
+ for (pi->x = pi->poc.tx0; pi->x < pi->poc.tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
+ for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
+ comp = &pi->comps[pi->compno];
+ // TODO
+ for (pi->resno = pi->poc.resno0; pi->resno < uint_min(pi->poc.resno1, comp->numresolutions); pi->resno++) {
+ OPJ_UINT32 levelno;
+ OPJ_INT32 trx0, try0;
+ OPJ_INT32 trx1, try1;
+ OPJ_UINT32 rpx, rpy;
+ OPJ_INT32 prci, prcj;
+ res = &comp->resolutions[pi->resno];
+ levelno = comp->numresolutions - 1 - pi->resno;
+ trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
+ try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
+ trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);
+ try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
+ rpx = res->pdx + levelno;
+ rpy = res->pdy + levelno;
+ if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpx))))){
+ continue;
+ }
+ if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
+ continue;
+ }
+
+ if ((res->pw==0)||(res->ph==0)) continue;
+
+ if ((trx0==trx1)||(try0==try1)) continue;
+
+ prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno), res->pdx)
+ - int_floordivpow2(trx0, res->pdx);
+ prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy)
+ - int_floordivpow2(try0, res->pdy);
+ pi->precno = prci + prcj * res->pw;
+ for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
+ index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
+ if (!pi->include[index]) {
+ pi->include[index] = 1;
+ return true;
+ }
+LABEL_SKIP:;
+ }
+ }
+ }
+ }
+ }
+
+ return false;
+}
+
+static bool pi_next_cprl(opj_pi_iterator_t * pi) {
+ opj_pi_comp_t *comp = 00;
+ opj_pi_resolution_t *res = 00;
+ OPJ_UINT32 index = 0;
+
+ if (!pi->first) {
+ comp = &pi->comps[pi->compno];
+ goto LABEL_SKIP;
+ } else {
+ pi->first = 0;
+ }
+
+ for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
+ OPJ_UINT32 resno;
+ comp = &pi->comps[pi->compno];
+ pi->dx = 0;
+ pi->dy = 0;
+ for (resno = 0; resno < comp->numresolutions; resno++) {
+ OPJ_UINT32 dx, dy;
+ res = &comp->resolutions[resno];
+ dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
+ dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
+ pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
+ pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
+ }
+ if (!pi->tp_on){
+ pi->poc.ty0 = pi->ty0;
+ pi->poc.tx0 = pi->tx0;
+ pi->poc.ty1 = pi->ty1;
+ pi->poc.tx1 = pi->tx1;
+ }
+ for (pi->y = pi->poc.ty0; pi->y < pi->poc.ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
+ for (pi->x = pi->poc.tx0; pi->x < pi->poc.tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
+ // TODO
+ for (pi->resno = pi->poc.resno0; pi->resno < uint_min(pi->poc.resno1, comp->numresolutions); pi->resno++) {
+ OPJ_UINT32 levelno;
+ OPJ_INT32 trx0, try0;
+ OPJ_INT32 trx1, try1;
+ OPJ_UINT32 rpx, rpy;
+ OPJ_INT32 prci, prcj;
+ res = &comp->resolutions[pi->resno];
+ levelno = comp->numresolutions - 1 - pi->resno;
+ trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
+ try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
+ trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);
+ try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
+ rpx = res->pdx + levelno;
+ rpy = res->pdy + levelno;
+ if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpx))))){
+ continue;
+ }
+ if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
+ continue;
+ }
+
+ if ((res->pw==0)||(res->pw==0)) continue;
+
+ if ((trx0==trx1)||(try0==try1)) continue;
+
+ prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno), res->pdx)
+ - int_floordivpow2(trx0, res->pdx);
+ prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy)
+ - int_floordivpow2(try0, res->pdy);
+ pi->precno = prci + prcj * res->pw;
+ for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
+ index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
+ if (!pi->include[index]) {
+ pi->include[index] = 1;
+ return true;
+ }
+LABEL_SKIP:;
+ }
+ }
+ }
+ }
+ }
+
+ return false;
+}
+
+/*
+==========================================================
+ Packet iterator interface
+==========================================================
+*/
+opj_pi_iterator_t *pi_create_decode(
+ opj_image_t *p_image,
+ opj_cp_t *p_cp,
+ OPJ_UINT32 p_tile_no
+ )
+{
+ // loop
+ OPJ_UINT32 pino;
+ OPJ_UINT32 compno, resno;
+
+ // to store w, h, dx and dy fro all components and resolutions
+ OPJ_UINT32 * l_tmp_data;
+ OPJ_UINT32 ** l_tmp_ptr;
+
+ // encoding prameters to set
+ OPJ_UINT32 l_max_res;
+ OPJ_UINT32 l_max_prec;
+ OPJ_INT32 l_tx0,l_tx1,l_ty0,l_ty1;
+ OPJ_UINT32 l_dx_min,l_dy_min;
+ OPJ_UINT32 l_bound;
+ OPJ_UINT32 l_step_p , l_step_c , l_step_r , l_step_l ;
+ OPJ_UINT32 l_data_stride;
+
+ // pointers
+ opj_pi_iterator_t *l_pi = 00;
+ opj_tcp_t *l_tcp = 00;
+ const opj_tccp_t *l_tccp = 00;
+ opj_pi_comp_t *l_current_comp = 00;
+ opj_image_comp_t * l_img_comp = 00;
+ opj_pi_iterator_t * l_current_pi = 00;
+ OPJ_UINT32 * l_encoding_value_ptr = 00;
+
+ // preconditions in debug
+ assert(p_cp != 00);
+ assert(p_image != 00);
+ assert(p_tile_no < p_cp->tw * p_cp->th);
+
+ // initializations
+ l_tcp = &p_cp->tcps[p_tile_no];
+ l_bound = l_tcp->numpocs+1;
+
+ l_data_stride = 4 * J2K_MAXRLVLS;
+ l_tmp_data = opj_malloc(l_data_stride * p_image->numcomps * sizeof(OPJ_UINT32));
+ if
+ (! l_tmp_data)
+ {
+ return 00;
+ }
+ l_tmp_ptr = opj_malloc(p_image->numcomps * sizeof(OPJ_UINT32 *));
+ if
+ (! l_tmp_ptr)
+ {
+ opj_free(l_tmp_data);
+ return 00;
+ }
+
+ // memory allocation for pi
+ l_pi = pi_create(p_image,p_cp,p_tile_no);
+ if
+ (!l_pi)
+ {
+ opj_free(l_tmp_data);
+ opj_free(l_tmp_ptr);
+ return 00;
+ }
+
+ l_encoding_value_ptr = l_tmp_data;
+ // update pointer array
+ for
+ (compno = 0; compno < p_image->numcomps; ++compno)
+ {
+ l_tmp_ptr[compno] = l_encoding_value_ptr;
+ l_encoding_value_ptr += l_data_stride;
+ }
+ // get encoding parameters
+ get_all_encoding_parameters(p_image,p_cp,p_tile_no,&l_tx0,&l_tx1,&l_ty0,&l_ty1,&l_dx_min,&l_dy_min,&l_max_prec,&l_max_res,l_tmp_ptr);
+
+ // step calculations
+ l_step_p = 1;
+ l_step_c = l_max_prec * l_step_p;
+ l_step_r = p_image->numcomps * l_step_c;
+ l_step_l = l_max_res * l_step_r;
+
+ // set values for first packet iterator
+ l_current_pi = l_pi;
+
+ // memory allocation for include
+ l_current_pi->include = (OPJ_INT16*) opj_calloc(l_tcp->numlayers * l_step_l, sizeof(OPJ_INT16));
+ if
+ (!l_current_pi->include)
+ {
+ opj_free(l_tmp_data);
+ opj_free(l_tmp_ptr);
+ pi_destroy(l_pi, l_bound);
+ return 00;
+ }
+ memset(l_current_pi->include,0,l_tcp->numlayers * l_step_l* sizeof(OPJ_INT16));
+
+ // special treatment for the first packet iterator
+ l_current_comp = l_current_pi->comps;
+ l_img_comp = p_image->comps;
+ l_tccp = l_tcp->tccps;
+
+ l_current_pi->tx0 = l_tx0;
+ l_current_pi->ty0 = l_ty0;
+ l_current_pi->tx1 = l_tx1;
+ l_current_pi->ty1 = l_ty1;
+
+ //l_current_pi->dx = l_img_comp->dx;
+ //l_current_pi->dy = l_img_comp->dy;
+
+ l_current_pi->step_p = l_step_p;
+ l_current_pi->step_c = l_step_c;
+ l_current_pi->step_r = l_step_r;
+ l_current_pi->step_l = l_step_l;
+
+ /* allocation for components and number of components has already been calculated by pi_create */
+ for
+ (compno = 0; compno < l_current_pi->numcomps; ++compno)
+ {
+ opj_pi_resolution_t *l_res = l_current_comp->resolutions;
+ l_encoding_value_ptr = l_tmp_ptr[compno];
+
+ l_current_comp->dx = l_img_comp->dx;
+ l_current_comp->dy = l_img_comp->dy;
+ /* resolutions have already been initialized */
+ for
+ (resno = 0; resno < l_current_comp->numresolutions; resno++)
+ {
+ l_res->pdx = *(l_encoding_value_ptr++);
+ l_res->pdy = *(l_encoding_value_ptr++);
+ l_res->pw = *(l_encoding_value_ptr++);
+ l_res->ph = *(l_encoding_value_ptr++);
+ ++l_res;
+ }
+ ++l_current_comp;
+ ++l_img_comp;
+ ++l_tccp;
+ }
+ ++l_current_pi;
+
+ for
+ (pino = 1 ; pino<l_bound ; ++pino )
+ {
+ opj_pi_comp_t *l_current_comp = l_current_pi->comps;
+ opj_image_comp_t * l_img_comp = p_image->comps;
+ l_tccp = l_tcp->tccps;
+
+ l_current_pi->tx0 = l_tx0;
+ l_current_pi->ty0 = l_ty0;
+ l_current_pi->tx1 = l_tx1;
+ l_current_pi->ty1 = l_ty1;
+ //l_current_pi->dx = l_dx_min;
+ //l_current_pi->dy = l_dy_min;
+ l_current_pi->step_p = l_step_p;
+ l_current_pi->step_c = l_step_c;
+ l_current_pi->step_r = l_step_r;
+ l_current_pi->step_l = l_step_l;
+
+ /* allocation for components and number of components has already been calculated by pi_create */
+ for
+ (compno = 0; compno < l_current_pi->numcomps; ++compno)
+ {
+ opj_pi_resolution_t *l_res = l_current_comp->resolutions;
+ l_encoding_value_ptr = l_tmp_ptr[compno];
+
+ l_current_comp->dx = l_img_comp->dx;
+ l_current_comp->dy = l_img_comp->dy;
+ /* resolutions have already been initialized */
+ for
+ (resno = 0; resno < l_current_comp->numresolutions; resno++)
+ {
+ l_res->pdx = *(l_encoding_value_ptr++);
+ l_res->pdy = *(l_encoding_value_ptr++);
+ l_res->pw = *(l_encoding_value_ptr++);
+ l_res->ph = *(l_encoding_value_ptr++);
+ ++l_res;
+ }
+ ++l_current_comp;
+ ++l_img_comp;
+ ++l_tccp;
+ }
+ // special treatment
+ l_current_pi->include = (l_current_pi-1)->include;
+ ++l_current_pi;
+ }
+ opj_free(l_tmp_data);
+ l_tmp_data = 00;
+ opj_free(l_tmp_ptr);
+ l_tmp_ptr = 00;
+ if
+ (l_tcp->POC)
+ {
+ pi_update_decode_poc (l_pi,l_tcp,l_max_prec,l_max_res);
+ }
+ else
+ {
+ pi_update_decode_not_poc(l_pi,l_tcp,l_max_prec,l_max_res);
+ }
+ return l_pi;
+}
+
+void pi_update_decode_poc (opj_pi_iterator_t * p_pi,opj_tcp_t * p_tcp,OPJ_UINT32 p_max_precision,OPJ_UINT32 p_max_res)
+{
+ // loop
+ OPJ_UINT32 pino;
+
+ // encoding prameters to set
+ OPJ_UINT32 l_bound;
+
+ opj_pi_iterator_t * l_current_pi = 00;
+ opj_poc_t* l_current_poc = 0;
+
+ // preconditions in debug
+ assert(p_pi != 00);
+ assert(p_tcp != 00);
+
+ // initializations
+ l_bound = p_tcp->numpocs+1;
+ l_current_pi = p_pi;
+ l_current_poc = p_tcp->pocs;
+
+ for
+ (pino = 0;pino<l_bound;++pino)
+ {
+ l_current_pi->poc.prg = l_current_poc->prg;
+ l_current_pi->first = 1;
+
+ l_current_pi->poc.resno0 = l_current_poc->resno0;
+ l_current_pi->poc.compno0 = l_current_poc->compno0;
+ l_current_pi->poc.layno0 = 0;
+ l_current_pi->poc.precno0 = 0;
+ l_current_pi->poc.resno1 = l_current_poc->resno1;
+ l_current_pi->poc.compno1 = l_current_poc->compno1;
+ l_current_pi->poc.layno1 = l_current_poc->layno1;
+ l_current_pi->poc.precno1 = p_max_precision;
+ ++l_current_pi;
+ ++l_current_poc;
+ }
+}
+
+void pi_update_decode_not_poc (opj_pi_iterator_t * p_pi,opj_tcp_t * p_tcp,OPJ_UINT32 p_max_precision,OPJ_UINT32 p_max_res)
+{
+ // loop
+ OPJ_UINT32 pino;
+
+ // encoding prameters to set
+ OPJ_UINT32 l_bound;
+
+ opj_pi_iterator_t * l_current_pi = 00;
+ // preconditions in debug
+ assert(p_tcp != 00);
+ assert(p_pi != 00);
+
+ // initializations
+ l_bound = p_tcp->numpocs+1;
+ l_current_pi = p_pi;
+
+ for
+ (pino = 0;pino<l_bound;++pino)
+ {
+ l_current_pi->poc.prg = p_tcp->prg;
+ l_current_pi->first = 1;
+ l_current_pi->poc.resno0 = 0;
+ l_current_pi->poc.compno0 = 0;
+ l_current_pi->poc.layno0 = 0;
+ l_current_pi->poc.precno0 = 0;
+ l_current_pi->poc.resno1 = p_max_res;
+ l_current_pi->poc.compno1 = l_current_pi->numcomps;
+ l_current_pi->poc.layno1 = p_tcp->numlayers;
+ l_current_pi->poc.precno1 = p_max_precision;
+ ++l_current_pi;
+ }
+}
+
+/**
+ * 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 opj_image_t *p_image,
+ opj_cp_t *p_cp,
+ OPJ_UINT32 p_tile_no,
+ J2K_T2_MODE p_t2_mode
+ )
+{
+ // loop
+ OPJ_UINT32 pino;
+ OPJ_UINT32 compno, resno;
+
+ // to store w, h, dx and dy fro all components and resolutions
+ OPJ_UINT32 * l_tmp_data;
+ OPJ_UINT32 ** l_tmp_ptr;
+
+ // encoding prameters to set
+ OPJ_UINT32 l_max_res;
+ OPJ_UINT32 l_max_prec;
+ OPJ_INT32 l_tx0,l_tx1,l_ty0,l_ty1;
+ OPJ_UINT32 l_dx_min,l_dy_min;
+ OPJ_UINT32 l_bound;
+ OPJ_UINT32 l_step_p , l_step_c , l_step_r , l_step_l ;
+ OPJ_UINT32 l_data_stride;
+
+ // pointers
+ opj_pi_iterator_t *l_pi = 00;
+ opj_tcp_t *l_tcp = 00;
+ const opj_tccp_t *l_tccp = 00;
+ opj_pi_comp_t *l_current_comp = 00;
+ opj_image_comp_t * l_img_comp = 00;
+ opj_pi_iterator_t * l_current_pi = 00;
+ OPJ_UINT32 * l_encoding_value_ptr = 00;
+
+ // preconditions in debug
+ assert(p_cp != 00);
+ assert(p_image != 00);
+ assert(p_tile_no < p_cp->tw * p_cp->th);
+
+ // initializations
+ l_tcp = &p_cp->tcps[p_tile_no];
+ l_bound = l_tcp->numpocs+1;
+
+ l_data_stride = 4 * J2K_MAXRLVLS;
+ l_tmp_data = opj_malloc(l_data_stride * p_image->numcomps * sizeof(OPJ_UINT32));
+ if
+ (! l_tmp_data)
+ {
+ return 00;
+ }
+ l_tmp_ptr = opj_malloc(p_image->numcomps * sizeof(OPJ_UINT32 *));
+ if
+ (! l_tmp_ptr)
+ {
+ opj_free(l_tmp_data);
+ return 00;
+ }
+
+ // memory allocation for pi
+ l_pi = pi_create(p_image,p_cp,p_tile_no);
+ if
+ (!l_pi)
+ {
+ opj_free(l_tmp_data);
+ opj_free(l_tmp_ptr);
+ return 00;
+ }
+
+ l_encoding_value_ptr = l_tmp_data;
+ // update pointer array
+ for
+ (compno = 0; compno < p_image->numcomps; ++compno)
+ {
+ l_tmp_ptr[compno] = l_encoding_value_ptr;
+ l_encoding_value_ptr += l_data_stride;
+ }
+ // get encoding parameters
+ get_all_encoding_parameters(p_image,p_cp,p_tile_no,&l_tx0,&l_tx1,&l_ty0,&l_ty1,&l_dx_min,&l_dy_min,&l_max_prec,&l_max_res,l_tmp_ptr);
+
+ // step calculations
+ l_step_p = 1;
+ l_step_c = l_max_prec * l_step_p;
+ l_step_r = p_image->numcomps * l_step_c;
+ l_step_l = l_max_res * l_step_r;
+
+ // set values for first packet iterator
+ l_pi->tp_on = p_cp->m_specific_param.m_enc.m_tp_on;
+ l_current_pi = l_pi;
+
+ // memory allocation for include
+ l_current_pi->include = (OPJ_INT16*) opj_calloc(l_tcp->numlayers * l_step_l, sizeof(OPJ_INT16));
+ if
+ (!l_current_pi->include)
+ {
+ opj_free(l_tmp_data);
+ opj_free(l_tmp_ptr);
+ pi_destroy(l_pi, l_bound);
+ return 00;
+ }
+ memset(l_current_pi->include,0,l_tcp->numlayers * l_step_l* sizeof(OPJ_INT16));
+
+ // special treatment for the first packet iterator
+ l_current_comp = l_current_pi->comps;
+ l_img_comp = p_image->comps;
+ l_tccp = l_tcp->tccps;
+ l_current_pi->tx0 = l_tx0;
+ l_current_pi->ty0 = l_ty0;
+ l_current_pi->tx1 = l_tx1;
+ l_current_pi->ty1 = l_ty1;
+ l_current_pi->dx = l_dx_min;
+ l_current_pi->dy = l_dy_min;
+ l_current_pi->step_p = l_step_p;
+ l_current_pi->step_c = l_step_c;
+ l_current_pi->step_r = l_step_r;
+ l_current_pi->step_l = l_step_l;
+
+ /* allocation for components and number of components has already been calculated by pi_create */
+ for
+ (compno = 0; compno < l_current_pi->numcomps; ++compno)
+ {
+ opj_pi_resolution_t *l_res = l_current_comp->resolutions;
+ l_encoding_value_ptr = l_tmp_ptr[compno];
+
+ l_current_comp->dx = l_img_comp->dx;
+ l_current_comp->dy = l_img_comp->dy;
+ /* resolutions have already been initialized */
+ for
+ (resno = 0; resno < l_current_comp->numresolutions; resno++)
+ {
+ l_res->pdx = *(l_encoding_value_ptr++);
+ l_res->pdy = *(l_encoding_value_ptr++);
+ l_res->pw = *(l_encoding_value_ptr++);
+ l_res->ph = *(l_encoding_value_ptr++);
+ ++l_res;
+ }
+ ++l_current_comp;
+ ++l_img_comp;
+ ++l_tccp;
+ }
+ ++l_current_pi;
+
+ for
+ (pino = 1 ; pino<l_bound ; ++pino )
+ {
+ opj_pi_comp_t *l_current_comp = l_current_pi->comps;
+ opj_image_comp_t * l_img_comp = p_image->comps;
+ l_tccp = l_tcp->tccps;
+
+ l_current_pi->tx0 = l_tx0;
+ l_current_pi->ty0 = l_ty0;
+ l_current_pi->tx1 = l_tx1;
+ l_current_pi->ty1 = l_ty1;
+ l_current_pi->dx = l_dx_min;
+ l_current_pi->dy = l_dy_min;
+ l_current_pi->step_p = l_step_p;
+ l_current_pi->step_c = l_step_c;
+ l_current_pi->step_r = l_step_r;
+ l_current_pi->step_l = l_step_l;
+
+ /* allocation for components and number of components has already been calculated by pi_create */
+ for
+ (compno = 0; compno < l_current_pi->numcomps; ++compno)
+ {
+ opj_pi_resolution_t *l_res = l_current_comp->resolutions;
+ l_encoding_value_ptr = l_tmp_ptr[compno];
+
+ l_current_comp->dx = l_img_comp->dx;
+ l_current_comp->dy = l_img_comp->dy;
+ /* resolutions have already been initialized */
+ for
+ (resno = 0; resno < l_current_comp->numresolutions; resno++)
+ {
+ l_res->pdx = *(l_encoding_value_ptr++);
+ l_res->pdy = *(l_encoding_value_ptr++);
+ l_res->pw = *(l_encoding_value_ptr++);
+ l_res->ph = *(l_encoding_value_ptr++);
+ ++l_res;
+ }
+ ++l_current_comp;
+ ++l_img_comp;
+ ++l_tccp;
+ }
+ // special treatment
+ l_current_pi->include = (l_current_pi-1)->include;
+ ++l_current_pi;
+ }
+ opj_free(l_tmp_data);
+ l_tmp_data = 00;
+ opj_free(l_tmp_ptr);
+ l_tmp_ptr = 00;
+ if
+ (l_tcp->POC && ( p_cp->m_specific_param.m_enc.m_cinema || p_t2_mode == FINAL_PASS))
+ {
+ pi_update_encode_poc_and_final(p_cp,p_tile_no,l_tx0,l_tx1,l_ty0,l_ty1,l_max_prec,l_max_res,l_dx_min,l_dy_min);
+ }
+ else
+ {
+ pi_update_encode_not_poc(p_cp,p_image->numcomps,p_tile_no,l_tx0,l_tx1,l_ty0,l_ty1,l_max_prec,l_max_res,l_dx_min,l_dy_min);
+ }
+ return l_pi;
+}
+
+/**
+ * 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 opj_image_t *p_image,
+ opj_cp_t *p_cp,
+ OPJ_UINT32 p_tile_no
+ )
+{
+ // encoding prameters to set
+ OPJ_UINT32 l_max_res;
+ OPJ_UINT32 l_max_prec;
+ OPJ_INT32 l_tx0,l_tx1,l_ty0,l_ty1;
+ OPJ_UINT32 l_dx_min,l_dy_min;
+
+ // pointers
+ opj_tcp_t *l_tcp = 00;
+
+ // preconditions in debug
+ assert(p_cp != 00);
+ assert(p_image != 00);
+ assert(p_tile_no < p_cp->tw * p_cp->th);
+
+ l_tcp = &(p_cp->tcps[p_tile_no]);
+ // get encoding parameters
+ get_encoding_parameters(p_image,p_cp,p_tile_no,&l_tx0,&l_tx1,&l_ty0,&l_ty1,&l_dx_min,&l_dy_min,&l_max_prec,&l_max_res);
+ if
+ (l_tcp->POC)
+ {
+ pi_update_encode_poc_and_final(p_cp,p_tile_no,l_tx0,l_tx1,l_ty0,l_ty1,l_max_prec,l_max_res,l_dx_min,l_dy_min);
+ }
+ else
+ {
+ pi_update_encode_not_poc(p_cp,p_image->numcomps,p_tile_no,l_tx0,l_tx1,l_ty0,l_ty1,l_max_prec,l_max_res,l_dx_min,l_dy_min);
+ }
+}
+
+
+/**
+ * Gets the encoding parameters needed to update the coding parameters and all the pocs.
+ *
+ * @param p_image the image being encoded.
+ * @param p_cp the coding parameters.
+ * @param p_tileno the tile index of the tile being encoded.
+ * @param p_tx0 pointer that will hold the X0 parameter for the tile
+ * @param p_tx1 pointer that will hold the X1 parameter for the tile
+ * @param p_ty0 pointer that will hold the Y0 parameter for the tile
+ * @param p_ty1 pointer that will hold the Y1 parameter for the tile
+ * @param p_max_prec pointer that will hold the the maximum precision for all the bands of the tile
+ * @param p_max_res pointer that will hold the the maximum number of resolutions for all the poc inside the tile.
+ * @param dx_min pointer that will hold the the minimum dx of all the components of all the resolutions for the tile.
+ * @param dy_min pointer that will hold the the minimum dy of all the components of all the resolutions for the tile.
+ */
+void get_encoding_parameters(
+ const opj_image_t *p_image,
+ const opj_cp_t *p_cp,
+ OPJ_UINT32 p_tileno,
+ OPJ_INT32 * p_tx0,
+ OPJ_INT32 * p_tx1,
+ OPJ_INT32 * p_ty0,
+ OPJ_INT32 * p_ty1,
+ OPJ_UINT32 * p_dx_min,
+ OPJ_UINT32 * p_dy_min,
+ OPJ_UINT32 * p_max_prec,
+ OPJ_UINT32 * p_max_res
+ )
+{
+ // loop
+ OPJ_UINT32 compno, resno;
+ // pointers
+ const opj_tcp_t *l_tcp = 00;
+ const opj_tccp_t * l_tccp = 00;
+ const opj_image_comp_t * l_img_comp = 00;
+
+ // position in x and y of tile
+ OPJ_UINT32 p, q;
+
+ // preconditions in debug
+ assert(p_cp != 00);
+ assert(p_image != 00);
+ assert(p_tileno < p_cp->tw * p_cp->th);
+
+ // initializations
+ l_tcp = &p_cp->tcps [p_tileno];
+ l_img_comp = p_image->comps;
+ l_tccp = l_tcp->tccps;
+
+ /* here calculation of tx0, tx1, ty0, ty1, maxprec, dx and dy */
+ p = p_tileno % p_cp->tw;
+ q = p_tileno / p_cp->tw;
+
+ // find extent of tile
+ *p_tx0 = int_max(p_cp->tx0 + p * p_cp->tdx, p_image->x0);
+ *p_tx1 = int_min(p_cp->tx0 + (p + 1) * p_cp->tdx, p_image->x1);
+ *p_ty0 = int_max(p_cp->ty0 + q * p_cp->tdy, p_image->y0);
+ *p_ty1 = int_min(p_cp->ty0 + (q + 1) * p_cp->tdy, p_image->y1);
+
+ // max precision is 0 (can only grow)
+ *p_max_prec = 0;
+ *p_max_res = 0;
+
+ // take the largest value for dx_min and dy_min
+ *p_dx_min = 0x7fffffff;
+ *p_dy_min = 0x7fffffff;
+
+ for
+ (compno = 0; compno < p_image->numcomps; ++compno)
+ {
+ // aritmetic variables to calculate
+ OPJ_UINT32 l_level_no;
+ OPJ_INT32 l_rx0, l_ry0, l_rx1, l_ry1;
+ OPJ_INT32 l_px0, l_py0, l_px1, py1;
+ OPJ_UINT32 l_pdx, l_pdy;
+ OPJ_UINT32 l_pw, l_ph;
+ OPJ_UINT32 l_product;
+ OPJ_INT32 l_tcx0, l_tcy0, l_tcx1, l_tcy1;
+
+ l_tcx0 = int_ceildiv(*p_tx0, l_img_comp->dx);
+ l_tcy0 = int_ceildiv(*p_ty0, l_img_comp->dy);
+ l_tcx1 = int_ceildiv(*p_tx1, l_img_comp->dx);
+ l_tcy1 = int_ceildiv(*p_ty1, l_img_comp->dy);
+ if
+ (l_tccp->numresolutions > *p_max_res)
+ {
+ *p_max_res = l_tccp->numresolutions;
+ }
+ // use custom size for precincts
+ for
+ (resno = 0; resno < l_tccp->numresolutions; ++resno)
+ {
+ OPJ_UINT32 l_dx, l_dy;
+ // precinct width and height
+ l_pdx = l_tccp->prcw[resno];
+ l_pdy = l_tccp->prch[resno];
+
+ l_dx = l_img_comp->dx * (1 << (l_pdx + l_tccp->numresolutions - 1 - resno));
+ l_dy = l_img_comp->dy * (1 << (l_pdy + l_tccp->numresolutions - 1 - resno));
+ // take the minimum size for dx for each comp and resolution
+ *p_dx_min = uint_min(*p_dx_min, l_dx);
+ *p_dy_min = uint_min(*p_dy_min, l_dy);
+ // various calculations of extents
+ l_level_no = l_tccp->numresolutions - 1 - resno;
+ l_rx0 = int_ceildivpow2(l_tcx0, l_level_no);
+ l_ry0 = int_ceildivpow2(l_tcy0, l_level_no);
+ l_rx1 = int_ceildivpow2(l_tcx1, l_level_no);
+ l_ry1 = int_ceildivpow2(l_tcy1, l_level_no);
+ l_px0 = int_floordivpow2(l_rx0, l_pdx) << l_pdx;
+ l_py0 = int_floordivpow2(l_ry0, l_pdy) << l_pdy;
+ l_px1 = int_ceildivpow2(l_rx1, l_pdx) << l_pdx;
+ py1 = int_ceildivpow2(l_ry1, l_pdy) << l_pdy;
+ l_pw = (l_rx0==l_rx1)?0:((l_px1 - l_px0) >> l_pdx);
+ l_ph = (l_ry0==l_ry1)?0:((py1 - l_py0) >> l_pdy);
+ l_product = l_pw * l_ph;
+ // update precision
+ if
+ (l_product > *p_max_prec)
+ {
+ *p_max_prec = l_product;
+ }
+ }
+ ++l_img_comp;
+ ++l_tccp;
+ }
+}
+
+/**
+ * Gets the encoding parameters needed to update the coding parameters and all the pocs.
+ * The precinct widths, heights, dx and dy for each component at each resolution will be stored as well.
+ * the last parameter of the function should be an array of pointers of size nb components, each pointer leading
+ * to an area of size 4 * max_res. The data is stored inside this area with the following pattern :
+ * dx_compi_res0 , dy_compi_res0 , w_compi_res0, h_compi_res0 , dx_compi_res1 , dy_compi_res1 , w_compi_res1, h_compi_res1 , ...
+ *
+ * @param p_image the image being encoded.
+ * @param p_cp the coding parameters.
+ * @param tileno the tile index of the tile being encoded.
+ * @param p_tx0 pointer that will hold the X0 parameter for the tile
+ * @param p_tx1 pointer that will hold the X1 parameter for the tile
+ * @param p_ty0 pointer that will hold the Y0 parameter for the tile
+ * @param p_ty1 pointer that will hold the Y1 parameter for the tile
+ * @param p_max_prec pointer that will hold the the maximum precision for all the bands of the tile
+ * @param p_max_res pointer that will hold the the maximum number of resolutions for all the poc inside the tile.
+ * @param dx_min pointer that will hold the the minimum dx of all the components of all the resolutions for the tile.
+ * @param dy_min pointer that will hold the the minimum dy of all the components of all the resolutions for the tile.
+ * @param p_resolutions pointer to an area corresponding to the one described above.
+ */
+void get_all_encoding_parameters(
+ const opj_image_t *p_image,
+ const opj_cp_t *p_cp,
+ OPJ_UINT32 tileno,
+ OPJ_INT32 * p_tx0,
+ OPJ_INT32 * p_tx1,
+ OPJ_INT32 * p_ty0,
+ OPJ_INT32 * p_ty1,
+ OPJ_UINT32 * p_dx_min,
+ OPJ_UINT32 * p_dy_min,
+ OPJ_UINT32 * p_max_prec,
+ OPJ_UINT32 * p_max_res,
+ OPJ_UINT32 ** p_resolutions
+ )
+{
+ // loop
+ OPJ_UINT32 compno, resno;
+
+ // pointers
+ const opj_tcp_t *tcp = 00;
+ const opj_tccp_t * l_tccp = 00;
+ const opj_image_comp_t * l_img_comp = 00;
+
+ // to store l_dx, l_dy, w and h for each resolution and component.
+ OPJ_UINT32 * lResolutionPtr;
+
+ // position in x and y of tile
+ OPJ_UINT32 p, q;
+
+ // preconditions in debug
+ assert(p_cp != 00);
+ assert(p_image != 00);
+ assert(tileno < p_cp->tw * p_cp->th);
+
+ // initializations
+ tcp = &p_cp->tcps [tileno];
+ l_tccp = tcp->tccps;
+ l_img_comp = p_image->comps;
+
+ // position in x and y of tile
+
+ p = tileno % p_cp->tw;
+ q = tileno / p_cp->tw;
+
+ /* here calculation of tx0, tx1, ty0, ty1, maxprec, l_dx and l_dy */
+ *p_tx0 = int_max(p_cp->tx0 + p * p_cp->tdx, p_image->x0);
+ *p_tx1 = int_min(p_cp->tx0 + (p + 1) * p_cp->tdx, p_image->x1);
+ *p_ty0 = int_max(p_cp->ty0 + q * p_cp->tdy, p_image->y0);
+ *p_ty1 = int_min(p_cp->ty0 + (q + 1) * p_cp->tdy, p_image->y1);
+
+ // max precision and resolution is 0 (can only grow)
+ *p_max_prec = 0;
+ *p_max_res = 0;
+
+ // take the largest value for dx_min and dy_min
+ *p_dx_min = 0x7fffffff;
+ *p_dy_min = 0x7fffffff;
+
+ for
+ (compno = 0; compno < p_image->numcomps; ++compno)
+ {
+ // aritmetic variables to calculate
+ OPJ_UINT32 l_level_no;
+ OPJ_INT32 l_rx0, l_ry0, l_rx1, l_ry1;
+ OPJ_INT32 l_px0, l_py0, l_px1, py1;
+ OPJ_UINT32 l_product;
+ OPJ_INT32 l_tcx0, l_tcy0, l_tcx1, l_tcy1;
+ OPJ_UINT32 l_pdx, l_pdy , l_pw , l_ph;
+
+ lResolutionPtr = p_resolutions[compno];
+
+ l_tcx0 = int_ceildiv(*p_tx0, l_img_comp->dx);
+ l_tcy0 = int_ceildiv(*p_ty0, l_img_comp->dy);
+ l_tcx1 = int_ceildiv(*p_tx1, l_img_comp->dx);
+ l_tcy1 = int_ceildiv(*p_ty1, l_img_comp->dy);
+ if
+ (l_tccp->numresolutions > *p_max_res)
+ {
+ *p_max_res = l_tccp->numresolutions;
+ }
+
+ // use custom size for precincts
+ l_level_no = l_tccp->numresolutions - 1;
+ for
+ (resno = 0; resno < l_tccp->numresolutions; ++resno)
+ {
+ OPJ_UINT32 l_dx, l_dy;
+ // precinct width and height
+ l_pdx = l_tccp->prcw[resno];
+ l_pdy = l_tccp->prch[resno];
+ *lResolutionPtr++ = l_pdx;
+ *lResolutionPtr++ = l_pdy;
+ l_dx = l_img_comp->dx * (1 << (l_pdx + l_level_no));
+ l_dy = l_img_comp->dy * (1 << (l_pdy + l_level_no));
+ // take the minimum size for l_dx for each comp and resolution
+ *p_dx_min = int_min(*p_dx_min, l_dx);
+ *p_dy_min = int_min(*p_dy_min, l_dy);
+ // various calculations of extents
+
+ l_rx0 = int_ceildivpow2(l_tcx0, l_level_no);
+ l_ry0 = int_ceildivpow2(l_tcy0, l_level_no);
+ l_rx1 = int_ceildivpow2(l_tcx1, l_level_no);
+ l_ry1 = int_ceildivpow2(l_tcy1, l_level_no);
+ l_px0 = int_floordivpow2(l_rx0, l_pdx) << l_pdx;
+ l_py0 = int_floordivpow2(l_ry0, l_pdy) << l_pdy;
+ l_px1 = int_ceildivpow2(l_rx1, l_pdx) << l_pdx;
+ py1 = int_ceildivpow2(l_ry1, l_pdy) << l_pdy;
+ l_pw = (l_rx0==l_rx1)?0:((l_px1 - l_px0) >> l_pdx);
+ l_ph = (l_ry0==l_ry1)?0:((py1 - l_py0) >> l_pdy);
+ *lResolutionPtr++ = l_pw;
+ *lResolutionPtr++ = l_ph;
+ l_product = l_pw * l_ph;
+ // update precision
+ if
+ (l_product > *p_max_prec)
+ {
+ *p_max_prec = l_product;
+ }
+ --l_level_no;
+ }
+ ++l_tccp;
+ ++l_img_comp;
+ }
+}
+
+/**
+ * Allocates memory for a packet iterator. Data and data sizes are set by this operation.
+ * No other data is set. The include section of the packet iterator is not allocated.
+ *
+ * @param p_image the image used to initialize the packet iterator (in fact only the number of components is relevant.
+ * @param p_cp the coding parameters.
+ * @param p_tile_no the index of the tile from which creating the packet iterator.
+ */
+opj_pi_iterator_t * pi_create(
+ const opj_image_t *image,
+ const opj_cp_t *cp,
+ OPJ_UINT32 tileno
+ )
+{
+ // loop
+ OPJ_UINT32 pino, compno;
+ // number of poc in the p_pi
+ OPJ_UINT32 l_poc_bound;
+
+ // pointers to tile coding parameters and components.
+ opj_pi_iterator_t *l_pi = 00;
+ opj_tcp_t *tcp = 00;
+ const opj_tccp_t *tccp = 00;
+
+ // current packet iterator being allocated
+ opj_pi_iterator_t *l_current_pi = 00;
+
+ // preconditions in debug
+ assert(cp != 00);
+ assert(image != 00);
+ assert(tileno < cp->tw * cp->th);
+
+ // initializations
+ tcp = &cp->tcps[tileno];
+ l_poc_bound = tcp->numpocs+1;
+
+
+ // memory allocations
+ l_pi = (opj_pi_iterator_t*) opj_calloc((l_poc_bound), sizeof(opj_pi_iterator_t));
+
+ if
+ (!l_pi)
+ {
+ return 00;
+ }
+ memset(l_pi,0,l_poc_bound * sizeof(opj_pi_iterator_t));
+ l_current_pi = l_pi;
+ for
+ (pino = 0; pino < l_poc_bound ; ++pino)
+ {
+ l_current_pi->comps = (opj_pi_comp_t*) opj_calloc(image->numcomps, sizeof(opj_pi_comp_t));
+ if
+ (! l_current_pi->comps)
+ {
+ pi_destroy(l_pi, l_poc_bound);
+ return 00;
+ }
+ l_current_pi->numcomps = image->numcomps;
+ memset(l_current_pi->comps,0,image->numcomps * sizeof(opj_pi_comp_t));
+ for
+ (compno = 0; compno < image->numcomps; ++compno)
+ {
+ opj_pi_comp_t *comp = &l_current_pi->comps[compno];
+ tccp = &tcp->tccps[compno];
+ comp->resolutions = (opj_pi_resolution_t*) opj_malloc(tccp->numresolutions * sizeof(opj_pi_resolution_t));
+ if
+ (!comp->resolutions)
+ {
+ pi_destroy(l_pi, l_poc_bound);
+ return 00;
+ }
+ comp->numresolutions = tccp->numresolutions;
+ memset(comp->resolutions,0,tccp->numresolutions * sizeof(opj_pi_resolution_t));
+ }
+ ++l_current_pi;
+ }
+ return l_pi;
+}
+
+/**
+ * Updates the coding parameters if the encoding is used with Progression order changes and final (or cinema parameters are used).
+ *
+ * @param p_cp the coding parameters to modify
+ * @param p_tileno the tile index being concerned.
+ * @param p_tx0 X0 parameter for the tile
+ * @param p_tx1 X1 parameter for the tile
+ * @param p_ty0 Y0 parameter for the tile
+ * @param p_ty1 Y1 parameter for the tile
+ * @param p_max_prec the maximum precision for all the bands of the tile
+ * @param p_max_res the maximum number of resolutions for all the poc inside the tile.
+ * @param dx_min the minimum dx of all the components of all the resolutions for the tile.
+ * @param dy_min the minimum dy of all the components of all the resolutions for the tile.
+ */
+void pi_update_encode_poc_and_final (
+ opj_cp_t *p_cp,
+ OPJ_UINT32 p_tileno,
+ OPJ_INT32 p_tx0,
+ OPJ_INT32 p_tx1,
+ OPJ_INT32 p_ty0,
+ OPJ_INT32 p_ty1,
+ OPJ_UINT32 p_max_prec,
+ OPJ_UINT32 p_max_res,
+ OPJ_UINT32 p_dx_min,
+ OPJ_UINT32 p_dy_min)
+{
+ // loop
+ OPJ_UINT32 pino;
+ // tile coding parameter
+ opj_tcp_t *l_tcp = 00;
+ // current poc being updated
+ opj_poc_t * l_current_poc = 00;
+
+ // number of pocs
+ OPJ_UINT32 l_poc_bound;
+
+ // preconditions in debug
+ assert(p_cp != 00);
+ assert(p_tileno < p_cp->tw * p_cp->th);
+
+ // initializations
+ l_tcp = &p_cp->tcps [p_tileno];
+ /* number of iterations in the loop */
+ l_poc_bound = l_tcp->numpocs+1;
+
+ // start at first element, and to make sure the compiler will not make a calculation each time in the loop
+ // store a pointer to the current element to modify rather than l_tcp->pocs[i]
+ l_current_poc = l_tcp->pocs;
+
+ l_current_poc->compS = l_current_poc->compno0;
+ l_current_poc->compE = l_current_poc->compno1;
+ l_current_poc->resS = l_current_poc->resno0;
+ l_current_poc->resE = l_current_poc->resno1;
+ l_current_poc->layE = l_current_poc->layno1;
+
+ // special treatment for the first element
+ l_current_poc->layS = 0;
+ l_current_poc->prg = l_current_poc->prg1;
+ l_current_poc->prcS = 0;
+
+ l_current_poc->prcE = p_max_prec;
+ l_current_poc->txS = p_tx0;
+ l_current_poc->txE = p_tx1;
+ l_current_poc->tyS = p_ty0;
+ l_current_poc->tyE = p_ty1;
+ l_current_poc->dx = p_dx_min;
+ l_current_poc->dy = p_dy_min;
+
+ ++ l_current_poc;
+ for
+ (pino = 1;pino < l_poc_bound ; ++pino)
+ {
+ l_current_poc->compS = l_current_poc->compno0;
+ l_current_poc->compE= l_current_poc->compno1;
+ l_current_poc->resS = l_current_poc->resno0;
+ l_current_poc->resE = l_current_poc->resno1;
+ l_current_poc->layE = l_current_poc->layno1;
+ l_current_poc->prg = l_current_poc->prg1;
+ l_current_poc->prcS = 0;
+ // special treatment here different from the first element
+ l_current_poc->layS = (l_current_poc->layE > (l_current_poc-1)->layE) ? l_current_poc->layE : 0;
+
+ l_current_poc->prcE = p_max_prec;
+ l_current_poc->txS = p_tx0;
+ l_current_poc->txE = p_tx1;
+ l_current_poc->tyS = p_ty0;
+ l_current_poc->tyE = p_ty1;
+ l_current_poc->dx = p_dx_min;
+ l_current_poc->dy = p_dy_min;
+ ++ l_current_poc;
+ }
+}
+
+/**
+ * Updates the coding parameters if the encoding is not used with Progression order changes and final (and cinema parameters are used).
+ *
+ * @param p_cp the coding parameters to modify
+ * @param p_tileno the tile index being concerned.
+ * @param p_tx0 X0 parameter for the tile
+ * @param p_tx1 X1 parameter for the tile
+ * @param p_ty0 Y0 parameter for the tile
+ * @param p_ty1 Y1 parameter for the tile
+ * @param p_max_prec the maximum precision for all the bands of the tile
+ * @param p_max_res the maximum number of resolutions for all the poc inside the tile.
+ * @param dx_min the minimum dx of all the components of all the resolutions for the tile.
+ * @param dy_min the minimum dy of all the components of all the resolutions for the tile.
+ */
+void pi_update_encode_not_poc (
+ opj_cp_t *p_cp,
+ OPJ_UINT32 p_num_comps,
+ OPJ_UINT32 p_tileno,
+ OPJ_INT32 p_tx0,
+ OPJ_INT32 p_tx1,
+ OPJ_INT32 p_ty0,
+ OPJ_INT32 p_ty1,
+ OPJ_UINT32 p_max_prec,
+ OPJ_UINT32 p_max_res,
+ OPJ_UINT32 p_dx_min,
+ OPJ_UINT32 p_dy_min)
+{
+ // loop
+ OPJ_UINT32 pino;
+ // tile coding parameter
+ opj_tcp_t *l_tcp = 00;
+ // current poc being updated
+ opj_poc_t * l_current_poc = 00;
+ // number of pocs
+ OPJ_UINT32 l_poc_bound;
+
+ // preconditions in debug
+ assert(p_cp != 00);
+ assert(p_tileno < p_cp->tw * p_cp->th);
+
+ // initializations
+ l_tcp = &p_cp->tcps [p_tileno];
+
+ /* number of iterations in the loop */
+ l_poc_bound = l_tcp->numpocs+1;
+
+ // start at first element, and to make sure the compiler will not make a calculation each time in the loop
+ // store a pointer to the current element to modify rather than l_tcp->pocs[i]
+ l_current_poc = l_tcp->pocs;
+
+ for
+ (pino = 0; pino < l_poc_bound ; ++pino)
+ {
+ l_current_poc->compS = 0;
+ l_current_poc->compE = p_num_comps;/*p_image->numcomps;*/
+ l_current_poc->resS = 0;
+ l_current_poc->resE = p_max_res;
+ l_current_poc->layS = 0;
+ l_current_poc->layE = l_tcp->numlayers;
+ l_current_poc->prg = l_tcp->prg;
+ l_current_poc->prcS = 0;
+ l_current_poc->prcE = p_max_prec;
+ l_current_poc->txS = p_tx0;
+ l_current_poc->txE = p_tx1;
+ l_current_poc->tyS = p_ty0;
+ l_current_poc->tyE = p_ty1;
+ l_current_poc->dx = p_dx_min;
+ l_current_poc->dy = p_dy_min;
+ ++ l_current_poc;
+ }
+}
+
+/**
+ * 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)
+{
+ OPJ_UINT32 compno, pino;
+ opj_pi_iterator_t *l_current_pi = p_pi;
+ if
+ (p_pi)
+ {
+ if
+ (p_pi->include)
+ {
+ opj_free(p_pi->include);
+ p_pi->include = 00;
+ }
+ // TODO
+ for
+ (pino = 0; pino < p_nb_elements; ++pino)
+ {
+ if
+ (l_current_pi->comps)
+ {
+ opj_pi_comp_t *l_current_component = l_current_pi->comps;
+ for
+ (compno = 0; compno < l_current_pi->numcomps; compno++)
+ {
+ if
+ (l_current_component->resolutions)
+ {
+ opj_free(l_current_component->resolutions);
+ l_current_component->resolutions = 00;
+ }
+ ++l_current_component;
+ }
+ opj_free(l_current_pi->comps);
+ l_current_pi->comps = 0;
+ }
+ ++l_current_pi;
+ }
+ opj_free(p_pi);
+ }
+}
+
+bool pi_next(opj_pi_iterator_t * pi) {
+ switch (pi->poc.prg) {
+ case LRCP:
+ return pi_next_lrcp(pi);
+ case RLCP:
+ return pi_next_rlcp(pi);
+ case RPCL:
+ return pi_next_rpcl(pi);
+ case PCRL:
+ return pi_next_pcrl(pi);
+ case CPRL:
+ return pi_next_cprl(pi);
+ case PROG_UNKNOWN:
+ return false;
+ }
+
+ return false;
+}
+
+OPJ_INT32 pi_check_next_level(OPJ_INT32 pos,opj_cp_t *cp,OPJ_UINT32 tileno, OPJ_UINT32 pino, const OPJ_CHAR *prog)
+{
+ OPJ_INT32 i,l;
+ opj_tcp_t *tcps =&cp->tcps[tileno];
+ opj_poc_t *tcp = &tcps->pocs[pino];
+ if(pos>=0){
+ for(i=pos;pos>=0;i--){
+ switch(prog[i]){
+ case 'R':
+ if(tcp->res_t==tcp->resE){
+ l=pi_check_next_level(pos-1,cp,tileno,pino,prog);
+ if(l==1){
+ return 1;
+ }else{
+ return 0;
+ }
+ }else{
+ return 1;
+ }
+ break;
+ case 'C':
+ if(tcp->comp_t==tcp->compE){
+ l=pi_check_next_level(pos-1,cp,tileno,pino,prog);
+ if(l==1){
+ return 1;
+ }else{
+ return 0;
+ }
+ }else{
+ return 1;
+ }
+ break;
+ case 'L':
+ if(tcp->lay_t==tcp->layE){
+ l=pi_check_next_level(pos-1,cp,tileno,pino,prog);
+ if(l==1){
+ return 1;
+ }else{
+ return 0;
+ }
+ }else{
+ return 1;
+ }
+ break;
+ case 'P':
+ switch(tcp->prg){
+ case LRCP||RLCP:
+ if(tcp->prc_t == tcp->prcE){
+ l=pi_check_next_level(i-1,cp,tileno,pino,prog);
+ if(l==1){
+ return 1;
+ }else{
+ return 0;
+ }
+ }else{
+ return 1;
+ }
+ break;
+ default:
+ if(tcp->tx0_t == tcp->txE){
+ //TY
+ if(tcp->ty0_t == tcp->tyE){
+ l=pi_check_next_level(i-1,cp,tileno,pino,prog);
+ if(l==1){
+ return 1;
+ }else{
+ return 0;
+ }
+ }else{
+ return 1;
+ }//TY
+ }else{
+ return 1;
+ }
+ break;
+ }//end case P
+ }//end switch
+ }//end for
+ }//end if
+ return 0;
+}
+
+
+void pi_create_encode( opj_pi_iterator_t *pi, opj_cp_t *cp,OPJ_UINT32 tileno, OPJ_UINT32 pino,OPJ_UINT32 tpnum, OPJ_INT32 tppos, J2K_T2_MODE t2_mode)
+{
+ const OPJ_CHAR *prog;
+ OPJ_INT32 i,l;
+ OPJ_UINT32 incr_top=1,resetX=0;
+ opj_tcp_t *tcps =&cp->tcps[tileno];
+ opj_poc_t *tcp= &tcps->pocs[pino];
+
+ prog = j2k_convert_progression_order(tcp->prg);
+
+ pi[pino].first = 1;
+ pi[pino].poc.prg = tcp->prg;
+
+ if(!(cp->m_specific_param.m_enc.m_tp_on&& ((!cp->m_specific_param.m_enc.m_cinema && (t2_mode == FINAL_PASS)) || cp->m_specific_param.m_enc.m_cinema))){
+ pi[pino].poc.resno0 = tcp->resS;
+ pi[pino].poc.resno1 = tcp->resE;
+ pi[pino].poc.compno0 = tcp->compS;
+ pi[pino].poc.compno1 = tcp->compE;
+ pi[pino].poc.layno0 = tcp->layS;
+ pi[pino].poc.layno1 = tcp->layE;
+ pi[pino].poc.precno0 = tcp->prcS;
+ pi[pino].poc.precno1 = tcp->prcE;
+ pi[pino].poc.tx0 = tcp->txS;
+ pi[pino].poc.ty0 = tcp->tyS;
+ pi[pino].poc.tx1 = tcp->txE;
+ pi[pino].poc.ty1 = tcp->tyE;
+ }else {
+ for(i=tppos+1;i<4;i++){
+ switch(prog[i]){
+ case 'R':
+ pi[pino].poc.resno0 = tcp->resS;
+ pi[pino].poc.resno1 = tcp->resE;
+ break;
+ case 'C':
+ pi[pino].poc.compno0 = tcp->compS;
+ pi[pino].poc.compno1 = tcp->compE;
+ break;
+ case 'L':
+ pi[pino].poc.layno0 = tcp->layS;
+ pi[pino].poc.layno1 = tcp->layE;
+ break;
+ case 'P':
+ switch(tcp->prg){
+ case LRCP:
+ case RLCP:
+ pi[pino].poc.precno0 = tcp->prcS;
+ pi[pino].poc.precno1 = tcp->prcE;
+ break;
+ default:
+ pi[pino].poc.tx0 = tcp->txS;
+ pi[pino].poc.ty0 = tcp->tyS;
+ pi[pino].poc.tx1 = tcp->txE;
+ pi[pino].poc.ty1 = tcp->tyE;
+ break;
+ }
+ break;
+ }
+ }
+
+ if(tpnum==0){
+ for(i=tppos;i>=0;i--){
+ switch(prog[i]){
+ case 'C':
+ tcp->comp_t = tcp->compS;
+ pi[pino].poc.compno0 = tcp->comp_t;
+ pi[pino].poc.compno1 = tcp->comp_t+1;
+ tcp->comp_t+=1;
+ break;
+ case 'R':
+ tcp->res_t = tcp->resS;
+ pi[pino].poc.resno0 = tcp->res_t;
+ pi[pino].poc.resno1 = tcp->res_t+1;
+ tcp->res_t+=1;
+ break;
+ case 'L':
+ tcp->lay_t = tcp->layS;
+ pi[pino].poc.layno0 = tcp->lay_t;
+ pi[pino].poc.layno1 = tcp->lay_t+1;
+ tcp->lay_t+=1;
+ break;
+ case 'P':
+ switch(tcp->prg){
+ case LRCP:
+ case RLCP:
+ tcp->prc_t = tcp->prcS;
+ pi[pino].poc.precno0 = tcp->prc_t;
+ pi[pino].poc.precno1 = tcp->prc_t+1;
+ tcp->prc_t+=1;
+ break;
+ default:
+ tcp->tx0_t = tcp->txS;
+ tcp->ty0_t = tcp->tyS;
+ pi[pino].poc.tx0 = tcp->tx0_t;
+ pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx - (tcp->tx0_t % tcp->dx);
+ pi[pino].poc.ty0 = tcp->ty0_t;
+ pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
+ tcp->tx0_t = pi[pino].poc.tx1;
+ tcp->ty0_t = pi[pino].poc.ty1;
+ break;
+ }
+ break;
+ }
+ }
+ incr_top=1;
+ }else{
+ for(i=tppos;i>=0;i--){
+ switch(prog[i]){
+ case 'C':
+ pi[pino].poc.compno0 = tcp->comp_t-1;
+ pi[pino].poc.compno1 = tcp->comp_t;
+ break;
+ case 'R':
+ pi[pino].poc.resno0 = tcp->res_t-1;
+ pi[pino].poc.resno1 = tcp->res_t;
+ break;
+ case 'L':
+ pi[pino].poc.layno0 = tcp->lay_t-1;
+ pi[pino].poc.layno1 = tcp->lay_t;
+ break;
+ case 'P':
+ switch(tcp->prg){
+ case LRCP:
+ case RLCP:
+ pi[pino].poc.precno0 = tcp->prc_t-1;
+ pi[pino].poc.precno1 = tcp->prc_t;
+ break;
+ default:
+ pi[pino].poc.tx0 = tcp->tx0_t - tcp->dx - (tcp->tx0_t % tcp->dx);
+ pi[pino].poc.tx1 = tcp->tx0_t ;
+ pi[pino].poc.ty0 = tcp->ty0_t - tcp->dy - (tcp->ty0_t % tcp->dy);
+ pi[pino].poc.ty1 = tcp->ty0_t ;
+ break;
+ }
+ break;
+ }
+ if(incr_top==1){
+ switch(prog[i]){
+ case 'R':
+ if(tcp->res_t==tcp->resE){
+ l=pi_check_next_level(i-1,cp,tileno,pino,prog);
+ if(l==1){
+ tcp->res_t = tcp->resS;
+ pi[pino].poc.resno0 = tcp->res_t;
+ pi[pino].poc.resno1 = tcp->res_t+1;
+ tcp->res_t+=1;
+ incr_top=1;
+ }else{
+ incr_top=0;
+ }
+ }else{
+ pi[pino].poc.resno0 = tcp->res_t;
+ pi[pino].poc.resno1 = tcp->res_t+1;
+ tcp->res_t+=1;
+ incr_top=0;
+ }
+ break;
+ case 'C':
+ if(tcp->comp_t ==tcp->compE){
+ l=pi_check_next_level(i-1,cp,tileno,pino,prog);
+ if(l==1){
+ tcp->comp_t = tcp->compS;
+ pi[pino].poc.compno0 = tcp->comp_t;
+ pi[pino].poc.compno1 = tcp->comp_t+1;
+ tcp->comp_t+=1;
+ incr_top=1;
+ }else{
+ incr_top=0;
+ }
+ }else{
+ pi[pino].poc.compno0 = tcp->comp_t;
+ pi[pino].poc.compno1 = tcp->comp_t+1;
+ tcp->comp_t+=1;
+ incr_top=0;
+ }
+ break;
+ case 'L':
+ if(tcp->lay_t == tcp->layE){
+ l=pi_check_next_level(i-1,cp,tileno,pino,prog);
+ if(l==1){
+ tcp->lay_t = tcp->layS;
+ pi[pino].poc.layno0 = tcp->lay_t;
+ pi[pino].poc.layno1 = tcp->lay_t+1;
+ tcp->lay_t+=1;
+ incr_top=1;
+ }else{
+ incr_top=0;
+ }
+ }else{
+ pi[pino].poc.layno0 = tcp->lay_t;
+ pi[pino].poc.layno1 = tcp->lay_t+1;
+ tcp->lay_t+=1;
+ incr_top=0;
+ }
+ break;
+ case 'P':
+ switch(tcp->prg){
+ case LRCP:
+ case RLCP:
+ if(tcp->prc_t == tcp->prcE){
+ l=pi_check_next_level(i-1,cp,tileno,pino,prog);
+ if(l==1){
+ tcp->prc_t = tcp->prcS;
+ pi[pino].poc.precno0 = tcp->prc_t;
+ pi[pino].poc.precno1 = tcp->prc_t+1;
+ tcp->prc_t+=1;
+ incr_top=1;
+ }else{
+ incr_top=0;
+ }
+ }else{
+ pi[pino].poc.precno0 = tcp->prc_t;
+ pi[pino].poc.precno1 = tcp->prc_t+1;
+ tcp->prc_t+=1;
+ incr_top=0;
+ }
+ break;
+ default:
+ if(tcp->tx0_t >= tcp->txE){
+ if(tcp->ty0_t >= tcp->tyE){
+ l=pi_check_next_level(i-1,cp,tileno,pino,prog);
+ if(l==1){
+ tcp->ty0_t = tcp->tyS;
+ pi[pino].poc.ty0 = tcp->ty0_t;
+ pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
+ tcp->ty0_t = pi[pino].poc.ty1;
+ incr_top=1;resetX=1;
+ }else{
+ incr_top=0;resetX=0;
+ }
+ }else{
+ pi[pino].poc.ty0 = tcp->ty0_t;
+ pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
+ tcp->ty0_t = pi[pino].poc.ty1;
+ incr_top=0;resetX=1;
+ }
+ if(resetX==1){
+ tcp->tx0_t = tcp->txS;
+ pi[pino].poc.tx0 = tcp->tx0_t;
+ pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx- (tcp->tx0_t % tcp->dx);
+ tcp->tx0_t = pi[pino].poc.tx1;
+ }
+ }else{
+ pi[pino].poc.tx0 = tcp->tx0_t;
+ pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx- (tcp->tx0_t % tcp->dx);
+ tcp->tx0_t = pi[pino].poc.tx1;
+ incr_top=0;
+ }
+ break;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+}
+
+
+
diff --git a/v2/libopenjpeg/pi.h b/v2/libopenjpeg/pi.h new file mode 100755 index 00000000..8e6b35fd --- /dev/null +++ b/v2/libopenjpeg/pi.h @@ -0,0 +1,181 @@ +/*
+ * 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) 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 __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
+packet following the progression order and change of it. The functions in PI.C are used
+by some function in T2.C.
+*/
+#include "openjpeg.h"
+#include "t2.h"
+/** @defgroup PI PI - Implementation of a packet iterator */
+/*@{*/
+struct opj_poc;
+struct opj_image;
+struct opj_cp;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_pi_resolution {
+ OPJ_UINT32 pdx, pdy;
+ OPJ_UINT32 pw, ph;
+} opj_pi_resolution_t;
+
+/**
+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 */
diff --git a/v2/libopenjpeg/profile.c b/v2/libopenjpeg/profile.c new file mode 100755 index 00000000..68c6c0c1 --- /dev/null +++ b/v2/libopenjpeg/profile.c @@ -0,0 +1,177 @@ +/*
+ * 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
diff --git a/v2/libopenjpeg/profile.h b/v2/libopenjpeg/profile.h new file mode 100755 index 00000000..f23fdb8b --- /dev/null +++ b/v2/libopenjpeg/profile.h @@ -0,0 +1,83 @@ +/*
+ * 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
diff --git a/v2/libopenjpeg/raw.c b/v2/libopenjpeg/raw.c new file mode 100755 index 00000000..a243c461 --- /dev/null +++ b/v2/libopenjpeg/raw.c @@ -0,0 +1,89 @@ +/*
+ * 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 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.
+ *
+ * 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 "raw.h"
+#include "opj_malloc.h"
+
+/*
+==========================================================
+ local functions
+==========================================================
+*/
+
+
+/*
+==========================================================
+ RAW encoding interface
+==========================================================
+*/
+
+opj_raw_t* raw_create(void) {
+ opj_raw_t *raw = (opj_raw_t*)opj_malloc(sizeof(opj_raw_t));
+ return raw;
+}
+
+void raw_destroy(opj_raw_t *raw) {
+ if(raw) {
+ opj_free(raw);
+ }
+}
+
+OPJ_UINT32 raw_numbytes(opj_raw_t *raw) {
+ 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;
+}
+
diff --git a/v2/libopenjpeg/raw.h b/v2/libopenjpeg/raw.h new file mode 100755 index 00000000..bb80c625 --- /dev/null +++ b/v2/libopenjpeg/raw.h @@ -0,0 +1,101 @@ +/*
+ * 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 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.
+ *
+ * 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 __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.
+*/
+#include "openjpeg.h"
+/** @defgroup RAW RAW - Implementation of operations for raw encoding */
+/*@{*/
+
+/**
+RAW encoding operations
+*/
+typedef struct opj_raw {
+ /** 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 */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+/**
+Create a new RAW handle
+@return Returns a new RAW handle if successful, returns NULL otherwise
+*/
+opj_raw_t* raw_create(void);
+/**
+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 /* __RAW_H */
diff --git a/v2/libopenjpeg/t1.c b/v2/libopenjpeg/t1.c new file mode 100755 index 00000000..4f95fc61 --- /dev/null +++ b/v2/libopenjpeg/t1.c @@ -0,0 +1,1286 @@ +/*
+ * 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) 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.
+ */
+
+#include "t1.h"
+#include "t1_luts.h"
+#include "opj_includes.h"
+#include "j2k.h"
+#include "tcd.h"
+#include "mqc.h"
+#include "raw.h"
+#include "opj_malloc.h"
+#include "int.h"
+#include "dwt.h"
+#include "fix.h"
+/** @defgroup T1 T1 - Implementation of the tier-1 coding */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+static INLINE OPJ_BYTE t1_getctxno_zc(OPJ_UINT32 f, OPJ_UINT32 orient);
+static OPJ_BYTE t1_getctxno_sc(OPJ_UINT32 f);
+static INLINE OPJ_UINT32 t1_getctxno_mag(OPJ_UINT32 f);
+static OPJ_BYTE t1_getspb(OPJ_UINT32 f);
+static OPJ_INT16 t1_getnmsedec_sig(OPJ_UINT32 x, OPJ_UINT32 bitpos);
+static OPJ_INT16 t1_getnmsedec_ref(OPJ_UINT32 x, OPJ_UINT32 bitpos);
+static void t1_updateflags(flag_t *flagsp, OPJ_UINT32 s, OPJ_UINT32 stride);
+/**
+Encode significant pass
+*/
+static void t1_enc_sigpass_step(
+ opj_t1_t *t1,
+ flag_t *flagsp,
+ OPJ_INT32 *datap,
+ OPJ_UINT32 orient,
+ OPJ_INT32 bpno,
+ OPJ_INT32 one,
+ OPJ_INT32 *nmsedec,
+ OPJ_BYTE type,
+ OPJ_UINT32 vsc);
+/**
+Decode significant pass
+*/
+static void t1_dec_sigpass_step(
+ opj_t1_t *t1,
+ flag_t *flagsp,
+ OPJ_INT32 *datap,
+ OPJ_UINT32 orient,
+ OPJ_INT32 oneplushalf,
+ OPJ_BYTE type,
+ OPJ_UINT32 vsc);
+/**
+Encode significant pass
+*/
+static void t1_enc_sigpass(
+ opj_t1_t *t1,
+ OPJ_INT32 bpno,
+ OPJ_UINT32 orient,
+ OPJ_INT32 *nmsedec,
+ OPJ_BYTE type,
+ OPJ_UINT32 cblksty);
+/**
+Decode significant pass
+*/
+static void t1_dec_sigpass(
+ opj_t1_t *t1,
+ OPJ_INT32 bpno,
+ OPJ_UINT32 orient,
+ OPJ_BYTE type,
+ OPJ_UINT32 cblksty);
+/**
+Encode refinement pass
+*/
+static void t1_enc_refpass_step(
+ opj_t1_t *t1,
+ flag_t *flagsp,
+ OPJ_INT32 *datap,
+ OPJ_INT32 bpno,
+ OPJ_INT32 one,
+ OPJ_INT32 *nmsedec,
+ OPJ_BYTE type,
+ OPJ_UINT32 vsc);
+/**
+Decode refinement pass
+*/
+static void t1_dec_refpass_step(
+ opj_t1_t *t1,
+ flag_t *flagsp,
+ OPJ_INT32 *datap,
+ OPJ_INT32 poshalf,
+ OPJ_INT32 neghalf,
+ OPJ_BYTE type,
+ OPJ_UINT32 vsc);
+/**
+Encode refinement pass
+*/
+static void t1_enc_refpass(
+ opj_t1_t *t1,
+ OPJ_INT32 bpno,
+ OPJ_INT32 *nmsedec,
+ OPJ_BYTE type,
+ OPJ_UINT32 cblksty);
+/**
+Decode refinement pass
+*/
+static void t1_dec_refpass(
+ opj_t1_t *t1,
+ OPJ_INT32 bpno,
+ OPJ_BYTE type,
+ OPJ_UINT32 cblksty);
+/**
+Encode clean-up pass
+*/
+static void t1_enc_clnpass_step(
+ opj_t1_t *t1,
+ flag_t *flagsp,
+ OPJ_INT32 *datap,
+ OPJ_UINT32 orient,
+ OPJ_INT32 bpno,
+ OPJ_INT32 one,
+ OPJ_INT32 *nmsedec,
+ OPJ_UINT32 partial,
+ OPJ_UINT32 vsc);
+/**
+Decode clean-up pass
+*/
+static void t1_dec_clnpass_step(
+ opj_t1_t *t1,
+ flag_t *flagsp,
+ OPJ_INT32 *datap,
+ OPJ_UINT32 orient,
+ OPJ_INT32 oneplushalf,
+ OPJ_UINT32 partial,
+ OPJ_UINT32 vsc);
+/**
+Encode clean-up pass
+*/
+static void t1_enc_clnpass(
+ opj_t1_t *t1,
+ OPJ_INT32 bpno,
+ OPJ_UINT32 orient,
+ OPJ_INT32 *nmsedec,
+ OPJ_UINT32 cblksty);
+/**
+Decode clean-up pass
+*/
+static void t1_dec_clnpass(
+ opj_t1_t *t1,
+ OPJ_INT32 bpno,
+ OPJ_UINT32 orient,
+ OPJ_UINT32 cblksty);
+
+static OPJ_FLOAT64 t1_getwmsedec(
+ OPJ_INT32 nmsedec,
+ OPJ_UINT32 compno,
+ OPJ_UINT32 level,
+ OPJ_UINT32 orient,
+ OPJ_INT32 bpno,
+ OPJ_UINT32 qmfbid,
+ OPJ_FLOAT64 stepsize,
+ OPJ_UINT32 numcomps,
+ const OPJ_FLOAT64 * mct_norms);
+/**
+Encode 1 code-block
+@param t1 T1 handle
+@param cblk Code-block coding parameters
+@param orient
+@param compno Component number
+@param level
+@param qmfbid
+@param stepsize
+@param cblksty Code-block style
+@param numcomps
+@param tile
+*/
+static void t1_encode_cblk(
+ opj_t1_t *t1,
+ opj_tcd_cblk_enc_t* cblk,
+ OPJ_UINT32 orient,
+ OPJ_UINT32 compno,
+ OPJ_UINT32 level,
+ OPJ_UINT32 qmfbid,
+ OPJ_FLOAT64 stepsize,
+ OPJ_UINT32 cblksty,
+ OPJ_UINT32 numcomps,
+ opj_tcd_tile_t * tile,
+ const OPJ_FLOAT64 * mct_norms);
+/**
+Decode 1 code-block
+@param t1 T1 handle
+@param cblk Code-block coding parameters
+@param orient
+@param roishift Region of interest shifting value
+@param cblksty Code-block style
+*/
+static void t1_decode_cblk(
+ opj_t1_t *t1,
+ opj_tcd_cblk_dec_t* cblk,
+ OPJ_UINT32 orient,
+ OPJ_UINT32 roishift,
+ OPJ_UINT32 cblksty);
+
+/*@}*/
+
+/*@}*/
+
+/* ----------------------------------------------------------------------- */
+
+static OPJ_BYTE t1_getctxno_zc(OPJ_UINT32 f, OPJ_UINT32 orient) {
+ return lut_ctxno_zc[(orient << 8) | (f & T1_SIG_OTH)];
+}
+
+static OPJ_BYTE t1_getctxno_sc(OPJ_UINT32 f) {
+ return lut_ctxno_sc[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
+}
+
+static OPJ_UINT32 t1_getctxno_mag(OPJ_UINT32 f) {
+ OPJ_UINT32 tmp1 = (f & T1_SIG_OTH) ? T1_CTXNO_MAG + 1 : T1_CTXNO_MAG;
+ OPJ_UINT32 tmp2 = (f & T1_REFINE) ? T1_CTXNO_MAG + 2 : tmp1;
+ return (tmp2);
+}
+
+static OPJ_BYTE t1_getspb(OPJ_UINT32 f) {
+ return lut_spb[(f & (T1_SIG_PRIM | T1_SGN)) >> 4];
+}
+
+static OPJ_INT16 t1_getnmsedec_sig(OPJ_UINT32 x, OPJ_UINT32 bitpos)
+{
+ if (bitpos > T1_NMSEDEC_FRACBITS) {
+ return lut_nmsedec_sig[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];
+ }
+
+ return lut_nmsedec_sig0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
+}
+
+static OPJ_INT16 t1_getnmsedec_ref(OPJ_UINT32 x, OPJ_UINT32 bitpos) {
+ if (bitpos > T1_NMSEDEC_FRACBITS) {
+ return lut_nmsedec_ref[(x >> (bitpos - T1_NMSEDEC_FRACBITS)) & ((1 << T1_NMSEDEC_BITS) - 1)];
+ }
+
+ return lut_nmsedec_ref0[x & ((1 << T1_NMSEDEC_BITS) - 1)];
+}
+
+static void t1_updateflags(flag_t *flagsp, OPJ_UINT32 s, OPJ_UINT32 stride) {
+ flag_t *np = flagsp - stride;
+ flag_t *sp = flagsp + stride;
+
+ static const flag_t mod[] = {
+ T1_SIG_S, T1_SIG_S|T1_SGN_S,
+ T1_SIG_E, T1_SIG_E|T1_SGN_E,
+ T1_SIG_W, T1_SIG_W|T1_SGN_W,
+ T1_SIG_N, T1_SIG_N|T1_SGN_N
+ };
+
+ np[-1] |= T1_SIG_SE;
+ np[0] |= mod[s];
+ np[1] |= T1_SIG_SW;
+
+ flagsp[-1] |= mod[s+2];
+ flagsp[0] |= T1_SIG;
+ flagsp[1] |= mod[s+4];
+
+ sp[-1] |= T1_SIG_NE;
+ sp[0] |= mod[s+6];
+ sp[1] |= T1_SIG_NW;
+}
+
+static void t1_enc_sigpass_step(
+ opj_t1_t *t1,
+ flag_t *flagsp,
+ OPJ_INT32 *datap,
+ OPJ_UINT32 orient,
+ OPJ_INT32 bpno,
+ OPJ_INT32 one,
+ OPJ_INT32 *nmsedec,
+ OPJ_BYTE type,
+ OPJ_UINT32 vsc)
+{
+ OPJ_INT32 v;
+ OPJ_UINT32 flag;
+
+ opj_mqc_t *mqc = t1->mqc; /* MQC component */
+
+ flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
+ if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
+ v = int_abs(*datap) & one ? 1 : 0;
+ mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient)); /* ESSAI */
+ if (type == T1_TYPE_RAW) { /* BYPASS/LAZY MODE */
+ mqc_bypass_enc(mqc, v);
+ } else {
+ mqc_encode(mqc, v);
+ }
+ if (v) {
+ v = *datap < 0 ? 1 : 0;
+ *nmsedec += t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
+ mqc_setcurctx(mqc, t1_getctxno_sc(flag)); /* ESSAI */
+ if (type == T1_TYPE_RAW) { /* BYPASS/LAZY MODE */
+ mqc_bypass_enc(mqc, v);
+ } else {
+ mqc_encode(mqc, v ^ t1_getspb(flag));
+ }
+ t1_updateflags(flagsp, v, t1->flags_stride);
+ }
+ *flagsp |= T1_VISIT;
+ }
+}
+
+static void t1_dec_sigpass_step(
+ opj_t1_t *t1,
+ flag_t *flagsp,
+ OPJ_INT32 *datap,
+ OPJ_UINT32 orient,
+ OPJ_INT32 oneplushalf,
+ OPJ_BYTE type,
+ OPJ_UINT32 vsc)
+{
+ OPJ_UINT32 v, flag;
+
+ opj_raw_t *raw = t1->raw; /* RAW component */
+ opj_mqc_t *mqc = t1->mqc; /* MQC component */
+
+ flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
+ if ((flag & T1_SIG_OTH) && !(flag & (T1_SIG | T1_VISIT))) {
+ if (type == T1_TYPE_RAW) {
+ if (raw_decode(raw)) {
+ v = raw_decode(raw); /* ESSAI */
+ *datap = v ? -oneplushalf : oneplushalf;
+ t1_updateflags(flagsp, v, t1->flags_stride);
+ }
+ } else {
+ mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
+ if (mqc_decode(mqc)) {
+ mqc_setcurctx(mqc, t1_getctxno_sc(flag));
+ v = mqc_decode(mqc) ^ t1_getspb(flag);
+ *datap = v ? -oneplushalf : oneplushalf;
+ t1_updateflags(flagsp, v, t1->flags_stride);
+ }
+ }
+ *flagsp |= T1_VISIT;
+ }
+} /* VSC and BYPASS by Antonin */
+
+static void t1_enc_sigpass(
+ opj_t1_t *t1,
+ OPJ_INT32 bpno,
+ OPJ_UINT32 orient,
+ OPJ_INT32 *nmsedec,
+ OPJ_BYTE type,
+ OPJ_UINT32 cblksty)
+{
+ OPJ_UINT32 i, j, k, vsc;
+ OPJ_INT32 one;
+
+ *nmsedec = 0;
+ one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
+ for (k = 0; k < t1->h; k += 4) {
+ for (i = 0; i < t1->w; ++i) {
+ for (j = k; j < k + 4 && j < t1->h; ++j) {
+ vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
+ t1_enc_sigpass_step(
+ t1,
+ &t1->flags[((j+1) * t1->flags_stride) + i + 1],
+ &t1->data[(j * t1->w) + i],
+ orient,
+ bpno,
+ one,
+ nmsedec,
+ type,
+ vsc);
+ }
+ }
+ }
+}
+
+static void t1_dec_sigpass(
+ opj_t1_t *t1,
+ OPJ_INT32 bpno,
+ OPJ_UINT32 orient,
+ OPJ_BYTE type,
+ OPJ_UINT32 cblksty)
+{
+ OPJ_UINT32 i, j, k, vsc;
+ OPJ_INT32 one, half, oneplushalf;
+ one = 1 << bpno;
+ half = one >> 1;
+ oneplushalf = one | half;
+ for (k = 0; k < t1->h; k += 4) {
+ for (i = 0; i < t1->w; ++i) {
+ for (j = k; j < k + 4 && j < t1->h; ++j) {
+ vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
+ t1_dec_sigpass_step(
+ t1,
+ &t1->flags[((j+1) * t1->flags_stride) + i + 1],
+ &t1->data[(j * t1->w) + i],
+ orient,
+ oneplushalf,
+ type,
+ vsc);
+ }
+ }
+ }
+} /* VSC and BYPASS by Antonin */
+
+static void t1_enc_refpass_step(
+ opj_t1_t *t1,
+ flag_t *flagsp,
+ OPJ_INT32 *datap,
+ OPJ_INT32 bpno,
+ OPJ_INT32 one,
+ OPJ_INT32 *nmsedec,
+ OPJ_BYTE type,
+ OPJ_UINT32 vsc)
+{
+ OPJ_INT32 v;
+ OPJ_UINT32 flag;
+
+ opj_mqc_t *mqc = t1->mqc; /* MQC component */
+
+ flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
+ if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
+ *nmsedec += t1_getnmsedec_ref(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
+ v = int_abs(*datap) & one ? 1 : 0;
+ mqc_setcurctx(mqc, t1_getctxno_mag(flag)); /* ESSAI */
+ if (type == T1_TYPE_RAW) { /* BYPASS/LAZY MODE */
+ mqc_bypass_enc(mqc, v);
+ } else {
+ mqc_encode(mqc, v);
+ }
+ *flagsp |= T1_REFINE;
+ }
+}
+
+static void t1_dec_refpass_step(
+ opj_t1_t *t1,
+ flag_t *flagsp,
+ OPJ_INT32 *datap,
+ OPJ_INT32 poshalf,
+ OPJ_INT32 neghalf,
+ OPJ_BYTE type,
+ OPJ_UINT32 vsc)
+{
+ OPJ_INT32 t;
+ OPJ_UINT32 v,flag;
+
+ opj_mqc_t *mqc = t1->mqc; /* MQC component */
+ opj_raw_t *raw = t1->raw; /* RAW component */
+
+ flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
+ if ((flag & (T1_SIG | T1_VISIT)) == T1_SIG) {
+ mqc_setcurctx(mqc, t1_getctxno_mag(flag)); /* ESSAI */
+ if (type == T1_TYPE_RAW) {
+ v = raw_decode(raw);
+ } else {
+ v = mqc_decode(mqc);
+ }
+ t = v ? poshalf : neghalf;
+ *datap += *datap < 0 ? -t : t;
+ *flagsp |= T1_REFINE;
+ }
+} /* VSC and BYPASS by Antonin */
+
+static void t1_enc_refpass(
+ opj_t1_t *t1,
+ OPJ_INT32 bpno,
+ OPJ_INT32 *nmsedec,
+ OPJ_BYTE type,
+ OPJ_UINT32 cblksty)
+{
+ OPJ_UINT32 i, j, k, vsc;
+ OPJ_INT32 one;
+
+ *nmsedec = 0;
+ one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
+ for (k = 0; k < t1->h; k += 4) {
+ for (i = 0; i < t1->w; ++i) {
+ for (j = k; j < k + 4 && j < t1->h; ++j) {
+ vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
+ t1_enc_refpass_step(
+ t1,
+ &t1->flags[((j+1) * t1->flags_stride) + i + 1],
+ &t1->data[(j * t1->w) + i],
+ bpno,
+ one,
+ nmsedec,
+ type,
+ vsc);
+ }
+ }
+ }
+}
+
+static void t1_dec_refpass(
+ opj_t1_t *t1,
+ OPJ_INT32 bpno,
+ OPJ_BYTE type,
+ OPJ_UINT32 cblksty)
+{
+ OPJ_UINT32 i, j, k;
+ OPJ_INT32 one, poshalf, neghalf;
+ OPJ_UINT32 vsc;
+ one = 1 << bpno;
+ poshalf = one >> 1;
+ neghalf = bpno > 0 ? -poshalf : -1;
+ for (k = 0; k < t1->h; k += 4) {
+ for (i = 0; i < t1->w; ++i) {
+ for (j = k; j < k + 4 && j < t1->h; ++j) {
+ vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
+ t1_dec_refpass_step(
+ t1,
+ &t1->flags[((j+1) * t1->flags_stride) + i + 1],
+ &t1->data[(j * t1->w) + i],
+ poshalf,
+ neghalf,
+ type,
+ vsc);
+ }
+ }
+ }
+} /* VSC and BYPASS by Antonin */
+
+static void t1_enc_clnpass_step(
+ opj_t1_t *t1,
+ flag_t *flagsp,
+ OPJ_INT32 *datap,
+ OPJ_UINT32 orient,
+ OPJ_INT32 bpno,
+ OPJ_INT32 one,
+ OPJ_INT32 *nmsedec,
+ OPJ_UINT32 partial,
+ OPJ_UINT32 vsc)
+{
+ OPJ_INT32 v;
+ OPJ_UINT32 flag;
+
+ opj_mqc_t *mqc = t1->mqc; /* MQC component */
+
+ flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
+ if (partial) {
+ goto LABEL_PARTIAL;
+ }
+ if (!(*flagsp & (T1_SIG | T1_VISIT))) {
+ mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
+ v = int_abs(*datap) & one ? 1 : 0;
+ mqc_encode(mqc, v);
+ if (v) {
+LABEL_PARTIAL:
+ *nmsedec += t1_getnmsedec_sig(int_abs(*datap), bpno + T1_NMSEDEC_FRACBITS);
+ mqc_setcurctx(mqc, t1_getctxno_sc(flag));
+ v = *datap < 0 ? 1 : 0;
+ mqc_encode(mqc, v ^ t1_getspb(flag));
+ t1_updateflags(flagsp, v, t1->flags_stride);
+ }
+ }
+ *flagsp &= ~T1_VISIT;
+}
+
+static void t1_dec_clnpass_step(
+ opj_t1_t *t1,
+ flag_t *flagsp,
+ OPJ_INT32 *datap,
+ OPJ_UINT32 orient,
+ OPJ_INT32 oneplushalf,
+ OPJ_UINT32 partial,
+ OPJ_UINT32 vsc)
+{
+ OPJ_INT32 v;
+ OPJ_UINT32 flag;
+
+ opj_mqc_t *mqc = t1->mqc; /* MQC component */
+
+ flag = vsc ? ((*flagsp) & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) : (*flagsp);
+ if (partial) {
+ goto LABEL_PARTIAL;
+ }
+ if (!(flag & (T1_SIG | T1_VISIT))) {
+ mqc_setcurctx(mqc, t1_getctxno_zc(flag, orient));
+ if (mqc_decode(mqc)) {
+LABEL_PARTIAL:
+ mqc_setcurctx(mqc, t1_getctxno_sc(flag));
+ v = mqc_decode(mqc) ^ t1_getspb(flag);
+ *datap = v ? -oneplushalf : oneplushalf;
+ t1_updateflags(flagsp, v, t1->flags_stride);
+ }
+ }
+ *flagsp &= ~T1_VISIT;
+} /* VSC and BYPASS by Antonin */
+
+static void t1_enc_clnpass(
+ opj_t1_t *t1,
+ OPJ_INT32 bpno,
+ OPJ_UINT32 orient,
+ OPJ_INT32 *nmsedec,
+ OPJ_UINT32 cblksty)
+{
+ OPJ_UINT32 i, j, k;
+ OPJ_INT32 one;
+ OPJ_UINT32 agg, runlen, vsc;
+
+ opj_mqc_t *mqc = t1->mqc; /* MQC component */
+
+ *nmsedec = 0;
+ one = 1 << (bpno + T1_NMSEDEC_FRACBITS);
+ for (k = 0; k < t1->h; k += 4) {
+ for (i = 0; i < t1->w; ++i) {
+ if (k + 3 < t1->h) {
+ if (cblksty & J2K_CCP_CBLKSTY_VSC) {
+ agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+ || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+ || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+ || (MACRO_t1_flags(1 + k + 3,1 + i)
+ & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
+ } else {
+ agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+ || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+ || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+ || MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
+ }
+ } else {
+ agg = 0;
+ }
+ if (agg) {
+ for (runlen = 0; runlen < 4; ++runlen) {
+ if (int_abs(t1->data[((k + runlen)*t1->w) + i]) & one)
+ break;
+ }
+ mqc_setcurctx(mqc, T1_CTXNO_AGG);
+ mqc_encode(mqc, runlen != 4);
+ if (runlen == 4) {
+ continue;
+ }
+ mqc_setcurctx(mqc, T1_CTXNO_UNI);
+ mqc_encode(mqc, runlen >> 1);
+ mqc_encode(mqc, runlen & 1);
+ } else {
+ runlen = 0;
+ }
+ for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
+ vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
+ t1_enc_clnpass_step(
+ t1,
+ &t1->flags[((j+1) * t1->flags_stride) + i + 1],
+ &t1->data[(j * t1->w) + i],
+ orient,
+ bpno,
+ one,
+ nmsedec,
+ agg && (j == k + runlen),
+ vsc);
+ }
+ }
+ }
+}
+
+static void t1_dec_clnpass(
+ opj_t1_t *t1,
+ OPJ_INT32 bpno,
+ OPJ_UINT32 orient,
+ OPJ_UINT32 cblksty)
+{
+ OPJ_UINT32 i, j, k, one;
+ OPJ_INT32 half, oneplushalf;
+ OPJ_UINT32 agg, runlen, vsc;
+ OPJ_UINT32 segsym = cblksty & J2K_CCP_CBLKSTY_SEGSYM;
+
+ opj_mqc_t *mqc = t1->mqc; /* MQC component */
+
+ one = 1 << bpno;
+ half = one >> 1;
+ oneplushalf = one | half;
+ for (k = 0; k < t1->h; k += 4) {
+ for (i = 0; i < t1->w; ++i) {
+ if (k + 3 < t1->h) {
+ if (cblksty & J2K_CCP_CBLKSTY_VSC) {
+ agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+ || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+ || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+ || (MACRO_t1_flags(1 + k + 3,1 + i)
+ & (~(T1_SIG_S | T1_SIG_SE | T1_SIG_SW | T1_SGN_S))) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
+ } else {
+ agg = !(MACRO_t1_flags(1 + k,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+ || MACRO_t1_flags(1 + k + 1,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+ || MACRO_t1_flags(1 + k + 2,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH)
+ || MACRO_t1_flags(1 + k + 3,1 + i) & (T1_SIG | T1_VISIT | T1_SIG_OTH));
+ }
+ } else {
+ agg = 0;
+ }
+ if (agg) {
+ mqc_setcurctx(mqc, T1_CTXNO_AGG);
+ if (!mqc_decode(mqc)) {
+ continue;
+ }
+ mqc_setcurctx(mqc, T1_CTXNO_UNI);
+ runlen = mqc_decode(mqc);
+ runlen = (runlen << 1) | mqc_decode(mqc);
+ } else {
+ runlen = 0;
+ }
+ for (j = k + runlen; j < k + 4 && j < t1->h; ++j) {
+ vsc = ((cblksty & J2K_CCP_CBLKSTY_VSC) && (j == k + 3 || j == t1->h - 1)) ? 1 : 0;
+ t1_dec_clnpass_step(
+ t1,
+ &t1->flags[((j+1) * t1->flags_stride) + i + 1],
+ &t1->data[(j * t1->w) + i],
+ orient,
+ oneplushalf,
+ agg && (j == k + runlen),
+ vsc);
+ }
+ }
+ }
+ if (segsym) {
+ OPJ_UINT32 v = 0;
+ mqc_setcurctx(mqc, T1_CTXNO_UNI);
+ v = mqc_decode(mqc);
+ v = (v << 1) | mqc_decode(mqc);
+ v = (v << 1) | mqc_decode(mqc);
+ v = (v << 1) | mqc_decode(mqc);
+ /*
+ if (v!=0xa) {
+ opj_event_msg(t1->cinfo, EVT_WARNING, "Bad segmentation symbol %x\n", v);
+ }
+ */
+ }
+} /* VSC and BYPASS by Antonin */
+
+
+/** mod fixed_quality */
+static OPJ_FLOAT64 t1_getwmsedec(
+ OPJ_INT32 nmsedec,
+ OPJ_UINT32 compno,
+ OPJ_UINT32 level,
+ OPJ_UINT32 orient,
+ OPJ_INT32 bpno,
+ OPJ_UINT32 qmfbid,
+ OPJ_FLOAT64 stepsize,
+ OPJ_UINT32 numcomps,
+ const OPJ_FLOAT64 * mct_norms)
+{
+ OPJ_FLOAT64 w1 = 1, w2, wmsedec;
+ if
+ (mct_norms)
+ {
+ w1 = mct_norms[compno];
+ }
+ if (qmfbid == 1)
+ {
+ w2 = dwt_getnorm(level, orient);
+ } else { /* if (qmfbid == 0) */
+ w2 = dwt_getnorm_real(level, orient);
+ }
+ wmsedec = w1 * w2 * stepsize * (1 << bpno);
+ wmsedec *= wmsedec * nmsedec / 8192.0;
+ return wmsedec;
+}
+
+static bool allocate_buffers(
+ opj_t1_t *t1,
+ OPJ_UINT32 w,
+ OPJ_UINT32 h)
+{
+ OPJ_UINT32 datasize=w * h;
+ OPJ_UINT32 flagssize;
+
+ if(datasize > t1->datasize){
+ opj_aligned_free(t1->data);
+ t1->data = (OPJ_INT32*) opj_aligned_malloc(datasize * sizeof(OPJ_INT32));
+ if(!t1->data){
+ return false;
+ }
+ t1->datasize=datasize;
+ }
+ memset(t1->data,0,datasize * sizeof(OPJ_INT32));
+
+ t1->flags_stride=w+2;
+ flagssize=t1->flags_stride * (h+2);
+
+ if(flagssize > t1->flagssize){
+ opj_aligned_free(t1->flags);
+ t1->flags = (flag_t*) opj_aligned_malloc(flagssize * sizeof(flag_t));
+ if(!t1->flags){
+ return false;
+ }
+ t1->flagssize=flagssize;
+ }
+ memset(t1->flags,0,flagssize * sizeof(flag_t));
+
+ t1->w=w;
+ t1->h=h;
+
+ return true;
+}
+
+/** mod fixed_quality */
+static void t1_encode_cblk(
+ opj_t1_t *t1,
+ opj_tcd_cblk_enc_t* cblk,
+ OPJ_UINT32 orient,
+ OPJ_UINT32 compno,
+ OPJ_UINT32 level,
+ OPJ_UINT32 qmfbid,
+ OPJ_FLOAT64 stepsize,
+ OPJ_UINT32 cblksty,
+ OPJ_UINT32 numcomps,
+ opj_tcd_tile_t * tile,
+ const OPJ_FLOAT64 * mct_norms)
+{
+ OPJ_FLOAT64 cumwmsedec = 0.0;
+
+ opj_mqc_t *mqc = t1->mqc; /* MQC component */
+
+ OPJ_UINT32 passno;
+ OPJ_INT32 bpno;
+ OPJ_UINT32 passtype;
+ OPJ_INT32 nmsedec = 0;
+ OPJ_INT32 max;
+ OPJ_UINT32 i;
+ OPJ_BYTE type = T1_TYPE_MQ;
+ OPJ_FLOAT64 tempwmsedec;
+
+ max = 0;
+ for (i = 0; i < t1->w * t1->h; ++i) {
+ OPJ_INT32 tmp = abs(t1->data[i]);
+ max = int_max(max, tmp);
+ }
+
+ cblk->numbps = max ? (int_floorlog2(max) + 1) - T1_NMSEDEC_FRACBITS : 0;
+
+ bpno = cblk->numbps - 1;
+ passtype = 2;
+
+ mqc_resetstates(mqc);
+ mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
+ mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
+ mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
+ mqc_init_enc(mqc, cblk->data);
+
+ for (passno = 0; bpno >= 0; ++passno) {
+ opj_tcd_pass_t *pass = &cblk->passes[passno];
+ OPJ_UINT32 correction = 3;
+ type = ((bpno < ((OPJ_INT32) (cblk->numbps) - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
+
+ switch (passtype) {
+ case 0:
+ t1_enc_sigpass(t1, bpno, orient, &nmsedec, type, cblksty);
+ break;
+ case 1:
+ t1_enc_refpass(t1, bpno, &nmsedec, type, cblksty);
+ break;
+ case 2:
+ t1_enc_clnpass(t1, bpno, orient, &nmsedec, cblksty);
+ /* code switch SEGMARK (i.e. SEGSYM) */
+ if (cblksty & J2K_CCP_CBLKSTY_SEGSYM)
+ mqc_segmark_enc(mqc);
+ break;
+ }
+
+ /* fixed_quality */
+ tempwmsedec = t1_getwmsedec(nmsedec, compno, level, orient, bpno, qmfbid, stepsize, numcomps,mct_norms) ;
+ cumwmsedec += tempwmsedec;
+ tile->distotile += tempwmsedec;
+
+ /* Code switch "RESTART" (i.e. TERMALL) */
+ if ((cblksty & J2K_CCP_CBLKSTY_TERMALL) && !((passtype == 2) && (bpno - 1 < 0))) {
+ if (type == T1_TYPE_RAW) {
+ mqc_flush(mqc);
+ correction = 1;
+ /* correction = mqc_bypass_flush_enc(); */
+ } else { /* correction = mqc_restart_enc(); */
+ mqc_flush(mqc);
+ correction = 1;
+ }
+ pass->term = 1;
+ } else {
+ if (((bpno < ((OPJ_INT32) (cblk->numbps) - 4) && (passtype > 0))
+ || ((bpno == (cblk->numbps - 4)) && (passtype == 2))) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) {
+ if (type == T1_TYPE_RAW) {
+ mqc_flush(mqc);
+ correction = 1;
+ /* correction = mqc_bypass_flush_enc(); */
+ } else { /* correction = mqc_restart_enc(); */
+ mqc_flush(mqc);
+ correction = 1;
+ }
+ pass->term = 1;
+ } else {
+ pass->term = 0;
+ }
+ }
+
+ if (++passtype == 3) {
+ passtype = 0;
+ bpno--;
+ }
+
+ if (pass->term && bpno > 0) {
+ type = ((bpno < ((OPJ_INT32) (cblk->numbps) - 4)) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
+ if (type == T1_TYPE_RAW)
+ mqc_bypass_init_enc(mqc);
+ else
+ mqc_restart_init_enc(mqc);
+ }
+
+ pass->distortiondec = cumwmsedec;
+ pass->rate = mqc_numbytes(mqc) + correction; /* FIXME */
+
+ /* Code-switch "RESET" */
+ if (cblksty & J2K_CCP_CBLKSTY_RESET)
+ mqc_reset_enc(mqc);
+ }
+
+ /* Code switch "ERTERM" (i.e. PTERM) */
+ if (cblksty & J2K_CCP_CBLKSTY_PTERM)
+ mqc_erterm_enc(mqc);
+ else /* Default coding */ if (!(cblksty & J2K_CCP_CBLKSTY_LAZY))
+ mqc_flush(mqc);
+
+ cblk->totalpasses = passno;
+
+ for (passno = 0; passno<cblk->totalpasses; passno++) {
+ opj_tcd_pass_t *pass = &cblk->passes[passno];
+ if (pass->rate > mqc_numbytes(mqc))
+ pass->rate = mqc_numbytes(mqc);
+ /*Preventing generation of FF as last data byte of a pass*/
+ if((pass->rate>1) && (cblk->data[pass->rate - 1] == 0xFF)){
+ pass->rate--;
+ }
+ pass->len = pass->rate - (passno == 0 ? 0 : cblk->passes[passno - 1].rate);
+ }
+}
+
+static void t1_decode_cblk(
+ opj_t1_t *t1,
+ opj_tcd_cblk_dec_t* cblk,
+ OPJ_UINT32 orient,
+ OPJ_UINT32 roishift,
+ OPJ_UINT32 cblksty)
+{
+ opj_raw_t *raw = t1->raw; /* RAW component */
+ opj_mqc_t *mqc = t1->mqc; /* MQC component */
+
+ OPJ_INT32 bpno;
+ OPJ_UINT32 passtype;
+ OPJ_UINT32 segno, passno;
+ OPJ_BYTE type = T1_TYPE_MQ; /* BYPASS mode */
+
+ if(!allocate_buffers(
+ t1,
+ cblk->x1 - cblk->x0,
+ cblk->y1 - cblk->y0))
+ {
+ return;
+ }
+
+ bpno = roishift + cblk->numbps - 1;
+ passtype = 2;
+
+ mqc_resetstates(mqc);
+ mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
+ mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
+ mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
+
+ for (segno = 0; segno < cblk->real_num_segs; ++segno) {
+ opj_tcd_seg_t *seg = &cblk->segs[segno];
+
+ /* BYPASS mode */
+ type = ((bpno <= ((OPJ_INT32) (cblk->numbps) - 1) - 4) && (passtype < 2) && (cblksty & J2K_CCP_CBLKSTY_LAZY)) ? T1_TYPE_RAW : T1_TYPE_MQ;
+ /* FIXME: slviewer gets here with a null pointer. Why? Partially downloaded and/or corrupt textures? */
+ if(seg->data == 00){
+ continue;
+ }
+ if (type == T1_TYPE_RAW) {
+ raw_init_dec(raw, (*seg->data) + seg->dataindex, seg->len);
+ } else {
+ mqc_init_dec(mqc, (*seg->data) + seg->dataindex, seg->len);
+ }
+
+ for (passno = 0; passno < seg->real_num_passes; ++passno) {
+ switch (passtype) {
+ case 0:
+ t1_dec_sigpass(t1, bpno+1, orient, type, cblksty);
+ break;
+ case 1:
+ t1_dec_refpass(t1, bpno+1, type, cblksty);
+ break;
+ case 2:
+ t1_dec_clnpass(t1, bpno+1, orient, cblksty);
+ break;
+ }
+
+ if ((cblksty & J2K_CCP_CBLKSTY_RESET) && type == T1_TYPE_MQ) {
+ mqc_resetstates(mqc);
+ mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
+ mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
+ mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
+ }
+ if (++passtype == 3) {
+ passtype = 0;
+ bpno--;
+ }
+ }
+ }
+}
+
+/* ----------------------------------------------------------------------- */
+/**
+ * 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()
+{
+ opj_t1_t *l_t1 = 00;
+
+ l_t1 = (opj_t1_t*) opj_malloc(sizeof(opj_t1_t));
+ if
+ (!l_t1)
+ {
+ return 00;
+ }
+ memset(l_t1,0,sizeof(opj_t1_t));
+
+ /* create MQC and RAW handles */
+ l_t1->mqc = mqc_create();
+ if
+ (! l_t1->mqc)
+ {
+ t1_destroy(l_t1);
+ return 00;
+ }
+ l_t1->raw = raw_create();
+ if
+ (! l_t1->raw)
+ {
+ t1_destroy(l_t1);
+ return 00;
+ }
+ return l_t1;
+}
+
+/**
+ * Destroys a previously created T1 handle
+ *
+ * @param p_t1 Tier 1 handle to destroy
+*/
+void t1_destroy(opj_t1_t *p_t1)
+{
+ if
+ (! p_t1)
+ {
+ return;
+ }
+
+ /* destroy MQC and RAW handles */
+ mqc_destroy(p_t1->mqc);
+ p_t1->mqc = 00;
+ raw_destroy(p_t1->raw);
+ p_t1->raw = 00;
+ if
+ (p_t1->data)
+ {
+ opj_aligned_free(p_t1->data);
+ p_t1->data = 00;
+ }
+ if
+ (p_t1->flags)
+ {
+ opj_aligned_free(p_t1->flags);
+ p_t1->flags = 00;
+ }
+ opj_free(p_t1);
+}
+
+bool t1_encode_cblks(
+ opj_t1_t *t1,
+ opj_tcd_tile_t *tile,
+ opj_tcp_t *tcp,
+ const OPJ_FLOAT64 * mct_norms)
+{
+ OPJ_UINT32 compno, resno, bandno, precno, cblkno;
+
+ tile->distotile = 0; /* fixed_quality */
+
+ for (compno = 0; compno < tile->numcomps; ++compno) {
+ opj_tcd_tilecomp_t* tilec = &tile->comps[compno];
+ opj_tccp_t* tccp = &tcp->tccps[compno];
+ OPJ_UINT32 tile_w = tilec->x1 - tilec->x0;
+
+ for (resno = 0; resno < tilec->numresolutions; ++resno) {
+ opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+
+ for (bandno = 0; bandno < res->numbands; ++bandno) {
+ opj_tcd_band_t* restrict band = &res->bands[bandno];
+
+ for (precno = 0; precno < res->pw * res->ph; ++precno) {
+ opj_tcd_precinct_t *prc = &band->precincts[precno];
+
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
+ opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
+ OPJ_INT32 * restrict datap;
+ OPJ_INT32* restrict tiledp;
+ OPJ_UINT32 cblk_w;
+ OPJ_UINT32 cblk_h;
+ OPJ_UINT32 i, j;
+
+ OPJ_INT32 x = cblk->x0 - band->x0;
+ OPJ_INT32 y = cblk->y0 - band->y0;
+ if (band->bandno & 1) {
+ opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
+ x += pres->x1 - pres->x0;
+ }
+ if (band->bandno & 2) {
+ opj_tcd_resolution_t *pres = &tilec->resolutions[resno - 1];
+ y += pres->y1 - pres->y0;
+ }
+
+ if(!allocate_buffers(
+ t1,
+ cblk->x1 - cblk->x0,
+ cblk->y1 - cblk->y0))
+ {
+ return false;
+ }
+
+ datap=t1->data;
+ cblk_w = t1->w;
+ cblk_h = t1->h;
+
+ tiledp=&tilec->data[(y * tile_w) + x];
+ if (tccp->qmfbid == 1) {
+ for (j = 0; j < cblk_h; ++j) {
+ for (i = 0; i < cblk_w; ++i) {
+ OPJ_INT32 tmp = tiledp[(j * tile_w) + i];
+ datap[(j * cblk_w) + i] = tmp << T1_NMSEDEC_FRACBITS;
+ }
+ }
+ } else { /* if (tccp->qmfbid == 0) */
+ for (j = 0; j < cblk_h; ++j) {
+ for (i = 0; i < cblk_w; ++i) {
+ OPJ_INT32 tmp = tiledp[(j * tile_w) + i];
+ datap[(j * cblk_w) + i] =
+ fix_mul(
+ tmp,
+ 8192 * 8192 / ((OPJ_INT32) floor(band->stepsize * 8192))) >> (11 - T1_NMSEDEC_FRACBITS);
+ }
+ }
+ }
+
+ t1_encode_cblk(
+ t1,
+ cblk,
+ band->bandno,
+ compno,
+ tilec->numresolutions - 1 - resno,
+ tccp->qmfbid,
+ band->stepsize,
+ tccp->cblksty,
+ tile->numcomps,
+ tile,
+ mct_norms);
+
+ } /* cblkno */
+ } /* precno */
+ } /* bandno */
+ } /* resno */
+ } /* compno */
+ return true;
+}
+
+void t1_decode_cblks(
+ opj_t1_t* t1,
+ opj_tcd_tilecomp_t* tilec,
+ opj_tccp_t* tccp)
+{
+ OPJ_UINT32 resno, bandno, precno, cblkno;
+
+ OPJ_UINT32 tile_w = tilec->x1 - tilec->x0;
+
+ for (resno = 0; resno < tilec->minimum_num_resolutions; ++resno) {
+ opj_tcd_resolution_t* res = &tilec->resolutions[resno];
+
+ for (bandno = 0; bandno < res->numbands; ++bandno) {
+ opj_tcd_band_t* restrict band = &res->bands[bandno];
+
+ for (precno = 0; precno < res->pw * res->ph; ++precno) {
+ opj_tcd_precinct_t* precinct = &band->precincts[precno];
+
+ for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
+ opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];
+ OPJ_INT32* restrict datap;
+ void* restrict tiledp;
+ OPJ_UINT32 cblk_w, cblk_h;
+ OPJ_INT32 x, y;
+ OPJ_UINT32 i, j;
+
+ t1_decode_cblk(
+ t1,
+ cblk,
+ band->bandno,
+ tccp->roishift,
+ tccp->cblksty);
+
+ x = cblk->x0 - band->x0;
+ y = cblk->y0 - band->y0;
+ if (band->bandno & 1) {
+ opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
+ x += pres->x1 - pres->x0;
+ }
+ if (band->bandno & 2) {
+ opj_tcd_resolution_t* pres = &tilec->resolutions[resno - 1];
+ y += pres->y1 - pres->y0;
+ }
+
+ datap=t1->data;
+ cblk_w = t1->w;
+ cblk_h = t1->h;
+
+ if (tccp->roishift) {
+ OPJ_INT32 thresh = 1 << tccp->roishift;
+ for (j = 0; j < cblk_h; ++j) {
+ for (i = 0; i < cblk_w; ++i) {
+ OPJ_INT32 val = datap[(j * cblk_w) + i];
+ OPJ_INT32 mag = abs(val);
+ if (mag >= thresh) {
+ mag >>= tccp->roishift;
+ datap[(j * cblk_w) + i] = val < 0 ? -mag : mag;
+ }
+ }
+ }
+ }
+
+ tiledp=(void*)&tilec->data[(y * tile_w) + x];
+ if (tccp->qmfbid == 1) {
+ for (j = 0; j < cblk_h; ++j) {
+ for (i = 0; i < cblk_w; ++i) {
+ OPJ_INT32 tmp = datap[(j * cblk_w) + i];
+ ((OPJ_INT32*)tiledp)[(j * tile_w) + i] = tmp >> 1;
+ }
+ }
+ } else { /* if (tccp->qmfbid == 0) */
+ for (j = 0; j < cblk_h; ++j) {
+ for (i = 0; i < cblk_w; ++i) {
+ float tmp = datap[(j * cblk_w) + i] * band->stepsize;
+ ((float*)tiledp)[(j * tile_w) + i] = tmp;
+ }
+ }
+ }
+ //opj_free(cblk->segs);
+ //cblk->segs = 00;
+ } /* cblkno */
+ } /* precno */
+ } /* bandno */
+ } /* resno */
+}
+
+
diff --git a/v2/libopenjpeg/t1.h b/v2/libopenjpeg/t1.h new file mode 100755 index 00000000..909c126c --- /dev/null +++ b/v2/libopenjpeg/t1.h @@ -0,0 +1,156 @@ +/*
+ * 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) 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 __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
+in T1.C are used by some function in TCD.C.
+*/
+#include "openjpeg.h"
+/** @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 */
+#define T1_SIG_SW 0x0004 /**< Context orientation : South-West direction */
+#define T1_SIG_NW 0x0008 /**< Context orientation : North-West direction */
+#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 {
+ /** MQC component */
+ struct opj_mqc *mqc;
+ /** RAW component */
+ struct opj_raw *raw;
+
+ OPJ_INT32 *data;
+ flag_t *flags;
+ OPJ_UINT32 w;
+ OPJ_UINT32 h;
+ 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();
+
+/**
+ * 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 */
diff --git a/v2/libopenjpeg/t1_generate_luts.c b/v2/libopenjpeg/t1_generate_luts.c new file mode 100755 index 00000000..1925b951 --- /dev/null +++ b/v2/libopenjpeg/t1_generate_luts.c @@ -0,0 +1,275 @@ +/* + * 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) 2007, Callum Lerwick <seg@haxxed.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "opj_includes.h" +#include <math.h> + +static int t1_init_ctxno_zc(int f, int orient) { + int h, v, d, n, t, hv; + n = 0; + h = ((f & T1_SIG_W) != 0) + ((f & T1_SIG_E) != 0); + v = ((f & T1_SIG_N) != 0) + ((f & T1_SIG_S) != 0); + d = ((f & T1_SIG_NW) != 0) + ((f & T1_SIG_NE) != 0) + ((f & T1_SIG_SE) != 0) + ((f & T1_SIG_SW) != 0); + + switch (orient) { + case 2: + t = h; + h = v; + v = t; + case 0: + case 1: + if (!h) { + if (!v) { + if (!d) + n = 0; + else if (d == 1) + n = 1; + else + n = 2; + } else if (v == 1) { + n = 3; + } else { + n = 4; + } + } else if (h == 1) { + if (!v) { + if (!d) + n = 5; + else + n = 6; + } else { + n = 7; + } + } else + n = 8; + break; + case 3: + hv = h + v; + if (!d) { + if (!hv) { + n = 0; + } else if (hv == 1) { + n = 1; + } else { + n = 2; + } + } else if (d == 1) { + if (!hv) { + n = 3; + } else if (hv == 1) { + n = 4; + } else { + n = 5; + } + } else if (d == 2) { + if (!hv) { + n = 6; + } else { + n = 7; + } + } else { + n = 8; + } + break; + } + + return (T1_CTXNO_ZC + n); +} + +static int t1_init_ctxno_sc(int f) { + int hc, vc, n; + n = 0; + + hc = int_min(((f & (T1_SIG_E | T1_SGN_E)) == + T1_SIG_E) + ((f & (T1_SIG_W | T1_SGN_W)) == T1_SIG_W), + 1) - int_min(((f & (T1_SIG_E | T1_SGN_E)) == + (T1_SIG_E | T1_SGN_E)) + + ((f & (T1_SIG_W | T1_SGN_W)) == + (T1_SIG_W | T1_SGN_W)), 1); + + vc = int_min(((f & (T1_SIG_N | T1_SGN_N)) == + T1_SIG_N) + ((f & (T1_SIG_S | T1_SGN_S)) == T1_SIG_S), + 1) - int_min(((f & (T1_SIG_N | T1_SGN_N)) == + (T1_SIG_N | T1_SGN_N)) + + ((f & (T1_SIG_S | T1_SGN_S)) == + (T1_SIG_S | T1_SGN_S)), 1); + + if (hc < 0) { + hc = -hc; + vc = -vc; + } + if (!hc) { + if (vc == -1) + n = 1; + else if (!vc) + n = 0; + else + n = 1; + } else if (hc == 1) { + if (vc == -1) + n = 2; + else if (!vc) + n = 3; + else + n = 4; + } + + return (T1_CTXNO_SC + n); +} + +static int t1_init_spb(int f) { + int hc, vc, n; + + hc = int_min(((f & (T1_SIG_E | T1_SGN_E)) == + T1_SIG_E) + ((f & (T1_SIG_W | T1_SGN_W)) == T1_SIG_W), + 1) - int_min(((f & (T1_SIG_E | T1_SGN_E)) == + (T1_SIG_E | T1_SGN_E)) + + ((f & (T1_SIG_W | T1_SGN_W)) == + (T1_SIG_W | T1_SGN_W)), 1); + + vc = int_min(((f & (T1_SIG_N | T1_SGN_N)) == + T1_SIG_N) + ((f & (T1_SIG_S | T1_SGN_S)) == T1_SIG_S), + 1) - int_min(((f & (T1_SIG_N | T1_SGN_N)) == + (T1_SIG_N | T1_SGN_N)) + + ((f & (T1_SIG_S | T1_SGN_S)) == + (T1_SIG_S | T1_SGN_S)), 1); + + if (!hc && !vc) + n = 0; + else + n = (!(hc > 0 || (!hc && vc > 0))); + + return n; +} + +void dump_array16(int array[],int size){ + int i; + --size; + for (i = 0; i < size; ++i) { + printf("0x%04x, ", array[i]); + if(!((i+1)&0x7)) + printf("\n "); + } + printf("0x%04x\n};\n\n", array[size]); +} + +int main(){ + int i, j; + double u, v, t; + + int lut_ctxno_zc[1024]; + int lut_nmsedec_sig[1 << T1_NMSEDEC_BITS]; + int lut_nmsedec_sig0[1 << T1_NMSEDEC_BITS]; + int lut_nmsedec_ref[1 << T1_NMSEDEC_BITS]; + int lut_nmsedec_ref0[1 << T1_NMSEDEC_BITS]; + + printf("/* This file was automatically generated by t1_generate_luts.c */\n\n"); + + // lut_ctxno_zc + for (j = 0; j < 4; ++j) { + for (i = 0; i < 256; ++i) { + int orient = j; + if (orient == 2) { + orient = 1; + } else if (orient == 1) { + orient = 2; + } + lut_ctxno_zc[(orient << 8) | i] = t1_init_ctxno_zc(i, j); + } + } + + printf("static char lut_ctxno_zc[1024] = {\n "); + for (i = 0; i < 1023; ++i) { + printf("%i, ", lut_ctxno_zc[i]); + if(!((i+1)&0x1f)) + printf("\n "); + } + printf("%i\n};\n\n", lut_ctxno_zc[1023]); + + // lut_ctxno_sc + printf("static char lut_ctxno_sc[256] = {\n "); + for (i = 0; i < 255; ++i) { + printf("0x%x, ", t1_init_ctxno_sc(i << 4)); + if(!((i+1)&0xf)) + printf("\n "); + } + printf("0x%x\n};\n\n", t1_init_ctxno_sc(255 << 4)); + + // lut_spb + printf("static char lut_spb[256] = {\n "); + for (i = 0; i < 255; ++i) { + printf("%i, ", t1_init_spb(i << 4)); + if(!((i+1)&0x1f)) + printf("\n "); + } + printf("%i\n};\n\n", t1_init_spb(255 << 4)); + + /* FIXME FIXME FIXME */ + /* fprintf(stdout,"nmsedec luts:\n"); */ + for (i = 0; i < (1 << T1_NMSEDEC_BITS); ++i) { + t = i / pow(2, T1_NMSEDEC_FRACBITS); + u = t; + v = t - 1.5; + lut_nmsedec_sig[i] = + int_max(0, + (int) (floor((u * u - v * v) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0)); + lut_nmsedec_sig0[i] = + int_max(0, + (int) (floor((u * u) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0)); + u = t - 1.0; + if (i & (1 << (T1_NMSEDEC_BITS - 1))) { + v = t - 1.5; + } else { + v = t - 0.5; + } + lut_nmsedec_ref[i] = + int_max(0, + (int) (floor((u * u - v * v) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0)); + lut_nmsedec_ref0[i] = + int_max(0, + (int) (floor((u * u) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0)); + } + + printf("static short lut_nmsedec_sig[1 << T1_NMSEDEC_BITS] = {\n "); + dump_array16(&lut_nmsedec_sig, 1 << T1_NMSEDEC_BITS); + + printf("static short lut_nmsedec_sig0[1 << T1_NMSEDEC_BITS] = {\n "); + dump_array16(&lut_nmsedec_sig0, 1 << T1_NMSEDEC_BITS); + + printf("static short lut_nmsedec_ref[1 << T1_NMSEDEC_BITS] = {\n "); + dump_array16(&lut_nmsedec_ref, 1 << T1_NMSEDEC_BITS); + + printf("static short lut_nmsedec_ref0[1 << T1_NMSEDEC_BITS] = {\n "); + dump_array16(&lut_nmsedec_ref0, 1 << T1_NMSEDEC_BITS); + + return 0; +} diff --git a/v2/libopenjpeg/t1_luts.h b/v2/libopenjpeg/t1_luts.h new file mode 100755 index 00000000..e5e33f66 --- /dev/null +++ b/v2/libopenjpeg/t1_luts.h @@ -0,0 +1,143 @@ +/* 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 +}; + diff --git a/v2/libopenjpeg/t2.c b/v2/libopenjpeg/t2.c new file mode 100755 index 00000000..d9baaaef --- /dev/null +++ b/v2/libopenjpeg/t2.c @@ -0,0 +1,1290 @@ +/*
+ * 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) 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 "openjpeg.h"
+#include "opj_includes.h"
+#include "t2.h"
+#include "bio.h"
+#include "tcd.h"
+#include "pi.h"
+#include "event.h"
+#include "j2k.h"
+#include "tgt.h"
+#include "int.h"
+#include "opj_malloc.h"
+#include "pi.h"
+
+
+/** @defgroup T2 T2 - Implementation of a tier-2 coding */
+/*@{*/
+
+/** @name Local static functions */
+/*@{*/
+
+static void t2_putcommacode(opj_bio_t *bio, OPJ_UINT32 n);
+static OPJ_UINT32 t2_getcommacode(opj_bio_t *bio);
+/**
+Variable length code for signalling delta Zil (truncation point)
+@param bio Bit Input/Output component
+@param n delta Zil
+*/
+static void t2_putnumpasses(opj_bio_t *bio, OPJ_UINT32 n);
+static OPJ_UINT32 t2_getnumpasses(opj_bio_t *bio);
+/**
+Encode a packet of a tile to a destination buffer
+@param tile Tile for which to write the packets
+@param tcp Tile coding parameters
+@param pi Packet identity
+@param dest Destination buffer
+@param len Length of the destination buffer
+@param cstr_info Codestream information structure
+@param tileno Number of the tile encoded
+@return
+*/
+static bool t2_encode_packet(
+ OPJ_UINT32 tileno,
+ opj_tcd_tile_t *tile,
+ opj_tcp_t *tcp,
+ opj_pi_iterator_t *pi,
+ OPJ_BYTE *dest,
+ OPJ_UINT32 * p_data_written,
+ OPJ_UINT32 len,
+ opj_codestream_info_t *cstr_info);
+/**
+@param seg
+@param cblksty
+@param first
+*/
+static bool t2_init_seg(opj_tcd_cblk_dec_t* cblk, OPJ_UINT32 index, OPJ_UINT32 cblksty, OPJ_UINT32 first);
+/**
+Decode a packet of a tile from a source buffer
+@param t2 T2 handle
+@param src Source buffer
+@param len Length of the source buffer
+@param tile Tile for which to write the packets
+@param tcp Tile coding parameters
+@param pi Packet identity
+@return
+*/
+static bool t2_decode_packet(
+ opj_t2_t* p_t2,
+ opj_tcd_tile_t *p_tile,
+ opj_tcp_t *p_tcp,
+ opj_pi_iterator_t *p_pi,
+ OPJ_BYTE *p_src,
+ OPJ_UINT32 * p_data_read,
+ OPJ_UINT32 p_max_length,
+ opj_packet_info_t *p_pack_info);
+
+/*@}*/
+
+/*@}*/
+
+/* ----------------------------------------------------------------------- */
+
+/* #define RESTART 0x04 */
+
+static void t2_putcommacode(opj_bio_t *bio, OPJ_UINT32 n) {
+ while
+ (--n != -1)
+ {
+ bio_write(bio, 1, 1);
+ }
+ bio_write(bio, 0, 1);
+}
+
+static OPJ_UINT32 t2_getcommacode(opj_bio_t *bio) {
+ OPJ_UINT32 n = 0;
+ while
+ (bio_read(bio, 1))
+ {
+ ++n;
+ }
+ return n;
+}
+
+static void t2_putnumpasses(opj_bio_t *bio, OPJ_UINT32 n) {
+ if (n == 1) {
+ bio_write(bio, 0, 1);
+ } else if (n == 2) {
+ bio_write(bio, 2, 2);
+ } else if (n <= 5) {
+ bio_write(bio, 0xc | (n - 3), 4);
+ } else if (n <= 36) {
+ bio_write(bio, 0x1e0 | (n - 6), 9);
+ } else if (n <= 164) {
+ bio_write(bio, 0xff80 | (n - 37), 16);
+ }
+}
+
+static OPJ_UINT32 t2_getnumpasses(opj_bio_t *bio) {
+ OPJ_UINT32 n;
+ if (!bio_read(bio, 1))
+ return 1;
+ if (!bio_read(bio, 1))
+ return 2;
+ if ((n = bio_read(bio, 2)) != 3)
+ return (3 + n);
+ if ((n = bio_read(bio, 5)) != 31)
+ return (6 + n);
+ return (37 + bio_read(bio, 7));
+}
+
+static bool t2_encode_packet(
+ OPJ_UINT32 tileno,
+ opj_tcd_tile_t * tile,
+ opj_tcp_t * tcp,
+ opj_pi_iterator_t *pi,
+ OPJ_BYTE *dest,
+ OPJ_UINT32 * p_data_written,
+ OPJ_UINT32 length,
+ opj_codestream_info_t *cstr_info)
+{
+ OPJ_UINT32 bandno, cblkno;
+ OPJ_BYTE *c = dest;
+ OPJ_UINT32 l_nb_bytes;
+ OPJ_UINT32 compno = pi->compno; /* component value */
+ OPJ_UINT32 resno = pi->resno; /* resolution level value */
+ OPJ_UINT32 precno = pi->precno; /* precinct value */
+ OPJ_UINT32 layno = pi->layno; /* quality layer value */
+ OPJ_UINT32 l_nb_blocks;
+ opj_tcd_band_t *band = 00;
+ opj_tcd_cblk_enc_t* cblk = 00;
+ opj_tcd_pass_t *pass = 00;
+
+ opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
+ opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+
+ opj_bio_t *bio = 00; /* BIO component */
+
+ /* <SOP 0xff91> */
+ if (tcp->csty & J2K_CP_CSTY_SOP) {
+ c[0] = 255;
+ c[1] = 145;
+ c[2] = 0;
+ c[3] = 4;
+ c[4] = (tile->packno % 65536) / 256;
+ c[5] = (tile->packno % 65536) % 256;
+ c += 6;
+ length -= 6;
+ }
+ /* </SOP> */
+
+ if (!layno) {
+ band = res->bands;
+ for
+ (bandno = 0; bandno < res->numbands; ++bandno)
+ {
+ opj_tcd_precinct_t *prc = &band->precincts[precno];
+ tgt_reset(prc->incltree);
+ tgt_reset(prc->imsbtree);
+ l_nb_blocks = prc->cw * prc->ch;
+ for
+ (cblkno = 0; cblkno < l_nb_blocks; ++cblkno)
+ {
+ opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
+ cblk->numpasses = 0;
+ tgt_setvalue(prc->imsbtree, cblkno, band->numbps - cblk->numbps);
+ }
+ ++band;
+ }
+ }
+
+ bio = bio_create();
+ bio_init_enc(bio, c, length);
+ bio_write(bio, 1, 1); /* Empty header bit */
+
+ /* Writing Packet header */
+ band = res->bands;
+ for
+ (bandno = 0; bandno < res->numbands; ++bandno)
+ {
+ opj_tcd_precinct_t *prc = &band->precincts[precno];
+ l_nb_blocks = prc->cw * prc->ch;
+ cblk = prc->cblks.enc;
+ for (cblkno = 0; cblkno < l_nb_blocks; ++cblkno)
+ {
+ opj_tcd_layer_t *layer = &cblk->layers[layno];
+ if
+ (!cblk->numpasses && layer->numpasses)
+ {
+ tgt_setvalue(prc->incltree, cblkno, layno);
+ }
+ ++cblk;
+ }
+ cblk = prc->cblks.enc;
+ for
+ (cblkno = 0; cblkno < l_nb_blocks; cblkno++)
+ {
+ opj_tcd_layer_t *layer = &cblk->layers[layno];
+ OPJ_UINT32 increment = 0;
+ OPJ_UINT32 nump = 0;
+ OPJ_UINT32 len = 0, passno;
+ OPJ_UINT32 l_nb_passes;
+ /* cblk inclusion bits */
+ if (!cblk->numpasses) {
+ tgt_encode(bio, prc->incltree, cblkno, layno + 1);
+ } else {
+ bio_write(bio, layer->numpasses != 0, 1);
+ }
+ /* if cblk not included, go to the next cblk */
+ if
+ (!layer->numpasses)
+ {
+ ++cblk;
+ continue;
+ }
+ /* if first instance of cblk --> zero bit-planes information */
+ if
+ (!cblk->numpasses)
+ {
+ cblk->numlenbits = 3;
+ tgt_encode(bio, prc->imsbtree, cblkno, 999);
+ }
+ /* number of coding passes included */
+ t2_putnumpasses(bio, layer->numpasses);
+ l_nb_passes = cblk->numpasses + layer->numpasses;
+ pass = cblk->passes + cblk->numpasses;
+ /* computation of the increase of the length indicator and insertion in the header */
+ for
+ (passno = cblk->numpasses; passno < l_nb_passes; ++passno)
+ {
+ ++nump;
+ len += pass->len;
+ if
+ (pass->term || passno == (cblk->numpasses + layer->numpasses) - 1)
+ {
+ increment = int_max(increment, int_floorlog2(len) + 1 - (cblk->numlenbits + int_floorlog2(nump)));
+ len = 0;
+ nump = 0;
+ }
+ ++pass;
+ }
+ t2_putcommacode(bio, increment);
+
+ /* computation of the new Length indicator */
+ cblk->numlenbits += increment;
+
+ pass = cblk->passes + cblk->numpasses;
+ /* insertion of the codeword segment length */
+ for
+ (passno = cblk->numpasses; passno < l_nb_passes; ++passno)
+ {
+ nump++;
+ len += pass->len;
+ if
+ (pass->term || passno == (cblk->numpasses + layer->numpasses) - 1)
+ {
+ bio_write(bio, len, cblk->numlenbits + int_floorlog2(nump));
+ len = 0;
+ nump = 0;
+ }
+ ++pass;
+ }
+ ++cblk;
+ }
+ ++band;
+ }
+
+ if
+ (bio_flush(bio))
+ {
+ bio_destroy(bio);
+ return false; /* modified to eliminate longjmp !! */
+ }
+ l_nb_bytes = bio_numbytes(bio);
+ c += l_nb_bytes;
+ length -= l_nb_bytes;
+ bio_destroy(bio);
+
+ /* <EPH 0xff92> */
+ if (tcp->csty & J2K_CP_CSTY_EPH) {
+ c[0] = 255;
+ c[1] = 146;
+ c += 2;
+ length -= 2;
+ }
+ /* </EPH> */
+
+ /* << INDEX */
+ // End of packet header position. Currently only represents the distance to start of packet
+ // Will be updated later by incrementing with packet start value
+ if(cstr_info && cstr_info->index_write) {
+ opj_packet_info_t *info_PK = &cstr_info->tile[tileno].packet[cstr_info->packno];
+ info_PK->end_ph_pos = (OPJ_INT32)(c - dest);
+ }
+ /* INDEX >> */
+
+ /* Writing the packet body */
+ band = res->bands;
+ for
+ (bandno = 0; bandno < res->numbands; bandno++)
+ {
+ opj_tcd_precinct_t *prc = &band->precincts[precno];
+ l_nb_blocks = prc->cw * prc->ch;
+ cblk = prc->cblks.enc;
+ for
+ (cblkno = 0; cblkno < l_nb_blocks; ++cblkno)
+ {
+ opj_tcd_layer_t *layer = &cblk->layers[layno];
+ if
+ (!layer->numpasses)
+ {
+ ++cblk;
+ continue;
+ }
+ if
+ (layer->len > length)
+ {
+ return false;
+ }
+ memcpy(c, layer->data, layer->len);
+ cblk->numpasses += layer->numpasses;
+ c += layer->len;
+ length -= layer->len;
+ /* << INDEX */
+ if(cstr_info && cstr_info->index_write) {
+ opj_packet_info_t *info_PK = &cstr_info->tile[tileno].packet[cstr_info->packno];
+ info_PK->disto += layer->disto;
+ if (cstr_info->D_max < info_PK->disto) {
+ cstr_info->D_max = info_PK->disto;
+ }
+ }
+ ++cblk;
+ /* INDEX >> */
+ }
+ ++band;
+ }
+ * p_data_written += (c - dest);
+ return true;
+}
+
+static bool t2_init_seg(opj_tcd_cblk_dec_t* cblk, OPJ_UINT32 index, OPJ_UINT32 cblksty, OPJ_UINT32 first)
+{
+ opj_tcd_seg_t* seg = 00;
+ OPJ_UINT32 l_nb_segs = index + 1;
+
+ if
+ (l_nb_segs > cblk->m_current_max_segs)
+ {
+ cblk->m_current_max_segs += J2K_DEFAULT_NB_SEGS;
+ cblk->segs = (opj_tcd_seg_t*) opj_realloc(cblk->segs, cblk->m_current_max_segs * sizeof(opj_tcd_seg_t));
+ if
+ (! cblk->segs)
+ {
+ return false;
+ }
+ }
+ seg = &cblk->segs[index];
+ memset(seg,0,sizeof(opj_tcd_seg_t));
+
+ if (cblksty & J2K_CCP_CBLKSTY_TERMALL) {
+ seg->maxpasses = 1;
+ }
+ else if (cblksty & J2K_CCP_CBLKSTY_LAZY) {
+ if (first) {
+ seg->maxpasses = 10;
+ } else {
+ seg->maxpasses = (((seg - 1)->maxpasses == 1) || ((seg - 1)->maxpasses == 10)) ? 2 : 1;
+ }
+ } else {
+ seg->maxpasses = 109;
+ }
+ return true;
+}
+
+static bool t2_read_packet_header(
+ opj_t2_t* p_t2,
+ opj_tcd_tile_t *p_tile,
+ opj_tcp_t *p_tcp,
+ opj_pi_iterator_t *p_pi,
+ bool * p_is_data_present,
+ OPJ_BYTE *p_src_data,
+ OPJ_UINT32 * p_data_read,
+ OPJ_UINT32 p_max_length,
+ opj_packet_info_t *p_pack_info)
+{
+ /* loop */
+ OPJ_UINT32 bandno, cblkno;
+ OPJ_UINT32 l_nb_code_blocks;
+ OPJ_UINT32 l_remaining_length;
+ OPJ_UINT32 l_header_length;
+ OPJ_UINT32 * l_modified_length_ptr = 00;
+ OPJ_BYTE *l_current_data = p_src_data;
+ opj_cp_t *l_cp = p_t2->cp;
+ opj_bio_t *l_bio = 00; /* BIO component */
+ opj_tcd_band_t *l_band = 00;
+ opj_tcd_cblk_dec_t* l_cblk = 00;
+ opj_tcd_resolution_t* l_res = &p_tile->comps[p_pi->compno].resolutions[p_pi->resno];
+
+ OPJ_BYTE *l_header_data = 00;
+ OPJ_BYTE **l_header_data_start = 00;
+
+ OPJ_UINT32 l_present;
+
+ if
+ (p_pi->layno == 0)
+ {
+ l_band = l_res->bands;
+ /* reset tagtrees */
+ for
+ (bandno = 0; bandno < l_res->numbands; ++bandno)
+ {
+ opj_tcd_precinct_t *l_prc = &l_band->precincts[p_pi->precno];
+
+ if (
+ ! ((l_band->x1-l_band->x0 == 0)||(l_band->y1-l_band->y0 == 0)))
+ {
+ tgt_reset(l_prc->incltree);
+ tgt_reset(l_prc->imsbtree);
+ l_cblk = l_prc->cblks.dec;
+ l_nb_code_blocks = l_prc->cw * l_prc->ch;
+ for
+ (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno)
+ {
+ l_cblk->numsegs = 0;
+ l_cblk->real_num_segs = 0;
+ ++l_cblk;
+ }
+ }
+ ++l_band;
+ }
+ }
+
+ /* SOP markers */
+
+ if (p_tcp->csty & J2K_CP_CSTY_SOP) {
+ if ((*l_current_data) != 0xff || (*(l_current_data + 1) != 0x91)) {
+ // TODO opj_event_msg(t2->cinfo->event_mgr, EVT_WARNING, "Expected SOP marker\n");
+ } else {
+ l_current_data += 6;
+ }
+
+ /** TODO : check the Nsop value */
+ }
+
+ /*
+ When the marker PPT/PPM is used the packet header are store in PPT/PPM marker
+ This part deal with this caracteristic
+ step 1: Read packet header in the saved structure
+ step 2: Return to codestream for decoding
+ */
+
+ l_bio = bio_create();
+ if
+ (! l_bio)
+ {
+ return false;
+ }
+
+ if
+ (l_cp->ppm == 1)
+ { /* PPM */
+ l_header_data_start = &l_cp->ppm_data;
+ l_header_data = *l_header_data_start;
+ l_modified_length_ptr = &(l_cp->ppm_len);
+
+ }
+ else if
+ (p_tcp->ppt == 1)
+ { /* PPT */
+ l_header_data_start = &(p_tcp->ppt_data);
+ l_header_data = *l_header_data_start;
+ l_modified_length_ptr = &(p_tcp->ppt_len);
+ }
+ else
+ { /* Normal Case */
+ l_header_data_start = &(l_current_data);
+ l_header_data = *l_header_data_start;
+ l_remaining_length = p_src_data+p_max_length-l_header_data;
+ l_modified_length_ptr = &(l_remaining_length);
+ }
+ bio_init_dec(l_bio, l_header_data,*l_modified_length_ptr);
+ l_present = bio_read(l_bio, 1);
+ if
+ (!l_present)
+ {
+ bio_inalign(l_bio);
+ l_header_data += bio_numbytes(l_bio);
+ bio_destroy(l_bio);
+ /* EPH markers */
+ if (p_tcp->csty & J2K_CP_CSTY_EPH) {
+ if ((*l_header_data) != 0xff || (*(l_header_data + 1) != 0x92)) {
+ printf("Error : expected EPH marker\n");
+ } else {
+ l_header_data += 2;
+ }
+ }
+ l_header_length = (l_header_data - *l_header_data_start);
+ *l_modified_length_ptr -= l_header_length;
+ *l_header_data_start += l_header_length;
+ /* << INDEX */
+ // End of packet header position. Currently only represents the distance to start of packet
+ // Will be updated later by incrementing with packet start value
+ if
+ (p_pack_info)
+ {
+ p_pack_info->end_ph_pos = (OPJ_INT32)(l_current_data - p_src_data);
+ }
+ /* INDEX >> */
+ * p_is_data_present = false;
+ *p_data_read = l_current_data - p_src_data;
+ return true;
+ }
+
+ l_band = l_res->bands;
+ for
+ (bandno = 0; bandno < l_res->numbands; ++bandno)
+ {
+ opj_tcd_precinct_t *l_prc = &(l_band->precincts[p_pi->precno]);
+
+ if ((l_band->x1-l_band->x0 == 0)||(l_band->y1-l_band->y0 == 0))
+ {
+ ++l_band;
+ continue;
+ }
+ l_nb_code_blocks = l_prc->cw * l_prc->ch;
+ l_cblk = l_prc->cblks.dec;
+ for
+ (cblkno = 0; cblkno < l_nb_code_blocks; cblkno++)
+ {
+ OPJ_UINT32 l_included,l_increment, l_segno;
+ OPJ_INT32 n;
+ /* if cblk not yet included before --> inclusion tagtree */
+ if
+ (!l_cblk->numsegs)
+ {
+ l_included = tgt_decode(l_bio, l_prc->incltree, cblkno, p_pi->layno + 1);
+ /* else one bit */
+ }
+ else
+ {
+ l_included = bio_read(l_bio, 1);
+ }
+ /* if cblk not included */
+ if
+ (!l_included)
+ {
+ l_cblk->numnewpasses = 0;
+ ++l_cblk;
+ continue;
+ }
+ /* if cblk not yet included --> zero-bitplane tagtree */
+ if
+ (!l_cblk->numsegs)
+ {
+ OPJ_UINT32 i = 0;
+ while
+ (!tgt_decode(l_bio, l_prc->imsbtree, cblkno, i))
+ {
+ ++i;
+ }
+ l_cblk->numbps = l_band->numbps + 1 - i;
+ l_cblk->numlenbits = 3;
+ }
+ /* number of coding passes */
+ l_cblk->numnewpasses = t2_getnumpasses(l_bio);
+ l_increment = t2_getcommacode(l_bio);
+ /* length indicator increment */
+ l_cblk->numlenbits += l_increment;
+ l_segno = 0;
+ if
+ (!l_cblk->numsegs)
+ {
+ if
+ (! t2_init_seg(l_cblk, l_segno, p_tcp->tccps[p_pi->compno].cblksty, 1))
+ {
+ bio_destroy(l_bio);
+ return false;
+ }
+
+ }
+ else
+ {
+ l_segno = l_cblk->numsegs - 1;
+ if
+ (l_cblk->segs[l_segno].numpasses == l_cblk->segs[l_segno].maxpasses)
+ {
+ ++l_segno;
+ if
+ (! t2_init_seg(l_cblk, l_segno, p_tcp->tccps[p_pi->compno].cblksty, 0))
+ {
+ bio_destroy(l_bio);
+ return false;
+ }
+ }
+ }
+ n = l_cblk->numnewpasses;
+
+ do {
+ l_cblk->segs[l_segno].numnewpasses = int_min(l_cblk->segs[l_segno].maxpasses - l_cblk->segs[l_segno].numpasses, n);
+ l_cblk->segs[l_segno].newlen = bio_read(l_bio, l_cblk->numlenbits + uint_floorlog2(l_cblk->segs[l_segno].numnewpasses));
+ n -= l_cblk->segs[l_segno].numnewpasses;
+ if
+ (n > 0)
+ {
+ ++l_segno;
+ if
+ (! t2_init_seg(l_cblk, l_segno, p_tcp->tccps[p_pi->compno].cblksty, 0))
+ {
+ bio_destroy(l_bio);
+ return false;
+ }
+ }
+ }
+ while (n > 0);
+ ++l_cblk;
+ }
+ ++l_band;
+ }
+
+ if
+ (bio_inalign(l_bio))
+ {
+ bio_destroy(l_bio);
+ return false;
+ }
+
+ l_header_data += bio_numbytes(l_bio);
+ bio_destroy(l_bio);
+
+ /* EPH markers */
+ if (p_tcp->csty & J2K_CP_CSTY_EPH) {
+ if ((*l_header_data) != 0xff || (*(l_header_data + 1) != 0x92)) {
+ // TODO opj_event_msg(t2->cinfo->event_mgr, EVT_ERROR, "Expected EPH marker\n");
+ } else {
+ l_header_data += 2;
+ }
+ }
+
+
+ l_header_length = (l_header_data - *l_header_data_start);
+ *l_modified_length_ptr -= l_header_length;
+ *l_header_data_start += l_header_length;
+ /* << INDEX */
+ // End of packet header position. Currently only represents the distance to start of packet
+ // Will be updated later by incrementing with packet start value
+ if
+ (p_pack_info)
+ {
+ p_pack_info->end_ph_pos = (OPJ_INT32)(l_current_data - p_src_data);
+ }
+ /* INDEX >> */
+ * p_is_data_present = true;
+ *p_data_read = l_current_data - p_src_data;
+ return true;
+}
+
+static bool t2_read_packet_data(
+ opj_t2_t* p_t2,
+ opj_tcd_tile_t *p_tile,
+ opj_pi_iterator_t *p_pi,
+ OPJ_BYTE *p_src_data,
+ OPJ_UINT32 * p_data_read,
+ OPJ_UINT32 p_max_length,
+ opj_packet_info_t *pack_info)
+{
+ OPJ_UINT32 bandno, cblkno;
+ OPJ_UINT32 l_nb_code_blocks;
+ OPJ_BYTE *l_current_data = p_src_data;
+ opj_tcd_band_t *l_band = 00;
+ opj_tcd_cblk_dec_t* l_cblk = 00;
+ opj_tcd_resolution_t* l_res = &p_tile->comps[p_pi->compno].resolutions[p_pi->resno];
+
+ l_band = l_res->bands;
+ for
+ (bandno = 0; bandno < l_res->numbands; ++bandno)
+ {
+ opj_tcd_precinct_t *l_prc = &l_band->precincts[p_pi->precno];
+
+ if
+ ((l_band->x1-l_band->x0 == 0)||(l_band->y1-l_band->y0 == 0))
+ {
+ ++l_band;
+ continue;
+ }
+ l_nb_code_blocks = l_prc->cw * l_prc->ch;
+ l_cblk = l_prc->cblks.dec;
+ for
+ (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno)
+ {
+ opj_tcd_seg_t *l_seg = 00;
+ if
+ (!l_cblk->numnewpasses)
+ {
+ /* nothing to do */
+ ++l_cblk;
+ continue;
+ }
+ if
+ (!l_cblk->numsegs)
+ {
+ l_seg = l_cblk->segs;
+ ++l_cblk->numsegs;
+ l_cblk->len = 0;
+ }
+ else
+ {
+ l_seg = &l_cblk->segs[l_cblk->numsegs - 1];
+ if
+ (l_seg->numpasses == l_seg->maxpasses)
+ {
+ ++l_seg;
+ ++l_cblk->numsegs;
+ }
+ }
+
+ do
+ {
+ if
+ (l_current_data + l_seg->newlen > p_src_data + p_max_length)
+ {
+ return false;
+ }
+
+#ifdef USE_JPWL
+ /* we need here a j2k handle to verify if making a check to
+ the validity of cblocks parameters is selected from user (-W) */
+
+ /* let's check that we are not exceeding */
+ if ((cblk->len + seg->newlen) > 8192) {
+ opj_event_msg(t2->cinfo, EVT_WARNING,
+ "JPWL: segment too long (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
+ seg->newlen, cblkno, precno, bandno, resno, compno);
+ if (!JPWL_ASSUME) {
+ opj_event_msg(t2->cinfo, EVT_ERROR, "JPWL: giving up\n");
+ return -999;
+ }
+ seg->newlen = 8192 - cblk->len;
+ opj_event_msg(t2->cinfo, EVT_WARNING, " - truncating segment to %d\n", seg->newlen);
+ break;
+ };
+
+#endif /* USE_JPWL */
+
+ memcpy(l_cblk->data + l_cblk->len, l_current_data, l_seg->newlen);
+ if
+ (l_seg->numpasses == 0)
+ {
+ l_seg->data = &l_cblk->data;
+ l_seg->dataindex = l_cblk->len;
+ }
+ l_current_data += l_seg->newlen;
+ l_seg->numpasses += l_seg->numnewpasses;
+ l_cblk->numnewpasses -= l_seg->numnewpasses;
+
+ l_seg->real_num_passes = l_seg->numpasses;
+ l_cblk->len += l_seg->newlen;
+ l_seg->len += l_seg->newlen;
+ if
+ (l_cblk->numnewpasses > 0)
+ {
+ ++l_seg;
+ ++l_cblk->numsegs;
+ }
+ }
+ while (l_cblk->numnewpasses > 0);
+ l_cblk->real_num_segs = l_cblk->numsegs;
+ ++l_cblk;
+ }
+ ++l_band;
+ }
+ *(p_data_read) = l_current_data - p_src_data;
+ return true;
+}
+
+
+static bool t2_skip_packet_data(
+ opj_t2_t* p_t2,
+ opj_tcd_tile_t *p_tile,
+ opj_pi_iterator_t *p_pi,
+ OPJ_UINT32 * p_data_read,
+ OPJ_UINT32 p_max_length,
+ opj_packet_info_t *pack_info)
+{
+ OPJ_UINT32 bandno, cblkno;
+ OPJ_UINT32 l_nb_code_blocks;
+ opj_tcd_band_t *l_band = 00;
+ opj_tcd_cblk_dec_t* l_cblk = 00;
+
+ opj_tcd_resolution_t* l_res = &p_tile->comps[p_pi->compno].resolutions[p_pi->resno];
+
+ *p_data_read = 0;
+ l_band = l_res->bands;
+ for
+ (bandno = 0; bandno < l_res->numbands; ++bandno)
+ {
+ opj_tcd_precinct_t *l_prc = &l_band->precincts[p_pi->precno];
+
+ if
+ ((l_band->x1-l_band->x0 == 0)||(l_band->y1-l_band->y0 == 0))
+ {
+ ++l_band;
+ continue;
+ }
+ l_nb_code_blocks = l_prc->cw * l_prc->ch;
+ l_cblk = l_prc->cblks.dec;
+ for
+ (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno)
+ {
+ opj_tcd_seg_t *l_seg = 00;
+ if
+ (!l_cblk->numnewpasses)
+ {
+ /* nothing to do */
+ ++l_cblk;
+ continue;
+ }
+ if
+ (!l_cblk->numsegs)
+ {
+ l_seg = l_cblk->segs;
+ ++l_cblk->numsegs;
+ l_cblk->len = 0;
+ }
+ else
+ {
+ l_seg = &l_cblk->segs[l_cblk->numsegs - 1];
+ if
+ (l_seg->numpasses == l_seg->maxpasses)
+ {
+ ++l_seg;
+ ++l_cblk->numsegs;
+ }
+ }
+
+ do
+ {
+ if
+ (* p_data_read + l_seg->newlen > p_max_length)
+ {
+ return false;
+ }
+
+#ifdef USE_JPWL
+ /* we need here a j2k handle to verify if making a check to
+ the validity of cblocks parameters is selected from user (-W) */
+
+ /* let's check that we are not exceeding */
+ if ((cblk->len + seg->newlen) > 8192) {
+ opj_event_msg(t2->cinfo, EVT_WARNING,
+ "JPWL: segment too long (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
+ seg->newlen, cblkno, precno, bandno, resno, compno);
+ if (!JPWL_ASSUME) {
+ opj_event_msg(t2->cinfo, EVT_ERROR, "JPWL: giving up\n");
+ return -999;
+ }
+ seg->newlen = 8192 - cblk->len;
+ opj_event_msg(t2->cinfo, EVT_WARNING, " - truncating segment to %d\n", seg->newlen);
+ break;
+ };
+
+#endif /* USE_JPWL */
+ *(p_data_read) += l_seg->newlen;
+ l_seg->numpasses += l_seg->numnewpasses;
+ l_cblk->numnewpasses -= l_seg->numnewpasses;
+ if
+ (l_cblk->numnewpasses > 0)
+ {
+ ++l_seg;
+ ++l_cblk->numsegs;
+ }
+ }
+ while (l_cblk->numnewpasses > 0);
+ ++l_cblk;
+ }
+ }
+ return true;
+}
+
+static bool t2_decode_packet(
+ opj_t2_t* p_t2,
+ opj_tcd_tile_t *p_tile,
+ opj_tcp_t *p_tcp,
+ opj_pi_iterator_t *p_pi,
+ OPJ_BYTE *p_src,
+ OPJ_UINT32 * p_data_read,
+ OPJ_UINT32 p_max_length,
+ opj_packet_info_t *p_pack_info)
+{
+ bool l_read_data;
+ OPJ_UINT32 l_nb_bytes_read = 0;
+ OPJ_UINT32 l_nb_total_bytes_read = 0;
+
+ *p_data_read = 0;
+
+ if
+ (! t2_read_packet_header(p_t2,p_tile,p_tcp,p_pi,&l_read_data,p_src,&l_nb_bytes_read,p_max_length,p_pack_info))
+ {
+ return false;
+ }
+ p_src += l_nb_bytes_read;
+ l_nb_total_bytes_read += l_nb_bytes_read;
+ p_max_length -= l_nb_bytes_read;
+ /* we should read data for the packet */
+ if
+ (l_read_data)
+ {
+ l_nb_bytes_read = 0;
+ if
+ (! t2_read_packet_data(p_t2,p_tile,p_pi,p_src,&l_nb_bytes_read,p_max_length,p_pack_info))
+ {
+ return false;
+ }
+ l_nb_total_bytes_read += l_nb_bytes_read;
+ }
+ *p_data_read = l_nb_total_bytes_read;
+ return true;
+}
+
+static bool t2_skip_packet(
+ opj_t2_t* p_t2,
+ opj_tcd_tile_t *p_tile,
+ opj_tcp_t *p_tcp,
+ opj_pi_iterator_t *p_pi,
+ OPJ_BYTE *p_src,
+ OPJ_UINT32 * p_data_read,
+ OPJ_UINT32 p_max_length,
+ opj_packet_info_t *p_pack_info)
+{
+ bool l_read_data;
+ OPJ_UINT32 l_nb_bytes_read = 0;
+ OPJ_UINT32 l_nb_total_bytes_read = 0;
+
+ *p_data_read = 0;
+
+ if
+ (! t2_read_packet_header(p_t2,p_tile,p_tcp,p_pi,&l_read_data,p_src,&l_nb_bytes_read,p_max_length,p_pack_info))
+ {
+ return false;
+ }
+ p_src += l_nb_bytes_read;
+ l_nb_total_bytes_read += l_nb_bytes_read;
+ p_max_length -= l_nb_bytes_read;
+ /* we should read data for the packet */
+ if
+ (l_read_data)
+ {
+ l_nb_bytes_read = 0;
+ if
+ (! t2_skip_packet_data(p_t2,p_tile,p_pi,&l_nb_bytes_read,p_max_length,p_pack_info))
+ {
+ return false;
+ }
+ l_nb_total_bytes_read += l_nb_bytes_read;
+ }
+ *p_data_read = l_nb_total_bytes_read;
+ return true;
+}
+
+/* ----------------------------------------------------------------------- */
+
+bool t2_encode_packets(
+ opj_t2_t* p_t2,
+ OPJ_UINT32 p_tile_no,
+ opj_tcd_tile_t *p_tile,
+ OPJ_UINT32 p_maxlayers,
+ OPJ_BYTE *p_dest,
+ OPJ_UINT32 * p_data_written,
+ OPJ_UINT32 p_max_len,
+ opj_codestream_info_t *cstr_info,
+ OPJ_UINT32 p_tp_num,
+ OPJ_INT32 p_tp_pos,
+ OPJ_UINT32 p_pino,
+ J2K_T2_MODE p_t2_mode)
+{
+ OPJ_BYTE *l_current_data = p_dest;
+ OPJ_UINT32 l_nb_bytes = 0;
+ OPJ_UINT32 compno;
+ OPJ_UINT32 poc;
+ opj_pi_iterator_t *l_pi = 00;
+ opj_pi_iterator_t *l_current_pi = 00;
+ opj_image_t *l_image = p_t2->image;
+ opj_cp_t *l_cp = p_t2->cp;
+ opj_tcp_t *l_tcp = &l_cp->tcps[p_tile_no];
+ OPJ_UINT32 pocno = l_cp->m_specific_param.m_enc.m_cinema == CINEMA4K_24? 2: 1;
+ OPJ_UINT32 l_max_comp = l_cp->m_specific_param.m_enc.m_max_comp_size > 0 ? l_image->numcomps : 1;
+ OPJ_UINT32 l_nb_pocs = l_tcp->numpocs + 1;
+
+ l_pi = pi_initialise_encode(l_image, l_cp, p_tile_no, p_t2_mode);
+ if
+ (!l_pi)
+ {
+ return false;
+ }
+ * p_data_written = 0;
+ if
+ (p_t2_mode == THRESH_CALC )
+ { /* Calculating threshold */
+ l_current_pi = l_pi;
+ for
+ (compno = 0; compno < l_max_comp; ++compno)
+ {
+ OPJ_UINT32 l_comp_len = 0;
+ l_current_pi = l_pi;
+
+ for
+ (poc = 0; poc < pocno ; ++poc)
+ {
+ OPJ_UINT32 l_tp_num = compno;
+ pi_create_encode(l_pi, l_cp,p_tile_no,poc,l_tp_num,p_tp_pos,p_t2_mode);
+ while
+ (pi_next(l_current_pi))
+ {
+ if
+ (l_current_pi->layno < p_maxlayers)
+ {
+ l_nb_bytes = 0;
+ if
+ (! t2_encode_packet(p_tile_no,p_tile, l_tcp, l_current_pi, l_current_data, &l_nb_bytes, p_max_len, cstr_info))
+ {
+ pi_destroy(l_pi, l_nb_pocs);
+ return false;
+ }
+ l_comp_len += l_nb_bytes;
+ l_current_data += l_nb_bytes;
+ p_max_len -= l_nb_bytes;
+ * p_data_written += l_nb_bytes;
+ }
+ }
+ if
+ (l_cp->m_specific_param.m_enc.m_max_comp_size)
+ {
+ if
+ (l_comp_len > l_cp->m_specific_param.m_enc.m_max_comp_size)
+ {
+ pi_destroy(l_pi, l_nb_pocs);
+ return false;
+ }
+ }
+ ++l_current_pi;
+ }
+ }
+ }
+ else
+ { /* t2_mode == FINAL_PASS */
+ pi_create_encode(l_pi, l_cp,p_tile_no,p_pino,p_tp_num,p_tp_pos,p_t2_mode);
+ l_current_pi = &l_pi[p_pino];
+ while
+ (pi_next(l_current_pi))
+ {
+ if
+ (l_current_pi->layno < p_maxlayers)
+ {
+ l_nb_bytes=0;
+ if
+ (! t2_encode_packet(p_tile_no,p_tile, l_tcp, l_current_pi, l_current_data, &l_nb_bytes, p_max_len, cstr_info))
+ {
+ pi_destroy(l_pi, l_nb_pocs);
+ return false;
+ }
+ l_current_data += l_nb_bytes;
+ p_max_len -= l_nb_bytes;
+ * p_data_written += l_nb_bytes;
+
+ /* INDEX >> */
+ if(cstr_info) {
+ if(cstr_info->index_write) {
+ opj_tile_info_t *info_TL = &cstr_info->tile[p_tile_no];
+ opj_packet_info_t *info_PK = &info_TL->packet[cstr_info->packno];
+ if (!cstr_info->packno) {
+ info_PK->start_pos = info_TL->end_header + 1;
+ } else {
+ info_PK->start_pos = ((l_cp->m_specific_param.m_enc.m_tp_on | l_tcp->POC)&& info_PK->start_pos) ? info_PK->start_pos : info_TL->packet[cstr_info->packno - 1].end_pos + 1;
+ }
+ info_PK->end_pos = info_PK->start_pos + l_nb_bytes - 1;
+ info_PK->end_ph_pos += info_PK->start_pos - 1; // End of packet header which now only represents the distance
+ // to start of packet is incremented by value of start of packet
+ }
+
+ cstr_info->packno++;
+ }
+ /* << INDEX */
+ ++p_tile->packno;
+ }
+ }
+ }
+ pi_destroy(l_pi, l_nb_pocs);
+ return true;
+}
+
+bool t2_decode_packets(
+ opj_t2_t *p_t2,
+ OPJ_UINT32 p_tile_no,
+ struct opj_tcd_tile *p_tile,
+ OPJ_BYTE *p_src,
+ OPJ_UINT32 * p_data_read,
+ OPJ_UINT32 p_max_len,
+ struct opj_codestream_info *p_cstr_info)
+{
+ OPJ_BYTE *l_current_data = p_src;
+ opj_pi_iterator_t *l_pi = 00;
+ OPJ_UINT32 pino;
+ opj_image_t *l_image = p_t2->image;
+ opj_cp_t *l_cp = p_t2->cp;
+ opj_cp_t *cp = p_t2->cp;
+ opj_tcp_t *l_tcp = &(p_t2->cp->tcps[p_tile_no]);
+ OPJ_UINT32 l_nb_bytes_read;
+ OPJ_UINT32 l_nb_pocs = l_tcp->numpocs + 1;
+ opj_pi_iterator_t *l_current_pi = 00;
+ OPJ_UINT32 curtp = 0;
+ OPJ_UINT32 tp_start_packno;
+ opj_packet_info_t *l_pack_info = 00;
+ opj_image_comp_t* l_img_comp = 00;
+
+
+ if
+ (p_cstr_info)
+ {
+ l_pack_info = p_cstr_info->tile[p_tile_no].packet;
+ }
+
+ /* create a packet iterator */
+ l_pi = pi_create_decode(l_image, l_cp, p_tile_no);
+ if
+ (!l_pi)
+ {
+ return false;
+ }
+
+ tp_start_packno = 0;
+ l_current_pi = l_pi;
+
+ for
+ (pino = 0; pino <= l_tcp->numpocs; ++pino)
+ {
+ while
+ (pi_next(l_current_pi))
+ {
+
+ if
+ (l_tcp->num_layers_to_decode > l_current_pi->layno && l_current_pi->resno < p_tile->comps[l_current_pi->compno].minimum_num_resolutions)
+ {
+ l_nb_bytes_read = 0;
+ if
+ (! t2_decode_packet(p_t2,p_tile,l_tcp,l_current_pi,l_current_data,&l_nb_bytes_read,p_max_len,l_pack_info))
+ {
+ pi_destroy(l_pi,l_nb_pocs);
+ return false;
+ }
+ l_img_comp = &(l_image->comps[l_current_pi->compno]);
+ l_img_comp->resno_decoded = uint_max(l_current_pi->resno, l_img_comp->resno_decoded);
+ }
+ else
+ {
+ l_nb_bytes_read = 0;
+ if
+ (! t2_skip_packet(p_t2,p_tile,l_tcp,l_current_pi,l_current_data,&l_nb_bytes_read,p_max_len,l_pack_info))
+ {
+ pi_destroy(l_pi,l_nb_pocs);
+ return false;
+ }
+ }
+ l_current_data += l_nb_bytes_read;
+ p_max_len -= l_nb_bytes_read;
+
+ /* INDEX >> */
+ if(p_cstr_info) {
+ opj_tile_info_t *info_TL = &p_cstr_info->tile[p_tile_no];
+ opj_packet_info_t *info_PK = &info_TL->packet[p_cstr_info->packno];
+ if (!p_cstr_info->packno) {
+ info_PK->start_pos = info_TL->end_header + 1;
+ } else if (info_TL->packet[p_cstr_info->packno-1].end_pos >= (OPJ_INT32)p_cstr_info->tile[p_tile_no].tp[curtp].tp_end_pos){ // New tile part
+ info_TL->tp[curtp].tp_numpacks = p_cstr_info->packno - tp_start_packno; // Number of packets in previous tile-part
+ tp_start_packno = p_cstr_info->packno;
+ curtp++;
+ info_PK->start_pos = p_cstr_info->tile[p_tile_no].tp[curtp].tp_end_header+1;
+ } else {
+ info_PK->start_pos = (cp->m_specific_param.m_enc.m_tp_on && info_PK->start_pos) ? info_PK->start_pos : info_TL->packet[p_cstr_info->packno - 1].end_pos + 1;
+ }
+ info_PK->end_pos = info_PK->start_pos + l_nb_bytes_read - 1;
+ info_PK->end_ph_pos += info_PK->start_pos - 1; // End of packet header which now only represents the distance
+ ++p_cstr_info->packno;
+ }
+ /* << INDEX */
+ }
+ ++l_current_pi;
+ }
+ /* INDEX >> */
+ if
+ (p_cstr_info) {
+ p_cstr_info->tile[p_tile_no].tp[curtp].tp_numpacks = p_cstr_info->packno - tp_start_packno; // Number of packets in last tile-part
+ }
+ /* << INDEX */
+
+ /* don't forget to release pi */
+ pi_destroy(l_pi,l_nb_pocs);
+ *p_data_read = l_current_data - p_src;
+ return true;
+}
+
+/* ----------------------------------------------------------------------- */
+/**
+ * Creates a Tier 2 handle
+ *
+ * @param p_image Source or destination image
+ * @param p_cp Image coding parameters.
+ * @return a new T2 handle if successful, NULL otherwise.
+*/
+opj_t2_t* t2_create(
+ opj_image_t *p_image,
+ opj_cp_t *p_cp)
+{
+ /* create the tcd structure */
+ opj_t2_t *l_t2 = (opj_t2_t*)opj_malloc(sizeof(opj_t2_t));
+ if
+ (!l_t2)
+ {
+ return 00;
+ }
+ memset(l_t2,0,sizeof(opj_t2_t));
+ l_t2->image = p_image;
+ l_t2->cp = p_cp;
+ return l_t2;
+}
+
+/**
+ * Destroys a Tier 2 handle.
+ *
+ * @param p_t2 the Tier 2 handle to destroy
+*/
+void t2_destroy(opj_t2_t *p_t2)
+{
+ if
+ (p_t2)
+ {
+ opj_free(p_t2);
+ }
+}
+
+
+
+
diff --git a/v2/libopenjpeg/t2.h b/v2/libopenjpeg/t2.h new file mode 100755 index 00000000..0ecf95bf --- /dev/null +++ b/v2/libopenjpeg/t2.h @@ -0,0 +1,120 @@ +/*
+ * 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) 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 __T2_H
+#define __T2_H
+/**
+@file t2.h
+@brief Implementation of a tier-2 coding (packetization of code-block data) (T2)
+
+*/
+#include "openjpeg.h"
+
+struct opj_common_struct;
+struct opj_image;
+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
+ * @param p_cp Image coding parameters.
+ * @return a new T2 handle if successful, NULL otherwise.
+*/
+opj_t2_t* t2_create(struct opj_image *p_image, struct opj_cp *p_cp);
+
+/**
+ * Destroys a Tier 2 handle.
+ *
+ * @param p_t2 the Tier 2 handle to destroy
+*/
+void t2_destroy(opj_t2_t *t2);
+
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __T2_H */
diff --git a/v2/libopenjpeg/tcd.c b/v2/libopenjpeg/tcd.c new file mode 100755 index 00000000..b84c2ce5 --- /dev/null +++ b/v2/libopenjpeg/tcd.c @@ -0,0 +1,2121 @@ +/*
+ * 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 "tcd.h"
+#include "openjpeg.h"
+#include "j2k.h"
+#include "opj_includes.h"
+#include "event.h"
+#include "t2.h"
+#include "t1.h"
+#include "opj_malloc.h"
+#include "int.h"
+#include "tgt.h"
+#include "dwt.h"
+#include "mct.h"
+#include "j2k_lib.h"
+#include "profile.h"
+
+/**
+ * Deallocates the encoding data of the given precinct.
+ */
+static void tcd_code_block_enc_deallocate (opj_tcd_precinct_t * p_precinct);
+/**
+ * Allocates memory for an encoding code block.
+ */
+static bool tcd_code_block_enc_allocate (opj_tcd_cblk_enc_t * p_code_block);
+/**
+ * Allocates memory for a decoding code block.
+ */
+static bool tcd_code_block_dec_allocate (opj_tcd_cblk_dec_t * p_code_block);
+/**
+Free the memory allocated for encoding
+@param tcd TCD handle
+*/
+static void tcd_free_tile(opj_tcd_t *tcd);
+
+/* ----------------------------------------------------------------------- */
+
+/**
+Create a new TCD handle
+*/
+opj_tcd_t* tcd_create(bool p_is_decoder)
+{
+ opj_tcd_t *l_tcd = 00;
+
+ /* create the tcd structure */
+ l_tcd = (opj_tcd_t*) opj_malloc(sizeof(opj_tcd_t));
+ if
+ (!l_tcd)
+ {
+ return 00;
+ }
+ memset(l_tcd,0,sizeof(opj_tcd_t));
+ l_tcd->m_is_decoder = p_is_decoder ? 1 : 0;
+ l_tcd->tcd_image = (opj_tcd_image_t*)opj_malloc(sizeof(opj_tcd_image_t));
+ if
+ (!l_tcd->tcd_image)
+ {
+ opj_free(l_tcd);
+ return 00;
+ }
+ memset(l_tcd->tcd_image,0,sizeof(opj_tcd_image_t));
+ return l_tcd;
+}
+
+/**
+Destroy a previously created TCD handle
+*/
+void tcd_destroy(opj_tcd_t *tcd) {
+ if
+ (tcd)
+ {
+ tcd_free_tile(tcd);
+ if
+ (tcd->tcd_image)
+ {
+ opj_free(tcd->tcd_image);
+ tcd->tcd_image = 00;
+ }
+ opj_free(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).
+*/
+#define MACRO_TCD_ALLOCATE(FUNCTION,TYPE,FRACTION,ELEMENT,FUNCTION_ELEMENT) \
+bool FUNCTION \
+ ( \
+ opj_tcd_t *p_tcd, \
+ OPJ_UINT32 p_tile_no \
+ ) \
+{ \
+ OPJ_UINT32 (*l_gain_ptr)(OPJ_UINT32) = 00; \
+ OPJ_UINT32 compno, resno, bandno, precno, cblkno; \
+ opj_tcp_t * l_tcp = 00; \
+ opj_cp_t * l_cp = 00; \
+ opj_tcd_tile_t * l_tile = 00; \
+ opj_tccp_t *l_tccp = 00; \
+ opj_tcd_tilecomp_t *l_tilec = 00; \
+ opj_image_comp_t * l_image_comp = 00; \
+ opj_tcd_resolution_t *l_res = 00; \
+ opj_tcd_band_t *l_band = 00; \
+ opj_stepsize_t * l_step_size = 00; \
+ opj_tcd_precinct_t *l_current_precinct = 00; \
+ TYPE* l_code_block = 00; \
+ opj_image_t * l_image = 00; \
+ OPJ_UINT32 p,q; \
+ OPJ_UINT32 l_level_no; \
+ OPJ_UINT32 l_pdx, l_pdy; \
+ OPJ_UINT32 l_gain; \
+ OPJ_INT32 l_x0b, l_y0b; \
+ /* extent of precincts , top left, bottom right**/ \
+ OPJ_INT32 l_tl_prc_x_start, l_tl_prc_y_start, l_br_prc_x_end, l_br_prc_y_end; \
+ /* number of precinct for a resolution */ \
+ OPJ_UINT32 l_nb_precincts; \
+ /* room needed to store l_nb_precinct precinct for a resolution */ \
+ OPJ_UINT32 l_nb_precinct_size; \
+ /* number of code blocks for a precinct*/ \
+ OPJ_UINT32 l_nb_code_blocks; \
+ /* room needed to store l_nb_code_blocks code blocks for a precinct*/ \
+ OPJ_UINT32 l_nb_code_blocks_size; \
+ /* size of data for a tile */ \
+ OPJ_UINT32 l_data_size; \
+ l_cp = p_tcd->cp; \
+ l_tcp = &(l_cp->tcps[p_tile_no]); \
+ l_tile = p_tcd->tcd_image->tiles; \
+ l_tccp = l_tcp->tccps; \
+ l_tilec = l_tile->comps; \
+ l_image = p_tcd->image; \
+ l_image_comp = p_tcd->image->comps; \
+ \
+ p = p_tile_no % l_cp->tw; /* tile coordinates */ \
+ q = p_tile_no / l_cp->tw; \
+ \
+ /* 4 borders of the tile rescale on the image if necessary */ \
+ l_tile->x0 = int_max(l_cp->tx0 + p * l_cp->tdx, l_image->x0); \
+ l_tile->y0 = int_max(l_cp->ty0 + q * l_cp->tdy, l_image->y0); \
+ l_tile->x1 = int_min(l_cp->tx0 + (p + 1) * l_cp->tdx, l_image->x1); \
+ l_tile->y1 = int_min(l_cp->ty0 + (q + 1) * l_cp->tdy, l_image->y1); \
+ /*tile->numcomps = image->numcomps; */ \
+ for \
+ (compno = 0; compno < l_tile->numcomps; ++compno) \
+ { \
+ /* border of each l_tile component (global) */ \
+ l_tilec->x0 = int_ceildiv(l_tile->x0, l_image_comp->dx); \
+ l_tilec->y0 = int_ceildiv(l_tile->y0, l_image_comp->dy); \
+ l_tilec->x1 = int_ceildiv(l_tile->x1, l_image_comp->dx); \
+ l_tilec->y1 = int_ceildiv(l_tile->y1, l_image_comp->dy); \
+ \
+ l_data_size = (l_tilec->x1 - l_tilec->x0) \
+ * (l_tilec->y1 - l_tilec->y0) * sizeof(OPJ_UINT32 ); \
+ l_tilec->numresolutions = l_tccp->numresolutions; \
+ if \
+ (l_tccp->numresolutions < l_cp->m_specific_param.m_dec.m_reduce)\
+ { \
+ l_tilec->minimum_num_resolutions = 1; \
+ } \
+ else \
+ { \
+ l_tilec->minimum_num_resolutions = l_tccp->numresolutions - l_cp->m_specific_param.m_dec.m_reduce;\
+ } \
+ if \
+ (l_tilec->data == 00) \
+ { \
+ l_tilec->data = (OPJ_INT32 *) opj_aligned_malloc(l_data_size); \
+ if \
+ (! l_tilec->data ) \
+ { \
+ return false; \
+ } \
+ l_tilec->data_size = l_data_size; \
+ } \
+ else if \
+ (l_data_size > l_tilec->data_size) \
+ { \
+ l_tilec->data = (OPJ_INT32 *) opj_realloc(l_tilec->data, l_data_size);\
+ if \
+ (! l_tilec->data) \
+ { \
+ return false; \
+ } \
+ l_tilec->data_size = l_data_size; \
+ } \
+ l_data_size = l_tilec->numresolutions * sizeof(opj_tcd_resolution_t);\
+ if \
+ (l_tilec->resolutions == 00) \
+ { \
+ l_tilec->resolutions = (opj_tcd_resolution_t *) opj_malloc(l_data_size);\
+ if \
+ (! l_tilec->resolutions ) \
+ { \
+ return false; \
+ } \
+ l_tilec->resolutions_size = l_data_size; \
+ memset(l_tilec->resolutions,0,l_data_size); \
+ } \
+ else if \
+ (l_data_size > l_tilec->resolutions_size) \
+ { \
+ l_tilec->resolutions = (opj_tcd_resolution_t *) opj_realloc(l_tilec->resolutions, l_data_size);\
+ if \
+ (! l_tilec->resolutions) \
+ { \
+ return false; \
+ } \
+ memset(((OPJ_BYTE*) l_tilec->resolutions)+l_tilec->resolutions_size,0,l_data_size - l_tilec->resolutions_size);\
+ l_tilec->resolutions_size = l_data_size; \
+ } \
+ l_level_no = l_tilec->numresolutions - 1; \
+ l_res = l_tilec->resolutions; \
+ l_step_size = l_tccp->stepsizes; \
+ if \
+ (l_tccp->qmfbid == 0) \
+ { \
+ l_gain_ptr = &dwt_getgain_real; \
+ } \
+ else \
+ { \
+ l_gain_ptr = &dwt_getgain; \
+ } \
+ for \
+ (resno = 0; resno < l_tilec->numresolutions; ++resno) \
+ { \
+ OPJ_INT32 tlcbgxstart, tlcbgystart, brcbgxend, brcbgyend; \
+ OPJ_UINT32 cbgwidthexpn, cbgheightexpn; \
+ OPJ_UINT32 cblkwidthexpn, cblkheightexpn; \
+ /* border for each resolution level (global) */ \
+ l_res->x0 = int_ceildivpow2(l_tilec->x0, l_level_no); \
+ l_res->y0 = int_ceildivpow2(l_tilec->y0, l_level_no); \
+ l_res->x1 = int_ceildivpow2(l_tilec->x1, l_level_no); \
+ l_res->y1 = int_ceildivpow2(l_tilec->y1, l_level_no); \
+ /* p. 35, table A-23, ISO/IEC FDIS154444-1 : 2000 (18 august 2000) */\
+ l_pdx = l_tccp->prcw[resno]; \
+ l_pdy = l_tccp->prch[resno]; \
+ /* p. 64, B.6, ISO/IEC FDIS15444-1 : 2000 (18 august 2000) */ \
+ l_tl_prc_x_start = int_floordivpow2(l_res->x0, l_pdx) << l_pdx; \
+ l_tl_prc_y_start = int_floordivpow2(l_res->y0, l_pdy) << l_pdy; \
+ l_br_prc_x_end = int_ceildivpow2(l_res->x1, l_pdx) << l_pdx; \
+ l_br_prc_y_end = int_ceildivpow2(l_res->y1, l_pdy) << l_pdy; \
+ \
+ l_res->pw = (l_res->x0 == l_res->x1) ? 0 : ((l_br_prc_x_end - l_tl_prc_x_start) >> l_pdx);\
+ l_res->ph = (l_res->y0 == l_res->y1) ? 0 : ((l_br_prc_y_end - l_tl_prc_y_start) >> l_pdy);\
+ l_nb_precincts = l_res->pw * l_res->ph; \
+ l_nb_precinct_size = l_nb_precincts * sizeof(opj_tcd_precinct_t);\
+ if \
+ (resno == 0) \
+ { \
+ tlcbgxstart = l_tl_prc_x_start; \
+ tlcbgystart = l_tl_prc_y_start; \
+ brcbgxend = l_br_prc_x_end; \
+ brcbgyend = l_br_prc_y_end; \
+ cbgwidthexpn = l_pdx; \
+ cbgheightexpn = l_pdy; \
+ l_res->numbands = 1; \
+ } \
+ else \
+ { \
+ tlcbgxstart = int_ceildivpow2(l_tl_prc_x_start, 1); \
+ tlcbgystart = int_ceildivpow2(l_tl_prc_y_start, 1); \
+ brcbgxend = int_ceildivpow2(l_br_prc_x_end, 1); \
+ brcbgyend = int_ceildivpow2(l_br_prc_y_end, 1); \
+ cbgwidthexpn = l_pdx - 1; \
+ cbgheightexpn = l_pdy - 1; \
+ l_res->numbands = 3; \
+ } \
+ \
+ cblkwidthexpn = uint_min(l_tccp->cblkw, cbgwidthexpn); \
+ cblkheightexpn = uint_min(l_tccp->cblkh, cbgheightexpn); \
+ l_band = l_res->bands; \
+ for \
+ (bandno = 0; bandno < l_res->numbands; ++bandno) \
+ { \
+ OPJ_INT32 numbps; \
+ if \
+ (resno == 0) \
+ { \
+ l_band->bandno = 0 ; \
+ l_band->x0 = int_ceildivpow2(l_tilec->x0, l_level_no); \
+ l_band->y0 = int_ceildivpow2(l_tilec->y0, l_level_no); \
+ l_band->x1 = int_ceildivpow2(l_tilec->x1, l_level_no); \
+ l_band->y1 = int_ceildivpow2(l_tilec->y1, l_level_no); \
+ } \
+ else \
+ { \
+ l_band->bandno = bandno + 1; \
+ /* x0b = 1 if bandno = 1 or 3 */ \
+ l_x0b = l_band->bandno&1; \
+ /* y0b = 1 if bandno = 2 or 3 */ \
+ l_y0b = (l_band->bandno)>>1; \
+ /* l_band border (global) */ \
+ l_band->x0 = int_ceildivpow2(l_tilec->x0 - (1 << l_level_no) * l_x0b, l_level_no + 1);\
+ l_band->y0 = int_ceildivpow2(l_tilec->y0 - (1 << l_level_no) * l_y0b, l_level_no + 1);\
+ l_band->x1 = int_ceildivpow2(l_tilec->x1 - (1 << l_level_no) * l_x0b, l_level_no + 1);\
+ l_band->y1 = int_ceildivpow2(l_tilec->y1 - (1 << l_level_no) * l_y0b, l_level_no + 1);\
+ } \
+ /** avoid an if with storing function pointer */ \
+ l_gain = (*l_gain_ptr) (l_band->bandno); \
+ numbps = l_image_comp->prec + l_gain; \
+ l_band->stepsize = (OPJ_FLOAT32)(((1.0 + l_step_size->mant / 2048.0) * pow(2.0, (OPJ_INT32) (numbps - l_step_size->expn)))) * FRACTION;\
+ l_band->numbps = l_step_size->expn + l_tccp->numgbits - 1; /* WHY -1 ? */\
+ if \
+ (! l_band->precincts) \
+ { \
+ l_band->precincts = (opj_tcd_precinct_t *) opj_malloc(/*3 * */ l_nb_precinct_size);\
+ if \
+ (! l_band->precincts) \
+ { \
+ return false; \
+ } \
+ memset(l_band->precincts,0,l_nb_precinct_size); \
+ l_band->precincts_data_size = l_nb_precinct_size; \
+ } \
+ else if \
+ (l_band->precincts_data_size < l_nb_precinct_size) \
+ { \
+ l_band->precincts = (opj_tcd_precinct_t *) opj_realloc(l_band->precincts,/*3 * */ l_nb_precinct_size);\
+ if \
+ (! l_band->precincts) \
+ { \
+ return false; \
+ } \
+ memset(((OPJ_BYTE *) l_band->precincts) + l_band->precincts_data_size,0,l_nb_precinct_size - l_band->precincts_data_size);\
+ l_band->precincts_data_size = l_nb_precinct_size; \
+ } \
+ l_current_precinct = l_band->precincts; \
+ for \
+ (precno = 0; precno < l_nb_precincts; ++precno) \
+ { \
+ OPJ_INT32 tlcblkxstart, tlcblkystart, brcblkxend, brcblkyend; \
+ OPJ_INT32 cbgxstart = tlcbgxstart + (precno % l_res->pw) * (1 << cbgwidthexpn);\
+ OPJ_INT32 cbgystart = tlcbgystart + (precno / l_res->pw) * (1 << cbgheightexpn);\
+ OPJ_INT32 cbgxend = cbgxstart + (1 << cbgwidthexpn); \
+ OPJ_INT32 cbgyend = cbgystart + (1 << cbgheightexpn); \
+ /* precinct size (global) */ \
+ l_current_precinct->x0 = int_max(cbgxstart, l_band->x0);\
+ l_current_precinct->y0 = int_max(cbgystart, l_band->y0);\
+ l_current_precinct->x1 = int_min(cbgxend, l_band->x1); \
+ l_current_precinct->y1 = int_min(cbgyend, l_band->y1); \
+ tlcblkxstart = int_floordivpow2(l_current_precinct->x0, cblkwidthexpn) << cblkwidthexpn;\
+ tlcblkystart = int_floordivpow2(l_current_precinct->y0, cblkheightexpn) << cblkheightexpn;\
+ brcblkxend = int_ceildivpow2(l_current_precinct->x1, cblkwidthexpn) << cblkwidthexpn;\
+ brcblkyend = int_ceildivpow2(l_current_precinct->y1, cblkheightexpn) << cblkheightexpn;\
+ l_current_precinct->cw = (brcblkxend - tlcblkxstart) >> cblkwidthexpn;\
+ l_current_precinct->ch = (brcblkyend - tlcblkystart) >> cblkheightexpn;\
+ l_nb_code_blocks = l_current_precinct->cw * l_current_precinct->ch;\
+ l_nb_code_blocks_size = l_nb_code_blocks * sizeof(TYPE);\
+ if \
+ (! l_current_precinct->cblks.ELEMENT) \
+ { \
+ l_current_precinct->cblks.ELEMENT = (TYPE*) opj_malloc(l_nb_code_blocks_size);\
+ if \
+ (! l_current_precinct->cblks.ELEMENT ) \
+ { \
+ return false; \
+ } \
+ memset(l_current_precinct->cblks.ELEMENT,0,l_nb_code_blocks_size);\
+ l_current_precinct->block_size = l_nb_code_blocks_size;\
+ } \
+ else if \
+ (l_nb_code_blocks_size > l_current_precinct->block_size)\
+ { \
+ l_current_precinct->cblks.ELEMENT = (TYPE*) \
+ opj_realloc(l_current_precinct->cblks.ELEMENT, l_nb_code_blocks_size);\
+ if \
+ (! l_current_precinct->cblks.ELEMENT ) \
+ { \
+ return false; \
+ } \
+ memset(((OPJ_BYTE *) l_current_precinct->cblks.ELEMENT) + l_current_precinct->block_size\
+ ,0 \
+ ,l_nb_code_blocks_size - l_current_precinct->block_size);\
+ l_current_precinct->block_size = l_nb_code_blocks_size;\
+ } \
+ if \
+ (! l_current_precinct->incltree) \
+ { \
+ l_current_precinct->incltree = tgt_create(l_current_precinct->cw,\
+ l_current_precinct->ch);\
+ } \
+ else \
+ { \
+ l_current_precinct->incltree = tgt_init(l_current_precinct->incltree,\
+ l_current_precinct->cw, \
+ l_current_precinct->ch);\
+ } \
+ if \
+ (! l_current_precinct->incltree) \
+ { \
+ return false; \
+ } \
+ if \
+ (! l_current_precinct->imsbtree) \
+ { \
+ l_current_precinct->imsbtree = tgt_create( \
+ l_current_precinct->cw,\
+ l_current_precinct->ch);\
+ } \
+ else \
+ { \
+ l_current_precinct->imsbtree = tgt_init( \
+ l_current_precinct->imsbtree,\
+ l_current_precinct->cw,\
+ l_current_precinct->ch);\
+ } \
+ if \
+ (! l_current_precinct->imsbtree) \
+ { \
+ return false; \
+ } \
+ l_code_block = l_current_precinct->cblks.ELEMENT; \
+ for \
+ (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno) \
+ { \
+ OPJ_INT32 cblkxstart = tlcblkxstart + (cblkno % l_current_precinct->cw) * (1 << cblkwidthexpn);\
+ OPJ_INT32 cblkystart = tlcblkystart + (cblkno / l_current_precinct->cw) * (1 << cblkheightexpn);\
+ OPJ_INT32 cblkxend = cblkxstart + (1 << cblkwidthexpn); \
+ OPJ_INT32 cblkyend = cblkystart + (1 << cblkheightexpn); \
+ /* code-block size (global) */ \
+ l_code_block->x0 = int_max(cblkxstart, l_current_precinct->x0);\
+ l_code_block->y0 = int_max(cblkystart, l_current_precinct->y0);\
+ l_code_block->x1 = int_min(cblkxend, l_current_precinct->x1);\
+ l_code_block->y1 = int_min(cblkyend, l_current_precinct->y1);\
+ if \
+ (! FUNCTION_ELEMENT(l_code_block)) \
+ { \
+ return false; \
+ } \
+ ++l_code_block; \
+ } \
+ ++l_current_precinct; \
+ } /* precno */ \
+ ++l_band; \
+ ++l_step_size; \
+ } /* bandno */ \
+ ++l_res; \
+ --l_level_no; \
+ } /* resno */ \
+ ++l_tccp; \
+ ++l_tilec; \
+ ++l_image_comp; \
+ } /* compno */ \
+ return true; \
+} \
+
+MACRO_TCD_ALLOCATE(tcd_init_encode_tile,opj_tcd_cblk_enc_t,1.f,enc,tcd_code_block_enc_allocate)
+MACRO_TCD_ALLOCATE(tcd_init_decode_tile,opj_tcd_cblk_dec_t,0.5f,dec,tcd_code_block_dec_allocate)
+
+#undef MACRO_TCD_ALLOCATE
+
+/**
+ * Allocates memory for an encoding code block.
+ */
+bool tcd_code_block_enc_allocate (opj_tcd_cblk_enc_t * p_code_block)
+{
+ if
+ (! p_code_block->data)
+ {
+ p_code_block->data = (OPJ_BYTE*) opj_malloc(8192+1);
+ if
+ (! p_code_block->data)
+ {
+ return false;
+ }
+ p_code_block->data+=1;
+ /* no memset since data */
+ p_code_block->layers = (opj_tcd_layer_t*) opj_malloc(100 * sizeof(opj_tcd_layer_t));
+ if
+ (! p_code_block->layers)
+ {
+ return false;
+ }
+ p_code_block->passes = (opj_tcd_pass_t*) opj_malloc(100 * sizeof(opj_tcd_pass_t));
+ if
+ (! p_code_block->passes)
+ {
+ return false;
+ }
+ }
+ memset(p_code_block->layers,0,100 * sizeof(opj_tcd_layer_t));
+ memset(p_code_block->passes,0,100 * sizeof(opj_tcd_pass_t));
+ return true;
+}
+
+/**
+ * Allocates memory for a decoding code block.
+ */
+bool tcd_code_block_dec_allocate (opj_tcd_cblk_dec_t * p_code_block)
+{
+ OPJ_UINT32 l_seg_size;
+
+ if
+ (! p_code_block->data)
+ {
+ p_code_block->data = (OPJ_BYTE*) opj_malloc(8192);
+ if
+ (! p_code_block->data)
+ {
+ return false;
+ }
+ l_seg_size = J2K_DEFAULT_NB_SEGS * sizeof(opj_tcd_seg_t);
+ p_code_block->segs = (opj_tcd_seg_t *) opj_malloc(l_seg_size);
+ if
+ (! p_code_block->segs)
+ {
+ return false;
+ }
+ memset(p_code_block->segs,0,l_seg_size);
+ p_code_block->m_current_max_segs = J2K_DEFAULT_NB_SEGS;
+ }
+ // TODO
+ //p_code_block->numsegs = 0;
+ return true;
+}
+
+/**
+ * Deallocates the encoding data of the given precinct.
+ */
+void tcd_code_block_enc_deallocate (opj_tcd_precinct_t * p_precinct)
+{
+ OPJ_UINT32 cblkno , l_nb_code_blocks;
+
+ opj_tcd_cblk_enc_t * l_code_block = p_precinct->cblks.enc;
+ if
+ (l_code_block)
+ {
+ l_nb_code_blocks = p_precinct->block_size / sizeof(opj_tcd_cblk_enc_t);
+ for
+ (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno)
+ {
+ if
+ (l_code_block->data)
+ {
+ opj_free(l_code_block->data-1);
+ l_code_block->data = 00;
+ }
+ if
+ (l_code_block->layers)
+ {
+ opj_free(l_code_block->layers );
+ l_code_block->layers = 00;
+ }
+ if
+ (l_code_block->passes)
+ {
+ opj_free(l_code_block->passes );
+ l_code_block->passes = 00;
+ }
+ ++l_code_block;
+ }
+ opj_free(p_precinct->cblks.enc);
+ p_precinct->cblks.enc = 00;
+ }
+}
+
+/**
+ * Deallocates the encoding data of the given precinct.
+ */
+void tcd_code_block_dec_deallocate (opj_tcd_precinct_t * p_precinct)
+{
+ OPJ_UINT32 cblkno , l_nb_code_blocks;
+
+ opj_tcd_cblk_dec_t * l_code_block = p_precinct->cblks.dec;
+ if
+ (l_code_block)
+ {
+ l_nb_code_blocks = p_precinct->block_size / sizeof(opj_tcd_cblk_dec_t);
+ for
+ (cblkno = 0; cblkno < l_nb_code_blocks; ++cblkno)
+ {
+ if
+ (l_code_block->data)
+ {
+ opj_free(l_code_block->data);
+ l_code_block->data = 00;
+ }
+ if
+ (l_code_block->segs)
+ {
+ opj_free(l_code_block->segs );
+ l_code_block->segs = 00;
+ }
+ ++l_code_block;
+ }
+ opj_free(p_precinct->cblks.dec);
+ p_precinct->cblks.dec = 00;
+ }
+}
+
+void tcd_free_tile(opj_tcd_t *p_tcd)
+{
+ OPJ_UINT32 compno, resno, bandno, precno;
+ opj_tcd_tile_t *l_tile = 00;
+ opj_tcd_tilecomp_t *l_tile_comp = 00;
+ opj_tcd_resolution_t *l_res = 00;
+ opj_tcd_band_t *l_band = 00;
+ opj_tcd_precinct_t *l_precinct = 00;
+ OPJ_UINT32 l_nb_resolutions, l_nb_precincts;
+ void (* l_tcd_code_block_deallocate) (opj_tcd_precinct_t *) = 00;
+
+ if
+ (! p_tcd)
+ {
+ return;
+ }
+ if
+ (! p_tcd->tcd_image)
+ {
+ return;
+ }
+ if
+ (p_tcd->m_is_decoder)
+ {
+ l_tcd_code_block_deallocate = tcd_code_block_dec_deallocate;
+ }
+ else
+ {
+ l_tcd_code_block_deallocate = tcd_code_block_enc_deallocate;
+ }
+
+
+ l_tile = p_tcd->tcd_image->tiles;
+ if
+ (! l_tile)
+ {
+ return;
+ }
+ l_tile_comp = l_tile->comps;
+
+ for
+ (compno = 0; compno < l_tile->numcomps; ++compno)
+ {
+ l_res = l_tile_comp->resolutions;
+ if
+ (l_res)
+ {
+ l_nb_resolutions = l_tile_comp->resolutions_size / sizeof(opj_tcd_resolution_t);
+ for
+ (resno = 0; resno < l_nb_resolutions; ++resno)
+ {
+ l_band = l_res->bands;
+ for
+ (bandno = 0; bandno < 3; ++bandno)
+ {
+ l_precinct = l_band->precincts;
+ if
+ (l_precinct)
+ {
+ l_nb_precincts = l_band->precincts_data_size / sizeof(opj_tcd_precinct_t);
+ for
+ (precno = 0; precno < l_nb_precincts; ++precno)
+ {
+ tgt_destroy(l_precinct->incltree);
+ l_precinct->incltree = 00;
+ tgt_destroy(l_precinct->imsbtree);
+ l_precinct->imsbtree = 00;
+ (*l_tcd_code_block_deallocate) (l_precinct);
+ ++l_precinct;
+ }
+ opj_free(l_band->precincts);
+ l_band->precincts = 00;
+ }
+ ++l_band;
+ } /* for (resno */
+ ++l_res;
+ }
+ opj_free(l_tile_comp->resolutions);
+ l_tile_comp->resolutions = 00;
+ }
+ if
+ (l_tile_comp->data)
+ {
+ opj_aligned_free(l_tile_comp->data);
+ l_tile_comp->data = 00;
+ }
+ ++l_tile_comp;
+ }
+ opj_free(l_tile->comps);
+ l_tile->comps = 00;
+ opj_free(p_tcd->tcd_image->tiles);
+ p_tcd->tcd_image->tiles = 00;
+}
+
+bool tcd_init(
+ opj_tcd_t *p_tcd,
+ opj_image_t * p_image,
+ opj_cp_t * p_cp
+ )
+{
+ OPJ_UINT32 l_tile_comp_size;
+
+ p_tcd->image = p_image;
+ p_tcd->cp = p_cp;
+ p_tcd->tcd_image->tiles = (opj_tcd_tile_t *) opj_malloc(sizeof(opj_tcd_tile_t));
+
+ if
+ (! p_tcd->tcd_image->tiles)
+ {
+ return false;
+ }
+ memset(p_tcd->tcd_image->tiles,0, sizeof(opj_tcd_tile_t));
+
+ l_tile_comp_size = p_image->numcomps * sizeof(opj_tcd_tilecomp_t);
+ p_tcd->tcd_image->tiles->comps = (opj_tcd_tilecomp_t *) opj_malloc(l_tile_comp_size);
+ if
+ (! p_tcd->tcd_image->tiles->comps )
+ {
+ return false;
+ }
+ memset( p_tcd->tcd_image->tiles->comps , 0 , l_tile_comp_size);
+ p_tcd->tcd_image->tiles->numcomps = p_image->numcomps;
+ p_tcd->tp_pos = p_cp->m_specific_param.m_enc.m_tp_pos;
+ return true;
+}
+
+void tcd_makelayer_fixed(opj_tcd_t *tcd, OPJ_UINT32 layno, OPJ_UINT32 final) {
+ OPJ_UINT32 compno, resno, bandno, precno, cblkno;
+ OPJ_INT32 value; /*, matrice[tcd_tcp->numlayers][tcd_tile->comps[0].numresolutions][3]; */
+ OPJ_INT32 matrice[10][10][3];
+ OPJ_UINT32 i, j, k;
+
+ opj_cp_t *cp = tcd->cp;
+ opj_tcd_tile_t *tcd_tile = tcd->tcd_image->tiles;
+ opj_tcp_t *tcd_tcp = tcd->tcp;
+
+ for (compno = 0; compno < tcd_tile->numcomps; compno++) {
+ opj_tcd_tilecomp_t *tilec = &tcd_tile->comps[compno];
+ for (i = 0; i < tcd_tcp->numlayers; i++) {
+ for (j = 0; j < tilec->numresolutions; j++) {
+ for (k = 0; k < 3; k++) {
+ matrice[i][j][k] =
+ (OPJ_INT32) (cp->m_specific_param.m_enc.m_matrice[i * tilec->numresolutions * 3 + j * 3 + k]
+ * (OPJ_FLOAT32) (tcd->image->comps[compno].prec / 16.0));
+ }
+ }
+ }
+
+ for (resno = 0; resno < tilec->numresolutions; resno++) {
+ opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+ for (bandno = 0; bandno < res->numbands; bandno++) {
+ opj_tcd_band_t *band = &res->bands[bandno];
+ for (precno = 0; precno < res->pw * res->ph; precno++) {
+ opj_tcd_precinct_t *prc = &band->precincts[precno];
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+ opj_tcd_cblk_enc_t *cblk = &prc->cblks.enc[cblkno];
+ opj_tcd_layer_t *layer = &cblk->layers[layno];
+ OPJ_UINT32 n;
+ OPJ_INT32 imsb = tcd->image->comps[compno].prec - cblk->numbps; /* number of bit-plan equal to zero */
+ /* Correction of the matrix of coefficient to include the IMSB information */
+ if (layno == 0) {
+ value = matrice[layno][resno][bandno];
+ if (imsb >= value) {
+ value = 0;
+ } else {
+ value -= imsb;
+ }
+ } else {
+ value = matrice[layno][resno][bandno] - matrice[layno - 1][resno][bandno];
+ if (imsb >= matrice[layno - 1][resno][bandno]) {
+ value -= (imsb - matrice[layno - 1][resno][bandno]);
+ if (value < 0) {
+ value = 0;
+ }
+ }
+ }
+
+ if (layno == 0) {
+ cblk->numpassesinlayers = 0;
+ }
+
+ n = cblk->numpassesinlayers;
+ if (cblk->numpassesinlayers == 0) {
+ if (value != 0) {
+ n = 3 * value - 2 + cblk->numpassesinlayers;
+ } else {
+ n = cblk->numpassesinlayers;
+ }
+ } else {
+ n = 3 * value + cblk->numpassesinlayers;
+ }
+
+ layer->numpasses = n - cblk->numpassesinlayers;
+
+ if (!layer->numpasses)
+ continue;
+
+ if (cblk->numpassesinlayers == 0) {
+ layer->len = cblk->passes[n - 1].rate;
+ layer->data = cblk->data;
+ } else {
+ layer->len = cblk->passes[n - 1].rate - cblk->passes[cblk->numpassesinlayers - 1].rate;
+ layer->data = cblk->data + cblk->passes[cblk->numpassesinlayers - 1].rate;
+ }
+ if (final)
+ cblk->numpassesinlayers = n;
+ }
+ }
+ }
+ }
+ }
+}
+
+void tcd_rateallocate_fixed(opj_tcd_t *tcd) {
+ OPJ_UINT32 layno;
+ for (layno = 0; layno < tcd->tcp->numlayers; layno++) {
+ tcd_makelayer_fixed(tcd, layno, 1);
+ }
+}
+
+void tcd_makelayer(opj_tcd_t *tcd, OPJ_UINT32 layno, OPJ_FLOAT64 thresh, OPJ_UINT32 final) {
+ OPJ_UINT32 compno, resno, bandno, precno, cblkno;
+ OPJ_UINT32 passno;
+
+ opj_tcd_tile_t *tcd_tile = tcd->tcd_image->tiles;
+
+ tcd_tile->distolayer[layno] = 0; /* fixed_quality */
+
+ for (compno = 0; compno < tcd_tile->numcomps; compno++) {
+ opj_tcd_tilecomp_t *tilec = &tcd_tile->comps[compno];
+ for (resno = 0; resno < tilec->numresolutions; resno++) {
+ opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+ for (bandno = 0; bandno < res->numbands; bandno++) {
+ opj_tcd_band_t *band = &res->bands[bandno];
+ for (precno = 0; precno < res->pw * res->ph; precno++) {
+ opj_tcd_precinct_t *prc = &band->precincts[precno];
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+ opj_tcd_cblk_enc_t *cblk = &prc->cblks.enc[cblkno];
+ opj_tcd_layer_t *layer = &cblk->layers[layno];
+
+ OPJ_UINT32 n;
+ if (layno == 0) {
+ cblk->numpassesinlayers = 0;
+ }
+ n = cblk->numpassesinlayers;
+ for (passno = cblk->numpassesinlayers; passno < cblk->totalpasses; passno++) {
+ OPJ_INT32 dr;
+ OPJ_FLOAT64 dd;
+ opj_tcd_pass_t *pass = &cblk->passes[passno];
+ if (n == 0) {
+ dr = pass->rate;
+ dd = pass->distortiondec;
+ } else {
+ dr = pass->rate - cblk->passes[n - 1].rate;
+ dd = pass->distortiondec - cblk->passes[n - 1].distortiondec;
+ }
+ if (!dr) {
+ if (dd != 0)
+ n = passno + 1;
+ continue;
+ }
+ if (dd / dr >= thresh)
+ n = passno + 1;
+ }
+ layer->numpasses = n - cblk->numpassesinlayers;
+
+ if (!layer->numpasses) {
+ layer->disto = 0;
+ continue;
+ }
+ if (cblk->numpassesinlayers == 0) {
+ layer->len = cblk->passes[n - 1].rate;
+ layer->data = cblk->data;
+ layer->disto = cblk->passes[n - 1].distortiondec;
+ } else {
+ layer->len = cblk->passes[n - 1].rate - cblk->passes[cblk->numpassesinlayers - 1].rate;
+ layer->data = cblk->data + cblk->passes[cblk->numpassesinlayers - 1].rate;
+ layer->disto = cblk->passes[n - 1].distortiondec - cblk->passes[cblk->numpassesinlayers - 1].distortiondec;
+ }
+
+ tcd_tile->distolayer[layno] += layer->disto; /* fixed_quality */
+
+ if (final)
+ cblk->numpassesinlayers = n;
+ }
+ }
+ }
+ }
+ }
+}
+
+bool tcd_rateallocate(opj_tcd_t *tcd, OPJ_BYTE *dest, OPJ_UINT32 * p_data_written, OPJ_UINT32 len, opj_codestream_info_t *cstr_info) {
+ OPJ_UINT32 compno, resno, bandno, precno, cblkno, layno;
+ OPJ_UINT32 passno;
+ OPJ_FLOAT64 min, max;
+ OPJ_FLOAT64 cumdisto[100]; /* fixed_quality */
+ const OPJ_FLOAT64 K = 1; /* 1.1; fixed_quality */
+ OPJ_FLOAT64 maxSE = 0;
+
+ opj_cp_t *cp = tcd->cp;
+ opj_tcd_tile_t *tcd_tile = tcd->tcd_image->tiles;
+ opj_tcp_t *tcd_tcp = tcd->tcp;
+
+ min = DBL_MAX;
+ max = 0;
+
+ tcd_tile->numpix = 0; /* fixed_quality */
+
+ for (compno = 0; compno < tcd_tile->numcomps; compno++) {
+ opj_tcd_tilecomp_t *tilec = &tcd_tile->comps[compno];
+ tilec->numpix = 0;
+
+ for (resno = 0; resno < tilec->numresolutions; resno++) {
+ opj_tcd_resolution_t *res = &tilec->resolutions[resno];
+
+ for (bandno = 0; bandno < res->numbands; bandno++) {
+ opj_tcd_band_t *band = &res->bands[bandno];
+
+ for (precno = 0; precno < res->pw * res->ph; precno++) {
+ opj_tcd_precinct_t *prc = &band->precincts[precno];
+
+ for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
+ opj_tcd_cblk_enc_t *cblk = &prc->cblks.enc[cblkno];
+
+ for (passno = 0; passno < cblk->totalpasses; passno++) {
+ opj_tcd_pass_t *pass = &cblk->passes[passno];
+ OPJ_INT32 dr;
+ OPJ_FLOAT64 dd, rdslope;
+ if (passno == 0) {
+ dr = pass->rate;
+ dd = pass->distortiondec;
+ } else {
+ dr = pass->rate - cblk->passes[passno - 1].rate;
+ dd = pass->distortiondec - cblk->passes[passno - 1].distortiondec;
+ }
+ if (dr == 0) {
+ continue;
+ }
+ rdslope = dd / dr;
+ if (rdslope < min) {
+ min = rdslope;
+ }
+ if (rdslope > max) {
+ max = rdslope;
+ }
+ } /* passno */
+
+ /* fixed_quality */
+ tcd_tile->numpix += ((cblk->x1 - cblk->x0) * (cblk->y1 - cblk->y0));
+ tilec->numpix += ((cblk->x1 - cblk->x0) * (cblk->y1 - cblk->y0));
+ } /* cbklno */
+ } /* precno */
+ } /* bandno */
+ } /* resno */
+
+ maxSE += (((OPJ_FLOAT64)(1 << tcd->image->comps[compno].prec) - 1.0)
+ * ((OPJ_FLOAT64)(1 << tcd->image->comps[compno].prec) -1.0))
+ * ((OPJ_FLOAT64)(tilec->numpix));
+ } /* compno */
+
+ /* index file */
+ if(cstr_info) {
+ opj_tile_info_t *tile_info = &cstr_info->tile[tcd->tcd_tileno];
+ tile_info->numpix = tcd_tile->numpix;
+ tile_info->distotile = tcd_tile->distotile;
+ tile_info->thresh = (OPJ_FLOAT64 *) opj_malloc(tcd_tcp->numlayers * sizeof(OPJ_FLOAT64));
+ }
+
+ for (layno = 0; layno < tcd_tcp->numlayers; layno++) {
+ OPJ_FLOAT64 lo = min;
+ OPJ_FLOAT64 hi = max;
+ bool success = false;
+ OPJ_UINT32 maxlen = tcd_tcp->rates[layno] ? uint_min(((OPJ_UINT32) ceil(tcd_tcp->rates[layno])), len) : len;
+ OPJ_FLOAT64 goodthresh = 0;
+ OPJ_FLOAT64 stable_thresh = 0;
+ OPJ_UINT32 i;
+ OPJ_FLOAT64 distotarget; /* fixed_quality */
+
+ /* fixed_quality */
+ distotarget = tcd_tile->distotile - ((K * maxSE) / pow((OPJ_FLOAT32)10, tcd_tcp->distoratio[layno] / 10));
+
+ /* Don't try to find an optimal threshold but rather take everything not included yet, if
+ -r xx,yy,zz,0 (disto_alloc == 1 and rates == 0)
+ -q xx,yy,zz,0 (fixed_quality == 1 and distoratio == 0)
+ ==> possible to have some lossy layers and the last layer for sure lossless */
+ if ( ((cp->m_specific_param.m_enc.m_disto_alloc==1) && (tcd_tcp->rates[layno]>0)) || ((cp->m_specific_param.m_enc.m_fixed_quality==1) && (tcd_tcp->distoratio[layno]>0))) {
+ opj_t2_t *t2 = t2_create(tcd->image, cp);
+ OPJ_FLOAT64 thresh = 0;
+ if
+ (t2 == 00)
+ {
+ return false;
+ }
+
+ for
+ (i = 0; i < 32; ++i)
+ {
+ OPJ_FLOAT64 distoachieved = 0; /* fixed_quality */
+ thresh = (lo + hi) / 2;
+
+ tcd_makelayer(tcd, layno, thresh, 0);
+
+ if (cp->m_specific_param.m_enc.m_fixed_quality) { /* fixed_quality */
+ if(cp->m_specific_param.m_enc.m_cinema){
+ if
+ (! t2_encode_packets(t2,tcd->tcd_tileno, tcd_tile, layno + 1, dest, p_data_written, maxlen, cstr_info,tcd->cur_tp_num,tcd->tp_pos,tcd->cur_pino,THRESH_CALC))
+ {
+ lo = thresh;
+ continue;
+ }
+ else
+ {
+ distoachieved = layno == 0 ?
+ tcd_tile->distolayer[0] : cumdisto[layno - 1] + tcd_tile->distolayer[layno];
+ if (distoachieved < distotarget) {
+ hi=thresh;
+ stable_thresh = thresh;
+ continue;
+ }else{
+ lo=thresh;
+ }
+ }
+ }else{
+ distoachieved = (layno == 0) ?
+ tcd_tile->distolayer[0] : (cumdisto[layno - 1] + tcd_tile->distolayer[layno]);
+ if (distoachieved < distotarget) {
+ hi = thresh;
+ stable_thresh = thresh;
+ continue;
+ }
+ lo = thresh;
+ }
+ } else {
+ if
+ (! t2_encode_packets(t2, tcd->tcd_tileno, tcd_tile, layno + 1, dest,p_data_written, maxlen, cstr_info,tcd->cur_tp_num,tcd->tp_pos,tcd->cur_pino,THRESH_CALC))
+ {
+ /* TODO: what to do with l ??? seek / tell ??? */
+ /* opj_event_msg(tcd->cinfo, EVT_INFO, "rate alloc: len=%d, max=%d\n", l, maxlen); */
+ lo = thresh;
+ continue;
+ }
+ hi = thresh;
+ stable_thresh = thresh;
+ }
+ }
+ success = true;
+ goodthresh = stable_thresh == 0? thresh : stable_thresh;
+ t2_destroy(t2);
+ } else {
+ success = true;
+ goodthresh = min;
+ }
+
+ if (!success) {
+ return false;
+ }
+
+ if(cstr_info) { /* Threshold for Marcela Index */
+ cstr_info->tile[tcd->tcd_tileno].thresh[layno] = goodthresh;
+ }
+ tcd_makelayer(tcd, layno, goodthresh, 1);
+
+ /* fixed_quality */
+ cumdisto[layno] = (layno == 0) ? tcd_tile->distolayer[0] : (cumdisto[layno - 1] + tcd_tile->distolayer[layno]);
+ }
+
+ return true;
+}
+
+OPJ_UINT32 tcd_get_encoded_tile_size (
+ opj_tcd_t *p_tcd
+ )
+{
+ OPJ_UINT32 i,l_data_size = 0;
+ opj_image_comp_t * l_img_comp = 00;
+ opj_tcd_tilecomp_t * l_tilec = 00;
+ OPJ_UINT32 l_size_comp, l_remaining;
+
+ l_tilec = p_tcd->tcd_image->tiles->comps;
+ l_img_comp = p_tcd->image->comps;
+ for
+ (i=0;i<p_tcd->image->numcomps;++i)
+ {
+ l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/
+ l_remaining = l_img_comp->prec & 7; /* (%8) */
+ if
+ (l_remaining)
+ {
+ ++l_size_comp;
+ }
+ if
+ (l_size_comp == 3)
+ {
+ l_size_comp = 4;
+ }
+ l_data_size += l_size_comp * (l_tilec->x1 - l_tilec->x0) * (l_tilec->y1 - l_tilec->y0);
+ ++l_img_comp;
+ ++l_tilec;
+ }
+ return l_data_size;
+}
+
+bool tcd_copy_tile_data (
+ opj_tcd_t *p_tcd,
+ OPJ_BYTE * p_src,
+ OPJ_UINT32 p_src_length
+ )
+{
+ OPJ_UINT32 i,j,l_data_size = 0;
+ opj_image_comp_t * l_img_comp = 00;
+ opj_tcd_tilecomp_t * l_tilec = 00;
+ OPJ_UINT32 l_size_comp, l_remaining;
+ OPJ_UINT32 l_nb_elem;
+
+ l_data_size = tcd_get_encoded_tile_size(p_tcd);
+ if
+ (l_data_size != p_src_length)
+ {
+ return false;
+ }
+ l_tilec = p_tcd->tcd_image->tiles->comps;
+ l_img_comp = p_tcd->image->comps;
+ for
+ (i=0;i<p_tcd->image->numcomps;++i)
+ {
+ l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/
+ l_remaining = l_img_comp->prec & 7; /* (%8) */
+ l_nb_elem = (l_tilec->x1 - l_tilec->x0) * (l_tilec->y1 - l_tilec->y0);
+ if
+ (l_remaining)
+ {
+ ++l_size_comp;
+ }
+ if
+ (l_size_comp == 3)
+ {
+ l_size_comp = 4;
+ }
+ switch
+ (l_size_comp)
+ {
+ case 1:
+ {
+ OPJ_CHAR * l_src_ptr = (OPJ_CHAR *) p_src;
+ OPJ_INT32 * l_dest_ptr = l_tilec->data;
+ if
+ (l_img_comp->sgnd)
+ {
+ for
+ (j=0;j<l_nb_elem;++j)
+ {
+ *(l_dest_ptr++) = (OPJ_INT32) (*(l_src_ptr++));
+ }
+ }
+ else
+ {
+ for
+ (j=0;j<l_nb_elem;++j)
+ {
+ *(l_dest_ptr++) = (*(l_src_ptr++))&0xff;
+ }
+ }
+ p_src = (OPJ_BYTE*) l_src_ptr;
+ }
+ break;
+ case 2:
+ {
+ OPJ_INT32 * l_dest_ptr = l_tilec->data;
+ OPJ_INT16 * l_src_ptr = (OPJ_INT16 *) p_src;
+ if
+ (l_img_comp->sgnd)
+ {
+ for
+ (j=0;j<l_nb_elem;++j)
+ {
+ *(l_dest_ptr++) = (OPJ_INT32) (*(l_src_ptr++));
+ }
+ }
+ else
+ {
+ for
+ (j=0;j<l_nb_elem;++j)
+ {
+ *(l_dest_ptr++) = (*(l_src_ptr++))&0xffff;
+ }
+
+ }
+ p_src = (OPJ_BYTE*) l_src_ptr;
+ }
+ break;
+ case 4:
+ {
+ OPJ_INT32 * l_src_ptr = (OPJ_INT32 *) p_src;
+ OPJ_INT32 * l_dest_ptr = l_tilec->data;
+ for
+ (j=0;j<l_nb_elem;++j)
+ {
+ *(l_dest_ptr++) = (OPJ_INT32) (*(l_src_ptr++));
+ }
+ p_src = (OPJ_BYTE*) l_src_ptr;
+ }
+ break;
+ }
+ ++l_img_comp;
+ ++l_tilec;
+ }
+ return true;
+}
+
+bool tcd_update_tile_data (
+ opj_tcd_t *p_tcd,
+ OPJ_BYTE * p_dest,
+ OPJ_UINT32 p_dest_length
+ )
+{
+ OPJ_UINT32 i,j,k,l_data_size = 0;
+ opj_image_comp_t * l_img_comp = 00;
+ opj_tcd_tilecomp_t * l_tilec = 00;
+ opj_tcd_resolution_t * l_res;
+ OPJ_UINT32 l_size_comp, l_remaining;
+ OPJ_UINT32 l_stride, l_width,l_height;
+
+ l_data_size = tcd_get_decoded_tile_size(p_tcd);
+ if
+ (l_data_size > p_dest_length)
+ {
+ return false;
+ }
+
+ l_tilec = p_tcd->tcd_image->tiles->comps;
+ l_img_comp = p_tcd->image->comps;
+ for
+ (i=0;i<p_tcd->image->numcomps;++i)
+ {
+ l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/
+ l_remaining = l_img_comp->prec & 7; /* (%8) */
+ l_res = l_tilec->resolutions + l_img_comp->resno_decoded;
+ l_width = (l_res->x1 - l_res->x0);
+ l_height = (l_res->y1 - l_res->y0);
+ l_stride = (l_tilec->x1 - l_tilec->x0) - l_width;
+ if
+ (l_remaining)
+ {
+ ++l_size_comp;
+ }
+ if
+ (l_size_comp == 3)
+ {
+ l_size_comp = 4;
+ }
+ switch
+ (l_size_comp)
+ {
+ case 1:
+ {
+ OPJ_CHAR * l_dest_ptr = (OPJ_CHAR *) p_dest;
+ const OPJ_INT32 * l_src_ptr = l_tilec->data;
+ if
+ (l_img_comp->sgnd)
+ {
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (k=0;k<l_width;++k)
+ {
+ *(l_dest_ptr++) = (OPJ_CHAR) (*(l_src_ptr++));
+ }
+ l_src_ptr += l_stride;
+ }
+ }
+ else
+ {
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (k=0;k<l_width;++k)
+ {
+ *(l_dest_ptr++) = (OPJ_BYTE) ((*(l_src_ptr++))&0xff);
+ }
+ l_src_ptr += l_stride;
+ }
+ }
+ p_dest = (OPJ_BYTE *)l_dest_ptr;
+
+ }
+ break;
+ case 2:
+ {
+ const OPJ_INT32 * l_src_ptr = l_tilec->data;
+ OPJ_INT16 * l_dest_ptr = (OPJ_INT16 *) p_dest;
+ if
+ (l_img_comp->sgnd)
+ {
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (k=0;k<l_width;++k)
+ {
+ *(l_dest_ptr++) = (OPJ_INT16) (*(l_src_ptr++));
+ }
+ l_src_ptr += l_stride;
+ }
+ }
+ else
+ {
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (k=0;k<l_width;++k)
+ {
+ *(l_dest_ptr++) = (OPJ_UINT16) ((*(l_src_ptr++))&0xffff);
+ }
+ l_src_ptr += l_stride;
+ }
+ }
+ p_dest = (OPJ_BYTE*) l_dest_ptr;
+ }
+ break;
+ case 4:
+ {
+ OPJ_INT32 * l_dest_ptr = (OPJ_INT32 *) p_dest;
+ OPJ_INT32 * l_src_ptr = l_tilec->data;
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (k=0;k<l_width;++k)
+ {
+ *(l_dest_ptr++) = (*(l_src_ptr++));
+ }
+ l_src_ptr += l_stride;
+ }
+ p_dest = (OPJ_BYTE*) l_dest_ptr;
+ }
+ break;
+ }
+ ++l_img_comp;
+ ++l_tilec;
+ }
+ return true;
+}
+
+OPJ_UINT32 tcd_get_decoded_tile_size (
+ opj_tcd_t *p_tcd
+ )
+{
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_data_size = 0;
+ opj_image_comp_t * l_img_comp = 00;
+ opj_tcd_tilecomp_t * l_tile_comp = 00;
+ opj_tcd_resolution_t * l_res = 00;
+ OPJ_UINT32 l_size_comp, l_remaining;
+
+ l_tile_comp = p_tcd->tcd_image->tiles->comps;
+ l_img_comp = p_tcd->image->comps;
+ for
+ (i=0;i<p_tcd->image->numcomps;++i)
+ {
+ l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/
+ l_remaining = l_img_comp->prec & 7; /* (%8) */
+ if
+ (l_remaining)
+ {
+ ++l_size_comp;
+ }
+ if
+ (l_size_comp == 3)
+ {
+ l_size_comp = 4;
+ }
+ l_res = l_tile_comp->resolutions + l_tile_comp->minimum_num_resolutions - 1;
+ l_data_size += l_size_comp * (l_res->x1 - l_res->x0) * (l_res->y1 - l_res->y0);
+ ++l_img_comp;
+ ++l_tile_comp;
+ }
+ return l_data_size;
+}
+
+bool tcd_dc_level_shift_encode (
+ opj_tcd_t *p_tcd
+ )
+{
+ OPJ_UINT32 compno;
+ opj_tcd_tilecomp_t * l_tile_comp = 00;
+ opj_tccp_t * l_tccp = 00;
+ opj_image_comp_t * l_img_comp = 00;
+ opj_tcp_t * l_tcp = 00;
+ opj_tcd_tile_t * l_tile;
+ OPJ_UINT32 l_nb_elem,i;
+ OPJ_INT32 * l_current_ptr;
+
+ l_tile = p_tcd->tcd_image->tiles;
+ l_tile_comp = l_tile->comps;
+ l_tcp = p_tcd->tcp;
+ l_tccp = p_tcd->tcp->tccps;
+ l_img_comp = p_tcd->image->comps;
+ for
+ (compno = 0; compno < l_tile->numcomps; compno++)
+ {
+ l_current_ptr = l_tile_comp->data;
+ l_nb_elem = (l_tile_comp->x1 - l_tile_comp->x0) * (l_tile_comp->y1 - l_tile_comp->y0);
+ if
+ (l_tccp->qmfbid == 1)
+ {
+ for
+ (i = 0; i < l_nb_elem; ++i)
+ {
+ *l_current_ptr -= l_tccp->m_dc_level_shift ;
+ ++l_current_ptr;
+ }
+ }
+ else
+ {
+ for
+ (i = 0; i < l_nb_elem; ++i)
+ {
+ *l_current_ptr = (*l_current_ptr - l_tccp->m_dc_level_shift) << 11 ;
+ ++l_current_ptr;
+ }
+ }
+ ++l_img_comp;
+ ++l_tccp;
+ ++l_tile_comp;
+ }
+ return true;
+}
+
+bool tcd_mct_encode (
+ opj_tcd_t *p_tcd
+ )
+{
+ opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles;
+ opj_tcd_tilecomp_t * l_tile_comp = p_tcd->tcd_image->tiles->comps;
+ OPJ_UINT32 samples = (l_tile_comp->x1 - l_tile_comp->x0) * (l_tile_comp->y1 - l_tile_comp->y0);
+ OPJ_UINT32 i;
+ OPJ_BYTE ** l_data = 00;
+ opj_tcp_t * l_tcp = p_tcd->tcp;
+ if
+ (!p_tcd->tcp->mct)
+ {
+ return true;
+ }
+
+ if
+ (p_tcd->tcp->mct == 2)
+ {
+ if
+ (! p_tcd->tcp->m_mct_coding_matrix)
+ {
+ return true;
+ }
+ l_data = (OPJ_BYTE **) opj_malloc(l_tile->numcomps*sizeof(OPJ_BYTE*));
+ if
+ (! l_data)
+ {
+ return false;
+ }
+ for
+ (i=0;i<l_tile->numcomps;++i)
+ {
+ l_data[i] = (OPJ_BYTE*) l_tile_comp->data;
+ ++l_tile_comp;
+ }
+ if
+ (! mct_encode_custom(// MCT data
+ (OPJ_BYTE*) p_tcd->tcp->m_mct_coding_matrix,
+ // size of components
+ samples,
+ // components
+ l_data,
+ // nb of components (i.e. size of pData)
+ l_tile->numcomps,
+ // tells if the data is signed
+ p_tcd->image->comps->sgnd)
+ )
+ {
+ opj_free(l_data);
+ return false;
+ }
+ opj_free(l_data);
+ }
+ else if (l_tcp->tccps->qmfbid == 0)
+ {
+ mct_encode_real(l_tile->comps[0].data, l_tile->comps[1].data, l_tile->comps[2].data, samples);
+ }
+ else
+ {
+ mct_encode(l_tile->comps[0].data, l_tile->comps[1].data, l_tile->comps[2].data, samples);
+ }
+ return true;
+}
+
+bool tcd_dwt_encode (
+ opj_tcd_t *p_tcd
+ )
+{
+ opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles;
+ opj_tcd_tilecomp_t * l_tile_comp = p_tcd->tcd_image->tiles->comps;
+ opj_tccp_t * l_tccp = p_tcd->tcp->tccps;
+ OPJ_UINT32 compno;
+
+
+ for
+ (compno = 0; compno < l_tile->numcomps; ++compno)
+ {
+ if
+ (l_tccp->qmfbid == 1)
+ {
+ if
+ (! dwt_encode(l_tile_comp))
+ {
+ return false;
+ }
+ }
+ else if
+ (l_tccp->qmfbid == 0)
+ {
+ if
+ (! dwt_encode_real(l_tile_comp))
+ {
+ return false;
+ }
+ }
+ ++l_tile_comp;
+ ++l_tccp;
+ }
+ return true;
+}
+
+bool tcd_t1_encode (
+ opj_tcd_t *p_tcd
+ )
+{
+ opj_t1_t * l_t1;
+ const OPJ_FLOAT64 * l_mct_norms;
+ opj_tcp_t * l_tcp = p_tcd->tcp;
+
+ l_t1 = t1_create();
+ if
+ (l_t1 == 00)
+ {
+ return false;
+ }
+ if
+ (l_tcp->mct == 1)
+ {
+ // irreversible encoding
+ if
+ (l_tcp->tccps->qmfbid == 0)
+ {
+ l_mct_norms = get_mct_norms_real();
+ }
+ else
+ {
+ l_mct_norms = get_mct_norms();
+ }
+ }
+ else
+ {
+ l_mct_norms = (const OPJ_FLOAT64 *) (l_tcp->mct_norms);
+ }
+
+ if
+ (! t1_encode_cblks(l_t1, p_tcd->tcd_image->tiles , l_tcp, l_mct_norms))
+ {
+ t1_destroy(l_t1);
+ return false;
+ }
+ t1_destroy(l_t1);
+ return true;
+}
+
+bool tcd_t2_encode (
+ opj_tcd_t *p_tcd,
+ OPJ_BYTE * p_dest_data,
+ OPJ_UINT32 * p_data_written,
+ OPJ_UINT32 p_max_dest_size,
+ opj_codestream_info_t *p_cstr_info
+ )
+{
+ opj_t2_t * l_t2;
+
+ l_t2 = t2_create(p_tcd->image, p_tcd->cp);
+ if
+ (l_t2 == 00)
+ {
+ return false;
+ }
+
+ if
+ (! t2_encode_packets(
+ l_t2,
+ p_tcd->tcd_tileno,
+ p_tcd->tcd_image->tiles,
+ p_tcd->tcp->numlayers,
+ p_dest_data,
+ p_data_written,
+ p_max_dest_size,
+ p_cstr_info,
+ p_tcd->tp_num,
+ p_tcd->tp_pos,
+ p_tcd->cur_pino,
+ FINAL_PASS))
+ {
+ t2_destroy(l_t2);
+ return false;
+ }
+ t2_destroy(l_t2);
+
+ /*---------------CLEAN-------------------*/
+ return true;
+}
+
+bool tcd_rate_allocate_encode(
+ opj_tcd_t *p_tcd,
+ OPJ_BYTE * p_dest_data,
+ OPJ_UINT32 p_max_dest_size,
+ opj_codestream_info_t *p_cstr_info
+ )
+{
+ opj_cp_t * l_cp = p_tcd->cp;
+ OPJ_UINT32 l_nb_written = 0;
+
+ if
+ (p_cstr_info)
+ {
+ p_cstr_info->index_write = 0;
+ }
+ if
+ (l_cp->m_specific_param.m_enc.m_disto_alloc|| l_cp->m_specific_param.m_enc.m_fixed_quality)
+ { /* fixed_quality */
+ /* Normal Rate/distortion allocation */
+ if
+ (! tcd_rateallocate(p_tcd, p_dest_data,&l_nb_written, p_max_dest_size, p_cstr_info))
+ {
+ return false;
+ }
+ }
+ else
+ {
+ /* Fixed layer allocation */
+ tcd_rateallocate_fixed(p_tcd);
+ }
+ return true;
+}
+
+bool tcd_t2_decode (
+ opj_tcd_t *p_tcd,
+ OPJ_BYTE * p_src_data,
+ OPJ_UINT32 * p_data_read,
+ OPJ_UINT32 p_max_src_size,
+ opj_codestream_info_t *p_cstr_info
+ )
+{
+ opj_t2_t * l_t2;
+
+ l_t2 = t2_create(p_tcd->image, p_tcd->cp);
+ if
+ (l_t2 == 00)
+ {
+ return false;
+ }
+
+ if
+ (! t2_decode_packets(
+ l_t2,
+ p_tcd->tcd_tileno,
+ p_tcd->tcd_image->tiles,
+ p_src_data,
+ p_data_read,
+ p_max_src_size,
+ p_cstr_info))
+ {
+ t2_destroy(l_t2);
+ return false;
+ }
+ t2_destroy(l_t2);
+
+ /*---------------CLEAN-------------------*/
+ return true;
+}
+
+bool tcd_t1_decode (
+ opj_tcd_t *p_tcd
+ )
+{
+ OPJ_UINT32 compno;
+ opj_t1_t * l_t1;
+ opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles;
+ opj_tcd_tilecomp_t* l_tile_comp = l_tile->comps;
+ opj_tccp_t * l_tccp = p_tcd->tcp->tccps;
+
+
+ l_t1 = t1_create();
+ if
+ (l_t1 == 00)
+ {
+ return false;
+ }
+ for
+ (compno = 0; compno < l_tile->numcomps; ++compno)
+ {
+ /* The +3 is headroom required by the vectorized DWT */
+ t1_decode_cblks(l_t1, l_tile_comp, l_tccp);
+ ++l_tile_comp;
+ ++l_tccp;
+ }
+ t1_destroy(l_t1);
+ return true;
+}
+
+bool tcd_dwt_decode (
+ opj_tcd_t *p_tcd
+ )
+{
+ OPJ_UINT32 compno;
+ opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles;
+ opj_tcd_tilecomp_t * l_tile_comp = l_tile->comps;
+ opj_tccp_t * l_tccp = p_tcd->tcp->tccps;
+ opj_image_comp_t * l_img_comp = p_tcd->image->comps;
+
+ for
+ (compno = 0; compno < l_tile->numcomps; compno++)
+ {
+ /*
+ if (tcd->cp->reduce != 0) {
+ tcd->image->comps[compno].resno_decoded =
+ tile->comps[compno].numresolutions - tcd->cp->reduce - 1;
+ if (tcd->image->comps[compno].resno_decoded < 0)
+ {
+ return false;
+ }
+ }
+ numres2decode = tcd->image->comps[compno].resno_decoded + 1;
+ if(numres2decode > 0){
+ */
+ if
+ (l_tccp->qmfbid == 1)
+ {
+ if
+ (! dwt_decode(l_tile_comp, l_img_comp->resno_decoded+1))
+ {
+ return false;
+ }
+ }
+ else
+ {
+ if
+ (! dwt_decode_real(l_tile_comp, l_img_comp->resno_decoded+1))
+ {
+ return false;
+ }
+ }
+ ++l_tile_comp;
+ ++l_img_comp;
+ ++l_tccp;
+ }
+ return true;
+}
+bool tcd_mct_decode (
+ opj_tcd_t *p_tcd
+ )
+{
+ opj_tcd_tile_t * l_tile = p_tcd->tcd_image->tiles;
+ opj_tcp_t * l_tcp = p_tcd->tcp;
+ opj_tcd_tilecomp_t * l_tile_comp = l_tile->comps;
+ OPJ_UINT32 l_samples,i;
+
+ if
+ (! l_tcp->mct)
+ {
+ return true;
+ }
+ l_samples = (l_tile_comp->x1 - l_tile_comp->x0) * (l_tile_comp->y1 - l_tile_comp->y0);
+ if
+ (l_tcp->mct == 2)
+ {
+ OPJ_BYTE ** l_data;
+ if
+ (! l_tcp->m_mct_decoding_matrix)
+ {
+ return true;
+ }
+ l_data = (OPJ_BYTE **) opj_malloc(l_tile->numcomps*sizeof(OPJ_BYTE*));
+ if
+ (! l_data)
+ {
+ return false;
+ }
+ for
+ (i=0;i<l_tile->numcomps;++i)
+ {
+ l_data[i] = (OPJ_BYTE*) l_tile_comp->data;
+ ++l_tile_comp;
+ }
+ if
+ (! mct_decode_custom( // MCT data
+ (OPJ_BYTE*) l_tcp->m_mct_decoding_matrix,
+ // size of components
+ l_samples,
+ // components
+ l_data,
+ // nb of components (i.e. size of pData)
+ l_tile->numcomps,
+ // tells if the data is signed
+ p_tcd->image->comps->sgnd))
+ {
+ opj_free(l_data);
+ return false;
+ }
+ opj_free(l_data);
+ }
+ else
+ {
+ if
+ (l_tcp->tccps->qmfbid == 1)
+ {
+ mct_decode(
+ l_tile->comps[0].data,
+ l_tile->comps[1].data,
+ l_tile->comps[2].data,
+ l_samples);
+ }
+ else
+ {
+ mct_decode_real(
+ (float*)l_tile->comps[0].data,
+ (float*)l_tile->comps[1].data,
+ (float*)l_tile->comps[2].data,
+ l_samples);
+ }
+ }
+ return true;
+}
+
+bool tcd_dc_level_shift_decode (
+ opj_tcd_t *p_tcd
+ )
+{
+ OPJ_UINT32 compno;
+ opj_tcd_tilecomp_t * l_tile_comp = 00;
+ opj_tccp_t * l_tccp = 00;
+ opj_image_comp_t * l_img_comp = 00;
+ opj_tcd_resolution_t* l_res = 00;
+ opj_tcp_t * l_tcp = 00;
+ opj_tcd_tile_t * l_tile;
+ OPJ_UINT32 l_width,l_height,i,j;
+ OPJ_INT32 * l_current_ptr;
+ OPJ_INT32 l_min, l_max;
+ OPJ_UINT32 l_stride;
+
+ l_tile = p_tcd->tcd_image->tiles;
+ l_tile_comp = l_tile->comps;
+ l_tcp = p_tcd->tcp;
+ l_tccp = p_tcd->tcp->tccps;
+ l_img_comp = p_tcd->image->comps;
+
+ for
+ (compno = 0; compno < l_tile->numcomps; compno++)
+ {
+ l_res = l_tile_comp->resolutions + l_img_comp->resno_decoded;
+ l_width = (l_res->x1 - l_res->x0);
+ l_height = (l_res->y1 - l_res->y0);
+ l_stride = (l_tile_comp->x1 - l_tile_comp->x0) - l_width;
+ if
+ (l_img_comp->sgnd)
+ {
+ l_min = -(1 << (l_img_comp->prec - 1));
+ l_max = (1 << (l_img_comp->prec - 1)) - 1;
+ }
+ else
+ {
+ l_min = 0;
+ l_max = (1 << l_img_comp->prec) - 1;
+ }
+ l_current_ptr = l_tile_comp->data;
+ if
+ (l_tccp->qmfbid == 1)
+ {
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (i = 0; i < l_width; ++i)
+ {
+ *l_current_ptr = int_clamp(*l_current_ptr + l_tccp->m_dc_level_shift, l_min, l_max);
+ ++l_current_ptr;
+ }
+ l_current_ptr += l_stride;
+ }
+ }
+ else
+ {
+ for
+ (j=0;j<l_height;++j)
+ {
+ for
+ (i = 0; i < l_width; ++i)
+ {
+ OPJ_FLOAT32 l_value = *((OPJ_FLOAT32 *) l_current_ptr);
+ *l_current_ptr = int_clamp(lrintf(l_value) + l_tccp->m_dc_level_shift, l_min, l_max); ;
+ ++l_current_ptr;
+ }
+ l_current_ptr += l_stride;
+ }
+ }
+ ++l_img_comp;
+ ++l_tccp;
+ ++l_tile_comp;
+ }
+ return true;
+}
+
+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_max_length,
+ opj_codestream_info_t *p_cstr_info)
+{
+
+ if
+ (p_tcd->cur_tp_num == 0)
+ {
+ p_tcd->tcd_tileno = p_tile_no;
+ p_tcd->tcp = &p_tcd->cp->tcps[p_tile_no];
+ /* INDEX >> "Precinct_nb_X et Precinct_nb_Y" */
+ if(p_cstr_info)
+ {
+ OPJ_UINT32 l_num_packs = 0;
+ OPJ_UINT32 i;
+ opj_tcd_tilecomp_t *l_tilec_idx = &p_tcd->tcd_image->tiles->comps[0]; /* based on component 0 */
+ opj_tccp_t *l_tccp = p_tcd->tcp->tccps; /* based on component 0 */
+ for (i = 0; i < l_tilec_idx->numresolutions; i++) {
+ opj_tcd_resolution_t *l_res_idx = &l_tilec_idx->resolutions[i];
+
+ p_cstr_info->tile[p_tile_no].pw[i] = l_res_idx->pw;
+ p_cstr_info->tile[p_tile_no].ph[i] = l_res_idx->ph;
+
+ l_num_packs += l_res_idx->pw * l_res_idx->ph;
+ p_cstr_info->tile[p_tile_no].pdx[i] = l_tccp->prcw[i];
+ p_cstr_info->tile[p_tile_no].pdy[i] = l_tccp->prch[i];
+ }
+ p_cstr_info->tile[p_tile_no].packet = (opj_packet_info_t*) opj_calloc(p_cstr_info->numcomps * p_cstr_info->numlayers * l_num_packs, sizeof(opj_packet_info_t));
+ }
+ /* << INDEX */
+ _ProfStart(PGROUP_DC_SHIFT);
+ /*---------------TILE-------------------*/
+ if
+ (! tcd_dc_level_shift_encode(p_tcd))
+ {
+ return false;
+ }
+ _ProfStop(PGROUP_DC_SHIFT);
+
+ _ProfStart(PGROUP_MCT);
+ if
+ (! tcd_mct_encode(p_tcd))
+ {
+ return false;
+ }
+ _ProfStop(PGROUP_MCT);
+
+ _ProfStart(PGROUP_DWT);
+ if
+ (! tcd_dwt_encode(p_tcd))
+ {
+ return false;
+ }
+ _ProfStop(PGROUP_DWT);
+
+ _ProfStart(PGROUP_T1);
+ if
+ (! tcd_t1_encode(p_tcd))
+ {
+ return false;
+ }
+ _ProfStop(PGROUP_T1);
+
+ _ProfStart(PGROUP_RATE);
+ if
+ (! tcd_rate_allocate_encode(p_tcd,p_dest,p_max_length,p_cstr_info))
+ {
+ return false;
+ }
+ _ProfStop(PGROUP_RATE);
+
+ }
+ /*--------------TIER2------------------*/
+
+ /* INDEX */
+ if
+ (p_cstr_info)
+ {
+ p_cstr_info->index_write = 1;
+ }
+ _ProfStart(PGROUP_T2);
+ if
+ (! tcd_t2_encode(p_tcd,p_dest,p_data_written,p_max_length,p_cstr_info))
+ {
+ return false;
+ }
+ _ProfStop(PGROUP_T2);
+ /*---------------CLEAN-------------------*/
+ return true;
+}
+
+bool tcd_decode_tile(
+ opj_tcd_t *p_tcd,
+ OPJ_BYTE *p_src,
+ OPJ_UINT32 p_max_length,
+ OPJ_UINT32 p_tile_no,
+ opj_codestream_info_t *p_cstr_info)
+{
+ OPJ_UINT32 l_data_read;
+ p_tcd->tcd_tileno = p_tile_no;
+ p_tcd->tcp = &(p_tcd->cp->tcps[p_tile_no]);
+
+ /* INDEX >> */
+ if(p_cstr_info) {
+ OPJ_UINT32 resno, compno, numprec = 0;
+ for (compno = 0; compno < (OPJ_UINT32) p_cstr_info->numcomps; compno++) {
+ opj_tcp_t *tcp = &p_tcd->cp->tcps[0];
+ opj_tccp_t *tccp = &tcp->tccps[compno];
+ opj_tcd_tilecomp_t *tilec_idx = &p_tcd->tcd_image->tiles->comps[compno];
+ for (resno = 0; resno < tilec_idx->numresolutions; resno++) {
+ opj_tcd_resolution_t *res_idx = &tilec_idx->resolutions[resno];
+ p_cstr_info->tile[p_tile_no].pw[resno] = res_idx->pw;
+ p_cstr_info->tile[p_tile_no].ph[resno] = res_idx->ph;
+ numprec += res_idx->pw * res_idx->ph;
+ p_cstr_info->tile[p_tile_no].pdx[resno] = tccp->prcw[resno];
+ p_cstr_info->tile[p_tile_no].pdy[resno] = tccp->prch[resno];
+ }
+ }
+ p_cstr_info->tile[p_tile_no].packet = (opj_packet_info_t *) opj_malloc(p_cstr_info->numlayers * numprec * sizeof(opj_packet_info_t));
+ p_cstr_info->packno = 0;
+ }
+ /* << INDEX */
+
+ /*--------------TIER2------------------*/
+ _ProfStart(PGROUP_T2);
+ l_data_read = 0;
+ if
+ (! tcd_t2_decode(p_tcd,p_src,&l_data_read,p_max_length,p_cstr_info))
+ {
+ return false;
+ }
+ _ProfStop(PGROUP_T2);
+
+ /*------------------TIER1-----------------*/
+
+ _ProfStart(PGROUP_T1);
+ if
+ (! tcd_t1_decode(p_tcd))
+ {
+ return false;
+ }
+ _ProfStop(PGROUP_T1);
+
+ /*----------------DWT---------------------*/
+
+ _ProfStart(PGROUP_DWT);
+ if
+ (! tcd_dwt_decode(p_tcd))
+ {
+ return false;
+ }
+ _ProfStop(PGROUP_DWT);
+
+ /*----------------MCT-------------------*/
+ _ProfStart(PGROUP_MCT);
+ if
+ (! tcd_mct_decode(p_tcd))
+ {
+ return false;
+ }
+ _ProfStop(PGROUP_MCT);
+
+ _ProfStart(PGROUP_DC_SHIFT);
+ if
+ (! tcd_dc_level_shift_decode(p_tcd))
+ {
+ return false;
+ }
+ _ProfStop(PGROUP_DC_SHIFT);
+
+
+ /*---------------TILE-------------------*/
+ return true;
+}
diff --git a/v2/libopenjpeg/tcd.h b/v2/libopenjpeg/tcd.h new file mode 100755 index 00000000..95d49d47 --- /dev/null +++ b/v2/libopenjpeg/tcd.h @@ -0,0 +1,344 @@ +/*
+ * 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) 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 __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
+each other. The functions in TCD.C are used by some function in J2K.C.
+*/
+#include "openjpeg.h"
+/** @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
+*/
+typedef struct opj_tcd_seg {
+ 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
+*/
+typedef struct opj_tcd_pass {
+ OPJ_UINT32 rate;
+ OPJ_FLOAT64 distortiondec;
+ OPJ_UINT32 len;
+ OPJ_UINT32 term : 1;
+} opj_tcd_pass_t;
+
+/**
+FIXME: documentation
+*/
+typedef struct opj_tcd_layer {
+ 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
+*/
+typedef struct opj_tcd_cblk_enc {
+ OPJ_BYTE* data; /* Data */
+ 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
+*/
+typedef struct opj_tcd_precinct {
+ OPJ_INT32 x0, y0, x1, y1; /* dimension of the precinct : left upper corner (x0, y0) right low corner (x1,y1) */
+ 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
+*/
+typedef struct opj_tcd_band {
+ 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;
+
+/**
+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;
+
+/**
+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 */
diff --git a/v2/libopenjpeg/tgt.c b/v2/libopenjpeg/tgt.c new file mode 100755 index 00000000..5eb24893 --- /dev/null +++ b/v2/libopenjpeg/tgt.c @@ -0,0 +1,344 @@ +/*
+ * 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) 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 "tgt.h"
+#include "bio.h"
+#include "opj_malloc.h"
+
+/*
+==========================================================
+ Tag-tree coder interface
+==========================================================
+*/
+
+opj_tgt_tree_t *tgt_create(OPJ_UINT32 numleafsh, OPJ_UINT32 numleafsv) {
+ OPJ_INT32 nplh[32];
+ OPJ_INT32 nplv[32];
+ opj_tgt_node_t *node = 00;
+ 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));
+ if(!tree) return 00;
+ memset(tree,0,sizeof(opj_tgt_tree_t));
+
+ tree->numleafsh = numleafsh;
+ tree->numleafsv = numleafsv;
+
+ numlvls = 0;
+ nplh[0] = numleafsh;
+ nplv[0] = numleafsv;
+ tree->numnodes = 0;
+ do {
+ n = nplh[numlvls] * nplv[numlvls];
+ nplh[numlvls + 1] = (nplh[numlvls] + 1) / 2;
+ nplv[numlvls + 1] = (nplv[numlvls] + 1) / 2;
+ tree->numnodes += n;
+ ++numlvls;
+ } while (n > 1);
+
+ /* ADD */
+ if (tree->numnodes == 0) {
+ opj_free(tree);
+ return 00;
+ }
+
+ tree->nodes = (opj_tgt_node_t*) opj_calloc(tree->numnodes, sizeof(opj_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;
+ l_parent_node = &tree->nodes[tree->numleafsh * tree->numleafsv];
+ l_parent_node0 = l_parent_node;
+
+ for (i = 0; i < numlvls - 1; ++i) {
+ for (j = 0; j < nplv[i]; ++j) {
+ k = nplh[i];
+ while (--k >= 0) {
+ node->parent = l_parent_node;
+ ++node;
+ if (--k >= 0) {
+ node->parent = l_parent_node;
+ ++node;
+ }
+ ++l_parent_node;
+ }
+ if ((j & 1) || j == nplv[i] - 1) {
+ l_parent_node0 = l_parent_node;
+ } else {
+ l_parent_node = l_parent_node0;
+ l_parent_node0 += nplh[i];
+ }
+ }
+ }
+ node->parent = 0;
+ tgt_reset(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
+ (! p_tree)
+ {
+ return 00;
+ }
+ 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)
+{
+ if
+ (! 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];
+ while (node && node->value > value) {
+ node->value = value;
+ node = node->parent;
+ }
+}
+
+void tgt_encode(opj_bio_t *bio, opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT32 threshold) {
+ opj_tgt_node_t *stk[31];
+ opj_tgt_node_t **stkptr;
+ opj_tgt_node_t *node;
+ OPJ_INT32 low;
+
+ stkptr = stk;
+ node = &tree->nodes[leafno];
+ while (node->parent) {
+ *stkptr++ = node;
+ node = node->parent;
+ }
+
+ low = 0;
+ for (;;) {
+ if (low > node->low) {
+ node->low = low;
+ } else {
+ low = node->low;
+ }
+
+ while (low < threshold) {
+ if (low >= node->value) {
+ if (!node->known) {
+ bio_write(bio, 1, 1);
+ node->known = 1;
+ }
+ break;
+ }
+ bio_write(bio, 0, 1);
+ ++low;
+ }
+
+ node->low = low;
+ if (stkptr == stk)
+ break;
+ node = *--stkptr;
+ }
+}
+
+OPJ_UINT32 tgt_decode(opj_bio_t *bio, opj_tgt_tree_t *tree, OPJ_UINT32 leafno, OPJ_INT32 threshold) {
+ opj_tgt_node_t *stk[31];
+ opj_tgt_node_t **stkptr;
+ opj_tgt_node_t *node;
+ OPJ_INT32 low;
+
+ stkptr = stk;
+ node = &tree->nodes[leafno];
+ while (node->parent) {
+ *stkptr++ = node;
+ node = node->parent;
+ }
+
+ low = 0;
+ for (;;) {
+ if (low > node->low) {
+ node->low = low;
+ } else {
+ low = node->low;
+ }
+ while (low < threshold && low < node->value) {
+ if (bio_read(bio, 1)) {
+ node->value = low;
+ } else {
+ ++low;
+ }
+ }
+ node->low = low;
+ if (stkptr == stk) {
+ break;
+ }
+ node = *--stkptr;
+ }
+
+ return (node->value < threshold) ? 1 : 0;
+}
diff --git a/v2/libopenjpeg/tgt.h b/v2/libopenjpeg/tgt.h new file mode 100755 index 00000000..212060c0 --- /dev/null +++ b/v2/libopenjpeg/tgt.h @@ -0,0 +1,130 @@ +/*
+ * 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) 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 __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
+are used by some function in T2.C.
+*/
+#include "openjpeg.h"
+/** @defgroup TGT TGT - Implementation of a tag-tree coder */
+/*@{*/
+struct opj_bio;
+
+/**
+Tag node
+*/
+typedef struct opj_tgt_node
+{
+ struct opj_tgt_node *parent;
+ 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.
+ *
+ * @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);
+
+/**
+Destroy a tag-tree, liberating memory
+@param tree Tag-tree to destroy
+*/
+void tgt_destroy(opj_tgt_tree_t *tree);
+/**
+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);
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __TGT_H */
diff --git a/v2/libs/FreeImage/FreeImage.h b/v2/libs/FreeImage/FreeImage.h new file mode 100755 index 00000000..7125acc4 --- /dev/null +++ b/v2/libs/FreeImage/FreeImage.h @@ -0,0 +1,1046 @@ +// ==========================================================
+// FreeImage 3
+//
+// Design and implementation by
+// - Floris van den Berg (flvdberg@wxs.nl)
+// - Hervé Drolon (drolon@infonie.fr)
+//
+// Contributors:
+// - Adam Gates (radad@xoasis.com)
+// - Alex Kwak
+// - Alexander Dymerets (sashad@te.net.ua)
+// - Detlev Vendt (detlev.vendt@brillit.de)
+// - Jan L. Nauta (jln@magentammt.com)
+// - Jani Kajala (janik@remedy.fi)
+// - Juergen Riecker (j.riecker@gmx.de)
+// - Karl-Heinz Bussian (khbussian@moss.de)
+// - Laurent Rocher (rocherl@club-internet.fr)
+// - Luca Piergentili (l.pierge@terra.es)
+// - Machiel ten Brinke (brinkem@uni-one.nl)
+// - Markus Loibl (markus.loibl@epost.de)
+// - Martin Weber (martweb@gmx.net)
+// - Matthias Wandel (mwandel@rim.net)
+// - Michal Novotny (michal@etc.cz)
+// - Petr Pytelka (pyta@lightcomp.com)
+// - Riley McNiff (rmcniff@marexgroup.com)
+// - Ryan Rubley (ryan@lostreality.org)
+// - Volker Gärtner (volkerg@gmx.at)
+//
+// This file is part of FreeImage 3
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+#ifndef FREEIMAGE_H
+#define FREEIMAGE_H
+
+// Version information ------------------------------------------------------
+
+#define FREEIMAGE_MAJOR_VERSION 3
+#define FREEIMAGE_MINOR_VERSION 10
+#define FREEIMAGE_RELEASE_SERIAL 0
+
+// Compiler options ---------------------------------------------------------
+
+#include <wchar.h> // needed for UNICODE functions
+
+#if defined(FREEIMAGE_LIB)
+ #define DLL_API
+ #define DLL_CALLCONV
+#else
+ #if defined(_WIN32) || defined(__WIN32__)
+ #define DLL_CALLCONV __stdcall
+ // The following ifdef block is the standard way of creating macros which make exporting
+ // from a DLL simpler. All files within this DLL are compiled with the FREEIMAGE_EXPORTS
+ // symbol defined on the command line. this symbol should not be defined on any project
+ // that uses this DLL. This way any other project whose source files include this file see
+ // DLL_API functions as being imported from a DLL, wheras this DLL sees symbols
+ // defined with this macro as being exported.
+ #ifdef FREEIMAGE_EXPORTS
+ #define DLL_API __declspec(dllexport)
+ #else
+ #define DLL_API __declspec(dllimport)
+ #endif // FREEIMAGE_EXPORTS
+ #else
+ // try the gcc visibility support (see http://gcc.gnu.org/wiki/Visibility)
+ #if defined(__GNUC__) && ((__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+ #ifndef GCC_HASCLASSVISIBILITY
+ #define GCC_HASCLASSVISIBILITY
+ #endif
+ #endif // __GNUC__
+ #define DLL_CALLCONV
+ #if defined(GCC_HASCLASSVISIBILITY)
+ #define DLL_API __attribute__ ((visibility("default")))
+ #else
+ #define DLL_API
+ #endif
+ #endif // WIN32 / !WIN32
+#endif // FREEIMAGE_LIB
+
+// Some versions of gcc may have BYTE_ORDER or __BYTE_ORDER defined
+// If your big endian system isn't being detected, add an OS specific check
+#if (defined(BYTE_ORDER) && BYTE_ORDER==BIG_ENDIAN) || \
+ (defined(__BYTE_ORDER) && __BYTE_ORDER==__BIG_ENDIAN) || \
+ defined(__BIG_ENDIAN__)
+#define FREEIMAGE_BIGENDIAN
+#endif // BYTE_ORDER
+
+// This really only affects 24 and 32 bit formats, the rest are always RGB order.
+#define FREEIMAGE_COLORORDER_BGR 0
+#define FREEIMAGE_COLORORDER_RGB 1
+#if defined(__APPLE__) || defined(FREEIMAGE_BIGENDIAN)
+#define FREEIMAGE_COLORORDER FREEIMAGE_COLORORDER_RGB
+#else
+#define FREEIMAGE_COLORORDER FREEIMAGE_COLORORDER_BGR
+#endif
+
+// Ensure 4-byte enums if we're using Borland C++ compilers
+#if defined(__BORLANDC__)
+#pragma option push -b
+#endif
+
+// For C compatibility --------------------------------------------------------
+
+#ifdef __cplusplus
+#define FI_DEFAULT(x) = x
+#define FI_ENUM(x) enum x
+#define FI_STRUCT(x) struct x
+#else
+#define FI_DEFAULT(x)
+#define FI_ENUM(x) typedef int x; enum x
+#define FI_STRUCT(x) typedef struct x x; struct x
+#endif
+
+// Bitmap types -------------------------------------------------------------
+
+FI_STRUCT (FIBITMAP) { void *data; };
+FI_STRUCT (FIMULTIBITMAP) { void *data; };
+
+// Types used in the library (directly copied from Windows) -----------------
+
+#ifndef _WINDOWS_
+#define _WINDOWS_
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+#ifndef TRUE
+#define TRUE 1
+#endif
+#ifndef NULL
+#define NULL 0
+#endif
+
+#ifndef SEEK_SET
+#define SEEK_SET 0
+#define SEEK_CUR 1
+#define SEEK_END 2
+#endif
+
+#ifndef _MSC_VER
+// define portable types for 32-bit / 64-bit OS
+#include <inttypes.h>
+typedef int32_t BOOL;
+typedef uint8_t BYTE;
+typedef uint16_t WORD;
+typedef uint32_t DWORD;
+typedef int32_t LONG;
+#else
+// MS is not C99 ISO compliant
+typedef long BOOL;
+typedef unsigned char BYTE;
+typedef unsigned short WORD;
+typedef unsigned long DWORD;
+typedef long LONG;
+#endif // _MSC_VER
+
+#if (defined(_WIN32) || defined(__WIN32__))
+#pragma pack(push, 1)
+#else
+#pragma pack(1)
+#endif // WIN32
+
+typedef struct tagRGBQUAD {
+#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
+ BYTE rgbBlue;
+ BYTE rgbGreen;
+ BYTE rgbRed;
+#else
+ BYTE rgbRed;
+ BYTE rgbGreen;
+ BYTE rgbBlue;
+#endif // FREEIMAGE_COLORORDER
+ BYTE rgbReserved;
+} RGBQUAD;
+
+typedef struct tagRGBTRIPLE {
+#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
+ BYTE rgbtBlue;
+ BYTE rgbtGreen;
+ BYTE rgbtRed;
+#else
+ BYTE rgbtRed;
+ BYTE rgbtGreen;
+ BYTE rgbtBlue;
+#endif // FREEIMAGE_COLORORDER
+} RGBTRIPLE;
+
+#if (defined(_WIN32) || defined(__WIN32__))
+#pragma pack(pop)
+#else
+#pragma pack()
+#endif // WIN32
+
+typedef struct tagBITMAPINFOHEADER{
+ DWORD biSize;
+ LONG biWidth;
+ LONG biHeight;
+ WORD biPlanes;
+ WORD biBitCount;
+ DWORD biCompression;
+ DWORD biSizeImage;
+ LONG biXPelsPerMeter;
+ LONG biYPelsPerMeter;
+ DWORD biClrUsed;
+ DWORD biClrImportant;
+} BITMAPINFOHEADER, *PBITMAPINFOHEADER;
+
+typedef struct tagBITMAPINFO {
+ BITMAPINFOHEADER bmiHeader;
+ RGBQUAD bmiColors[1];
+} BITMAPINFO, *PBITMAPINFO;
+
+#endif // _WINDOWS_
+
+// Types used in the library (specific to FreeImage) ------------------------
+
+#if (defined(_WIN32) || defined(__WIN32__))
+#pragma pack(push, 1)
+#else
+#pragma pack(1)
+#endif // WIN32
+
+/** 48-bit RGB
+*/
+typedef struct tagFIRGB16 {
+ WORD red;
+ WORD green;
+ WORD blue;
+} FIRGB16;
+
+/** 64-bit RGBA
+*/
+typedef struct tagFIRGBA16 {
+ WORD red;
+ WORD green;
+ WORD blue;
+ WORD alpha;
+} FIRGBA16;
+
+/** 96-bit RGB Float
+*/
+typedef struct tagFIRGBF {
+ float red;
+ float green;
+ float blue;
+} FIRGBF;
+
+/** 128-bit RGBA Float
+*/
+typedef struct tagFIRGBAF {
+ float red;
+ float green;
+ float blue;
+ float alpha;
+} FIRGBAF;
+
+/** Data structure for COMPLEX type (complex number)
+*/
+typedef struct tagFICOMPLEX {
+ /// real part
+ double r;
+ /// imaginary part
+ double i;
+} FICOMPLEX;
+
+#if (defined(_WIN32) || defined(__WIN32__))
+#pragma pack(pop)
+#else
+#pragma pack()
+#endif // WIN32
+
+// Indexes for byte arrays, masks and shifts for treating pixels as words ---
+// These coincide with the order of RGBQUAD and RGBTRIPLE -------------------
+
+#ifndef FREEIMAGE_BIGENDIAN
+#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
+// Little Endian (x86 / MS Windows, Linux) : BGR(A) order
+#define FI_RGBA_RED 2
+#define FI_RGBA_GREEN 1
+#define FI_RGBA_BLUE 0
+#define FI_RGBA_ALPHA 3
+#define FI_RGBA_RED_MASK 0x00FF0000
+#define FI_RGBA_GREEN_MASK 0x0000FF00
+#define FI_RGBA_BLUE_MASK 0x000000FF
+#define FI_RGBA_ALPHA_MASK 0xFF000000
+#define FI_RGBA_RED_SHIFT 16
+#define FI_RGBA_GREEN_SHIFT 8
+#define FI_RGBA_BLUE_SHIFT 0
+#define FI_RGBA_ALPHA_SHIFT 24
+#else
+// Little Endian (x86 / MaxOSX) : RGB(A) order
+#define FI_RGBA_RED 0
+#define FI_RGBA_GREEN 1
+#define FI_RGBA_BLUE 2
+#define FI_RGBA_ALPHA 3
+#define FI_RGBA_RED_MASK 0x000000FF
+#define FI_RGBA_GREEN_MASK 0x0000FF00
+#define FI_RGBA_BLUE_MASK 0x00FF0000
+#define FI_RGBA_ALPHA_MASK 0xFF000000
+#define FI_RGBA_RED_SHIFT 0
+#define FI_RGBA_GREEN_SHIFT 8
+#define FI_RGBA_BLUE_SHIFT 16
+#define FI_RGBA_ALPHA_SHIFT 24
+#endif // FREEIMAGE_COLORORDER
+#else
+#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
+// Big Endian (PPC / none) : BGR(A) order
+#define FI_RGBA_RED 2
+#define FI_RGBA_GREEN 1
+#define FI_RGBA_BLUE 0
+#define FI_RGBA_ALPHA 3
+#define FI_RGBA_RED_MASK 0x0000FF00
+#define FI_RGBA_GREEN_MASK 0x00FF0000
+#define FI_RGBA_BLUE_MASK 0xFF000000
+#define FI_RGBA_ALPHA_MASK 0x000000FF
+#define FI_RGBA_RED_SHIFT 8
+#define FI_RGBA_GREEN_SHIFT 16
+#define FI_RGBA_BLUE_SHIFT 24
+#define FI_RGBA_ALPHA_SHIFT 0
+#else
+// Big Endian (PPC / Linux, MaxOSX) : RGB(A) order
+#define FI_RGBA_RED 0
+#define FI_RGBA_GREEN 1
+#define FI_RGBA_BLUE 2
+#define FI_RGBA_ALPHA 3
+#define FI_RGBA_RED_MASK 0xFF000000
+#define FI_RGBA_GREEN_MASK 0x00FF0000
+#define FI_RGBA_BLUE_MASK 0x0000FF00
+#define FI_RGBA_ALPHA_MASK 0x000000FF
+#define FI_RGBA_RED_SHIFT 24
+#define FI_RGBA_GREEN_SHIFT 16
+#define FI_RGBA_BLUE_SHIFT 8
+#define FI_RGBA_ALPHA_SHIFT 0
+#endif // FREEIMAGE_COLORORDER
+#endif // FREEIMAGE_BIGENDIAN
+
+#define FI_RGBA_RGB_MASK (FI_RGBA_RED_MASK|FI_RGBA_GREEN_MASK|FI_RGBA_BLUE_MASK)
+
+// The 16bit macros only include masks and shifts, since each color element is not byte aligned
+
+#define FI16_555_RED_MASK 0x7C00
+#define FI16_555_GREEN_MASK 0x03E0
+#define FI16_555_BLUE_MASK 0x001F
+#define FI16_555_RED_SHIFT 10
+#define FI16_555_GREEN_SHIFT 5
+#define FI16_555_BLUE_SHIFT 0
+#define FI16_565_RED_MASK 0xF800
+#define FI16_565_GREEN_MASK 0x07E0
+#define FI16_565_BLUE_MASK 0x001F
+#define FI16_565_RED_SHIFT 11
+#define FI16_565_GREEN_SHIFT 5
+#define FI16_565_BLUE_SHIFT 0
+
+// ICC profile support ------------------------------------------------------
+
+#define FIICC_DEFAULT 0x00
+#define FIICC_COLOR_IS_CMYK 0x01
+
+FI_STRUCT (FIICCPROFILE) {
+ WORD flags; // info flag
+ DWORD size; // profile's size measured in bytes
+ void *data; // points to a block of contiguous memory containing the profile
+};
+
+// Important enums ----------------------------------------------------------
+
+/** I/O image format identifiers.
+*/
+FI_ENUM(FREE_IMAGE_FORMAT) {
+ FIF_UNKNOWN = -1,
+ FIF_BMP = 0,
+ FIF_ICO = 1,
+ FIF_JPEG = 2,
+ FIF_JNG = 3,
+ FIF_KOALA = 4,
+ FIF_LBM = 5,
+ FIF_IFF = FIF_LBM,
+ FIF_MNG = 6,
+ FIF_PBM = 7,
+ FIF_PBMRAW = 8,
+ FIF_PCD = 9,
+ FIF_PCX = 10,
+ FIF_PGM = 11,
+ FIF_PGMRAW = 12,
+ FIF_PNG = 13,
+ FIF_PPM = 14,
+ FIF_PPMRAW = 15,
+ FIF_RAS = 16,
+ FIF_TARGA = 17,
+ FIF_TIFF = 18,
+ FIF_WBMP = 19,
+ FIF_PSD = 20,
+ FIF_CUT = 21,
+ FIF_XBM = 22,
+ FIF_XPM = 23,
+ FIF_DDS = 24,
+ FIF_GIF = 25,
+ FIF_HDR = 26,
+ FIF_FAXG3 = 27,
+ FIF_SGI = 28,
+ FIF_EXR = 29,
+ FIF_J2K = 30,
+ FIF_JP2 = 31
+};
+
+/** Image type used in FreeImage.
+*/
+FI_ENUM(FREE_IMAGE_TYPE) {
+ FIT_UNKNOWN = 0, // unknown type
+ FIT_BITMAP = 1, // standard image : 1-, 4-, 8-, 16-, 24-, 32-bit
+ FIT_UINT16 = 2, // array of unsigned short : unsigned 16-bit
+ FIT_INT16 = 3, // array of short : signed 16-bit
+ FIT_UINT32 = 4, // array of unsigned long : unsigned 32-bit
+ FIT_INT32 = 5, // array of long : signed 32-bit
+ FIT_FLOAT = 6, // array of float : 32-bit IEEE floating point
+ FIT_DOUBLE = 7, // array of double : 64-bit IEEE floating point
+ FIT_COMPLEX = 8, // array of FICOMPLEX : 2 x 64-bit IEEE floating point
+ FIT_RGB16 = 9, // 48-bit RGB image : 3 x 16-bit
+ FIT_RGBA16 = 10, // 64-bit RGBA image : 4 x 16-bit
+ FIT_RGBF = 11, // 96-bit RGB float image : 3 x 32-bit IEEE floating point
+ FIT_RGBAF = 12 // 128-bit RGBA float image : 4 x 32-bit IEEE floating point
+};
+
+/** Image color type used in FreeImage.
+*/
+FI_ENUM(FREE_IMAGE_COLOR_TYPE) {
+ FIC_MINISWHITE = 0, // min value is white
+ FIC_MINISBLACK = 1, // min value is black
+ FIC_RGB = 2, // RGB color model
+ FIC_PALETTE = 3, // color map indexed
+ FIC_RGBALPHA = 4, // RGB color model with alpha channel
+ FIC_CMYK = 5 // CMYK color model
+};
+
+/** Color quantization algorithms.
+Constants used in FreeImage_ColorQuantize.
+*/
+FI_ENUM(FREE_IMAGE_QUANTIZE) {
+ FIQ_WUQUANT = 0, // Xiaolin Wu color quantization algorithm
+ FIQ_NNQUANT = 1 // NeuQuant neural-net quantization algorithm by Anthony Dekker
+};
+
+/** Dithering algorithms.
+Constants used in FreeImage_Dither.
+*/
+FI_ENUM(FREE_IMAGE_DITHER) {
+ FID_FS = 0, // Floyd & Steinberg error diffusion
+ FID_BAYER4x4 = 1, // Bayer ordered dispersed dot dithering (order 2 dithering matrix)
+ FID_BAYER8x8 = 2, // Bayer ordered dispersed dot dithering (order 3 dithering matrix)
+ FID_CLUSTER6x6 = 3, // Ordered clustered dot dithering (order 3 - 6x6 matrix)
+ FID_CLUSTER8x8 = 4, // Ordered clustered dot dithering (order 4 - 8x8 matrix)
+ FID_CLUSTER16x16= 5, // Ordered clustered dot dithering (order 8 - 16x16 matrix)
+ FID_BAYER16x16 = 6 // Bayer ordered dispersed dot dithering (order 4 dithering matrix)
+};
+
+/** Lossless JPEG transformations
+Constants used in FreeImage_JPEGTransform
+*/
+FI_ENUM(FREE_IMAGE_JPEG_OPERATION) {
+ FIJPEG_OP_NONE = 0, // no transformation
+ FIJPEG_OP_FLIP_H = 1, // horizontal flip
+ FIJPEG_OP_FLIP_V = 2, // vertical flip
+ FIJPEG_OP_TRANSPOSE = 3, // transpose across UL-to-LR axis
+ FIJPEG_OP_TRANSVERSE = 4, // transpose across UR-to-LL axis
+ FIJPEG_OP_ROTATE_90 = 5, // 90-degree clockwise rotation
+ FIJPEG_OP_ROTATE_180 = 6, // 180-degree rotation
+ FIJPEG_OP_ROTATE_270 = 7 // 270-degree clockwise (or 90 ccw)
+};
+
+/** Tone mapping operators.
+Constants used in FreeImage_ToneMapping.
+*/
+FI_ENUM(FREE_IMAGE_TMO) {
+ FITMO_DRAGO03 = 0, // Adaptive logarithmic mapping (F. Drago, 2003)
+ FITMO_REINHARD05 = 1, // Dynamic range reduction inspired by photoreceptor physiology (E. Reinhard, 2005)
+ FITMO_FATTAL02 = 2 // Gradient domain high dynamic range compression (R. Fattal, 2002)
+};
+
+/** Upsampling / downsampling filters.
+Constants used in FreeImage_Rescale.
+*/
+FI_ENUM(FREE_IMAGE_FILTER) {
+ FILTER_BOX = 0, // Box, pulse, Fourier window, 1st order (constant) b-spline
+ FILTER_BICUBIC = 1, // Mitchell & Netravali's two-param cubic filter
+ FILTER_BILINEAR = 2, // Bilinear filter
+ FILTER_BSPLINE = 3, // 4th order (cubic) b-spline
+ FILTER_CATMULLROM = 4, // Catmull-Rom spline, Overhauser spline
+ FILTER_LANCZOS3 = 5 // Lanczos3 filter
+};
+
+/** Color channels.
+Constants used in color manipulation routines.
+*/
+FI_ENUM(FREE_IMAGE_COLOR_CHANNEL) {
+ FICC_RGB = 0, // Use red, green and blue channels
+ FICC_RED = 1, // Use red channel
+ FICC_GREEN = 2, // Use green channel
+ FICC_BLUE = 3, // Use blue channel
+ FICC_ALPHA = 4, // Use alpha channel
+ FICC_BLACK = 5, // Use black channel
+ FICC_REAL = 6, // Complex images: use real part
+ FICC_IMAG = 7, // Complex images: use imaginary part
+ FICC_MAG = 8, // Complex images: use magnitude
+ FICC_PHASE = 9 // Complex images: use phase
+};
+
+// Metadata support ---------------------------------------------------------
+
+/**
+ Tag data type information (based on TIFF specifications)
+
+ Note: RATIONALs are the ratio of two 32-bit integer values.
+*/
+FI_ENUM(FREE_IMAGE_MDTYPE) {
+ FIDT_NOTYPE = 0, // placeholder
+ FIDT_BYTE = 1, // 8-bit unsigned integer
+ FIDT_ASCII = 2, // 8-bit bytes w/ last byte null
+ FIDT_SHORT = 3, // 16-bit unsigned integer
+ FIDT_LONG = 4, // 32-bit unsigned integer
+ FIDT_RATIONAL = 5, // 64-bit unsigned fraction
+ FIDT_SBYTE = 6, // 8-bit signed integer
+ FIDT_UNDEFINED = 7, // 8-bit untyped data
+ FIDT_SSHORT = 8, // 16-bit signed integer
+ FIDT_SLONG = 9, // 32-bit signed integer
+ FIDT_SRATIONAL = 10, // 64-bit signed fraction
+ FIDT_FLOAT = 11, // 32-bit IEEE floating point
+ FIDT_DOUBLE = 12, // 64-bit IEEE floating point
+ FIDT_IFD = 13, // 32-bit unsigned integer (offset)
+ FIDT_PALETTE = 14 // 32-bit RGBQUAD
+};
+
+/**
+ Metadata models supported by FreeImage
+*/
+FI_ENUM(FREE_IMAGE_MDMODEL) {
+ FIMD_NODATA = -1,
+ FIMD_COMMENTS = 0, // single comment or keywords
+ FIMD_EXIF_MAIN = 1, // Exif-TIFF metadata
+ FIMD_EXIF_EXIF = 2, // Exif-specific metadata
+ FIMD_EXIF_GPS = 3, // Exif GPS metadata
+ FIMD_EXIF_MAKERNOTE = 4, // Exif maker note metadata
+ FIMD_EXIF_INTEROP = 5, // Exif interoperability metadata
+ FIMD_IPTC = 6, // IPTC/NAA metadata
+ FIMD_XMP = 7, // Abobe XMP metadata
+ FIMD_GEOTIFF = 8, // GeoTIFF metadata
+ FIMD_ANIMATION = 9, // Animation metadata
+ FIMD_CUSTOM = 10 // Used to attach other metadata types to a dib
+};
+
+/**
+ Handle to a metadata model
+*/
+FI_STRUCT (FIMETADATA) { void *data; };
+
+/**
+ Handle to a FreeImage tag
+*/
+FI_STRUCT (FITAG) { void *data; };
+
+// File IO routines ---------------------------------------------------------
+
+#ifndef FREEIMAGE_IO
+#define FREEIMAGE_IO
+
+typedef void* fi_handle;
+typedef unsigned (DLL_CALLCONV *FI_ReadProc) (void *buffer, unsigned size, unsigned count, fi_handle handle);
+typedef unsigned (DLL_CALLCONV *FI_WriteProc) (void *buffer, unsigned size, unsigned count, fi_handle handle);
+typedef int (DLL_CALLCONV *FI_SeekProc) (fi_handle handle, long offset, int origin);
+typedef long (DLL_CALLCONV *FI_TellProc) (fi_handle handle);
+
+#if (defined(_WIN32) || defined(__WIN32__))
+#pragma pack(push, 1)
+#else
+#pragma pack(1)
+#endif // WIN32
+
+FI_STRUCT(FreeImageIO) {
+ FI_ReadProc read_proc; // pointer to the function used to read data
+ FI_WriteProc write_proc; // pointer to the function used to write data
+ FI_SeekProc seek_proc; // pointer to the function used to seek
+ FI_TellProc tell_proc; // pointer to the function used to aquire the current position
+};
+
+#if (defined(_WIN32) || defined(__WIN32__))
+#pragma pack(pop)
+#else
+#pragma pack()
+#endif // WIN32
+
+/**
+Handle to a memory I/O stream
+*/
+FI_STRUCT (FIMEMORY) { void *data; };
+
+#endif // FREEIMAGE_IO
+
+// Plugin routines ----------------------------------------------------------
+
+#ifndef PLUGINS
+#define PLUGINS
+
+typedef const char *(DLL_CALLCONV *FI_FormatProc) ();
+typedef const char *(DLL_CALLCONV *FI_DescriptionProc) ();
+typedef const char *(DLL_CALLCONV *FI_ExtensionListProc) ();
+typedef const char *(DLL_CALLCONV *FI_RegExprProc) ();
+typedef void *(DLL_CALLCONV *FI_OpenProc)(FreeImageIO *io, fi_handle handle, BOOL read);
+typedef void (DLL_CALLCONV *FI_CloseProc)(FreeImageIO *io, fi_handle handle, void *data);
+typedef int (DLL_CALLCONV *FI_PageCountProc)(FreeImageIO *io, fi_handle handle, void *data);
+typedef int (DLL_CALLCONV *FI_PageCapabilityProc)(FreeImageIO *io, fi_handle handle, void *data);
+typedef FIBITMAP *(DLL_CALLCONV *FI_LoadProc)(FreeImageIO *io, fi_handle handle, int page, int flags, void *data);
+typedef BOOL (DLL_CALLCONV *FI_SaveProc)(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data);
+typedef BOOL (DLL_CALLCONV *FI_ValidateProc)(FreeImageIO *io, fi_handle handle);
+typedef const char *(DLL_CALLCONV *FI_MimeProc) ();
+typedef BOOL (DLL_CALLCONV *FI_SupportsExportBPPProc)(int bpp);
+typedef BOOL (DLL_CALLCONV *FI_SupportsExportTypeProc)(FREE_IMAGE_TYPE type);
+typedef BOOL (DLL_CALLCONV *FI_SupportsICCProfilesProc)();
+
+FI_STRUCT (Plugin) {
+ FI_FormatProc format_proc;
+ FI_DescriptionProc description_proc;
+ FI_ExtensionListProc extension_proc;
+ FI_RegExprProc regexpr_proc;
+ FI_OpenProc open_proc;
+ FI_CloseProc close_proc;
+ FI_PageCountProc pagecount_proc;
+ FI_PageCapabilityProc pagecapability_proc;
+ FI_LoadProc load_proc;
+ FI_SaveProc save_proc;
+ FI_ValidateProc validate_proc;
+ FI_MimeProc mime_proc;
+ FI_SupportsExportBPPProc supports_export_bpp_proc;
+ FI_SupportsExportTypeProc supports_export_type_proc;
+ FI_SupportsICCProfilesProc supports_icc_profiles_proc;
+};
+
+typedef void (DLL_CALLCONV *FI_InitProc)(Plugin *plugin, int format_id);
+
+#endif // PLUGINS
+
+
+// Load / Save flag constants -----------------------------------------------
+
+#define BMP_DEFAULT 0
+#define BMP_SAVE_RLE 1
+#define CUT_DEFAULT 0
+#define DDS_DEFAULT 0
+#define EXR_DEFAULT 0 // save data as half with piz-based wavelet compression
+#define EXR_FLOAT 0x0001 // save data as float instead of as half (not recommended)
+#define EXR_NONE 0x0002 // save with no compression
+#define EXR_ZIP 0x0004 // save with zlib compression, in blocks of 16 scan lines
+#define EXR_PIZ 0x0008 // save with piz-based wavelet compression
+#define EXR_PXR24 0x0010 // save with lossy 24-bit float compression
+#define EXR_B44 0x0020 // save with lossy 44% float compression - goes to 22% when combined with EXR_LC
+#define EXR_LC 0x0040 // save images with one luminance and two chroma channels, rather than as RGB (lossy compression)
+#define FAXG3_DEFAULT 0
+#define GIF_DEFAULT 0
+#define GIF_LOAD256 1 // Load the image as a 256 color image with ununsed palette entries, if it's 16 or 2 color
+#define GIF_PLAYBACK 2 // 'Play' the GIF to generate each frame (as 32bpp) instead of returning raw frame data when loading
+#define HDR_DEFAULT 0
+#define ICO_DEFAULT 0
+#define ICO_MAKEALPHA 1 // convert to 32bpp and create an alpha channel from the AND-mask when loading
+#define IFF_DEFAULT 0
+#define J2K_DEFAULT 0 // save with a 16:1 rate
+#define JP2_DEFAULT 0 // save with a 16:1 rate
+#define JPEG_DEFAULT 0 // loading (see JPEG_FAST); saving (see JPEG_QUALITYGOOD)
+#define JPEG_FAST 0x0001 // load the file as fast as possible, sacrificing some quality
+#define JPEG_ACCURATE 0x0002 // load the file with the best quality, sacrificing some speed
+#define JPEG_CMYK 0x0004 // load separated CMYK "as is" (use | to combine with other load flags)
+#define JPEG_QUALITYSUPERB 0x80 // save with superb quality (100:1)
+#define JPEG_QUALITYGOOD 0x0100 // save with good quality (75:1)
+#define JPEG_QUALITYNORMAL 0x0200 // save with normal quality (50:1)
+#define JPEG_QUALITYAVERAGE 0x0400 // save with average quality (25:1)
+#define JPEG_QUALITYBAD 0x0800 // save with bad quality (10:1)
+#define JPEG_PROGRESSIVE 0x2000 // save as a progressive-JPEG (use | to combine with other save flags)
+#define KOALA_DEFAULT 0
+#define LBM_DEFAULT 0
+#define MNG_DEFAULT 0
+#define PCD_DEFAULT 0
+#define PCD_BASE 1 // load the bitmap sized 768 x 512
+#define PCD_BASEDIV4 2 // load the bitmap sized 384 x 256
+#define PCD_BASEDIV16 3 // load the bitmap sized 192 x 128
+#define PCX_DEFAULT 0
+#define PNG_DEFAULT 0
+#define PNG_IGNOREGAMMA 1 // avoid gamma correction
+#define PNM_DEFAULT 0
+#define PNM_SAVE_RAW 0 // If set the writer saves in RAW format (i.e. P4, P5 or P6)
+#define PNM_SAVE_ASCII 1 // If set the writer saves in ASCII format (i.e. P1, P2 or P3)
+#define PSD_DEFAULT 0
+#define RAS_DEFAULT 0
+#define SGI_DEFAULT 0
+#define TARGA_DEFAULT 0
+#define TARGA_LOAD_RGB888 1 // If set the loader converts RGB555 and ARGB8888 -> RGB888.
+#define TIFF_DEFAULT 0
+#define TIFF_CMYK 0x0001 // reads/stores tags for separated CMYK (use | to combine with compression flags)
+#define TIFF_PACKBITS 0x0100 // save using PACKBITS compression
+#define TIFF_DEFLATE 0x0200 // save using DEFLATE compression (a.k.a. ZLIB compression)
+#define TIFF_ADOBE_DEFLATE 0x0400 // save using ADOBE DEFLATE compression
+#define TIFF_NONE 0x0800 // save without any compression
+#define TIFF_CCITTFAX3 0x1000 // save using CCITT Group 3 fax encoding
+#define TIFF_CCITTFAX4 0x2000 // save using CCITT Group 4 fax encoding
+#define TIFF_LZW 0x4000 // save using LZW compression
+#define TIFF_JPEG 0x8000 // save using JPEG compression
+#define WBMP_DEFAULT 0
+#define XBM_DEFAULT 0
+#define XPM_DEFAULT 0
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Init / Error routines ----------------------------------------------------
+
+DLL_API void DLL_CALLCONV FreeImage_Initialise(BOOL load_local_plugins_only FI_DEFAULT(FALSE));
+DLL_API void DLL_CALLCONV FreeImage_DeInitialise(void);
+
+// Version routines ---------------------------------------------------------
+
+DLL_API const char *DLL_CALLCONV FreeImage_GetVersion(void);
+DLL_API const char *DLL_CALLCONV FreeImage_GetCopyrightMessage(void);
+
+// Message output functions -------------------------------------------------
+
+typedef void (*FreeImage_OutputMessageFunction)(FREE_IMAGE_FORMAT fif, const char *msg);
+typedef void (DLL_CALLCONV *FreeImage_OutputMessageFunctionStdCall)(FREE_IMAGE_FORMAT fif, const char *msg);
+
+DLL_API void DLL_CALLCONV FreeImage_SetOutputMessageStdCall(FreeImage_OutputMessageFunctionStdCall omf);
+DLL_API void DLL_CALLCONV FreeImage_SetOutputMessage(FreeImage_OutputMessageFunction omf);
+DLL_API void DLL_CALLCONV FreeImage_OutputMessageProc(int fif, const char *fmt, ...);
+
+// Allocate / Clone / Unload routines ---------------------------------------
+
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Allocate(int width, int height, int bpp, unsigned red_mask FI_DEFAULT(0), unsigned green_mask FI_DEFAULT(0), unsigned blue_mask FI_DEFAULT(0));
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_AllocateT(FREE_IMAGE_TYPE type, int width, int height, int bpp FI_DEFAULT(8), unsigned red_mask FI_DEFAULT(0), unsigned green_mask FI_DEFAULT(0), unsigned blue_mask FI_DEFAULT(0));
+DLL_API FIBITMAP * DLL_CALLCONV FreeImage_Clone(FIBITMAP *dib);
+DLL_API void DLL_CALLCONV FreeImage_Unload(FIBITMAP *dib);
+
+// Load / Save routines -----------------------------------------------------
+
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Load(FREE_IMAGE_FORMAT fif, const char *filename, int flags FI_DEFAULT(0));
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_LoadU(FREE_IMAGE_FORMAT fif, const wchar_t *filename, int flags FI_DEFAULT(0));
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_LoadFromHandle(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle, int flags FI_DEFAULT(0));
+DLL_API BOOL DLL_CALLCONV FreeImage_Save(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, const char *filename, int flags FI_DEFAULT(0));
+DLL_API BOOL DLL_CALLCONV FreeImage_SaveU(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, const wchar_t *filename, int flags FI_DEFAULT(0));
+DLL_API BOOL DLL_CALLCONV FreeImage_SaveToHandle(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags FI_DEFAULT(0));
+
+// Memory I/O stream routines -----------------------------------------------
+
+DLL_API FIMEMORY *DLL_CALLCONV FreeImage_OpenMemory(BYTE *data FI_DEFAULT(0), DWORD size_in_bytes FI_DEFAULT(0));
+DLL_API void DLL_CALLCONV FreeImage_CloseMemory(FIMEMORY *stream);
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_LoadFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY *stream, int flags FI_DEFAULT(0));
+DLL_API BOOL DLL_CALLCONV FreeImage_SaveToMemory(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, FIMEMORY *stream, int flags FI_DEFAULT(0));
+DLL_API long DLL_CALLCONV FreeImage_TellMemory(FIMEMORY *stream);
+DLL_API BOOL DLL_CALLCONV FreeImage_SeekMemory(FIMEMORY *stream, long offset, int origin);
+DLL_API BOOL DLL_CALLCONV FreeImage_AcquireMemory(FIMEMORY *stream, BYTE **data, DWORD *size_in_bytes);
+DLL_API unsigned DLL_CALLCONV FreeImage_ReadMemory(void *buffer, unsigned size, unsigned count, FIMEMORY *stream);
+DLL_API unsigned DLL_CALLCONV FreeImage_WriteMemory(const void *buffer, unsigned size, unsigned count, FIMEMORY *stream);
+DLL_API FIMULTIBITMAP *DLL_CALLCONV FreeImage_LoadMultiBitmapFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY *stream, int flags FI_DEFAULT(0));
+
+// Plugin Interface ---------------------------------------------------------
+
+DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_RegisterLocalPlugin(FI_InitProc proc_address, const char *format FI_DEFAULT(0), const char *description FI_DEFAULT(0), const char *extension FI_DEFAULT(0), const char *regexpr FI_DEFAULT(0));
+DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_RegisterExternalPlugin(const char *path, const char *format FI_DEFAULT(0), const char *description FI_DEFAULT(0), const char *extension FI_DEFAULT(0), const char *regexpr FI_DEFAULT(0));
+DLL_API int DLL_CALLCONV FreeImage_GetFIFCount(void);
+DLL_API int DLL_CALLCONV FreeImage_SetPluginEnabled(FREE_IMAGE_FORMAT fif, BOOL enable);
+DLL_API int DLL_CALLCONV FreeImage_IsPluginEnabled(FREE_IMAGE_FORMAT fif);
+DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFIFFromFormat(const char *format);
+DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFIFFromMime(const char *mime);
+DLL_API const char *DLL_CALLCONV FreeImage_GetFormatFromFIF(FREE_IMAGE_FORMAT fif);
+DLL_API const char *DLL_CALLCONV FreeImage_GetFIFExtensionList(FREE_IMAGE_FORMAT fif);
+DLL_API const char *DLL_CALLCONV FreeImage_GetFIFDescription(FREE_IMAGE_FORMAT fif);
+DLL_API const char *DLL_CALLCONV FreeImage_GetFIFRegExpr(FREE_IMAGE_FORMAT fif);
+DLL_API const char *DLL_CALLCONV FreeImage_GetFIFMimeType(FREE_IMAGE_FORMAT fif);
+DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFIFFromFilename(const char *filename);
+DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFIFFromFilenameU(const wchar_t *filename);
+DLL_API BOOL DLL_CALLCONV FreeImage_FIFSupportsReading(FREE_IMAGE_FORMAT fif);
+DLL_API BOOL DLL_CALLCONV FreeImage_FIFSupportsWriting(FREE_IMAGE_FORMAT fif);
+DLL_API BOOL DLL_CALLCONV FreeImage_FIFSupportsExportBPP(FREE_IMAGE_FORMAT fif, int bpp);
+DLL_API BOOL DLL_CALLCONV FreeImage_FIFSupportsExportType(FREE_IMAGE_FORMAT fif, FREE_IMAGE_TYPE type);
+DLL_API BOOL DLL_CALLCONV FreeImage_FIFSupportsICCProfiles(FREE_IMAGE_FORMAT fif);
+
+// Multipaging interface ----------------------------------------------------
+
+DLL_API FIMULTIBITMAP * DLL_CALLCONV FreeImage_OpenMultiBitmap(FREE_IMAGE_FORMAT fif, const char *filename, BOOL create_new, BOOL read_only, BOOL keep_cache_in_memory FI_DEFAULT(FALSE), int flags FI_DEFAULT(0));
+DLL_API BOOL DLL_CALLCONV FreeImage_CloseMultiBitmap(FIMULTIBITMAP *bitmap, int flags FI_DEFAULT(0));
+DLL_API int DLL_CALLCONV FreeImage_GetPageCount(FIMULTIBITMAP *bitmap);
+DLL_API void DLL_CALLCONV FreeImage_AppendPage(FIMULTIBITMAP *bitmap, FIBITMAP *data);
+DLL_API void DLL_CALLCONV FreeImage_InsertPage(FIMULTIBITMAP *bitmap, int page, FIBITMAP *data);
+DLL_API void DLL_CALLCONV FreeImage_DeletePage(FIMULTIBITMAP *bitmap, int page);
+DLL_API FIBITMAP * DLL_CALLCONV FreeImage_LockPage(FIMULTIBITMAP *bitmap, int page);
+DLL_API void DLL_CALLCONV FreeImage_UnlockPage(FIMULTIBITMAP *bitmap, FIBITMAP *data, BOOL changed);
+DLL_API BOOL DLL_CALLCONV FreeImage_MovePage(FIMULTIBITMAP *bitmap, int target, int source);
+DLL_API BOOL DLL_CALLCONV FreeImage_GetLockedPageNumbers(FIMULTIBITMAP *bitmap, int *pages, int *count);
+
+// Filetype request routines ------------------------------------------------
+
+DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileType(const char *filename, int size FI_DEFAULT(0));
+DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeU(const wchar_t *filename, int size FI_DEFAULT(0));
+DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeFromHandle(FreeImageIO *io, fi_handle handle, int size FI_DEFAULT(0));
+DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeFromMemory(FIMEMORY *stream, int size FI_DEFAULT(0));
+
+// Image type request routine -----------------------------------------------
+
+DLL_API FREE_IMAGE_TYPE DLL_CALLCONV FreeImage_GetImageType(FIBITMAP *dib);
+
+// FreeImage helper routines ------------------------------------------------
+
+DLL_API BOOL DLL_CALLCONV FreeImage_IsLittleEndian(void);
+DLL_API BOOL DLL_CALLCONV FreeImage_LookupX11Color(const char *szColor, BYTE *nRed, BYTE *nGreen, BYTE *nBlue);
+DLL_API BOOL DLL_CALLCONV FreeImage_LookupSVGColor(const char *szColor, BYTE *nRed, BYTE *nGreen, BYTE *nBlue);
+
+
+// Pixel access routines ----------------------------------------------------
+
+DLL_API BYTE *DLL_CALLCONV FreeImage_GetBits(FIBITMAP *dib);
+DLL_API BYTE *DLL_CALLCONV FreeImage_GetScanLine(FIBITMAP *dib, int scanline);
+
+DLL_API BOOL DLL_CALLCONV FreeImage_GetPixelIndex(FIBITMAP *dib, unsigned x, unsigned y, BYTE *value);
+DLL_API BOOL DLL_CALLCONV FreeImage_GetPixelColor(FIBITMAP *dib, unsigned x, unsigned y, RGBQUAD *value);
+DLL_API BOOL DLL_CALLCONV FreeImage_SetPixelIndex(FIBITMAP *dib, unsigned x, unsigned y, BYTE *value);
+DLL_API BOOL DLL_CALLCONV FreeImage_SetPixelColor(FIBITMAP *dib, unsigned x, unsigned y, RGBQUAD *value);
+
+// DIB info routines --------------------------------------------------------
+
+DLL_API unsigned DLL_CALLCONV FreeImage_GetColorsUsed(FIBITMAP *dib);
+DLL_API unsigned DLL_CALLCONV FreeImage_GetBPP(FIBITMAP *dib);
+DLL_API unsigned DLL_CALLCONV FreeImage_GetWidth(FIBITMAP *dib);
+DLL_API unsigned DLL_CALLCONV FreeImage_GetHeight(FIBITMAP *dib);
+DLL_API unsigned DLL_CALLCONV FreeImage_GetLine(FIBITMAP *dib);
+DLL_API unsigned DLL_CALLCONV FreeImage_GetPitch(FIBITMAP *dib);
+DLL_API unsigned DLL_CALLCONV FreeImage_GetDIBSize(FIBITMAP *dib);
+DLL_API RGBQUAD *DLL_CALLCONV FreeImage_GetPalette(FIBITMAP *dib);
+
+DLL_API unsigned DLL_CALLCONV FreeImage_GetDotsPerMeterX(FIBITMAP *dib);
+DLL_API unsigned DLL_CALLCONV FreeImage_GetDotsPerMeterY(FIBITMAP *dib);
+DLL_API void DLL_CALLCONV FreeImage_SetDotsPerMeterX(FIBITMAP *dib, unsigned res);
+DLL_API void DLL_CALLCONV FreeImage_SetDotsPerMeterY(FIBITMAP *dib, unsigned res);
+
+DLL_API BITMAPINFOHEADER *DLL_CALLCONV FreeImage_GetInfoHeader(FIBITMAP *dib);
+DLL_API BITMAPINFO *DLL_CALLCONV FreeImage_GetInfo(FIBITMAP *dib);
+DLL_API FREE_IMAGE_COLOR_TYPE DLL_CALLCONV FreeImage_GetColorType(FIBITMAP *dib);
+
+DLL_API unsigned DLL_CALLCONV FreeImage_GetRedMask(FIBITMAP *dib);
+DLL_API unsigned DLL_CALLCONV FreeImage_GetGreenMask(FIBITMAP *dib);
+DLL_API unsigned DLL_CALLCONV FreeImage_GetBlueMask(FIBITMAP *dib);
+
+DLL_API unsigned DLL_CALLCONV FreeImage_GetTransparencyCount(FIBITMAP *dib);
+DLL_API BYTE * DLL_CALLCONV FreeImage_GetTransparencyTable(FIBITMAP *dib);
+DLL_API void DLL_CALLCONV FreeImage_SetTransparent(FIBITMAP *dib, BOOL enabled);
+DLL_API void DLL_CALLCONV FreeImage_SetTransparencyTable(FIBITMAP *dib, BYTE *table, int count);
+DLL_API BOOL DLL_CALLCONV FreeImage_IsTransparent(FIBITMAP *dib);
+DLL_API void DLL_CALLCONV FreeImage_SetTransparentIndex(FIBITMAP *dib, int index);
+DLL_API int DLL_CALLCONV FreeImage_GetTransparentIndex(FIBITMAP *dib);
+
+DLL_API BOOL DLL_CALLCONV FreeImage_HasBackgroundColor(FIBITMAP *dib);
+DLL_API BOOL DLL_CALLCONV FreeImage_GetBackgroundColor(FIBITMAP *dib, RGBQUAD *bkcolor);
+DLL_API BOOL DLL_CALLCONV FreeImage_SetBackgroundColor(FIBITMAP *dib, RGBQUAD *bkcolor);
+
+
+// ICC profile routines -----------------------------------------------------
+
+DLL_API FIICCPROFILE *DLL_CALLCONV FreeImage_GetICCProfile(FIBITMAP *dib);
+DLL_API FIICCPROFILE *DLL_CALLCONV FreeImage_CreateICCProfile(FIBITMAP *dib, void *data, long size);
+DLL_API void DLL_CALLCONV FreeImage_DestroyICCProfile(FIBITMAP *dib);
+
+// Line conversion routines -------------------------------------------------
+
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To4(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine8To4(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To4_555(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To4_565(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine24To4(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine32To4(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To8(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine4To8(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To8_555(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To8_565(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine24To8(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine32To8(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To16_555(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine4To16_555(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine8To16_555(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine16_565_To16_555(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine24To16_555(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine32To16_555(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To16_565(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine4To16_565(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine8To16_565(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine16_555_To16_565(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine24To16_565(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine32To16_565(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To24(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine4To24(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine8To24(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To24_555(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To24_565(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine32To24(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To32(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine4To32(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine8To32(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To32_555(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To32_565(BYTE *target, BYTE *source, int width_in_pixels);
+DLL_API void DLL_CALLCONV FreeImage_ConvertLine24To32(BYTE *target, BYTE *source, int width_in_pixels);
+
+// Smart conversion routines ------------------------------------------------
+
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo4Bits(FIBITMAP *dib);
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo8Bits(FIBITMAP *dib);
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToGreyscale(FIBITMAP *dib);
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo16Bits555(FIBITMAP *dib);
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo16Bits565(FIBITMAP *dib);
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo24Bits(FIBITMAP *dib);
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertTo32Bits(FIBITMAP *dib);
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ColorQuantize(FIBITMAP *dib, FREE_IMAGE_QUANTIZE quantize);
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ColorQuantizeEx(FIBITMAP *dib, FREE_IMAGE_QUANTIZE quantize FI_DEFAULT(FIQ_WUQUANT), int PaletteSize FI_DEFAULT(256), int ReserveSize FI_DEFAULT(0), RGBQUAD *ReservePalette FI_DEFAULT(NULL));
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Threshold(FIBITMAP *dib, BYTE T);
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Dither(FIBITMAP *dib, FREE_IMAGE_DITHER algorithm);
+
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertFromRawBits(BYTE *bits, int width, int height, int pitch, unsigned bpp, unsigned red_mask, unsigned green_mask, unsigned blue_mask, BOOL topdown FI_DEFAULT(FALSE));
+DLL_API void DLL_CALLCONV FreeImage_ConvertToRawBits(BYTE *bits, FIBITMAP *dib, int pitch, unsigned bpp, unsigned red_mask, unsigned green_mask, unsigned blue_mask, BOOL topdown FI_DEFAULT(FALSE));
+
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToRGBF(FIBITMAP *dib);
+
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToStandardType(FIBITMAP *src, BOOL scale_linear FI_DEFAULT(TRUE));
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ConvertToType(FIBITMAP *src, FREE_IMAGE_TYPE dst_type, BOOL scale_linear FI_DEFAULT(TRUE));
+
+// tone mapping operators
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_ToneMapping(FIBITMAP *dib, FREE_IMAGE_TMO tmo, double first_param FI_DEFAULT(0), double second_param FI_DEFAULT(0));
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_TmoDrago03(FIBITMAP *src, double gamma FI_DEFAULT(2.2), double exposure FI_DEFAULT(0));
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_TmoReinhard05(FIBITMAP *src, double intensity FI_DEFAULT(0), double contrast FI_DEFAULT(0));
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_TmoFattal02(FIBITMAP *src, double color_saturation FI_DEFAULT(0.5), double attenuation FI_DEFAULT(0.85));
+
+// ZLib interface -----------------------------------------------------------
+
+DLL_API DWORD DLL_CALLCONV FreeImage_ZLibCompress(BYTE *target, DWORD target_size, BYTE *source, DWORD source_size);
+DLL_API DWORD DLL_CALLCONV FreeImage_ZLibUncompress(BYTE *target, DWORD target_size, BYTE *source, DWORD source_size);
+DLL_API DWORD DLL_CALLCONV FreeImage_ZLibGZip(BYTE *target, DWORD target_size, BYTE *source, DWORD source_size);
+DLL_API DWORD DLL_CALLCONV FreeImage_ZLibGUnzip(BYTE *target, DWORD target_size, BYTE *source, DWORD source_size);
+DLL_API DWORD DLL_CALLCONV FreeImage_ZLibCRC32(DWORD crc, BYTE *source, DWORD source_size);
+
+// --------------------------------------------------------------------------
+// Metadata routines --------------------------------------------------------
+// --------------------------------------------------------------------------
+
+// tag creation / destruction
+DLL_API FITAG *DLL_CALLCONV FreeImage_CreateTag();
+DLL_API void DLL_CALLCONV FreeImage_DeleteTag(FITAG *tag);
+DLL_API FITAG *DLL_CALLCONV FreeImage_CloneTag(FITAG *tag);
+
+// tag getters and setters
+DLL_API const char *DLL_CALLCONV FreeImage_GetTagKey(FITAG *tag);
+DLL_API const char *DLL_CALLCONV FreeImage_GetTagDescription(FITAG *tag);
+DLL_API WORD DLL_CALLCONV FreeImage_GetTagID(FITAG *tag);
+DLL_API FREE_IMAGE_MDTYPE DLL_CALLCONV FreeImage_GetTagType(FITAG *tag);
+DLL_API DWORD DLL_CALLCONV FreeImage_GetTagCount(FITAG *tag);
+DLL_API DWORD DLL_CALLCONV FreeImage_GetTagLength(FITAG *tag);
+DLL_API const void *DLL_CALLCONV FreeImage_GetTagValue(FITAG *tag);
+
+DLL_API BOOL DLL_CALLCONV FreeImage_SetTagKey(FITAG *tag, const char *key);
+DLL_API BOOL DLL_CALLCONV FreeImage_SetTagDescription(FITAG *tag, const char *description);
+DLL_API BOOL DLL_CALLCONV FreeImage_SetTagID(FITAG *tag, WORD id);
+DLL_API BOOL DLL_CALLCONV FreeImage_SetTagType(FITAG *tag, FREE_IMAGE_MDTYPE type);
+DLL_API BOOL DLL_CALLCONV FreeImage_SetTagCount(FITAG *tag, DWORD count);
+DLL_API BOOL DLL_CALLCONV FreeImage_SetTagLength(FITAG *tag, DWORD length);
+DLL_API BOOL DLL_CALLCONV FreeImage_SetTagValue(FITAG *tag, const void *value);
+
+// iterator
+DLL_API FIMETADATA *DLL_CALLCONV FreeImage_FindFirstMetadata(FREE_IMAGE_MDMODEL model, FIBITMAP *dib, FITAG **tag);
+DLL_API BOOL DLL_CALLCONV FreeImage_FindNextMetadata(FIMETADATA *mdhandle, FITAG **tag);
+DLL_API void DLL_CALLCONV FreeImage_FindCloseMetadata(FIMETADATA *mdhandle);
+
+// metadata setter and getter
+DLL_API BOOL DLL_CALLCONV FreeImage_SetMetadata(FREE_IMAGE_MDMODEL model, FIBITMAP *dib, const char *key, FITAG *tag);
+DLL_API BOOL DLL_CALLCONV FreeImage_GetMetadata(FREE_IMAGE_MDMODEL model, FIBITMAP *dib, const char *key, FITAG **tag);
+
+// helpers
+DLL_API unsigned DLL_CALLCONV FreeImage_GetMetadataCount(FREE_IMAGE_MDMODEL model, FIBITMAP *dib);
+
+// tag to C string conversion
+DLL_API const char* DLL_CALLCONV FreeImage_TagToString(FREE_IMAGE_MDMODEL model, FITAG *tag, char *Make FI_DEFAULT(NULL));
+
+// --------------------------------------------------------------------------
+// Image manipulation toolkit -----------------------------------------------
+// --------------------------------------------------------------------------
+
+// rotation and flipping
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_RotateClassic(FIBITMAP *dib, double angle);
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_RotateEx(FIBITMAP *dib, double angle, double x_shift, double y_shift, double x_origin, double y_origin, BOOL use_mask);
+DLL_API BOOL DLL_CALLCONV FreeImage_FlipHorizontal(FIBITMAP *dib);
+DLL_API BOOL DLL_CALLCONV FreeImage_FlipVertical(FIBITMAP *dib);
+DLL_API BOOL DLL_CALLCONV FreeImage_JPEGTransform(const char *src_file, const char *dst_file, FREE_IMAGE_JPEG_OPERATION operation, BOOL perfect FI_DEFAULT(FALSE));
+
+// upsampling / downsampling
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Rescale(FIBITMAP *dib, int dst_width, int dst_height, FREE_IMAGE_FILTER filter);
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_MakeThumbnail(FIBITMAP *dib, int max_pixel_size, BOOL convert FI_DEFAULT(TRUE));
+
+// color manipulation routines (point operations)
+DLL_API BOOL DLL_CALLCONV FreeImage_AdjustCurve(FIBITMAP *dib, BYTE *LUT, FREE_IMAGE_COLOR_CHANNEL channel);
+DLL_API BOOL DLL_CALLCONV FreeImage_AdjustGamma(FIBITMAP *dib, double gamma);
+DLL_API BOOL DLL_CALLCONV FreeImage_AdjustBrightness(FIBITMAP *dib, double percentage);
+DLL_API BOOL DLL_CALLCONV FreeImage_AdjustContrast(FIBITMAP *dib, double percentage);
+DLL_API BOOL DLL_CALLCONV FreeImage_Invert(FIBITMAP *dib);
+DLL_API BOOL DLL_CALLCONV FreeImage_GetHistogram(FIBITMAP *dib, DWORD *histo, FREE_IMAGE_COLOR_CHANNEL channel FI_DEFAULT(FICC_BLACK));
+DLL_API int DLL_CALLCONV FreeImage_GetAdjustColorsLookupTable(BYTE *LUT, double brightness, double contrast, double gamma, BOOL invert);
+DLL_API BOOL DLL_CALLCONV FreeImage_AdjustColors(FIBITMAP *dib, double brightness, double contrast, double gamma, BOOL invert FI_DEFAULT(FALSE));
+DLL_API unsigned DLL_CALLCONV FreeImage_ApplyColorMapping(FIBITMAP *dib, RGBQUAD *srccolors, RGBQUAD *dstcolors, unsigned count, BOOL ignore_alpha, BOOL swap);
+DLL_API unsigned DLL_CALLCONV FreeImage_SwapColors(FIBITMAP *dib, RGBQUAD *color_a, RGBQUAD *color_b, BOOL ignore_alpha);
+DLL_API unsigned DLL_CALLCONV FreeImage_ApplyPaletteIndexMapping(FIBITMAP *dib, BYTE *srcindices, BYTE *dstindices, unsigned count, BOOL swap);
+DLL_API unsigned DLL_CALLCONV FreeImage_SwapPaletteIndices(FIBITMAP *dib, BYTE *index_a, BYTE *index_b);
+
+// channel processing routines
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_GetChannel(FIBITMAP *dib, FREE_IMAGE_COLOR_CHANNEL channel);
+DLL_API BOOL DLL_CALLCONV FreeImage_SetChannel(FIBITMAP *dib, FIBITMAP *dib8, FREE_IMAGE_COLOR_CHANNEL channel);
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_GetComplexChannel(FIBITMAP *src, FREE_IMAGE_COLOR_CHANNEL channel);
+DLL_API BOOL DLL_CALLCONV FreeImage_SetComplexChannel(FIBITMAP *dst, FIBITMAP *src, FREE_IMAGE_COLOR_CHANNEL channel);
+
+// copy / paste / composite routines
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Copy(FIBITMAP *dib, int left, int top, int right, int bottom);
+DLL_API BOOL DLL_CALLCONV FreeImage_Paste(FIBITMAP *dst, FIBITMAP *src, int left, int top, int alpha);
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Composite(FIBITMAP *fg, BOOL useFileBkg FI_DEFAULT(FALSE), RGBQUAD *appBkColor FI_DEFAULT(NULL), FIBITMAP *bg FI_DEFAULT(NULL));
+DLL_API BOOL DLL_CALLCONV FreeImage_JPEGCrop(const char *src_file, const char *dst_file, int left, int top, int right, int bottom);
+DLL_API BOOL DLL_CALLCONV FreeImage_PreMultiplyWithAlpha(FIBITMAP *dib);
+
+// miscellaneous algorithms
+DLL_API FIBITMAP *DLL_CALLCONV FreeImage_MultigridPoissonSolver(FIBITMAP *Laplacian, int ncycle FI_DEFAULT(3));
+
+// restore the borland-specific enum size option
+#if defined(__BORLANDC__)
+#pragma option pop
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // FREEIMAGE_H
diff --git a/v2/libs/FreeImage/freeimage.s.lib b/v2/libs/FreeImage/freeimage.s.lib Binary files differnew file mode 100755 index 00000000..ca3c5002 --- /dev/null +++ b/v2/libs/FreeImage/freeimage.s.lib diff --git a/v2/libs/FreeImage/libfreeimage.a b/v2/libs/FreeImage/libfreeimage.a Binary files differnew file mode 100644 index 00000000..1b0c1ec5 --- /dev/null +++ b/v2/libs/FreeImage/libfreeimage.a diff --git a/v2/libs/FreeImage/libfreeimage.s.a b/v2/libs/FreeImage/libfreeimage.s.a Binary files differnew file mode 100755 index 00000000..e6863c3f --- /dev/null +++ b/v2/libs/FreeImage/libfreeimage.s.a diff --git a/v2/libs/libtiff/libtiff.lib b/v2/libs/libtiff/libtiff.lib Binary files differnew file mode 100755 index 00000000..24b8abcd --- /dev/null +++ b/v2/libs/libtiff/libtiff.lib diff --git a/v2/libs/libtiff/tiff.h b/v2/libs/libtiff/tiff.h new file mode 100755 index 00000000..6330795b --- /dev/null +++ b/v2/libs/libtiff/tiff.h @@ -0,0 +1,647 @@ +/* $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: */ diff --git a/v2/libs/libtiff/tiffconf.h b/v2/libs/libtiff/tiffconf.h new file mode 100755 index 00000000..2d62fec0 --- /dev/null +++ b/v2/libs/libtiff/tiffconf.h @@ -0,0 +1,101 @@ +/* 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_ */ diff --git a/v2/libs/libtiff/tiffio.h b/v2/libs/libtiff/tiffio.h new file mode 100755 index 00000000..7aaf5613 --- /dev/null +++ b/v2/libs/libtiff/tiffio.h @@ -0,0 +1,515 @@ +/* $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: */ diff --git a/v2/libs/libtiff/tiffvers.h b/v2/libs/libtiff/tiffvers.h new file mode 100755 index 00000000..9744f8d3 --- /dev/null +++ b/v2/libs/libtiff/tiffvers.h @@ -0,0 +1,9 @@ +#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 diff --git a/v2/opj_configure.h.in b/v2/opj_configure.h.in new file mode 100755 index 00000000..24352a88 --- /dev/null +++ b/v2/opj_configure.h.in @@ -0,0 +1,16 @@ +/*
+ * 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
+#cmakedefine CMAKE_WORDS_BIGENDIAN
+#ifdef CMAKE_WORDS_BIGENDIAN
+ #define OPJ_BIG_ENDIAN
+#else
+ #define OPJ_LITTLE_ENDIAN
+#endif
+
+#endif /* __OPJ_CONFIGURE_H */
diff --git a/v2/test_Free_image_V2_tile_handling/CMakeLists.txt b/v2/test_Free_image_V2_tile_handling/CMakeLists.txt new file mode 100755 index 00000000..c392b72b --- /dev/null +++ b/v2/test_Free_image_V2_tile_handling/CMakeLists.txt @@ -0,0 +1,29 @@ +# Build the demo app, small examples
+
+# First thing define the common source:
+
+# Then check if getopt is present:
+INCLUDE (${CMAKE_ROOT}/Modules/CheckIncludeFile.cmake)
+
+# 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)
+
+INCLUDE(${OPENJPEG_SOURCE_DIR}/Free_CMakeImport.cmake)
+
+# Loop over all executables:
+FOREACH(exe test2_encoder test2_decoder)
+
+ ADD_EXECUTABLE(${exe} ${exe}.c)
+ TARGET_LINK_LIBRARIES(${exe} ${OPJ_PREFIX}openjpeg)
+ # Install exe
+ INSTALL_TARGETS(/bin/ ${exe})
+ENDFOREACH(exe)
+
diff --git a/v2/test_Free_image_V2_tile_handling/test2_decoder.c b/v2/test_Free_image_V2_tile_handling/test2_decoder.c new file mode 100755 index 00000000..c1886e43 --- /dev/null +++ b/v2/test_Free_image_V2_tile_handling/test2_decoder.c @@ -0,0 +1,367 @@ +/*
+ * 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.
+ */
+
+#define USE_OPJ_DEPRECATED
+/* set this macro to enable profiling for the given test */
+/* warning : in order to be effective, openjpeg must have been built with profiling enabled !! */
+//#define _PROFILE
+#include "openjpeg.h"
+#include "FreeImage.h"
+#ifdef WIN32
+#include <malloc.h>
+#endif
+#include <string.h>
+#include <stdlib.h>
+
+#define NB_EXTENSIONS 2
+/* -------------------------------------------------------------------------- */
+struct opj_format
+{
+ const char * m_extension;
+ OPJ_CODEC_FORMAT m_format;
+};
+
+const struct opj_format c_extensions[] =
+{
+ {".j2k",CODEC_J2K},
+ {".jp2",CODEC_JP2}
+};
+
+OPJ_CODEC_FORMAT get_format (const char * l_file_name)
+{
+ OPJ_INT32 i;
+ const struct opj_format * l_current = c_extensions;
+ for
+ (i=0;i<NB_EXTENSIONS;++i)
+ {
+ if
+ (! memcmp(l_current->m_extension,l_file_name + strlen(l_file_name)-4,4))
+ {
+ return l_current->m_format;
+ }
+ ++l_current;
+ }
+ return CODEC_UNKNOWN;
+}
+
+/**
+sample error callback expecting a FILE* client object
+*/
+void error_callback_file(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_file(const char *msg, void *client_data) {
+ FILE *stream = (FILE*)client_data;
+ fprintf(stream, "[WARNING] %s", msg);
+}
+/**
+sample error debug callback expecting no client object
+*/
+void error_callback(const char *msg, void *client_data) {
+ (void)client_data;
+ fprintf(stdout, "[ERROR] %s", msg);
+}
+/**
+sample warning debug callback expecting no client object
+*/
+void warning_callback(const char *msg, void *client_data) {
+ (void)client_data;
+ fprintf(stdout, "[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 [])
+{
+ opj_dparameters_t l_param;
+ opj_codec_t * l_codec;
+ opj_image_t * l_image;
+ FILE * l_file;
+ opj_stream_t * l_stream;
+ OPJ_UINT32 l_data_size;
+ OPJ_UINT32 l_max_data_size = 1000;
+ OPJ_UINT32 l_tile_index;
+ OPJ_BYTE * l_data = (OPJ_BYTE *) malloc(1000);
+ bool l_go_on = true;
+ OPJ_INT32 l_tile_x0,l_tile_y0;
+ OPJ_UINT32 l_tile_width,l_tile_height,l_nb_tiles_x,l_nb_tiles_y,l_nb_comps;
+ OPJ_INT32 l_current_tile_x0,l_current_tile_y0,l_current_tile_x1,l_current_tile_y1;
+ char * l_input_file,* l_output_file;
+ OPJ_INT32 l_min_x, l_min_y, l_max_x, l_max_y;
+ OPJ_CODEC_FORMAT l_codec_format;
+ FIBITMAP * l_bitmap;
+ char * l_image_data;
+ OPJ_INT32 l_req_x,l_req_y;
+ OPJ_UINT32 l_image_width,l_image_height,l_image_boundary,l_offset;
+ char * l_tile_ptr [3];
+ char * l_line_ptr, * l_current_ptr;
+ OPJ_UINT32 i,j;
+
+ if
+ (argc != 8)
+ {
+ printf("usage : ... \n");
+ return 1;
+ }
+
+ PROFINIT();
+ FreeImage_Initialise(0);
+
+ l_input_file = argv[1];
+ l_output_file = argv[2];
+ l_min_x = atoi(argv[3]);
+ l_min_y = atoi(argv[4]);
+ l_max_x = atoi(argv[5]);
+ l_max_y = atoi(argv[6]);
+
+ l_codec_format = get_format(l_input_file);
+
+ if
+ ((! l_data) || (l_codec_format == CODEC_UNKNOWN))
+ {
+ return 1;
+ }
+
+
+ opj_set_default_decoder_parameters(&l_param);
+
+ /** you may here add custom decoding parameters */
+ /* do not use layer decoding limitations */
+ l_param.cp_layer = 0;
+
+ /* do not use resolutions reductions */
+ l_param.cp_reduce = atoi(argv[7]);
+
+ /* to decode only a part of the image data */
+ //opj_restrict_decoding(&l_param,0,0,1000,1000);
+
+ l_codec = opj_create_decompress(l_codec_format);
+ if
+ (! l_codec)
+ {
+ free(l_data);
+ return 1;
+ }
+
+ /* catch events using our callbacks and give a local context */
+ opj_set_info_handler(l_codec, info_callback,00);
+ opj_set_warning_handler(l_codec, warning_callback,00);
+ opj_set_error_handler(l_codec, error_callback,00);
+ opj_restrict_decoding(&l_param,l_min_x, l_min_y, l_max_x, l_max_y);
+
+ if
+ (! opj_setup_decoder(l_codec,&l_param))
+ {
+ free(l_data);
+ opj_destroy_codec(l_codec);
+ return 1;
+ }
+
+ l_file = fopen(l_input_file,"rb");
+ if
+ (! l_file)
+ {
+ fprintf(stdout, "Error opening input file\n");
+ free(l_data);
+ opj_destroy_codec(l_codec);
+ return 1;
+ }
+
+ l_stream = opj_stream_create_default_file_stream(l_file,true);
+
+ if
+ (! opj_read_header(l_codec,
+ &l_image,
+ &l_tile_x0,
+ &l_tile_y0,
+ &l_tile_width,
+ &l_tile_height,
+ &l_nb_tiles_x,
+ &l_nb_tiles_y,
+ l_stream))
+ {
+ free(l_data);
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ return 1;
+ }
+
+ if
+ ((l_tile_x0 != 0) || (l_tile_y0 != 0))
+ {
+ free(l_data);
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ return 1;
+ }
+
+ l_min_x -= l_min_x % l_tile_width;
+ l_min_y -= l_min_y % l_tile_height;
+
+ l_req_x = l_max_x % l_tile_width;
+ if
+ (l_req_x)
+ {
+ l_max_x += l_tile_width - l_req_x;
+ }
+
+ l_req_y = l_max_y % l_tile_height;
+ if
+ (l_req_y)
+ {
+ l_max_y += l_tile_height - l_req_y;
+ }
+
+ l_min_x = l_min_x < l_image->x0 ? l_image->x0 : l_min_x;
+ l_min_y = l_min_y < l_image->y0 ? l_image->y0 : l_min_y;
+ l_max_x = l_max_x > l_image->x1 ? l_image->x1 : l_max_x;
+ l_max_y = l_max_y > l_image->y1 ? l_image->y1 : l_max_y;
+
+ l_image_width = (l_max_x - l_min_x + (1 << l_param.cp_reduce) - 1) >> l_param.cp_reduce;
+ l_image_height = (l_max_y - l_min_y + (1 << l_param.cp_reduce) - 1) >> l_param.cp_reduce;
+ l_image_boundary = 3 * l_image_width;
+ l_req_x = l_image_boundary % 4;
+ if
+ (l_req_x)
+ {
+ l_image_boundary += 4-l_req_x;
+ }
+
+ l_bitmap = FreeImage_Allocate(l_image_width, l_image_height, 24, 0, 0, 0);
+ l_image_data = FreeImage_GetBits(l_bitmap);
+
+ while
+ (l_go_on)
+ {
+ if
+ (! opj_read_tile_header(
+ l_codec,
+ &l_tile_index,
+ &l_data_size,
+ &l_current_tile_x0,
+ &l_current_tile_y0,
+ &l_current_tile_x1,
+ &l_current_tile_y1,
+ &l_nb_comps,
+ &l_go_on,
+ l_stream))
+ {
+ free(l_data);
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+ if
+ (l_go_on)
+ {
+ if
+ (l_data_size > l_max_data_size)
+ {
+ l_data = (OPJ_BYTE *) realloc(l_data,l_data_size);
+ if
+ (! l_data)
+ {
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+ l_max_data_size = l_data_size;
+ }
+
+ if
+ (! opj_decode_tile_data(l_codec,l_tile_index,l_data,l_data_size,l_stream))
+ {
+ free(l_data);
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+ /** now should inspect image to know the reduction factor and then how to behave with data */
+ l_offset = (((l_max_y - l_current_tile_y0 + (1 << l_param.cp_reduce) - 1)>>l_param.cp_reduce) - 1) * l_image_boundary + ((l_current_tile_x0 - l_min_x + (1 << l_param.cp_reduce) - 1)>> l_param.cp_reduce )* 3;
+
+ l_tile_width = (l_current_tile_x1 - l_current_tile_x0 + (1 << l_param.cp_reduce) - 1)>>l_param.cp_reduce;
+ l_tile_height = (l_current_tile_y1 - l_current_tile_y0 + (1 << l_param.cp_reduce) - 1)>>l_param.cp_reduce;
+ l_tile_ptr[0] = l_data + 2 * l_tile_width * l_tile_height;
+ l_tile_ptr[1] = l_data + l_tile_width * l_tile_height;
+ l_tile_ptr[2] = l_data ;
+ l_line_ptr = l_image_data + l_offset;
+ for
+ (i=0;i<l_tile_width;++i)
+ {
+ l_current_ptr = l_line_ptr;
+ for
+ (j=0;j<l_tile_height;++j)
+ {
+ *(l_current_ptr++) = *(l_tile_ptr[0]++);
+ *(l_current_ptr++) = *(l_tile_ptr[1]++);
+ *(l_current_ptr++) = *(l_tile_ptr[2]++);
+ }
+ l_line_ptr -= l_image_boundary;
+ }
+ }
+ }
+ if
+ (! opj_end_decompress(l_codec,l_stream))
+ {
+ free(l_data);
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+ free(l_data);
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+
+ // Print profiling
+ PROFPRINT();
+ FreeImage_Save(0,l_bitmap,l_output_file,0);
+ FreeImage_Unload(l_bitmap);
+
+ return 0;
+}
diff --git a/v2/test_Free_image_V2_tile_handling/test2_encoder.c b/v2/test_Free_image_V2_tile_handling/test2_encoder.c new file mode 100755 index 00000000..ec87e420 --- /dev/null +++ b/v2/test_Free_image_V2_tile_handling/test2_encoder.c @@ -0,0 +1,492 @@ +/*
+ * 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.
+ */
+#define USE_OPJ_DEPRECATED
+/* set this macro to enable profiling for the given test */
+/* warning : in order to be effective, openjpeg must have been built with profiling enabled !! */
+//#define _PROFILE
+
+#include "openjpeg.h"
+#include <FreeImage.h>
+#include <string.h>
+#include <stdlib.h>
+
+/* -------------------------------------------------------------------------- */
+
+/**
+sample error callback expecting a FILE* client object
+*/
+void error_callback_file(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_file(const char *msg, void *client_data) {
+ FILE *stream = (FILE*)client_data;
+ fprintf(stream, "[WARNING] %s", msg);
+}
+/**
+sample error debug callback expecting no client object
+*/
+void error_callback(const char *msg, void *client_data) {
+ (void)client_data;
+ fprintf(stdout, "[ERROR] %s", msg);
+}
+/**
+sample warning debug callback expecting no client object
+*/
+void warning_callback(const char *msg, void *client_data) {
+ (void)client_data;
+ fprintf(stdout, "[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);
+}
+
+struct opj_format
+{
+ const char * m_extension;
+ OPJ_CODEC_FORMAT m_format;
+};
+
+const struct opj_format c_extensions[] =
+{
+ {".j2k",CODEC_J2K},
+ {".jp2",CODEC_JP2}
+};
+
+#define NB_EXTENSIONS 2
+OPJ_CODEC_FORMAT get_format (const char * l_file_name)
+{
+ OPJ_INT32 i;
+ const struct opj_format * l_current = c_extensions;
+ for
+ (i=0;i<NB_EXTENSIONS;++i)
+ {
+ if
+ (! memcmp(l_current->m_extension,l_file_name + strlen(l_file_name)-4,4))
+ {
+ return l_current->m_format;
+ }
+ ++l_current;
+ }
+ return CODEC_UNKNOWN;
+}
+
+/* -------------------------------------------------------------------------- */
+
+int main (int argc, char * argv [])
+{
+ opj_cparameters_t l_param;
+ opj_codec_t * l_codec;
+ opj_image_t * l_image;
+ opj_image_cmptparm_t l_params [3];
+ FILE * l_file;
+ opj_stream_t * l_stream;
+ opj_image_cmptparm_t * l_current_param_ptr;
+ OPJ_UINT32 i,j,k,l;
+ OPJ_BYTE *l_tile_data,*l_line_ptr,*l_current_ptr;
+ OPJ_BYTE * l_tile_ptr [3];
+ OPJ_UINT32 l_tile_width,l_image_width,l_image_height,l_chunk_size,l_image_boundary,l_req_x,l_req_y,l_nb_tiles_x,l_nb_tiles_y,l_current_tile_nb,l_data_size;
+ OPJ_UINT32 l_offset;
+
+ OPJ_CODEC_FORMAT l_codec_format;
+ FIBITMAP * l_bitmap;
+ FREE_IMAGE_FORMAT l_input_format;
+ char * l_image_data;
+ char * l_input_file,*l_output_file;
+ if
+ (argc != 6)
+ {
+ printf("usage \n");
+ return 1;
+ }
+
+ l_input_file = argv[1];
+ l_output_file = argv[2];
+ l_tile_width = atoi(argv[3]);
+
+ FreeImage_Initialise(0);
+
+ l_codec_format = get_format(l_output_file);
+ if
+ (l_codec_format == CODEC_UNKNOWN)
+ {
+ return 1;
+ }
+
+ l_input_format = FreeImage_GetFileType(l_input_file,0);
+ if
+ (l_input_format == -1)
+ {
+ return 1;
+ }
+ l_bitmap = FreeImage_Load(l_input_format,l_input_file,0);
+ l_image_data = FreeImage_GetBits(l_bitmap);
+ l_image_width = FreeImage_GetWidth(l_bitmap);
+ l_image_height = FreeImage_GetHeight(l_bitmap);
+ l_chunk_size = FreeImage_GetBPP(l_bitmap);
+ l_chunk_size /= 8;
+
+ if
+ (l_chunk_size < 3)
+ {
+ return 1;
+ }
+ l_image_boundary = l_image_width * l_chunk_size;
+
+ l_req_x = l_image_boundary % 4;
+ if
+ (l_req_x)
+ {
+ l_image_boundary += 4 - l_req_x;
+ }
+
+ l_tile_data = (OPJ_BYTE*) malloc(l_tile_width * l_tile_width * 3);
+
+ l_nb_tiles_x = l_image_width / l_tile_width;
+ l_req_x = l_image_width % l_tile_width;
+ l_nb_tiles_y = l_image_height / l_tile_width;
+ l_req_y = l_image_height % l_tile_width;
+
+ opj_set_default_encoder_parameters(&l_param);
+ /** you may here add custom encoding parameters */
+ /* rate specifications */
+ /** number of quality layers in the stream */
+ l_param.tcp_numlayers = 1;
+ l_param.cp_fixed_quality = 1;
+ /* is using others way of calculation */
+ /* l_param.cp_disto_alloc = 1 or l_param.cp_fixed_alloc = 1 */
+ /* l_param.tcp_rates[0] = ... */
+
+
+ /* tile definitions parameters */
+ /* position of the tile grid aligned with the image */
+ l_param.cp_tx0 = 0;
+ l_param.cp_ty0 = 0;
+ /* tile size, we are using tile based encoding */
+ l_param.tile_size_on = true;
+ l_param.cp_tdx = l_tile_width;
+ l_param.cp_tdy = l_tile_width;
+
+ /* use irreversible encoding ?*/
+ l_param.irreversible = atoi(argv[5]);
+
+ /* do not bother with mct, the rsiz is set when calling opj_set_MCT*/
+ /*l_param.cp_rsiz = STD_RSIZ;*/
+
+ /* no cinema */
+ /*l_param.cp_cinema = 0;*/
+
+ /* no not bother using SOP or EPH markers, do not use custom size precinct */
+ /* number of precincts to specify */
+ /* l_param.csty = 0;*/
+ /* l_param.res_spec = ... */
+ /* l_param.prch_init[i] = .. */
+ /* l_param.prcw_init[i] = .. */
+
+
+ /* do not use progression order changes */
+ /*l_param.numpocs = 0;*/
+ /* l_param.POC[i].... */
+
+ /* do not restrain the size for a component.*/
+ /* l_param.max_comp_size = 0; */
+
+ /** block encoding style for each component, do not use at the moment */
+ /** J2K_CCP_CBLKSTY_TERMALL, J2K_CCP_CBLKSTY_LAZY, J2K_CCP_CBLKSTY_VSC, J2K_CCP_CBLKSTY_SEGSYM, J2K_CCP_CBLKSTY_RESET */
+ /* l_param.mode = 0;*/
+
+ /** number of resolutions */
+ l_param.numresolution = atoi(argv[4]);
+
+ /** progression order to use*/
+ /** LRCP, RLCP, RPCL, PCRL, CPRL */
+ l_param.prog_order = LRCP;
+
+ /** no "region" of interest, more precisally component */
+ /* l_param.roi_compno = -1; */
+ /* l_param.roi_shift = 0; */
+
+ /* we are not using multiple tile parts for a tile. */
+ /* l_param.tp_on = 0; */
+ /* l_param.tp_flag = 0; */
+
+ l_param.tcp_mct = 1;
+ /* if we are using mct */
+ /* opj_set_MCT(&l_param,l_mct,l_offsets,NUM_COMPS); */
+
+
+ /* image definition */
+ l_current_param_ptr = l_params;
+ for
+ (i=0;i<3;++i)
+ {
+ /* do not bother bpp useless */
+ /*l_current_param_ptr->bpp = COMP_PREC;*/
+ l_current_param_ptr->dx = 1;
+ l_current_param_ptr->dy = 1;
+ l_current_param_ptr->h = l_image_height;
+ l_current_param_ptr->sgnd = 0;
+ l_current_param_ptr->prec = 8;
+ l_current_param_ptr->w = l_image_width;
+ l_current_param_ptr->x0 = 0;
+ l_current_param_ptr->y0 = 0;
+ ++l_current_param_ptr;
+ }
+
+ l_codec = opj_create_compress(l_codec_format);
+ if
+ (! l_codec)
+ {
+ return 1;
+ }
+
+ /* catch events using our callbacks and give a local context */
+ opj_set_info_handler(l_codec, info_callback,00);
+ opj_set_warning_handler(l_codec, warning_callback,00);
+ opj_set_error_handler(l_codec, error_callback,00);
+
+ l_image = opj_image_tile_create(3,l_params,CLRSPC_SRGB);
+ if
+ (! l_image)
+ {
+ opj_destroy_codec(l_codec);
+ return 1;
+ }
+ l_image->x0 = 0;
+ l_image->y0 = 0;
+ l_image->x1 = l_image_width;
+ l_image->y1 = l_image_height;
+ l_image->color_space = CLRSPC_SRGB;
+
+ if
+ (! opj_setup_encoder(l_codec,&l_param,l_image))
+ {
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+
+ l_file = fopen(l_output_file,"wb");
+ if
+ (! l_file)
+ {
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+
+ l_stream = opj_stream_create_default_file_stream(l_file,false);
+
+ if
+ (! opj_start_compress(l_codec,l_image,l_stream))
+ {
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+
+ l_current_tile_nb = 0;
+
+ for
+ (i=0;i<l_nb_tiles_y;++i)
+ {
+ for
+ (j=0;j<l_nb_tiles_x;++j)
+ {
+ l_offset = (l_image_height - i * l_tile_width - 1) * l_image_boundary + l_chunk_size * j * l_tile_width;
+ l_line_ptr = l_image_data + l_offset;
+ l_tile_ptr[0] = l_tile_data;
+ l_tile_ptr[1] = l_tile_data + l_tile_width * l_tile_width;
+ l_tile_ptr[2] = l_tile_data + 2 * l_tile_width * l_tile_width;
+ for
+ (k=0;k<l_tile_width;++k)
+ {
+ l_current_ptr = l_line_ptr;
+ for
+ (l=0;l<l_tile_width;++l)
+ {
+ *(l_tile_ptr[0]++) = *(l_current_ptr+2);
+ *(l_tile_ptr[1]++) = *(l_current_ptr+1);
+ *(l_tile_ptr[2]++) = *(l_current_ptr);
+ l_current_ptr += l_chunk_size;
+ }
+ l_line_ptr -= l_image_boundary;
+ }
+ l_data_size = l_tile_width * l_tile_width * 3;
+ if
+ (! opj_write_tile(l_codec,l_current_tile_nb++,l_tile_data,l_data_size,l_stream))
+ {
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+ }
+ if
+ (l_req_x)
+ {
+ l_offset = (l_image_height - i * l_tile_width - 1) * l_image_boundary + l_chunk_size * j * l_tile_width;
+ l_line_ptr = l_image_data + l_offset;
+ l_tile_ptr[0] = l_tile_data;
+ l_tile_ptr[1] = l_tile_data + l_tile_width * l_req_x;
+ l_tile_ptr[2] = l_tile_data + 2 * l_tile_width * l_req_x;
+ for
+ (k=0;k<l_tile_width;++k)
+ {
+ l_current_ptr = l_line_ptr;
+ for
+ (l=0;l<l_req_x;++l)
+ {
+ *(l_tile_ptr[0]++) = *(l_current_ptr+2);
+ *(l_tile_ptr[1]++) = *(l_current_ptr+1);
+ *(l_tile_ptr[2]++) = *(l_current_ptr);
+ l_current_ptr += l_chunk_size;
+ }
+ l_line_ptr -= l_image_boundary;
+ }
+ l_data_size = l_tile_width * l_req_x * 3;
+ if
+ (! opj_write_tile(l_codec,l_current_tile_nb++,l_tile_data,l_data_size,l_stream))
+ {
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+
+ }
+ }
+ if
+ (l_req_y)
+ {
+ for
+ (j=0;j<l_nb_tiles_x;++j)
+ {
+ l_offset = (l_image_height - i * l_tile_width - 1) * l_image_boundary + l_chunk_size * j * l_tile_width;
+ l_line_ptr = l_image_data + l_offset;
+ l_tile_ptr[0] = l_tile_data;
+ l_tile_ptr[1] = l_tile_data + l_tile_width * l_req_y;
+ l_tile_ptr[2] = l_tile_data + 2 * l_tile_width * l_req_y;
+ for
+ (k=0;k<l_req_y;++k)
+ {
+ l_current_ptr = l_line_ptr;
+ for
+ (l=0;l<l_tile_width;++l)
+ {
+ *(l_tile_ptr[0]++) = *(l_current_ptr+2);
+ *(l_tile_ptr[1]++) = *(l_current_ptr+1);
+ *(l_tile_ptr[2]++) = *(l_current_ptr);
+ l_current_ptr += l_chunk_size;
+ }
+ l_line_ptr -= l_image_boundary;
+ }
+ l_data_size = l_req_y * l_tile_width * 3;
+ if
+ (! opj_write_tile(l_codec,l_current_tile_nb++,l_tile_data,l_data_size,l_stream))
+ {
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+ }
+ if
+ (l_req_x)
+ {
+ l_offset = (l_image_height - i * l_tile_width - 1) * l_image_boundary + l_chunk_size * j * l_tile_width;
+ l_line_ptr = l_image_data + l_offset;
+ l_tile_ptr[0] = l_tile_data;
+ l_tile_ptr[1] = l_tile_data + l_req_x * l_req_y;
+ l_tile_ptr[2] = l_tile_data + 2 * l_req_x * l_req_y;
+ for
+ (k=0;k<l_req_y;++k)
+ {
+ l_current_ptr = l_line_ptr;
+ for
+ (l=0;l<l_req_x;++l)
+ {
+ *(l_tile_ptr[0]++) = *(l_current_ptr+2);
+ *(l_tile_ptr[1]++) = *(l_current_ptr+1);
+ *(l_tile_ptr[2]++) = *(l_current_ptr);
+ l_current_ptr += l_chunk_size;
+ }
+ l_line_ptr -= l_image_boundary;
+ }
+ l_data_size = l_req_y * l_req_x * 3;
+ if
+ (! opj_write_tile(l_codec,l_current_tile_nb++,l_tile_data,l_data_size,l_stream))
+ {
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+ }
+ }
+
+
+ if
+ (! opj_end_compress(l_codec,l_stream))
+ {
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+
+
+ FreeImage_DeInitialise();
+
+ // Print profiling
+ PROFPRINT();
+
+ return 0;
+}
+
+
+
+
+
+
diff --git a/v2/test_V2_tile_handling/CMakeLists.txt b/v2/test_V2_tile_handling/CMakeLists.txt new file mode 100755 index 00000000..bf3098a9 --- /dev/null +++ b/v2/test_V2_tile_handling/CMakeLists.txt @@ -0,0 +1,27 @@ +# Build the demo app, small examples
+
+# First thing define the common source:
+
+# Then check if getopt is present:
+INCLUDE (${CMAKE_ROOT}/Modules/CheckIncludeFile.cmake)
+
+# 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)
+
+
+# Loop over all executables:
+FOREACH(exe test_encoder test_decoder)
+ ADD_EXECUTABLE(${exe} ${exe}.c)
+ TARGET_LINK_LIBRARIES(${exe} ${OPJ_PREFIX}openjpeg)
+ # Install exe
+ INSTALL_TARGETS(/bin/ ${exe})
+ENDFOREACH(exe)
+
diff --git a/v2/test_V2_tile_handling/test_decoder.c b/v2/test_V2_tile_handling/test_decoder.c new file mode 100755 index 00000000..e6d71341 --- /dev/null +++ b/v2/test_V2_tile_handling/test_decoder.c @@ -0,0 +1,244 @@ +/*
+ * 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.
+ */
+#define USE_OPJ_DEPRECATED
+/* set this macro to enable profiling for the given test */
+/* warning : in order to be effective, openjpeg must have been built with profiling enabled !! */
+//#define _PROFILE
+
+#include "openjpeg.h"
+#ifdef WIN32
+#include <malloc.h>
+#endif
+#define DA_X0 0
+#define DA_Y0 0
+#define DA_X1 1000
+#define DA_Y1 1000
+#define INPUT_FILE "test.j2k"
+
+/* -------------------------------------------------------------------------- */
+
+/**
+sample error callback expecting a FILE* client object
+*/
+void error_callback_file(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_file(const char *msg, void *client_data) {
+ FILE *stream = (FILE*)client_data;
+ fprintf(stream, "[WARNING] %s", msg);
+}
+/**
+sample error debug callback expecting no client object
+*/
+void error_callback(const char *msg, void *client_data) {
+ (void)client_data;
+ fprintf(stdout, "[ERROR] %s", msg);
+}
+/**
+sample warning debug callback expecting no client object
+*/
+void warning_callback(const char *msg, void *client_data) {
+ (void)client_data;
+ fprintf(stdout, "[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 ()
+{
+ opj_dparameters_t l_param;
+ opj_codec_t * l_codec;
+ opj_image_t * l_image;
+ FILE * l_file;
+ opj_stream_t * l_stream;
+ OPJ_UINT32 l_data_size;
+ OPJ_UINT32 l_max_data_size = 1000;
+ OPJ_UINT32 l_tile_index;
+ OPJ_BYTE * l_data = (OPJ_BYTE *) malloc(1000);
+ bool l_go_on = true;
+ OPJ_INT32 l_tile_x0,l_tile_y0;
+ OPJ_UINT32 l_tile_width,l_tile_height,l_nb_tiles_x,l_nb_tiles_y,l_nb_comps;
+ OPJ_INT32 l_current_tile_x0,l_current_tile_y0,l_current_tile_x1,l_current_tile_y1;
+
+ PROFINIT();
+
+
+ if
+ (! l_data)
+ {
+ return 1;
+ }
+ opj_set_default_decoder_parameters(&l_param);
+
+ /** you may here add custom decoding parameters */
+ /* do not use layer decoding limitations */
+ l_param.cp_layer = 0;
+
+ /* do not use resolutions reductions */
+ l_param.cp_reduce = 0;
+
+ /* to decode only a part of the image data */
+ //opj_restrict_decoding(&l_param,0,0,1000,1000);
+
+ l_codec = opj_create_decompress(CODEC_J2K);
+ if
+ (! l_codec)
+ {
+ free(l_data);
+ return 1;
+ }
+
+ /* catch events using our callbacks and give a local context */
+ opj_set_info_handler(l_codec, info_callback,00);
+ opj_set_warning_handler(l_codec, warning_callback,00);
+ opj_set_error_handler(l_codec, error_callback,00);
+
+ if
+ (! opj_setup_decoder(l_codec,&l_param))
+ {
+ free(l_data);
+ opj_destroy_codec(l_codec);
+ return 1;
+ }
+
+ l_file = fopen(INPUT_FILE,"rb");
+ if
+ (! l_file)
+ {
+ fprintf(stdout, "Error opening input file\n");
+ free(l_data);
+ opj_destroy_codec(l_codec);
+ return 1;
+ }
+
+ l_stream = opj_stream_create_default_file_stream(l_file,true);
+
+ if
+ (! opj_read_header(l_codec,
+ &l_image,
+ &l_tile_x0,
+ &l_tile_y0,
+ &l_tile_width,
+ &l_tile_height,
+ &l_nb_tiles_x,
+ &l_nb_tiles_y,
+ l_stream))
+ {
+ free(l_data);
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ return 1;
+ }
+ printf("Setting decoding area to %d,%d,%d,%d\n", DA_X0, DA_Y0, DA_X1, DA_Y1);
+ opj_set_decode_area(l_codec, DA_X0, DA_Y0, DA_X1, DA_Y1);
+ while
+ (l_go_on)
+ {
+ if
+ (! opj_read_tile_header(
+ l_codec,
+ &l_tile_index,
+ &l_data_size,
+ &l_current_tile_x0,
+ &l_current_tile_y0,
+ &l_current_tile_x1,
+ &l_current_tile_y1,
+ &l_nb_comps,
+ &l_go_on,
+ l_stream))
+ {
+ free(l_data);
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+ if
+ (l_go_on)
+ {
+ if
+ (l_data_size > l_max_data_size)
+ {
+ l_data = (OPJ_BYTE *) realloc(l_data,l_data_size);
+ if
+ (! l_data)
+ {
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+ l_max_data_size = l_data_size;
+ }
+
+ if
+ (! opj_decode_tile_data(l_codec,l_tile_index,l_data,l_data_size,l_stream))
+ {
+ free(l_data);
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+ /** now should inspect image to know the reduction factor and then how to behave with data */
+ }
+ }
+ if
+ (! opj_end_decompress(l_codec,l_stream))
+ {
+ free(l_data);
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+ free(l_data);
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+
+ // Print profiling
+ PROFPRINT();
+
+ return 0;
+}
diff --git a/v2/test_V2_tile_handling/test_encoder.c b/v2/test_V2_tile_handling/test_encoder.c new file mode 100755 index 00000000..1fe17e23 --- /dev/null +++ b/v2/test_V2_tile_handling/test_encoder.c @@ -0,0 +1,299 @@ +/*
+ * 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.
+ */
+#define USE_OPJ_DEPRECATED
+
+#include "openjpeg.h"
+/* set this macro to enable profiling for the given test */
+/* warning : in order to be effective, openjpeg must have been built with profiling enabled !! */
+//#define _PROFILE
+
+#ifdef WIN32
+#include "windows.h" // needed for rand() function
+#endif
+
+
+#define NUM_COMPS 3
+#define IMAGE_WIDTH 2000
+#define IMAGE_HEIGHT 2000
+#define TILE_WIDTH 1000
+#define TILE_HEIGHT 1000
+#define COMP_PREC 8
+#define OUTPUT_FILE "test.j2k"
+
+/* -------------------------------------------------------------------------- */
+
+/**
+sample error callback expecting a FILE* client object
+*/
+void error_callback_file(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_file(const char *msg, void *client_data) {
+ FILE *stream = (FILE*)client_data;
+ fprintf(stream, "[WARNING] %s", msg);
+}
+/**
+sample error debug callback expecting no client object
+*/
+void error_callback(const char *msg, void *client_data) {
+ (void)client_data;
+ fprintf(stdout, "[ERROR] %s", msg);
+}
+/**
+sample warning debug callback expecting no client object
+*/
+void warning_callback(const char *msg, void *client_data) {
+ (void)client_data;
+ fprintf(stdout, "[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 ()
+{
+ opj_cparameters_t l_param;
+ opj_codec_t * l_codec;
+ opj_image_t * l_image;
+ opj_image_cmptparm_t l_params [NUM_COMPS];
+ FILE * l_file;
+ opj_stream_t * l_stream;
+ OPJ_UINT32 l_nb_tiles = (IMAGE_WIDTH/TILE_WIDTH) * (IMAGE_HEIGHT/TILE_HEIGHT);
+ OPJ_UINT32 l_data_size = TILE_WIDTH * TILE_HEIGHT * NUM_COMPS * (COMP_PREC/8);
+
+ const OPJ_FLOAT32 l_mct [] =
+ {
+ 1 , 0 , 0 ,
+ 0 , 1 , 0 ,
+ 0 , 0 , 1
+ };
+
+ const OPJ_INT32 l_offsets [] =
+ {
+ 128 , 128 , 128
+ };
+
+ opj_image_cmptparm_t * l_current_param_ptr;
+ OPJ_UINT32 i;
+ OPJ_BYTE *l_data;
+
+ PROFINIT();
+ l_data = (OPJ_BYTE*) malloc(TILE_WIDTH * TILE_HEIGHT * NUM_COMPS * (COMP_PREC/8) * sizeof(OPJ_BYTE));
+
+ fprintf(stdout, "Encoding random values -> keep in mind that this is very hard to compress\n");
+ for
+ (i=0;i<l_data_size;++i)
+ {
+ l_data[i] = rand();
+ }
+
+ opj_set_default_encoder_parameters(&l_param);
+ /** you may here add custom encoding parameters */
+ /* rate specifications */
+ /** number of quality layers in the stream */
+ l_param.tcp_numlayers = 1;
+ l_param.cp_fixed_quality = 1;
+ l_param.tcp_distoratio[0] = 20;
+ /* is using others way of calculation */
+ /* l_param.cp_disto_alloc = 1 or l_param.cp_fixed_alloc = 1 */
+ /* l_param.tcp_rates[0] = ... */
+
+
+ /* tile definitions parameters */
+ /* position of the tile grid aligned with the image */
+ l_param.cp_tx0 = 0;
+ l_param.cp_ty0 = 0;
+ /* tile size, we are using tile based encoding */
+ l_param.tile_size_on = true;
+ l_param.cp_tdx = TILE_WIDTH;
+ l_param.cp_tdy = TILE_HEIGHT;
+
+ /* use irreversible encoding ?*/
+ l_param.irreversible = 1;
+
+ /* do not bother with mct, the rsiz is set when calling opj_set_MCT*/
+ /*l_param.cp_rsiz = STD_RSIZ;*/
+
+ /* no cinema */
+ /*l_param.cp_cinema = 0;*/
+
+ /* no not bother using SOP or EPH markers, do not use custom size precinct */
+ /* number of precincts to specify */
+ /* l_param.csty = 0;*/
+ /* l_param.res_spec = ... */
+ /* l_param.prch_init[i] = .. */
+ /* l_param.prcw_init[i] = .. */
+
+
+ /* do not use progression order changes */
+ /*l_param.numpocs = 0;*/
+ /* l_param.POC[i].... */
+
+ /* do not restrain the size for a component.*/
+ /* l_param.max_comp_size = 0; */
+
+ /** block encoding style for each component, do not use at the moment */
+ /** J2K_CCP_CBLKSTY_TERMALL, J2K_CCP_CBLKSTY_LAZY, J2K_CCP_CBLKSTY_VSC, J2K_CCP_CBLKSTY_SEGSYM, J2K_CCP_CBLKSTY_RESET */
+ /* l_param.mode = 0;*/
+
+ /** number of resolutions */
+ l_param.numresolution = 6;
+
+ /** progression order to use*/
+ /** LRCP, RLCP, RPCL, PCRL, CPRL */
+ l_param.prog_order = LRCP;
+
+ /** no "region" of interest, more precisally component */
+ /* l_param.roi_compno = -1; */
+ /* l_param.roi_shift = 0; */
+
+ /* we are not using multiple tile parts for a tile. */
+ /* l_param.tp_on = 0; */
+ /* l_param.tp_flag = 0; */
+
+ /* if we are using mct */
+ /* opj_set_MCT(&l_param,l_mct,l_offsets,NUM_COMPS); */
+
+
+ /* image definition */
+ l_current_param_ptr = l_params;
+ for
+ (i=0;i<NUM_COMPS;++i)
+ {
+ /* do not bother bpp useless */
+ /*l_current_param_ptr->bpp = COMP_PREC;*/
+ l_current_param_ptr->dx = 1;
+ l_current_param_ptr->dy = 1;
+ l_current_param_ptr->h = IMAGE_HEIGHT;
+ l_current_param_ptr->sgnd = 0;
+ l_current_param_ptr->prec = COMP_PREC;
+ l_current_param_ptr->w = IMAGE_WIDTH;
+ l_current_param_ptr->x0 = 0;
+ l_current_param_ptr->y0 = 0;
+ ++l_current_param_ptr;
+ }
+
+ l_codec = opj_create_compress(CODEC_J2K);
+ if
+ (! l_codec)
+ {
+ return 1;
+ }
+
+ /* catch events using our callbacks and give a local context */
+ opj_set_info_handler(l_codec, info_callback,00);
+ opj_set_warning_handler(l_codec, warning_callback,00);
+ opj_set_error_handler(l_codec, error_callback,00);
+
+ l_image = opj_image_tile_create(NUM_COMPS,l_params,CLRSPC_SRGB);
+ if
+ (! l_image)
+ {
+ opj_destroy_codec(l_codec);
+ return 1;
+ }
+ l_image->x0 = 0;
+ l_image->y0 = 0;
+ l_image->x1 = IMAGE_WIDTH;
+ l_image->y1 = IMAGE_HEIGHT;
+ l_image->color_space = CLRSPC_SRGB;
+
+ if
+ (! opj_setup_encoder(l_codec,&l_param,l_image))
+ {
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+
+ l_file = fopen(OUTPUT_FILE,"wb");
+ if
+ (! l_file)
+ {
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+
+ l_stream = opj_stream_create_default_file_stream(l_file,false);
+
+ if
+ (! opj_start_compress(l_codec,l_image,l_stream))
+ {
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+ for
+ (i=0;i<l_nb_tiles;++i)
+ {
+ if
+ (! opj_write_tile(l_codec,i,l_data,l_data_size,l_stream))
+ {
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+ }
+ if
+ (! opj_end_compress(l_codec,l_stream))
+ {
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+ return 1;
+ }
+ opj_stream_destroy(l_stream);
+ fclose(l_file);
+ opj_destroy_codec(l_codec);
+ opj_image_destroy(l_image);
+
+ // Print profiling
+ PROFPRINT();
+
+ return 0;
+}
+
+
+
+
+
+
|