Merge pull request #1350 from rouault/remove_jpwl_jp3d_mj2
Remove obsolete components JPWL, JP3D and MJ2
This commit is contained in:
commit
5f653ad673
|
@ -264,20 +264,16 @@ endif()
|
|||
#-----------------------------------------------------------------------------
|
||||
# Build Applications
|
||||
option(BUILD_CODEC "Build the CODEC executables" ON)
|
||||
option(BUILD_MJ2 "Build the MJ2 executables." OFF)
|
||||
option(BUILD_JPWL "Build the JPWL library and executables" OFF)
|
||||
option(BUILD_JPIP "Build the JPIP library and executables." OFF)
|
||||
if(BUILD_JPIP)
|
||||
option(BUILD_JPIP_SERVER "Build the JPIP server." OFF)
|
||||
endif()
|
||||
option(BUILD_VIEWER "Build the OPJViewer executable (C++)" OFF)
|
||||
option(BUILD_JAVA "Build the openjpeg jar (Java)" OFF)
|
||||
option(BUILD_JP3D "Build the JP3D comp" OFF)
|
||||
mark_as_advanced(BUILD_VIEWER)
|
||||
mark_as_advanced(BUILD_JAVA)
|
||||
mark_as_advanced(BUILD_JP3D)
|
||||
|
||||
if(BUILD_CODEC OR BUILD_MJ2)
|
||||
if(BUILD_CODEC)
|
||||
# OFF: It will only build 3rd party libs if they are not found on the system
|
||||
# ON: 3rd party libs will ALWAYS be build, and used
|
||||
option(BUILD_THIRDPARTY "Build the thirdparty executables if it is needed" OFF)
|
||||
|
@ -367,14 +363,6 @@ if(BUILD_PKGCONFIG_FILES)
|
|||
${CMAKE_CURRENT_BINARY_DIR}/libopenjp2.pc @ONLY)
|
||||
install( FILES ${CMAKE_CURRENT_BINARY_DIR}/libopenjp2.pc DESTINATION
|
||||
${OPENJPEG_INSTALL_LIB_DIR}/pkgconfig )
|
||||
#
|
||||
if(BUILD_JPWL)
|
||||
# install in lib and not share (see multi-arch note above)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/lib/openjpwl/libopenjpwl.pc.cmake.in
|
||||
${CMAKE_CURRENT_BINARY_DIR}/libopenjpwl.pc @ONLY)
|
||||
install( FILES ${CMAKE_CURRENT_BINARY_DIR}/libopenjpwl.pc DESTINATION
|
||||
${OPENJPEG_INSTALL_LIB_DIR}/pkgconfig )
|
||||
endif()
|
||||
#
|
||||
if(BUILD_JPIP)
|
||||
# install in lib and not share (see multi-arch note above)
|
||||
|
@ -383,14 +371,6 @@ if(BUILD_PKGCONFIG_FILES)
|
|||
install( FILES ${CMAKE_CURRENT_BINARY_DIR}/libopenjpip.pc DESTINATION
|
||||
${OPENJPEG_INSTALL_LIB_DIR}/pkgconfig )
|
||||
endif()
|
||||
#
|
||||
if(BUILD_JP3D)
|
||||
# install in lib and not share (see multi-arch note above)
|
||||
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/lib/openjp3d/libopenjp3d.pc.cmake.in
|
||||
${CMAKE_CURRENT_BINARY_DIR}/libopenjp3d.pc @ONLY)
|
||||
install( FILES ${CMAKE_CURRENT_BINARY_DIR}/libopenjp3d.pc DESTINATION
|
||||
${OPENJPEG_INSTALL_LIB_DIR}/pkgconfig )
|
||||
endif()
|
||||
endif()
|
||||
|
||||
#-----------------------------------------------------------------------------
|
||||
|
|
12
README.md
12
README.md
|
@ -29,18 +29,12 @@ The library is developed and maintained by the Image and Signal Processing Group
|
|||
* src
|
||||
* lib
|
||||
* openjp2: contains the sources of the openjp2 library (Part 1 & 2)
|
||||
* openjpwl: contains the additional sources if you want to build a JPWL-flavoured library.
|
||||
* openjpip: complete client-server architecture for remote browsing of jpeg 2000 images.
|
||||
* openjp3d: JP3D implementation
|
||||
* openmj2: MJ2 implementation
|
||||
* bin: contains all applications that use the openjpeg library
|
||||
* common: common files to all applications
|
||||
* jp2: a basic codec
|
||||
* mj2: motion jpeg 2000 executables
|
||||
* jpip: OpenJPIP applications (server and dec server)
|
||||
* java: a Java client viewer for JPIP
|
||||
* jp3d: JP3D applications
|
||||
* tcltk: a test tool for JP3D
|
||||
* wx
|
||||
* OPJViewer: gui for displaying j2k files (based on wxWidget)
|
||||
* wrapping
|
||||
|
@ -57,6 +51,12 @@ See [INSTALL](https://github.com/uclouvain/openjpeg/blob/master/INSTALL.md) for
|
|||
|
||||
See [NEWS](https://github.com/uclouvain/openjpeg/blob/master/NEWS.md) for user visible changes in successive releases.
|
||||
|
||||
## Deprecated components
|
||||
|
||||
The openjpwl, openjp3d and openmj2 components have been removed after the
|
||||
2.4.0 release. Their building and working state is unknown. People interested
|
||||
in them should start from the 2.4.0 tag.
|
||||
|
||||
## API/ABI
|
||||
|
||||
An API/ABI timeline is automatically updated [here][link-api-timeline].
|
||||
|
|
|
@ -4,18 +4,9 @@ add_subdirectory(common)
|
|||
add_subdirectory(jp2)
|
||||
|
||||
# optionals components:
|
||||
if(BUILD_JPWL)
|
||||
add_subdirectory(jpwl)
|
||||
endif()
|
||||
if(BUILD_MJ2)
|
||||
add_subdirectory(mj2)
|
||||
endif()
|
||||
if(BUILD_JPIP)
|
||||
add_subdirectory(jpip)
|
||||
endif()
|
||||
if(BUILD_JP3D)
|
||||
add_subdirectory(jp3d)
|
||||
endif()
|
||||
|
||||
# wx apps:
|
||||
add_subdirectory(wx)
|
||||
|
|
|
@ -1,41 +0,0 @@
|
|||
# Build the demo app, small examples
|
||||
|
||||
# First thing define the common source:
|
||||
set(common_SRCS
|
||||
convert.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/bin/common/opj_getopt.c
|
||||
)
|
||||
|
||||
# Headers file are located here:
|
||||
include_directories(
|
||||
${OPENJPEG_BINARY_DIR}/src/lib/openjp2 # opj_config.h
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openjp3d
|
||||
${LCMS_INCLUDE_DIRNAME}
|
||||
${OPENJPEG_SOURCE_DIR}/src/bin/common
|
||||
${Z_INCLUDE_DIRNAME}
|
||||
${PNG_INCLUDE_DIRNAME}
|
||||
${TIFF_INCLUDE_DIRNAME}
|
||||
)
|
||||
|
||||
if(WIN32)
|
||||
if(BUILD_SHARED_LIBS)
|
||||
add_definitions(-DOPJ_EXPORTS)
|
||||
else()
|
||||
add_definitions(-DOPJ_STATIC)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# Loop over all executables:
|
||||
foreach(exe opj_jp3d_compress opj_jp3d_decompress)
|
||||
add_executable(${exe} ${exe}.c ${common_SRCS})
|
||||
target_link_libraries(${exe} openjp3d)
|
||||
# On unix you need to link to the math library:
|
||||
if(UNIX)
|
||||
target_link_libraries(${exe} m)
|
||||
endif(UNIX)
|
||||
# Install exe
|
||||
install(TARGETS ${exe}
|
||||
EXPORT OpenJP3DTargets
|
||||
DESTINATION ${OPENJPEG_INSTALL_BIN_DIR} COMPONENT Applications
|
||||
)
|
||||
endforeach()
|
File diff suppressed because it is too large
Load Diff
|
@ -1,52 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* Copyright (c) 2006, Mónica Díez García, Image Processing Laboratory, University of Valladolid, Spain
|
||||
* 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 __JP3D_CONVERT_H
|
||||
#define __JP3D_CONVERT_H
|
||||
|
||||
/**
|
||||
Load a single volume component encoded in PGX file format
|
||||
@param filename Name of the PGX file to load
|
||||
@param parameters *List ?*
|
||||
@return Returns a greyscale volume if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_volume_t* pgxtovolume(char *filename, opj_cparameters_t *parameters);
|
||||
|
||||
int volumetopgx(opj_volume_t *volume, char *outfile);
|
||||
|
||||
opj_volume_t* bintovolume(char *filename, char *fileimg,
|
||||
opj_cparameters_t *parameters);
|
||||
|
||||
int volumetobin(opj_volume_t *volume, char *outfile);
|
||||
|
||||
opj_volume_t* imgtovolume(char *fileimg, opj_cparameters_t *parameters);
|
||||
|
||||
#endif /* __J2K_CONVERT_H */
|
||||
|
|
@ -1,119 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 1987, 1993, 1994
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the University of
|
||||
* California, Berkeley and its contributors.
|
||||
* 4. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/* last review : october 29th, 2002 */
|
||||
|
||||
#if defined(LIBC_SCCS) && !defined(lint)
|
||||
static char sccsid[] = "@(#)getopt.c 8.3 (Berkeley) 4/27/95";
|
||||
#endif /* LIBC_SCCS and not lint */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
int opterr = 1, /* if error message should be printed */
|
||||
optind = 1, /* index into parent argv vector */
|
||||
optopt, /* character checked for validity */
|
||||
optreset; /* reset getopt */
|
||||
char *optarg; /* argument associated with option */
|
||||
|
||||
#define BADCH (int)'?'
|
||||
#define BADARG (int)':'
|
||||
#define EMSG ""
|
||||
|
||||
/*
|
||||
* getopt --
|
||||
* Parse argc/argv argument vector.
|
||||
*/
|
||||
int getopt(int nargc, char *const *nargv, const char *ostr)
|
||||
{
|
||||
|
||||
# define __progname nargv[0] /* program name */
|
||||
|
||||
static char *place = EMSG; /* option letter processing */
|
||||
char *oli; /* option letter list index */
|
||||
|
||||
if (optreset || !*place) { /* update scanning pointer */
|
||||
optreset = 0;
|
||||
if (optind >= nargc || *(place = nargv[optind]) != '-') {
|
||||
place = EMSG;
|
||||
return (-1);
|
||||
}
|
||||
if (place[1] && *++place == '-') { /* found "--" */
|
||||
++optind;
|
||||
place = EMSG;
|
||||
return (-1);
|
||||
}
|
||||
} /* option letter okay? */
|
||||
|
||||
if ((optopt = (int) * place++) == (int) ':' || !(oli = strchr(ostr, optopt))) {
|
||||
/* if the user didn't specify '-' as an option, assume it means -1. */
|
||||
if (optopt == (int) '-') {
|
||||
return (-1);
|
||||
}
|
||||
if (!*place) {
|
||||
++optind;
|
||||
}
|
||||
if (opterr && *ostr != ':') {
|
||||
(void) fprintf(stdout, "[ERROR] %s: illegal option -- %c\n", __progname,
|
||||
optopt);
|
||||
}
|
||||
return (BADCH);
|
||||
}
|
||||
|
||||
if (*++oli != ':') { /* don't need argument */
|
||||
optarg = NULL;
|
||||
if (!*place) {
|
||||
++optind;
|
||||
}
|
||||
} else { /* need an argument */
|
||||
if (*place) { /* no white space */
|
||||
optarg = place;
|
||||
} else if (nargc <= ++optind) { /* no arg */
|
||||
place = EMSG;
|
||||
if (*ostr == ':') {
|
||||
return (BADARG);
|
||||
}
|
||||
if (opterr) {
|
||||
(void) fprintf(stdout, "[ERROR] %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 */
|
||||
}
|
|
@ -1,14 +0,0 @@
|
|||
/* last review : october 29th, 2002 */
|
||||
|
||||
#ifndef _GETOPT_H_
|
||||
#define _GETOPT_H_
|
||||
|
||||
extern int opterr;
|
||||
extern int optind;
|
||||
extern int optopt;
|
||||
extern int optreset;
|
||||
extern char *optarg;
|
||||
|
||||
extern int getopt(int nargc, char *const *nargv, const char *ostr);
|
||||
|
||||
#endif /* _GETOPT_H_ */
|
|
@ -1,989 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* Copyright (c) 2006, Mónica Díez García, Image Processing Laboratory, University of Valladolid, Spain
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "opj_config.h"
|
||||
#include "openjp3d.h"
|
||||
#include "opj_getopt.h"
|
||||
#include "convert.h"
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#else
|
||||
#define stricmp strcasecmp
|
||||
#define strnicmp strncasecmp
|
||||
#endif /* _WIN32 */
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
void encode_help_display()
|
||||
{
|
||||
fprintf(stdout, "List of parameters for the JPEG2000 Part 10 encoder:\n");
|
||||
fprintf(stdout, "------------\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "Required Parameters (except with -h):\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout,
|
||||
"-i : source file (-i source.bin or source*.pgx) \n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout,
|
||||
"-m : source characteristics file (-m imgfile.img) \n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "-o : destination file (-o dest.jp3d) \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, "-n : number of resolutions (-n 3,3,3) \n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout,
|
||||
"-I : use the irreversible transforms: ICT + DWT 9-7 (-I) \n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "-C : coding algorithm (-C 2EB) [2EB, 3EB] \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 compression factor.\n");
|
||||
fprintf(stdout, " - Rate 1 means lossless compression\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, "-b : size of code block (-b 32,32,32) \n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "-c : size of precinct (-c 128,128,128) \n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "-t : size of tile (-t 512,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,2) [-s X,Y,Z] \n");
|
||||
fprintf(stdout, " - Remark: subsampling bigger than 2 can produce error\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 : code-block style (-M 0) [1=BYPASS(LAZY) 2=RESET 4=RESTART(TERMALL)\n");
|
||||
fprintf(stdout, " 8=VSC 16=PTERM 32=SEGSYM 64=3DCTXT] \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, "-D : define DC offset (-D 12) \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 volume (-d 150,300,100) \n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout,
|
||||
"-l : offset of the origin of the tiles (-l 100,75,25) \n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "DEFAULT CODING:\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 x 2^15 (means 1 precinct)\n");
|
||||
fprintf(stdout, " * Size of code-block : 64 x 64 x 64\n");
|
||||
fprintf(stdout, " * Number of resolutions in x, y and z axis: 3\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, y or z 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 volume\n");
|
||||
fprintf(stdout, " * No offset of the origin of the tiles\n");
|
||||
fprintf(stdout, " * Reversible DWT 5-3 on each 2D slice\n");
|
||||
fprintf(stdout, " * Coding algorithm: 2D-EBCOT \n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "REMARKS:\n");
|
||||
fprintf(stdout, "---------\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout,
|
||||
"- The markers written to the main_header are : SOC SIZ COD QCD COM.\n");
|
||||
fprintf(stdout,
|
||||
"- COD and QCD markers will never appear in the tile_header.\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout,
|
||||
"- You need enough disk space memory (twice the original) to encode \n");
|
||||
fprintf(stdout,
|
||||
"the volume,i.e. for a 1.5 GB volume you need a minimum of 3GB of disk memory)\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout,
|
||||
"- When loading *.pgx files, a relative path to directory is needed for input argument \n");
|
||||
fprintf(stdout,
|
||||
" followed by the common prefix of the slices and a '*' character representing sequential numeration.\n");
|
||||
fprintf(stdout, "( -i relativepath/slices*.pgx )\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, " - The index file has the structure below:\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "\t Image_height Image_width Image_depth\n");
|
||||
fprintf(stdout, "\t Progression order: 0 (LRCP)\n");
|
||||
fprintf(stdout, "\t Tiles_size_X Tiles_size_Y Tiles_size_Z\n");
|
||||
fprintf(stdout, "\t Components_nb\n");
|
||||
fprintf(stdout, "\t Layers_nb\n");
|
||||
fprintf(stdout, "\t Decomposition_levels\n");
|
||||
fprintf(stdout,
|
||||
"\t [Precincts_size_X_res_Nr Precincts_size_Y_res_Nr Precincts_size_Z_res_Nr]\n\t ...\n");
|
||||
fprintf(stdout,
|
||||
"\t [Precincts_size_X_res_0 Precincts_size_Y_res_0 Precincts_size_Z_res_0]\n");
|
||||
fprintf(stdout, "\t Main_header_end_position\n");
|
||||
fprintf(stdout, "\t Codestream_size\n");
|
||||
fprintf(stdout,
|
||||
"\t Tile_0 [start_pos end_header end_pos TotalDisto NumPix MaxMSE]\n");
|
||||
fprintf(stdout, "\t ...\n");
|
||||
fprintf(stdout,
|
||||
"\t Tile_Nt [ '' '' '' '' '' '' ]\n");
|
||||
fprintf(stdout,
|
||||
"\t Tpacket_0 [Tile layer res. comp. prec. start_pos end_pos disto]\n");
|
||||
fprintf(stdout, "\t ...\n");
|
||||
fprintf(stdout,
|
||||
"\t Tpacket_Np ['' '' '' '' '' '' '' '' ]\n");
|
||||
fprintf(stdout, "\t MaxDisto\n");
|
||||
fprintf(stdout, "\t TotalDisto\n\n");
|
||||
fprintf(stdout, "\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;
|
||||
}
|
||||
|
||||
OPJ_TRANSFORM give_transform(char transform[4])
|
||||
{
|
||||
if (strncmp(transform, "2DWT", 4) == 0) {
|
||||
return TRF_2D_DWT;
|
||||
}
|
||||
if (strncmp(transform, "3DWT", 4) == 0) {
|
||||
return TRF_3D_DWT;
|
||||
}
|
||||
return TRF_UNKNOWN;
|
||||
}
|
||||
|
||||
OPJ_ENTROPY_CODING give_coding(char coding[3])
|
||||
{
|
||||
|
||||
if (strncmp(coding, "2EB", 3) == 0) {
|
||||
return ENCOD_2EB;
|
||||
}
|
||||
if (strncmp(coding, "3EB", 3) == 0) {
|
||||
return ENCOD_3EB;
|
||||
}
|
||||
/*if(strncmp(coding, "2GR", 3) == 0) {
|
||||
return ENCOD_2GR;
|
||||
}
|
||||
if(strncmp(coding, "3GR", 3) == 0) {
|
||||
return ENCOD_3GR;
|
||||
}*/
|
||||
|
||||
return ENCOD_UNKNOWN;
|
||||
}
|
||||
|
||||
int get_file_format(char *filename)
|
||||
{
|
||||
int i;
|
||||
static const char *extension[] = {"pgx", "bin", "img", "j3d", "jp3d", "j2k"};
|
||||
static const int format[] = { PGX_DFMT, BIN_DFMT, IMG_DFMT, J3D_CFMT, J3D_CFMT, J2K_CFMT};
|
||||
char * ext = strrchr(filename, '.');
|
||||
if (ext) {
|
||||
ext++;
|
||||
for (i = 0; i < sizeof(format) / sizeof(*format); i++) {
|
||||
if (strnicmp(ext, extension[i], 3) == 0) {
|
||||
return format[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------------------------ */
|
||||
|
||||
int parse_cmdline_encoder(int argc, char **argv, opj_cparameters_t *parameters)
|
||||
{
|
||||
int i, value;
|
||||
|
||||
/* parse the command line */
|
||||
|
||||
while (1) {
|
||||
int c = opj_getopt(argc, argv,
|
||||
"i:m:o:r:q:f:t:n:c:b:x:p:s:d:hP:S:E:M:D:R:l:T:C:A:I");
|
||||
if (c == -1) {
|
||||
break;
|
||||
}
|
||||
switch (c) {
|
||||
case 'i': { /* input file */
|
||||
char *infile = opj_optarg;
|
||||
parameters->decod_format = get_file_format(infile);
|
||||
switch (parameters->decod_format) {
|
||||
case PGX_DFMT:
|
||||
case BIN_DFMT:
|
||||
case IMG_DFMT:
|
||||
break;
|
||||
default:
|
||||
fprintf(stdout,
|
||||
"[ERROR] Unrecognized format for infile : %s [accept only *.pgx or *.bin] !!\n\n",
|
||||
infile);
|
||||
return 1;
|
||||
break;
|
||||
}
|
||||
strncpy(parameters->infile, infile, MAX_PATH);
|
||||
fprintf(stdout, "[INFO] Infile: %s \n", parameters->infile);
|
||||
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
case 'm': { /* input IMG file */
|
||||
char *imgfile = opj_optarg;
|
||||
int imgformat = get_file_format(imgfile);
|
||||
switch (imgformat) {
|
||||
case IMG_DFMT:
|
||||
break;
|
||||
default:
|
||||
fprintf(stdout,
|
||||
"[ERROR] Unrecognized format for imgfile : %s [accept only *.img] !!\n\n",
|
||||
imgfile);
|
||||
return 1;
|
||||
break;
|
||||
}
|
||||
strncpy(parameters->imgfile, imgfile, MAX_PATH);
|
||||
fprintf(stdout, "[INFO] Imgfile: %s Format: %d\n", parameters->imgfile,
|
||||
imgformat);
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
case 'o': { /* output file */
|
||||
char *outfile = opj_optarg;
|
||||
parameters->cod_format = get_file_format(outfile);
|
||||
switch (parameters->cod_format) {
|
||||
case J3D_CFMT:
|
||||
case J2K_CFMT:
|
||||
case LSE_CFMT:
|
||||
break;
|
||||
default:
|
||||
fprintf(stdout,
|
||||
"[ERROR] Unknown output format volume %s [only *.j2k, *.lse3d or *.jp3d]!! \n",
|
||||
outfile);
|
||||
return 1;
|
||||
break;
|
||||
}
|
||||
strncpy(parameters->outfile, outfile, MAX_PATH);
|
||||
fprintf(stdout, "[INFO] Outfile: %s \n", parameters->outfile);
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 'r': { /* define compression rates for each layer */
|
||||
char *s = opj_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 'q': { /* define distorsion (PSNR) for each layer */
|
||||
char *s = opj_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;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 'f': {
|
||||
fprintf(stdout, "/---------------------------------------------------\\\n");
|
||||
fprintf(stdout, "| Fixed layer allocation option not implemented !! |\n");
|
||||
fprintf(stdout, "\\---------------------------------------------------/\n");
|
||||
/*int *row = NULL, *col = NULL;
|
||||
int numlayers = 0, matrix_width = 0;
|
||||
|
||||
char *s = opj_optarg;
|
||||
sscanf(s, "%d", &numlayers);
|
||||
s++;
|
||||
if (numlayers > 9)
|
||||
s++;
|
||||
|
||||
parameters->tcp_numlayers = numlayers;
|
||||
matrix_width = parameters->numresolution[0] + parameters->numresolution[1] + parameters->numresolution[2];
|
||||
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 < matrix_width; j++) {
|
||||
col += 3; j+=2;
|
||||
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 */
|
||||
if (sscanf(opj_optarg, "%d,%d,%d", ¶meters->cp_tdx, ¶meters->cp_tdy,
|
||||
¶meters->cp_tdz) != 3) {
|
||||
fprintf(stdout,
|
||||
"[ERROR] '-t' 'dimensions of tiles' argument error ! [-t tdx,tdy,tdz]\n");
|
||||
return 1;
|
||||
}
|
||||
parameters->tile_size_on = true;
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 'n': { /* resolution */
|
||||
int aux;
|
||||
aux = sscanf(opj_optarg, "%d,%d,%d", ¶meters->numresolution[0],
|
||||
¶meters->numresolution[1], ¶meters->numresolution[2]);
|
||||
if (aux == 2) {
|
||||
parameters->numresolution[2] = 1;
|
||||
} else if (aux == 1) {
|
||||
parameters->numresolution[1] = parameters->numresolution[0];
|
||||
parameters->numresolution[2] = 1;
|
||||
} else if (aux == 0) {
|
||||
parameters->numresolution[0] = 1;
|
||||
parameters->numresolution[1] = 1;
|
||||
parameters->numresolution[2] = 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
case 'c': { /* precinct dimension */
|
||||
char sep;
|
||||
int res_spec = 0;
|
||||
int aux;
|
||||
char *s = opj_optarg;
|
||||
do {
|
||||
sep = 0;
|
||||
aux = sscanf(s, "[%d,%d,%d]%c", ¶meters->prct_init[0][res_spec],
|
||||
¶meters->prct_init[1][res_spec], ¶meters->prct_init[2][res_spec], &sep);
|
||||
if (sep == ',' && aux != 4) {
|
||||
fprintf(stdout,
|
||||
"[ERROR] '-c' 'dimensions of precincts' argument error ! [-c [prcx_res0,prcy_res0,prcz_res0],...,[prcx_resN,prcy_resN,prcz_resN]]\n");
|
||||
return 1;
|
||||
}
|
||||
parameters->csty |= 0x01;
|
||||
res_spec++;
|
||||
s = strpbrk(s, "]") + 2;
|
||||
} while (sep == ',');
|
||||
parameters->res_spec = res_spec; /* number of precinct size specifications */
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 'b': { /* code-block dimension */
|
||||
int cblockw_init = 0, cblockh_init = 0, cblockl_init = 0;
|
||||
if (sscanf(opj_optarg, "%d,%d,%d", &cblockw_init, &cblockh_init,
|
||||
&cblockl_init) != 3) {
|
||||
fprintf(stdout,
|
||||
"[ERROR] '-b' 'dimensions of codeblocks' argument error ! [-b cblkx,cblky,cblkz]\n");
|
||||
return 1;
|
||||
}
|
||||
if (cblockw_init * cblockh_init * cblockl_init > (1 << 18) ||
|
||||
cblockw_init > 1024 || cblockw_init < 4 || cblockh_init > 1024 ||
|
||||
cblockh_init < 4 || cblockl_init > 1024 || cblockl_init < 4) {
|
||||
fprintf(stdout,
|
||||
"[ERROR] Size of code_block error (option -b) !!\n\nRestriction :\n * width*height*length<=4096\n * 4<=width,height,length<= 1024\n\n");
|
||||
return 1;
|
||||
}
|
||||
parameters->cblock_init[0] = cblockw_init;
|
||||
parameters->cblock_init[1] = cblockh_init;
|
||||
parameters->cblock_init[2] = cblockl_init;
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 'x': { /* creation of index file */
|
||||
char *index = opj_optarg;
|
||||
strncpy(parameters->index, index, MAX_PATH);
|
||||
parameters->index_on = 1;
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 'p': { /* progression order */
|
||||
char progression[4];
|
||||
|
||||
strncpy(progression, opj_optarg, 4);
|
||||
parameters->prog_order = give_progression(progression);
|
||||
if (parameters->prog_order == -1) {
|
||||
fprintf(stdout,
|
||||
"[ERROR] Unrecognized progression order [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 's': { /* subsampling factor */
|
||||
if (sscanf(opj_optarg, "%d,%d,%d", ¶meters->subsampling_dx,
|
||||
¶meters->subsampling_dy, ¶meters->subsampling_dz) != 3) {
|
||||
fprintf(stdout, "[ERROR] '-s' sub-sampling argument error ! [-s dx,dy,dz]\n");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 'd': { /* coordonnate of the reference grid */
|
||||
if (sscanf(opj_optarg, "%d,%d,%d", ¶meters->volume_offset_x0,
|
||||
¶meters->volume_offset_y0, ¶meters->volume_offset_z0) != 3) {
|
||||
fprintf(stdout,
|
||||
"[ERROR] -d 'coordonnate of the reference grid' argument error !! [-d x0,y0,z0]\n");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 'h': { /* display an help description */
|
||||
encode_help_display();
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
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 = opj_optarg;
|
||||
POC = parameters->POC;
|
||||
|
||||
fprintf(stdout, "/----------------------------------\\\n");
|
||||
fprintf(stdout, "| POC option not fully tested !! |\n");
|
||||
fprintf(stdout, "\\----------------------------------/\n");
|
||||
|
||||
while (sscanf(s, "T%d=%d,%d,%d,%d,%d,%s", &POC[numpocs].tile,
|
||||
&POC[numpocs].resno0, &POC[numpocs].compno0,
|
||||
&POC[numpocs].layno1, &POC[numpocs].resno1,
|
||||
&POC[numpocs].compno1, POC[numpocs].progorder) == 7) {
|
||||
POC[numpocs].prg = give_progression(POC[numpocs].progorder);
|
||||
/* POC[numpocs].tile; */
|
||||
numpocs++;
|
||||
while (*s && *s != '/') {
|
||||
s++;
|
||||
}
|
||||
if (!*s) {
|
||||
break;
|
||||
}
|
||||
s++;
|
||||
}
|
||||
parameters->numpocs = numpocs;
|
||||
}
|
||||
break;
|
||||
|
||||
/* ------------------------------------------------------ */
|
||||
|
||||
case 'S': { /* SOP marker */
|
||||
parameters->csty |= 0x02;
|
||||
}
|
||||
break;
|
||||
|
||||
/* ------------------------------------------------------ */
|
||||
|
||||
case 'E': { /* EPH marker */
|
||||
parameters->csty |= 0x04;
|
||||
}
|
||||
break;
|
||||
|
||||
/* ------------------------------------------------------ */
|
||||
|
||||
case 'M': { /* Codification mode switch */
|
||||
fprintf(stdout, "[INFO] Mode switch option not fully tested !!\n");
|
||||
value = 0;
|
||||
if (sscanf(opj_optarg, "%d", &value) == 1) {
|
||||
for (i = 0; i <= 6; i++) {
|
||||
int cache = value & (1 << i);
|
||||
if (cache) {
|
||||
parameters->mode |= (1 << i);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
/* ------------------------------------------------------ */
|
||||
|
||||
case 'D': { /* DCO */
|
||||
if (sscanf(opj_optarg, "%d", ¶meters->dcoffset) != 1) {
|
||||
fprintf(stdout, "[ERROR] DC offset error !! [-D %d]\n", parameters->dcoffset);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
/* ------------------------------------------------------ */
|
||||
|
||||
case 'R': { /* ROI */
|
||||
if (sscanf(opj_optarg, "OI:c=%d,U=%d", ¶meters->roi_compno,
|
||||
¶meters->roi_shift) != 2) {
|
||||
fprintf(stdout, "[ERROR] ROI error !! [-ROI:c='compno',U='shift']\n");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
/* ------------------------------------------------------ */
|
||||
|
||||
case 'l': { /* Tile offset */
|
||||
if (sscanf(opj_optarg, "%d,%d,%d", ¶meters->cp_tx0, ¶meters->cp_ty0,
|
||||
¶meters->cp_tz0) != 3) {
|
||||
fprintf(stdout, "[ERROR] -l 'tile offset' argument error !! [-l X0,Y0,Z0]");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
/* ------------------------------------------------------
|
||||
|
||||
case 'T': // Transformation of original data (2D-DWT/3D-DWT/3D-RLS/2D-DWT+1D-RLS)
|
||||
{
|
||||
char transform[4];
|
||||
|
||||
strncpy(transform, opj_optarg, 4);
|
||||
parameters->transform_format = give_transform(transform);
|
||||
if (parameters->transform_format == -1) {
|
||||
fprintf(stdout, "[ERROR] -T 'Transform domain' argument error !! [-T 2DWT, 3DWT, 3RLS or 3LSE only]");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
------------------------------------------------------ */
|
||||
|
||||
case 'C': { /* Coding of transformed data */
|
||||
char coding[3];
|
||||
|
||||
strncpy(coding, opj_optarg, 3);
|
||||
parameters->encoding_format = give_coding(coding);
|
||||
if (parameters->encoding_format == -1) {
|
||||
fprintf(stdout,
|
||||
"[ERROR] -C 'Coding algorithm' argument error !! [-C 2EB, 3EB, 2GR, 3GR or GRI only]");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
/* ------------------------------------------------------ */
|
||||
|
||||
case 'I': { /* reversible or not */
|
||||
parameters->irreversible = 1;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
fprintf(stdout, "[ERROR] This option is not valid \"-%c %s\"\n", c, opj_optarg);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
/* check for possible errors */
|
||||
|
||||
if ((parameters->infile[0] == 0) || (parameters->outfile[0] == 0)) {
|
||||
fprintf(stdout, "usage: jp3d_vm_enc -i volume-file -o jp3d-file (+ options)\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if ((parameters->decod_format == BIN_DFMT) && (parameters->imgfile[0] == 0)) {
|
||||
fprintf(stdout,
|
||||
"usage: jp3d_vm_enc -i bin-volume-file -m img-file -o jp3d-file (+ options)\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if ((parameters->decod_format != BIN_DFMT) &&
|
||||
(parameters->decod_format != PGX_DFMT) &&
|
||||
(parameters->decod_format != IMG_DFMT)) {
|
||||
fprintf(stdout,
|
||||
"usage: jp3d_vm_enc -i input-volume-file [*.bin,*.pgx,*.img] -o jp3d-file [*.jp3d,*.j2k] (+ options)\n");
|
||||
return 1;
|
||||
}
|
||||
if ((parameters->cod_format != J3D_CFMT) &&
|
||||
(parameters->cod_format != J2K_CFMT)) {
|
||||
fprintf(stdout,
|
||||
"usage: jp3d_vm_enc -i input-volume-file [*.bin,*.pgx,*.img] -o jp3d-file [*.jp3d,*.j2k] (+ options)\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if ((parameters->encoding_format == ENCOD_2GR ||
|
||||
parameters->encoding_format == ENCOD_3GR) &&
|
||||
parameters->transform_format != TRF_3D_LSE &&
|
||||
parameters->transform_format != TRF_3D_RLS) {
|
||||
fprintf(stdout,
|
||||
"[ERROR] Entropy coding options -C [2GR,3GR] are only compatible with predictive-based transform algorithms: -T [3RLS,3LSE].\n");
|
||||
return 1;
|
||||
}
|
||||
if (parameters->encoding_format == ENCOD_3EB) {
|
||||
parameters->mode |= (1 << 6);
|
||||
}
|
||||
|
||||
if ((parameters->mode >> 6) & 1) {
|
||||
parameters->encoding_format = ENCOD_3EB;
|
||||
}
|
||||
|
||||
if ((parameters->numresolution[2] == 0 || (parameters->numresolution[1] == 0) ||
|
||||
(parameters->numresolution[0] == 0))) {
|
||||
fprintf(stdout,
|
||||
"[ERROR] -n 'resolution levels' argument error ! Resolutions must be greater than 1 in order to perform DWT.\n");
|
||||
return 1;
|
||||
}
|
||||
if (parameters->numresolution[1] != parameters->numresolution[0]) {
|
||||
fprintf(stdout,
|
||||
"[ERROR] -n 'resolution levels' argument error ! Resolutions in X and Y axis must be the same in this implementation.\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (parameters->numresolution[2] > parameters->numresolution[0]) {
|
||||
fprintf(stdout,
|
||||
"[ERROR] -n 'resolution levels' argument error ! Resolutions in Z axis must be lower than in X-Y axis.\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (parameters->dcoffset >= 128 && parameters->dcoffset <= -128) {
|
||||
fprintf(stdout,
|
||||
"[ERROR] -D 'DC offset' argument error ! Value must be -128<=DCO<=128.\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (parameters->numresolution[2] != 1) {
|
||||
parameters->transform_format = TRF_3D_DWT;
|
||||
/*fprintf(stdout, "[Warning] Resolution level in axial dim > 1 : 3D-DWT will be performed... \n");*/
|
||||
} else if (parameters->numresolution[2] == 1) {
|
||||
parameters->transform_format = TRF_2D_DWT;
|
||||
/*fprintf(stdout, "[Warning] Resolution level in axial dim == 1 : 2D-DWT will be performed... \n");*/
|
||||
}
|
||||
|
||||
if ((parameters->cod_format == J2K_CFMT) &&
|
||||
(parameters->transform_format != TRF_2D_DWT ||
|
||||
parameters->encoding_format != ENCOD_2EB)) {
|
||||
fprintf(stdout,
|
||||
"[WARNING] Incompatible options -o *.j2k and defined transform or encoding algorithm. Latter will be ignored\n");
|
||||
parameters->transform_format = TRF_2D_DWT;
|
||||
parameters->encoding_format = ENCOD_2EB;
|
||||
}
|
||||
|
||||
if ((parameters->cp_disto_alloc || parameters->cp_fixed_alloc ||
|
||||
parameters->cp_fixed_quality) &&
|
||||
(!(parameters->cp_disto_alloc ^ parameters->cp_fixed_quality))) {
|
||||
fprintf(stdout, "[ERROR] Options -r and -q 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.0; /* MOD antonin : losslessbug */
|
||||
parameters->tcp_numlayers++;
|
||||
parameters->cp_disto_alloc = 1;
|
||||
}
|
||||
|
||||
if ((parameters->cp_tx0 > parameters->volume_offset_x0) ||
|
||||
(parameters->cp_ty0 > parameters->volume_offset_y0) ||
|
||||
(parameters->cp_tz0 > parameters->volume_offset_z0)) {
|
||||
fprintf(stdout,
|
||||
"[ERROR] Tile offset dimension is unnappropriate --> TX0(%d)<=IMG_X0(%d) TYO(%d)<=IMG_Y0(%d) TZO(%d)<=IMG_Z0(%d)\n",
|
||||
parameters->cp_tx0, parameters->volume_offset_x0, parameters->cp_ty0,
|
||||
parameters->volume_offset_y0,
|
||||
parameters->cp_tz0, parameters->volume_offset_z0);
|
||||
return 1;
|
||||
}
|
||||
|
||||
for (i = 0; i < parameters->numpocs; i++) {
|
||||
if (parameters->POC[i].prg == -1) {
|
||||
fprintf(stdout,
|
||||
"[ERROR] 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;
|
||||
bool delete_comment = true;
|
||||
opj_cparameters_t parameters; /* compression parameters */
|
||||
opj_event_mgr_t event_mgr; /* event manager */
|
||||
opj_volume_t *volume = NULL;
|
||||
|
||||
/*
|
||||
configure the event callbacks (not required)
|
||||
setting of each callback is optional
|
||||
*/
|
||||
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
|
||||
event_mgr.error_handler = error_callback;
|
||||
event_mgr.warning_handler = warning_callback;
|
||||
event_mgr.info_handler = info_callback;
|
||||
|
||||
/* set encoding parameters to default values */
|
||||
opj_set_default_encoder_parameters(¶meters);
|
||||
|
||||
/* parse input and get user encoding parameters */
|
||||
if (parse_cmdline_encoder(argc, argv, ¶meters) == 1) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (parameters.cp_comment == NULL) {
|
||||
parameters.cp_comment = "Created by OpenJPEG version JP3D";
|
||||
/* no need to delete parameters.cp_comment on exit */
|
||||
delete_comment = false;
|
||||
}
|
||||
|
||||
/* encode the destination volume */
|
||||
/* ---------------------------- */
|
||||
if (parameters.cod_format == J3D_CFMT || parameters.cod_format == J2K_CFMT) {
|
||||
int codestream_length, pixels, bitsin;
|
||||
opj_cio_t *cio = NULL;
|
||||
FILE *f = NULL;
|
||||
opj_cinfo_t* cinfo = NULL;
|
||||
|
||||
/* decode the source volume */
|
||||
/* ----------------------- */
|
||||
switch (parameters.decod_format) {
|
||||
case PGX_DFMT:
|
||||
fprintf(stdout, "[INFO] Loading pgx file(s)\n");
|
||||
volume = pgxtovolume(parameters.infile, ¶meters);
|
||||
if (!volume) {
|
||||
fprintf(stdout, "[ERROR] Unable to load pgx files\n");
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
|
||||
case BIN_DFMT:
|
||||
fprintf(stdout, "[INFO] Loading bin file\n");
|
||||
volume = bintovolume(parameters.infile, parameters.imgfile, ¶meters);
|
||||
if (!volume) {
|
||||
fprintf(stdout, "[ERROR] Unable to load bin file\n");
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
|
||||
case IMG_DFMT:
|
||||
fprintf(stdout, "[INFO] Loading img file\n");
|
||||
volume = imgtovolume(parameters.infile, ¶meters);
|
||||
if (!volume) {
|
||||
fprintf(stderr, "[ERROR] Unable to load img file\n");
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
/* get a JP3D or J2K compressor handle */
|
||||
if (parameters.cod_format == J3D_CFMT) {
|
||||
cinfo = opj_create_compress(CODEC_J3D);
|
||||
} else if (parameters.cod_format == J2K_CFMT) {
|
||||
cinfo = opj_create_compress(CODEC_J2K);
|
||||
}
|
||||
|
||||
/* catch events using our callbacks and give a local context */
|
||||
opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stdout);
|
||||
|
||||
/* setup the encoder parameters using the current volume and using user parameters */
|
||||
opj_setup_encoder(cinfo, ¶meters, volume);
|
||||
|
||||
/* open a byte stream for writing */
|
||||
/* allocate memory for all tiles */
|
||||
cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
|
||||
|
||||
/* encode the volume */
|
||||
/*fprintf(stdout, "[INFO] Encode the volume\n");*/
|
||||
bSuccess = opj_encode(cinfo, cio, volume, parameters.index);
|
||||
if (!bSuccess) {
|
||||
opj_cio_close(cio);
|
||||
fprintf(stdout, "[ERROR] Failed to encode volume\n");
|
||||
return 1;
|
||||
}
|
||||
codestream_length = cio_tell(cio);
|
||||
pixels = (volume->x1 - volume->x0) * (volume->y1 - volume->y0) *
|
||||
(volume->z1 - volume->z0);
|
||||
bitsin = pixels * volume->comps[0].prec;
|
||||
fprintf(stdout,
|
||||
"[RESULT] Volume: %d x %d x %d (x %d bpv)\n Codestream: %d B, Ratio: %5.3f bpv, (%5.3f : 1) \n",
|
||||
(volume->x1 - volume->x0), (volume->y1 - volume->y0), (volume->z1 - volume->z0),
|
||||
volume->comps[0].prec,
|
||||
codestream_length, ((double)codestream_length * 8.0 / (double)pixels),
|
||||
((double)bitsin / (8.0 * (double)codestream_length)));
|
||||
|
||||
/* write the buffer to disk */
|
||||
f = fopen(parameters.outfile, "wb");
|
||||
if (!f) {
|
||||
fprintf(stdout, "[ERROR] Failed to open %s for writing\n", parameters.outfile);
|
||||
return 1;
|
||||
}
|
||||
fwrite(cio->buffer, 1, codestream_length, f);
|
||||
fclose(f);
|
||||
|
||||
/* close and free the byte stream */
|
||||
opj_cio_close(cio);
|
||||
|
||||
/* free remaining compression structures */
|
||||
opj_destroy_compress(cinfo);
|
||||
} else {
|
||||
fprintf(stdout, "[ERROR] Cod_format != JP3d !!! \n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* free user parameters structure */
|
||||
if (delete_comment) {
|
||||
if (parameters.cp_comment) {
|
||||
free(parameters.cp_comment);
|
||||
}
|
||||
}
|
||||
if (parameters.cp_matrice) {
|
||||
free(parameters.cp_matrice);
|
||||
}
|
||||
|
||||
/* free volume data */
|
||||
opj_volume_destroy(volume);
|
||||
|
||||
return 0;
|
||||
}
|
|
@ -1,601 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* Copyright (c) 2006, Mónica Díez García, Image Processing Laboratory, University of Valladolid, Spain
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "opj_config.h"
|
||||
#include "openjp3d.h"
|
||||
#include "opj_getopt.h"
|
||||
#include "convert.h"
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#else
|
||||
#define stricmp strcasecmp
|
||||
#define strnicmp strncasecmp
|
||||
#endif /* _WIN32 */
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
static double calc_PSNR(opj_volume_t *original, opj_volume_t *decoded)
|
||||
{
|
||||
int max, i, k, compno = 0, size;
|
||||
double sum, total = 0;
|
||||
int global = 1;
|
||||
|
||||
max = (original->comps[compno].prec <= 8) ? 255 : (1 <<
|
||||
original->comps[compno].prec) - 1;
|
||||
if (global) {
|
||||
size = (original->x1 - original->x0) * (original->y1 - original->y0) *
|
||||
(original->z1 - original->z0);
|
||||
|
||||
for (compno = 0; compno < original->numcomps; compno++) {
|
||||
for (sum = 0, i = 0; i < size; ++i) {
|
||||
if ((decoded->comps[compno].data[i] < 0) ||
|
||||
(decoded->comps[compno].data[i] > max)) {
|
||||
fprintf(stdout, "[WARNING] Data out of range during PSNR computing...\n");
|
||||
} else {
|
||||
sum += (original->comps[compno].data[i] - decoded->comps[compno].data[i]) *
|
||||
(original->comps[compno].data[i] - decoded->comps[compno].data[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
sum /= size;
|
||||
total = ((sum == 0.0) ? 0.0 : 10 * log10(max * max / sum));
|
||||
} else {
|
||||
size = (original->x1 - original->x0) * (original->y1 - original->y0);
|
||||
|
||||
for (k = 0; k < original->z1 - original->z0; k++) {
|
||||
int offset = k * size;
|
||||
for (sum = 0, compno = 0; compno < original->numcomps; compno++) {
|
||||
for (i = 0; i < size; ++i) {
|
||||
if ((decoded->comps[compno].data[i + offset] < 0) ||
|
||||
(decoded->comps[compno].data[i + offset] > max)) {
|
||||
fprintf(stdout, "[WARNING] Data out of range during PSNR computing...\n");
|
||||
} else {
|
||||
sum += (original->comps[compno].data[i + offset] - decoded->comps[compno].data[i
|
||||
+ offset]) * (original->comps[compno].data[i + offset] -
|
||||
decoded->comps[compno].data[i + offset]);
|
||||
}
|
||||
}
|
||||
}
|
||||
sum /= size;
|
||||
total = total + ((sum == 0.0) ? 0.0 : 10 * log10(max * max / sum));
|
||||
}
|
||||
|
||||
}
|
||||
if (total == 0) { /* perfect reconstruction, PSNR should return infinity */
|
||||
return -1.0;
|
||||
}
|
||||
|
||||
return total;
|
||||
/*return 20 * log10((max - 1) / sqrt(sum));*/
|
||||
}
|
||||
|
||||
static double calc_SSIM(opj_volume_t *original, opj_volume_t *decoded)
|
||||
{
|
||||
int max, i, compno = 0, size, sizeM;
|
||||
double sum;
|
||||
double mux = 0.0, muy = 0.0, sigmax = 0.0, sigmay = 0.0,
|
||||
sigmaxy = 0.0/*, structx = 0.0, structy = 0.0*/;
|
||||
double lcomp, ccomp, scomp;
|
||||
double C1, C2, C3;
|
||||
|
||||
max = (original->comps[compno].prec <= 8) ? 255 : (1 <<
|
||||
original->comps[compno].prec) - 1;
|
||||
size = (original->x1 - original->x0) * (original->y1 - original->y0) *
|
||||
(original->z1 - original->z0);
|
||||
|
||||
/*MSSIM*/
|
||||
|
||||
/* sizeM = size / (original->z1 - original->z0);*/
|
||||
|
||||
sizeM = size;
|
||||
for (sum = 0, i = 0; i < sizeM; ++i) {
|
||||
/* First, the luminance of each signal is compared.*/
|
||||
mux += original->comps[compno].data[i];
|
||||
muy += decoded->comps[compno].data[i];
|
||||
}
|
||||
mux /= sizeM;
|
||||
muy /= sizeM;
|
||||
|
||||
/*We use the standard deviation (the square root of variance) as an estimate of the signal contrast.*/
|
||||
for (sum = 0, i = 0; i < sizeM; ++i) {
|
||||
/* First, the luminance of each signal is compared.*/
|
||||
sigmax += (original->comps[compno].data[i] - mux) *
|
||||
(original->comps[compno].data[i] - mux);
|
||||
sigmay += (decoded->comps[compno].data[i] - muy) *
|
||||
(decoded->comps[compno].data[i] - muy);
|
||||
sigmaxy += (original->comps[compno].data[i] - mux) *
|
||||
(decoded->comps[compno].data[i] - muy);
|
||||
}
|
||||
sigmax /= sizeM - 1;
|
||||
sigmay /= sizeM - 1;
|
||||
sigmaxy /= sizeM - 1;
|
||||
|
||||
sigmax = sqrt(sigmax);
|
||||
sigmay = sqrt(sigmay);
|
||||
sigmaxy = sqrt(sigmaxy);
|
||||
|
||||
/*Third, the signal is normalized (divided) by its own standard deviation, */
|
||||
/*so that the two signals being compared have unit standard deviation.*/
|
||||
|
||||
/*Luminance comparison*/
|
||||
C1 = (0.01 * max) * (0.01 * max);
|
||||
lcomp = ((2 * mux * muy) + C1) / ((mux * mux) + (muy * mux) + C1);
|
||||
/*Constrast comparison*/
|
||||
C2 = (0.03 * max) * (0.03 * max);
|
||||
ccomp = ((2 * sigmax * sigmay) + C2) / ((sigmax * sigmax) +
|
||||
(sigmay * sigmay) + C2);
|
||||
/*Structure comparison*/
|
||||
C3 = C2 / 2;
|
||||
scomp = (sigmaxy + C3) / (sigmax * sigmay + C3);
|
||||
/*Similarity measure*/
|
||||
|
||||
sum = lcomp * ccomp * scomp;
|
||||
return sum;
|
||||
}
|
||||
|
||||
void decode_help_display()
|
||||
{
|
||||
fprintf(stdout, "HELP\n----\n\n");
|
||||
fprintf(stdout, "- the -h option displays this help information on screen\n\n");
|
||||
|
||||
fprintf(stdout, "List of parameters for the JPEG 2000 encoder:\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, " Required arguments \n");
|
||||
fprintf(stdout, " ---------------------------- \n");
|
||||
fprintf(stdout, " -i <compressed file> ( *.jp3d, *.j3d )\n");
|
||||
fprintf(stdout,
|
||||
" Currently accepts J3D-files. The file type is identified based on its suffix.\n");
|
||||
fprintf(stdout, " -o <decompressed file> ( *.pgx, *.bin )\n");
|
||||
fprintf(stdout,
|
||||
" Currently accepts PGX-files and BIN-files. Binary data is written to the file (not ascii). \n");
|
||||
fprintf(stdout,
|
||||
" If a PGX filename is given, there will be as many output files as slices; \n");
|
||||
fprintf(stdout,
|
||||
" an indice starting from 0 will then be appended to the output filename,\n");
|
||||
fprintf(stdout, " just before the \"pgx\" extension.\n");
|
||||
fprintf(stdout, " -m <characteristics file> ( *.img ) \n");
|
||||
fprintf(stdout,
|
||||
" Required only for BIN-files. Ascii data of volume characteristics is written. \n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, " Optional \n");
|
||||
fprintf(stdout, " ---------------------------- \n");
|
||||
fprintf(stdout, " -h \n ");
|
||||
fprintf(stdout, " Display the help information\n");
|
||||
fprintf(stdout, " -r <RFx,RFy,RFz>\n");
|
||||
fprintf(stdout,
|
||||
" Set the number of highest resolution levels to be discarded on each dimension. \n");
|
||||
fprintf(stdout,
|
||||
" The volume 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, " -O original-file \n");
|
||||
fprintf(stdout,
|
||||
" This option offers the possibility to compute some quality results \n");
|
||||
fprintf(stdout,
|
||||
" for the decompressed volume, like the PSNR value achieved or the global SSIM value. \n");
|
||||
fprintf(stdout,
|
||||
" Needs the original file in order to compare with the new one.\n");
|
||||
fprintf(stdout,
|
||||
" NOTE: Only valid when -r option is 0,0,0 (both original and decompressed volumes have same resolutions) \n");
|
||||
fprintf(stdout,
|
||||
" NOTE: If original file is .BIN file, the volume characteristics file shall be defined with the -m option. \n");
|
||||
fprintf(stdout, " (i.e. -O original-BIN-file -m original-IMG-file) \n");
|
||||
fprintf(stdout, " -BE \n");
|
||||
fprintf(stdout,
|
||||
" Define that the recovered volume data will be saved with big endian byte order.\n");
|
||||
fprintf(stdout, " By default, little endian byte order is used.\n");
|
||||
fprintf(stdout, "\n");
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
int get_file_format(char *filename)
|
||||
{
|
||||
int i;
|
||||
static const char *extension[] = {"pgx", "bin", "j3d", "jp3d", "j2k", "img"};
|
||||
static const int format[] = { PGX_DFMT, BIN_DFMT, J3D_CFMT, J3D_CFMT, J2K_CFMT, IMG_DFMT};
|
||||
char * ext = strrchr(filename, '.');
|
||||
if (ext) {
|
||||
ext++;
|
||||
for (i = 0; i < sizeof(format) / sizeof(format[0]); i++) {
|
||||
if (strnicmp(ext, extension[i], 3) == 0) {
|
||||
return format[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
int parse_cmdline_decoder(int argc, char **argv, opj_dparameters_t *parameters)
|
||||
{
|
||||
/* parse the command line */
|
||||
|
||||
while (1) {
|
||||
int c = opj_getopt(argc, argv, "i:o:O:r:l:B:m:h");
|
||||
if (c == -1) {
|
||||
break;
|
||||
}
|
||||
switch (c) {
|
||||
case 'i': { /* input file */
|
||||
char *infile = opj_optarg;
|
||||
parameters->decod_format = get_file_format(infile);
|
||||
switch (parameters->decod_format) {
|
||||
case J3D_CFMT:
|
||||
case J2K_CFMT:
|
||||
break;
|
||||
default:
|
||||
fprintf(stdout, "[ERROR] Unknown format for infile %s [only *.j3d]!! \n",
|
||||
infile);
|
||||
return 1;
|
||||
break;
|
||||
}
|
||||
strncpy(parameters->infile, infile, MAX_PATH);
|
||||
fprintf(stdout, "[INFO] Infile: %s \n", parameters->infile);
|
||||
|
||||
}
|
||||
break;
|
||||
|
||||
case 'm': { /* img file */
|
||||
char *imgfile = opj_optarg;
|
||||
int imgformat = get_file_format(imgfile);
|
||||
switch (imgformat) {
|
||||
case IMG_DFMT:
|
||||
break;
|
||||
default:
|
||||
fprintf(stdout,
|
||||
"[ERROR] Unrecognized format for imgfile : %s [accept only *.img] !!\n\n",
|
||||
imgfile);
|
||||
return 1;
|
||||
break;
|
||||
}
|
||||
strncpy(parameters->imgfile, imgfile, MAX_PATH);
|
||||
fprintf(stdout, "[INFO] Imgfile: %s Format: %d\n", parameters->imgfile,
|
||||
imgformat);
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 'o': { /* output file */
|
||||
char *outfile = opj_optarg;
|
||||
parameters->cod_format = get_file_format(outfile);
|
||||
switch (parameters->cod_format) {
|
||||
case PGX_DFMT:
|
||||
case BIN_DFMT:
|
||||
break;
|
||||
default:
|
||||
fprintf(stdout,
|
||||
"[ERROR] Unrecognized format for outfile : %s [accept only *.pgx or *.bin] !!\n\n",
|
||||
outfile);
|
||||
return 1;
|
||||
break;
|
||||
}
|
||||
strncpy(parameters->outfile, outfile, MAX_PATH);
|
||||
fprintf(stdout, "[INFO] Outfile: %s \n", parameters->outfile);
|
||||
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 'O': { /* Original image for PSNR computing */
|
||||
char *original = opj_optarg;
|
||||
parameters->orig_format = get_file_format(original);
|
||||
switch (parameters->orig_format) {
|
||||
case PGX_DFMT:
|
||||
case BIN_DFMT:
|
||||
break;
|
||||
default:
|
||||
fprintf(stdout,
|
||||
"[ERROR] Unrecognized format for original file : %s [accept only *.pgx or *.bin] !!\n\n",
|
||||
original);
|
||||
return 1;
|
||||
break;
|
||||
}
|
||||
strncpy(parameters->original, original, MAX_PATH);
|
||||
fprintf(stdout, "[INFO] Original file: %s \n", parameters->original);
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 'r': { /* reduce option */
|
||||
/*sscanf(opj_optarg, "%d, %d, %d", ¶meters->cp_reduce[0], ¶meters->cp_reduce[1], ¶meters->cp_reduce[2]);*/
|
||||
int aux;
|
||||
aux = sscanf(opj_optarg, "%d,%d,%d", ¶meters->cp_reduce[0],
|
||||
¶meters->cp_reduce[1], ¶meters->cp_reduce[2]);
|
||||
if (aux == 2) {
|
||||
parameters->cp_reduce[2] = 0;
|
||||
} else if (aux == 1) {
|
||||
parameters->cp_reduce[1] = parameters->cp_reduce[0];
|
||||
parameters->cp_reduce[2] = 0;
|
||||
} else if (aux == 0) {
|
||||
parameters->cp_reduce[0] = 0;
|
||||
parameters->cp_reduce[1] = 0;
|
||||
parameters->cp_reduce[2] = 0;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 'l': { /* layering option */
|
||||
sscanf(opj_optarg, "%d", ¶meters->cp_layer);
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 'B': { /* BIGENDIAN vs. LITTLEENDIAN */
|
||||
parameters->bigendian = 1;
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 'L': { /* BIGENDIAN vs. LITTLEENDIAN */
|
||||
parameters->decod_format = LSE_CFMT;
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
case 'h': { /* display an help description */
|
||||
decode_help_display();
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
default:
|
||||
fprintf(stdout, "[WARNING] This option is not valid \"-%c %s\"\n", c,
|
||||
opj_optarg);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* check for possible errors */
|
||||
|
||||
if ((parameters->infile[0] == 0) || (parameters->outfile[0] == 0)) {
|
||||
fprintf(stdout,
|
||||
"[ERROR] At least one required argument is missing\n Check jp3d_to_volume -help for usage information\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)
|
||||
{
|
||||
fprintf(stdout, "[INFO] %s", msg);
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
|
||||
opj_dparameters_t parameters; /* decompression parameters */
|
||||
opj_event_mgr_t event_mgr; /* event manager */
|
||||
opj_volume_t *volume = NULL;
|
||||
|
||||
opj_volume_t *original = NULL;
|
||||
opj_cparameters_t cparameters; /* original parameters */
|
||||
|
||||
FILE *fsrc = NULL;
|
||||
unsigned char *src = NULL;
|
||||
int file_length;
|
||||
int decodeok;
|
||||
double psnr, ssim;
|
||||
|
||||
opj_dinfo_t* dinfo = NULL; /* handle to a decompressor */
|
||||
opj_cio_t *cio = NULL;
|
||||
|
||||
/* configure the event callbacks (not required) */
|
||||
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
|
||||
event_mgr.error_handler = error_callback;
|
||||
event_mgr.warning_handler = warning_callback;
|
||||
event_mgr.info_handler = info_callback;
|
||||
|
||||
/* set decoding parameters to default values */
|
||||
opj_set_default_decoder_parameters(¶meters);
|
||||
|
||||
/* parse input and get user decoding parameters */
|
||||
strcpy(parameters.original, "NULL");
|
||||
strcpy(parameters.imgfile, "NULL");
|
||||
if (parse_cmdline_decoder(argc, argv, ¶meters) == 1) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* read the input file and put it in memory */
|
||||
/* ---------------------------------------- */
|
||||
fprintf(stdout, "[INFO] Loading %s file \n",
|
||||
parameters.decod_format == J3D_CFMT ? ".jp3d" : ".j2k");
|
||||
fsrc = fopen(parameters.infile, "rb");
|
||||
if (!fsrc) {
|
||||
fprintf(stdout, "[ERROR] Failed to open %s for reading\n", parameters.infile);
|
||||
return 1;
|
||||
}
|
||||
fseek(fsrc, 0, SEEK_END);
|
||||
file_length = ftell(fsrc);
|
||||
fseek(fsrc, 0, SEEK_SET);
|
||||
src = (unsigned char *) malloc(file_length);
|
||||
fread(src, 1, file_length, fsrc);
|
||||
fclose(fsrc);
|
||||
|
||||
/* decode the code-stream */
|
||||
/* ---------------------- */
|
||||
if (parameters.decod_format == J3D_CFMT ||
|
||||
parameters.decod_format == J2K_CFMT) {
|
||||
/* get a JP3D or J2K decoder handle */
|
||||
if (parameters.decod_format == J3D_CFMT) {
|
||||
dinfo = opj_create_decompress(CODEC_J3D);
|
||||
} else if (parameters.decod_format == J2K_CFMT) {
|
||||
dinfo = opj_create_decompress(CODEC_J2K);
|
||||
}
|
||||
|
||||
/* catch events using our callbacks and give a local context */
|
||||
opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, stderr);
|
||||
|
||||
/* setup the decoder decoding parameters using user parameters */
|
||||
opj_setup_decoder(dinfo, ¶meters);
|
||||
|
||||
/* open a byte stream */
|
||||
cio = opj_cio_open((opj_common_ptr)dinfo, src, file_length);
|
||||
|
||||
/* decode the stream and fill the volume structure */
|
||||
volume = opj_decode(dinfo, cio);
|
||||
if (!volume) {
|
||||
fprintf(stdout, "[ERROR] jp3d_to_volume: failed to decode volume!\n");
|
||||
opj_destroy_decompress(dinfo);
|
||||
opj_cio_close(cio);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* close the byte stream */
|
||||
opj_cio_close(cio);
|
||||
}
|
||||
|
||||
/* free the memory containing the code-stream */
|
||||
free(src);
|
||||
src = NULL;
|
||||
|
||||
/* create output volume */
|
||||
/* ------------------- */
|
||||
|
||||
switch (parameters.cod_format) {
|
||||
case PGX_DFMT: /* PGX */
|
||||
decodeok = volumetopgx(volume, parameters.outfile);
|
||||
if (decodeok) {
|
||||
fprintf(stdout, "[ERROR] Unable to write decoded volume into pgx files\n");
|
||||
}
|
||||
break;
|
||||
|
||||
case BIN_DFMT: /* BMP */
|
||||
decodeok = volumetobin(volume, parameters.outfile);
|
||||
if (decodeok) {
|
||||
fprintf(stdout, "[ERROR] Unable to write decoded volume into pgx files\n");
|
||||
}
|
||||
break;
|
||||
}
|
||||
switch (parameters.orig_format) {
|
||||
case PGX_DFMT: /* PGX */
|
||||
if (strcmp("NULL", parameters.original) != 0) {
|
||||
fprintf(stdout, "Loading original file %s \n", parameters.original);
|
||||
cparameters.subsampling_dx = 1;
|
||||
cparameters.subsampling_dy = 1;
|
||||
cparameters.subsampling_dz = 1;
|
||||
cparameters.volume_offset_x0 = 0;
|
||||
cparameters.volume_offset_y0 = 0;
|
||||
cparameters.volume_offset_z0 = 0;
|
||||
original = pgxtovolume(parameters.original, &cparameters);
|
||||
}
|
||||
break;
|
||||
|
||||
case BIN_DFMT: /* BMP */
|
||||
if (strcmp("NULL", parameters.original) != 0 &&
|
||||
strcmp("NULL", parameters.imgfile) != 0) {
|
||||
fprintf(stdout, "Loading original file %s %s\n", parameters.original,
|
||||
parameters.imgfile);
|
||||
cparameters.subsampling_dx = 1;
|
||||
cparameters.subsampling_dy = 1;
|
||||
cparameters.subsampling_dz = 1;
|
||||
cparameters.volume_offset_x0 = 0;
|
||||
cparameters.volume_offset_y0 = 0;
|
||||
cparameters.volume_offset_z0 = 0;
|
||||
original = bintovolume(parameters.original, parameters.imgfile, &cparameters);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
fprintf(stdout, "[RESULT] Volume: %d x %d x %d (x %d bpv)\n ",
|
||||
(volume->comps[0].w >> volume->comps[0].factor[0]),
|
||||
(volume->comps[0].h >> volume->comps[0].factor[1]),
|
||||
(volume->comps[0].l >> volume->comps[0].factor[2]),
|
||||
volume->comps[0].prec);
|
||||
|
||||
if (original) {
|
||||
psnr = calc_PSNR(original, volume);
|
||||
ssim = calc_SSIM(original, volume);
|
||||
if (psnr < 0.0) {
|
||||
fprintf(stdout, " PSNR: Inf , SSMI %f -- Perfect reconstruction!\n", ssim);
|
||||
} else {
|
||||
fprintf(stdout, " PSNR: %f , SSIM %f \n", psnr, ssim);
|
||||
}
|
||||
}
|
||||
/* free remaining structures */
|
||||
if (dinfo) {
|
||||
opj_destroy_decompress(dinfo);
|
||||
}
|
||||
|
||||
/* free volume data structure */
|
||||
opj_volume_destroy(volume);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,115 +0,0 @@
|
|||
#!/bin/sh
|
||||
# The next line is executed by /bin/sh, but not tcl \
|
||||
exec wish "$0" ${1+"$@"}
|
||||
lappend auto_path /usr/share/tcltk/bwidget1.9.2
|
||||
|
||||
namespace eval jp3dVM {
|
||||
|
||||
variable _progress 0
|
||||
variable _afterid ""
|
||||
variable _status "Compute in progress..."
|
||||
variable notebook
|
||||
variable mainframe
|
||||
variable dataout "Process execution information"
|
||||
variable status
|
||||
variable prgtext
|
||||
variable prgindic
|
||||
|
||||
set pwd [pwd]
|
||||
cd [file dirname [info script]]
|
||||
variable VMDIR [pwd]
|
||||
cd $pwd
|
||||
|
||||
foreach script {encoder.tcl decoder.tcl} {
|
||||
namespace inscope :: source $VMDIR/$script
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
proc jp3dVM::create { } {
|
||||
variable notebook
|
||||
variable mainframe
|
||||
variable dataout
|
||||
|
||||
bind all <F12> { catch {console show} }
|
||||
|
||||
# Menu description
|
||||
set descmenu {
|
||||
"&File" {} {} 0 {
|
||||
{command "E&xit" {} "Exit BWidget jp3dVM" {} -command exit}
|
||||
}
|
||||
"&Options" {} {} 0 {
|
||||
{command "&Encode" {} "Show encoder" {}
|
||||
-command {$jp3dVM::notebook raise [$jp3dVM::notebook page 0]}
|
||||
}
|
||||
{command "&Decode" {} "Show decoder" {}
|
||||
-command {$jp3dVM::notebook raise [$jp3dVM::notebook page 1]}
|
||||
}
|
||||
}
|
||||
"&Help" {} {} 0 {
|
||||
{command "&About authors..." {} "Show info about authors" {}
|
||||
-command {MessageDlg .msgdlg -parent . -title "About authors" -message " Copyright @ LPI-UVA 2006 " -type ok -icon info}}
|
||||
}
|
||||
}
|
||||
|
||||
set mainframe [MainFrame .mainframe \
|
||||
-menu $descmenu \
|
||||
-textvariable jp3dVM::status \
|
||||
-progressvar jp3dVM::prgindic]
|
||||
|
||||
$mainframe addindicator -text "JP3D Verification Model 1.0.0"
|
||||
|
||||
# NoteBook creation
|
||||
set frame [$mainframe getframe]
|
||||
set notebook [NoteBook $frame.nb]
|
||||
|
||||
set logo [frame $frame.logo]
|
||||
#creo imagen logo
|
||||
image create photo LPIimg -file logoLPI.gif
|
||||
set logoimg [Label $logo.logoimg -image LPIimg]
|
||||
|
||||
set f0 [VMEncoder::create $notebook]
|
||||
set f1 [VMDecoder::create $notebook]
|
||||
|
||||
set tfinfo [TitleFrame $frame.codinfo -text "Program Execution"]
|
||||
set codinfo [$tfinfo getframe]
|
||||
set sw [ScrolledWindow $codinfo.sw -relief sunken -borderwidth 2 -scrollbar both]
|
||||
set sf [ScrollableFrame $codinfo.sf ]
|
||||
$sw setwidget $sf
|
||||
set subf [$sf getframe]
|
||||
set labinfo [label $subf.labinfo -textvariable jp3dVM::dataout -justify left]
|
||||
|
||||
pack $labinfo -side left
|
||||
pack $sw
|
||||
|
||||
$notebook compute_size
|
||||
$notebook raise [$notebook page 0]
|
||||
|
||||
pack $logoimg -side left -fill x -expand yes
|
||||
pack $notebook -expand yes
|
||||
pack $logo $tfinfo -side left -expand yes
|
||||
pack $mainframe -fill both -expand yes
|
||||
update idletasks
|
||||
}
|
||||
|
||||
|
||||
proc jp3dVM::main {} {
|
||||
variable VMDIR
|
||||
|
||||
lappend ::auto_path [file dirname $VMDIR]
|
||||
namespace inscope :: package require BWidget
|
||||
|
||||
option add *TitleFrame.l.font {helvetica 11 bold italic}
|
||||
|
||||
wm withdraw .
|
||||
wm title . "JP3D Verification Model @ LPI"
|
||||
|
||||
jp3dVM::create
|
||||
BWidget::place . 0 0 center
|
||||
wm deiconify .
|
||||
raise .
|
||||
focus -force .
|
||||
}
|
||||
|
||||
jp3dVM::main
|
||||
wm geom . [wm geom .]
|
|
@ -1,13 +0,0 @@
|
|||
HOWTO USE THE TCL/TK APP IN 'jp3d/tcltk'
|
||||
----------------------------------------
|
||||
1. Download the 'BWidget-1.9.2'
|
||||
http://www.sourceforge.net/projects/tcllib/
|
||||
|
||||
2. Install it e.g. in '/usr/local/BWidget-1.9.2/'
|
||||
3. Add the lappend command in line 4
|
||||
to jp3d/tcltk/LPI_JP3D_VM.tcl:
|
||||
|
||||
#!/bin/sh
|
||||
# The next line is executed by /bin/sh, but not tcl \
|
||||
exec wish "$0" ${1+"$@"}
|
||||
lappend auto_path /usr/local/BWidget-1.9.2
|
Binary file not shown.
|
@ -1,272 +0,0 @@
|
|||
|
||||
namespace eval VMDecoder {
|
||||
variable var
|
||||
variable JP3Ddecoder "../bin/jp3d_to_volume.exe"
|
||||
#variable JP3Ddecoder "jp3d_to_volume.exe"
|
||||
}
|
||||
|
||||
|
||||
proc VMDecoder::create { nb } {
|
||||
variable var
|
||||
|
||||
set frameD [$nb insert end VMDecoder -text "Decoder"]
|
||||
set topfD [frame $frameD.topfD]
|
||||
set medfD [frame $frameD.medfD]
|
||||
set bottomfD [frame $frameD.bottomfD]
|
||||
set srcfD [TitleFrame $topfD.srcfD -text "Source"]
|
||||
set dstfD [TitleFrame $topfD.dstfD -text "Destination"]
|
||||
set paramfD [TitleFrame $medfD.paramfD -text "Decoding parameters"]
|
||||
set infofD [TitleFrame $medfD.infofD -text "Distortion measures"]
|
||||
|
||||
set frame1 [$srcfD getframe]
|
||||
_sourceD $frame1
|
||||
set frame2 [$dstfD getframe]
|
||||
_destinationD $frame2
|
||||
set frame3 [$infofD getframe]
|
||||
_originalD $frame3
|
||||
set frame4 [$paramfD getframe]
|
||||
_paramsD $frame4
|
||||
|
||||
set butD [Button $bottomfD.butD -text "Decode!" \
|
||||
-command "VMDecoder::_decode $frame1 $frame2 $frame3" \
|
||||
-helptext "Decoding trigger button"]
|
||||
set butR [Button $bottomfD.butR -text "Save info" \
|
||||
-command "VMDecoder::_save $frame3" \
|
||||
-helptext "Save information"]
|
||||
|
||||
pack $srcfD $dstfD -side left -fill both -padx 10 -ipadx 5 -expand yes
|
||||
pack $topfD -pady 4 -fill x
|
||||
|
||||
pack $paramfD $infofD -side left -fill both -padx 10 -pady 2 -ipadx 5 -expand yes
|
||||
pack $medfD -pady 4 -fill x
|
||||
|
||||
pack $butD $butR -side left -padx 4 -pady 5 -expand yes
|
||||
pack $bottomfD -pady 4 -fill x
|
||||
|
||||
return $frameD
|
||||
}
|
||||
|
||||
|
||||
proc fileDialogD {w ent operation} {
|
||||
|
||||
variable file
|
||||
|
||||
if {$operation == "open"} {
|
||||
#-----Type names---------Extension(s)---
|
||||
set types {
|
||||
{"JP3D Files" {.jp3d} }
|
||||
{"All files" *}
|
||||
}
|
||||
set file [tk_getOpenFile -filetypes $types -parent $w ]
|
||||
} elseif {$operation == "original"} {
|
||||
#-----Type names---------Extension(s)---
|
||||
set types {
|
||||
{"BIN Raw Image Files" {.bin} }
|
||||
{"PGX Raw Image Files" {.pgx} }
|
||||
{"All files" *}
|
||||
}
|
||||
set file [tk_getOpenFile -filetypes $types -parent $w ]
|
||||
} else {
|
||||
#-----Type names---------Extension(s)---
|
||||
set types {
|
||||
{"BIN Raw Image Files" {.bin} }
|
||||
{"PGX Raw Image Files" {.pgx} }
|
||||
{"All files" *}
|
||||
}
|
||||
set file [tk_getSaveFile -filetypes $types -parent $w -initialfile Untitled -defaultextension "*.bin"]
|
||||
}
|
||||
if {[string compare $file ""]} {
|
||||
$ent delete 0 end
|
||||
$ent insert end $file
|
||||
$ent xview moveto 1
|
||||
}
|
||||
}
|
||||
|
||||
proc VMDecoder::_sourceD { parent } {
|
||||
|
||||
variable var
|
||||
|
||||
set labsrcD [LabelFrame $parent.labsrcD -text "Select compressed file: " -side top \
|
||||
-anchor w -relief flat -borderwidth 0]
|
||||
set subsrcD [$labsrcD getframe]
|
||||
set listD [entry $subsrcD.entrysrcD -width 40 -textvariable VMDecoder::var(sourceD)]
|
||||
|
||||
set labbrw [LabelFrame $parent.labbrw -side top -anchor w -relief flat -borderwidth 0]
|
||||
set subbrw [$labbrw getframe]
|
||||
set butbrw [button $subbrw.butbrw -image [Bitmap::get open] \
|
||||
-relief raised -borderwidth 1 -padx 1 -pady 1 \
|
||||
-command "fileDialogD . $subsrcD.entrysrcD open"]
|
||||
|
||||
pack $listD -side top
|
||||
pack $butbrw -side top
|
||||
pack $labsrcD $labbrw -side left -fill both -expand yes
|
||||
|
||||
|
||||
}
|
||||
|
||||
proc VMDecoder::_destinationD { parent } {
|
||||
|
||||
variable var
|
||||
|
||||
set labdstD [LabelFrame $parent.labdstD -text "Save decompressed volume file(s) as: " -side top \
|
||||
-anchor w -relief flat -borderwidth 0]
|
||||
set subdstD [$labdstD getframe]
|
||||
set listD [entry $subdstD.entrydstD -width 40 -textvariable VMDecoder::var(destinationD)]
|
||||
|
||||
set labbrw [LabelFrame $parent.labbrw -side top -anchor w -relief flat -borderwidth 0]
|
||||
set subbrw [$labbrw getframe]
|
||||
set butbrw [button $subbrw.butbrw -image [Bitmap::get save] \
|
||||
-relief raised -borderwidth 1 -padx 1 -pady 1 \
|
||||
-command "fileDialogD . $subdstD.entrydstD save"]
|
||||
|
||||
pack $listD -side top
|
||||
pack $butbrw -side top
|
||||
pack $labdstD $labbrw -side left -fill both -expand yes
|
||||
}
|
||||
|
||||
proc VMDecoder::_originalD { parent } {
|
||||
|
||||
variable var
|
||||
|
||||
set laborgD [LabelFrame $parent.laborgD -text "Select original file: " -side top \
|
||||
-anchor w -relief flat -borderwidth 0]
|
||||
set suborgD [$laborgD getframe]
|
||||
set listorgD [entry $suborgD.entryorgD -width 30 -textvariable VMDecoder::var(originalD)]
|
||||
|
||||
set labbrw2 [LabelFrame $parent.labbrw2 -side top -anchor w -relief flat -borderwidth 0]
|
||||
set subbrw2 [$labbrw2 getframe]
|
||||
set butbrw2 [button $subbrw2.butbrw2 -image [Bitmap::get open] \
|
||||
-relief raised -borderwidth 1 -padx 1 -pady 1 \
|
||||
-command "fileDialogD . $suborgD.entryorgD original"]
|
||||
|
||||
set infoD [Label $parent.infoD -relief sunken -textvariable VMDecoder::var(decodinfo) -justify left]
|
||||
|
||||
pack $listorgD -side left -anchor n
|
||||
pack $butbrw2 -side left -anchor n
|
||||
pack $infoD -side bottom -anchor nw -pady 4 -ipadx 150 -ipady 20 -expand yes
|
||||
pack $laborgD $labbrw2 -side left -fill both
|
||||
|
||||
|
||||
}
|
||||
|
||||
proc VMDecoder::_paramsD { parent } {
|
||||
|
||||
variable var
|
||||
|
||||
########### DECODING #############
|
||||
set labcod [LabelFrame $parent.labcod -side top -anchor w -relief sunken -borderwidth 1]
|
||||
set subcod [$labcod getframe]
|
||||
|
||||
set frameres [frame $subcod.frameres -borderwidth 1]
|
||||
set labres [LabelEntry $frameres.labres -label "Resolutions to discard: " -labelwidth 20 -labelanchor w \
|
||||
-textvariable VMDecoder::var(resdiscard) -editable 1 \
|
||||
-helptext "Number of highest resolution levels to be discarded on each dimension" ]
|
||||
set VMDecoder::var(resdiscard) "0,0,0"
|
||||
|
||||
set framelayer [frame $subcod.framelayer -borderwidth 1]
|
||||
set lablayer [LabelEntry $framelayer.lablayer -label "Layers to decode: " -labelwidth 20 -labelanchor w \
|
||||
-textvariable VMDecoder::var(layer) -editable 1 \
|
||||
-helptext "Maximum number of quality layers to decode" ]
|
||||
set VMDecoder::var(layer) "All"
|
||||
|
||||
set framebe [frame $subcod.framebe -borderwidth 1]
|
||||
set chkbe [checkbutton $framebe.chkbe -text "Write decoded file with BigEndian byte order" \
|
||||
-variable VMDecoder::var(be) -onvalue 1 -offvalue 0 ]
|
||||
|
||||
pack $labres -side left -padx 2 -anchor n
|
||||
pack $lablayer -side left -padx 2 -anchor n
|
||||
pack $chkbe -side left -padx 2 -anchor w
|
||||
pack $frameres $framelayer $framebe -side top -anchor w
|
||||
|
||||
pack $subcod -anchor n
|
||||
pack $labcod -side left -fill both -padx 4 -expand yes
|
||||
}
|
||||
|
||||
|
||||
proc VMDecoder::_decode { framesrc framedst frameinfo} {
|
||||
|
||||
variable var
|
||||
|
||||
set sourceD [$framesrc.labsrcD.f.entrysrcD get ]
|
||||
set destinationD [$framedst.labdstD.f.entrydstD get ]
|
||||
set originD [$frameinfo.laborgD.f.entryorgD get ]
|
||||
set cond1 [string match *.pgx [string tolower $destinationD]]
|
||||
set cond2 [string match *\**.pgx [string tolower $destinationD]]
|
||||
set cond3 [string match *.bin [string tolower $destinationD]]
|
||||
|
||||
#comprobamos datos son correctos
|
||||
if {($cond1 == 1) && ($cond2 == 0)} {
|
||||
set pgx "*.pgx"
|
||||
set pattern [string range $destinationD 0 [expr [string length $destinationD]-5]]
|
||||
set destinationD $pattern$img
|
||||
} elseif {$sourceD == ""} {
|
||||
MessageDlg .msgdlg -parent . -message "Error : Source file is not defined !" -type ok -icon error
|
||||
} elseif {$destinationD == ""} {
|
||||
MessageDlg .msgdlg -parent . -message "Error : Destination file is not defined !" -type ok -icon error
|
||||
} else {
|
||||
|
||||
#creamos datain a partir de los parametros de entrada
|
||||
#set dirJP3Ddecoder [mk_relativepath $VMDecoder::JP3Ddecoder]
|
||||
set dirJP3Ddecoder $VMDecoder::JP3Ddecoder
|
||||
set datain [concat " $dirJP3Ddecoder -i [mk_relativepath $sourceD] "]
|
||||
set datain [concat " $datain -o [mk_relativepath $destinationD] "]
|
||||
if {$originD != ""} {
|
||||
set datain [concat " $datain -O [mk_relativepath $originD] "]
|
||||
if {$cond3 == 1} {
|
||||
set img ".img"
|
||||
set pattern [string range $originD 0 [expr [string length $originD]-5]]
|
||||
set pattern $pattern$img
|
||||
if {[file exists $pattern]} {
|
||||
set datain [concat " $datain -m [mk_relativepath $pattern] "]
|
||||
} else {
|
||||
MessageDlg .msgdlg -parent . -message "Error : IMG file associated to original BIN volume file not found in same directory !" -type ok -icon info
|
||||
}
|
||||
}
|
||||
}
|
||||
if {$VMDecoder::var(resdiscard) != "0,0,0"} {
|
||||
set datain [concat " $datain -r $VMDecoder::var(resdiscard) "]
|
||||
}
|
||||
if {$VMDecoder::var(layer) != "All" && $VMDecoder::var(layer) > 0} {
|
||||
set datain [concat " $datain -l $VMDecoder::var(layer) "]
|
||||
}
|
||||
if {$VMDecoder::var(be) == 1} {
|
||||
set datain [concat " $datain -BE"]
|
||||
}
|
||||
|
||||
set VMDecoder::var(progval) 10
|
||||
ProgressDlg .progress -parent . -title "Wait..." \
|
||||
-type infinite \
|
||||
-width 20 \
|
||||
-textvariable "Compute in progress..."\
|
||||
-variable VMDecoder::progval \
|
||||
-stop "Stop" \
|
||||
-command {destroy .progress}
|
||||
|
||||
after 200 set VMDecoder::var(progval) 2
|
||||
|
||||
set fp [open "| $datain " r+]
|
||||
fconfigure $fp -buffering line
|
||||
set jp3dVM::dataout [concat "EXECUTED PROGRAM:\n\t$datain"]
|
||||
while {-1 != [gets $fp tmp]} {
|
||||
set jp3dVM::dataout [concat "$jp3dVM::dataout\n$tmp"]
|
||||
}
|
||||
close $fp
|
||||
destroy .progress
|
||||
set cond [string first "ERROR" $jp3dVM::dataout]
|
||||
set cond2 [string first "PSNR" $jp3dVM::dataout]
|
||||
set cond3 [string first "RESULT" $jp3dVM::dataout]
|
||||
if {$cond != -1} {
|
||||
MessageDlg .msgdlg -parent . -message [string range $jp3dVM::dataout [expr $cond-1] end] -type ok -icon error
|
||||
} elseif {$cond3 != -1} {
|
||||
if {$cond2 != -1} {
|
||||
set VMDecoder::var(decodinfo) [string range $jp3dVM::dataout [expr $cond2-1] end]
|
||||
}
|
||||
MessageDlg .msgdlg -parent . -message [string range $jp3dVM::dataout [expr $cond3-1] end] -type ok -icon info
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
proc VMDecoder::_save { frameinfo } {
|
||||
|
||||
}
|
||||
|
|
@ -1,470 +0,0 @@
|
|||
|
||||
namespace eval VMEncoder {
|
||||
variable var
|
||||
variable JP3Dencoder "../bin/bin/volume_to_jp3d"
|
||||
}
|
||||
|
||||
proc VMEncoder::create { nb } {
|
||||
|
||||
set frame [$nb insert end VMEncoder -text "Encoder"]
|
||||
set topf [frame $frame.topf]
|
||||
set midf [frame $frame.midf]
|
||||
set bottomf [frame $frame.bottomf]
|
||||
set srcf [TitleFrame $topf.srcf -text "Source"]
|
||||
set dstf [TitleFrame $topf.dstf -text "Destination"]
|
||||
set Tparf [TitleFrame $midf.parfT -text "Transform Parameters"]
|
||||
set Cparf [TitleFrame $midf.parfC -text "Coding Parameters"]
|
||||
|
||||
set frame1 [$srcf getframe]
|
||||
VMEncoder::_sourceE $frame1
|
||||
|
||||
set frame2 [$dstf getframe]
|
||||
VMEncoder::_destinationE $frame2
|
||||
|
||||
set frame3 [$Tparf getframe]
|
||||
VMEncoder::_transformE $frame3
|
||||
|
||||
set frame4 [$Cparf getframe]
|
||||
VMEncoder::_codingE $frame4
|
||||
|
||||
set butE [Button $bottomf.butE -text "Encode!" \
|
||||
-command "VMEncoder::_encode $frame1 $frame2" \
|
||||
-helptext "Encoding trigger button"]
|
||||
set butR [Button $bottomf.butR -text "Restore defaults" \
|
||||
-command "VMEncoder::_reset $frame1 $frame2 $frame3 $frame4" \
|
||||
-helptext "Reset to default values"]
|
||||
|
||||
pack $srcf $dstf -side left -fill y -padx 4 -expand yes
|
||||
pack $topf -pady 2 -fill x
|
||||
|
||||
pack $Tparf $Cparf -side left -fill both -padx 4 -expand yes
|
||||
pack $midf -pady 2 -fill x
|
||||
|
||||
pack $butE $butR -side left -padx 40 -pady 5 -fill y -expand yes
|
||||
pack $bottomf -pady 2 -fill x
|
||||
|
||||
return $frame
|
||||
}
|
||||
|
||||
proc VMEncoder::_sourceE { parent } {
|
||||
|
||||
variable var
|
||||
|
||||
set labsrc [LabelFrame $parent.labsrc -text "Select volume file to encode: " -side top \
|
||||
-anchor w -relief flat -borderwidth 0]
|
||||
set subsrc [$labsrc getframe]
|
||||
set list [entry $subsrc.entrysrc -width 30 -textvariable VMDecoder::var(source)]
|
||||
|
||||
set labbrw [LabelFrame $parent.labbrw -side top -anchor w -relief flat -borderwidth 0]
|
||||
set subbrw [$labbrw getframe]
|
||||
set butbrw [button $subbrw.butbrw -image [Bitmap::get open] \
|
||||
-relief raised -borderwidth 1 -padx 1 -pady 1 \
|
||||
-command "fileDialogE . $subsrc.entrysrc open"]
|
||||
|
||||
pack $list -side top
|
||||
pack $butbrw -side top
|
||||
pack $labsrc $labbrw -side left -fill both -expand yes
|
||||
}
|
||||
|
||||
proc VMEncoder::_destinationE { parent } {
|
||||
|
||||
variable var
|
||||
|
||||
set labdst [LabelFrame $parent.labdst -text "Save compressed volume as: " -side top \
|
||||
-anchor w -relief flat -borderwidth 0]
|
||||
set subdst [$labdst getframe]
|
||||
set list [entry $subdst.entrydst -width 30 -textvariable VMDecoder::var(destination)]
|
||||
|
||||
set labbrw [LabelFrame $parent.labbrw -side top -anchor w -relief flat -borderwidth 0]
|
||||
set subbrw [$labbrw getframe]
|
||||
set butbrw [button $subbrw.butbrw -image [Bitmap::get save] \
|
||||
-relief raised -borderwidth 1 -padx 1 -pady 1 \
|
||||
-command "fileDialogE . $subdst.entrydst save"]
|
||||
|
||||
pack $list -side top
|
||||
pack $butbrw -side top
|
||||
pack $labdst $labbrw -side left -fill both -expand yes
|
||||
}
|
||||
|
||||
proc VMEncoder::_codingE { parent } {
|
||||
|
||||
|
||||
########### CODING #############
|
||||
set labcod [LabelFrame $parent.labcod -side top -anchor w -relief sunken -borderwidth 1]
|
||||
set subcod [$labcod getframe]
|
||||
|
||||
set framerate [frame $subcod.framerate -borderwidth 1]
|
||||
set labrate [LabelEntry $framerate.labrate -label "Rates: " -labelwidth 9 -labelanchor w \
|
||||
-textvariable VMEncoder::var(rate) -editable 1 \
|
||||
-helptext "Compression ratios for different layers (R1, R2, R3,...). If R=1, lossless coding" ]
|
||||
set VMEncoder::var(rate) "1"
|
||||
|
||||
set framecblk [frame $subcod.framecblk -borderwidth 1]
|
||||
set labcblk [LabelEntry $framecblk.labcblk -label "Codeblock: " -labelwidth 9 -labelanchor w \
|
||||
-textvariable VMEncoder::var(cblksize) -editable 1 \
|
||||
-helptext "Codeblock size (X, Y, Z)" ]
|
||||
set VMEncoder::var(cblksize) "64,64,64"
|
||||
|
||||
set frametile [frame $subcod.frametile -borderwidth 1]
|
||||
set labtile [LabelEntry $frametile.labtile -label "Tile size: " -labelwidth 9 -labelanchor w \
|
||||
-textvariable VMEncoder::var(tilesize) -editable 1 \
|
||||
-helptext "Tile size (X, Y, Z)" ]
|
||||
set VMEncoder::var(tilesize) "512,512,512"
|
||||
|
||||
set framesop [frame $subcod.framesop -borderwidth 1]
|
||||
set chksop [checkbutton $framesop.chksop -text "Write SOP marker" \
|
||||
-variable VMEncoder::var(sop) -onvalue 1 -offvalue 0 ]
|
||||
set frameeph [frame $subcod.frameeph -borderwidth 1]
|
||||
set chkeph [checkbutton $frameeph.chkeph -text "Write EPH marker" \
|
||||
-variable VMEncoder::var(eph) -onvalue 1 -offvalue 0 ]
|
||||
|
||||
set framepoc [frame $subcod.framepoc -borderwidth 1]
|
||||
set labpoc [label $framepoc.labpoc -text "Progression order: " ]
|
||||
set progorder [ComboBox $framepoc.progorder \
|
||||
-text {Choose a progression order} \
|
||||
-width 10 \
|
||||
-textvariable VMEncoder::var(progorder) \
|
||||
-values {"LRCP" "RLCP" "RPCL" "PCRL" "CPRL"} \
|
||||
-helptext "Progression order"]
|
||||
set VMEncoder::var(progorder) "LRCP"
|
||||
|
||||
pack $labrate -side left -padx 2 -anchor n
|
||||
pack $labcblk -side left -padx 2 -anchor n
|
||||
pack $labpoc $progorder -side left -padx 2 -anchor w
|
||||
#pack $labtile -side left -padx 2 -anchor n
|
||||
pack $chksop -side left -padx 2 -anchor w
|
||||
pack $chkeph -side left -padx 2 -anchor w
|
||||
########### ENTROPY CODING #############
|
||||
set labent [LabelFrame $parent.labent -text "Entropy Coding" -side top -anchor w -relief sunken -borderwidth 1]
|
||||
set subent [$labent getframe]
|
||||
foreach entval {2EB 3EB} entropy {2D_EBCOT 3D_EBCOT} {
|
||||
set rad [radiobutton $subent.$entval \
|
||||
-text $entropy \
|
||||
-variable VMEncoder::var(encoding) \
|
||||
-command "disableGR $entval $labcblk $progorder $labrate $chksop $chkeph" \
|
||||
-value $entval ]
|
||||
pack $rad -anchor w
|
||||
}
|
||||
$subent.2EB select
|
||||
|
||||
pack $subent -padx 2 -anchor n
|
||||
|
||||
pack $framerate $framecblk $framepoc $framesop $frameeph -side top -anchor w
|
||||
pack $subcod -anchor n
|
||||
|
||||
pack $labent $labcod -side left -fill both -padx 4 -expand yes
|
||||
|
||||
|
||||
}
|
||||
|
||||
proc VMEncoder::_transformE { parent } {
|
||||
|
||||
variable var
|
||||
|
||||
########### TRANSFORM #############
|
||||
set labtrf [LabelFrame $parent.labtrf -text "Transform" -side top -anchor w -relief sunken -borderwidth 1]
|
||||
set subtrf [$labtrf getframe]
|
||||
set labres [LabelFrame $parent.labres -side top -anchor w -relief sunken -borderwidth 1]
|
||||
set subres [$labres getframe]
|
||||
|
||||
########### ATK #############
|
||||
set frameatk [frame $subres.frameatk -borderwidth 1]
|
||||
set labatk [label $frameatk.labatk -text "Wavelet kernel: " -anchor w]
|
||||
set atk [ComboBox $frameatk.atk \
|
||||
-textvariable VMEncoder::var(atk) \
|
||||
-width 20 \
|
||||
-text {Choose a wavelet kernel} \
|
||||
-editable false \
|
||||
-values {"R5.3" "I9.7"} ]
|
||||
set VMEncoder::var(atk) "R5.3"
|
||||
pack $labatk $atk -side left -anchor w
|
||||
########### RESOLUTIONS #############
|
||||
set frameres1 [frame $subres.frameres1 -borderwidth 1]
|
||||
set labresolution [label $frameres1.labresol -text "Resolutions: " -anchor w ]
|
||||
set frameres2 [frame $subres.frameres2 -borderwidth 1]
|
||||
set labresX [label $frameres2.labresX -text " X" -anchor w ]
|
||||
set labresY [label $frameres2.labresY -text " Y" -anchor w ]
|
||||
set labresZ [label $frameres2.labresZ -text " Z" -anchor w ]
|
||||
|
||||
|
||||
set resX [SpinBox $frameres2.spinresX \
|
||||
-range {1 6 1} -textvariable VMEncoder::var(resX) \
|
||||
-helptext "Number of resolutions in X" \
|
||||
-width 3 \
|
||||
-editable false ]
|
||||
set resY [SpinBox $frameres2.spinresY \
|
||||
-range {1 6 1} -textvariable VMEncoder::var(resY) \
|
||||
-helptext "Number of resolutions in Y" \
|
||||
-width 3 \
|
||||
-editable false ]
|
||||
set resZ [SpinBox $frameres2.spinresZ \
|
||||
-range {1 6 1} -textvariable VMEncoder::var(resZ) \
|
||||
-helptext "Number of resolutions in Z" \
|
||||
-width 3 \
|
||||
-editable false \
|
||||
-state disabled ]
|
||||
set VMEncoder::var(resX) 3
|
||||
set VMEncoder::var(resY) 3
|
||||
set VMEncoder::var(resZ) 3
|
||||
|
||||
########### TRF #############
|
||||
foreach trfval {2DWT 3DWT} trf {2D-DWT 3D-DWT} {
|
||||
set rad [radiobutton $subtrf.$trfval -text $trf \
|
||||
-variable VMEncoder::var(transform) \
|
||||
-command "disable3RLS $trfval $atk $resX $resY $resZ"\
|
||||
-value $trfval ]
|
||||
pack $rad -anchor w
|
||||
}
|
||||
$subtrf.2DWT select
|
||||
|
||||
pack $subtrf -side left -padx 2 -pady 4
|
||||
|
||||
pack $labresolution -padx 2 -side left -anchor w
|
||||
pack $labresX $resX -padx 2 -side left -anchor w
|
||||
pack $labresY $resY -padx 2 -side left -anchor w
|
||||
pack $labresZ $resZ -padx 2 -side left -anchor w
|
||||
|
||||
pack $frameres1 -side top -fill x
|
||||
pack $frameres2 $frameatk -side top -padx 2 -pady 4 -anchor n
|
||||
|
||||
pack $subres -side left -padx 2 -pady 4
|
||||
pack $labtrf $labres -side left -fill both -padx 4 -expand yes
|
||||
}
|
||||
|
||||
|
||||
proc VMEncoder::_encode { framesrc framedst } {
|
||||
|
||||
variable var
|
||||
|
||||
set source [$framesrc.labsrc.f.entrysrc get ]
|
||||
set destination [$framedst.labdst.f.entrydst get ]
|
||||
set cond1 [string match *.pgx [string tolower $source]]
|
||||
set cond2 [string match *-*.pgx [string tolower $source]]
|
||||
set cond3 [string match *.bin [string tolower $source]]
|
||||
|
||||
set img ".img"
|
||||
set pattern [string range $source 0 [expr [string length $source]-5]]
|
||||
set pattern $pattern$img
|
||||
set exist [file exists $pattern]
|
||||
|
||||
#comprobamos datos son correctos
|
||||
if {($cond1 == 1) && ($cond2 == 0)} {
|
||||
MessageDlg .msgdlg -parent . -message "Info : Really want to encode an slice instead of a volume?.\n For a group of .pgx slices, name must contain a - denoting a sequential index!" -type ok -icon info
|
||||
}
|
||||
|
||||
if {$source == ""} {
|
||||
MessageDlg .msgdlg -parent . -message "Error : Source file is not defined !" -type ok -icon error
|
||||
} elseif {$destination == ""} {
|
||||
MessageDlg .msgdlg -parent . -message "Error : Destination file is not defined !" -type ok -icon error
|
||||
} elseif { ($VMEncoder::var(transform) != "3RLS") && ($VMEncoder::var(atk) == "Choose a wavelet transformation kernel") } {
|
||||
MessageDlg .msgdlg -parent . -title "Info" -message "Please choose a wavelet transformation kernel"\
|
||||
-type ok -icon warning
|
||||
} elseif {($exist == 0) && ($cond1 == 0) && ($cond3 == 1)} {
|
||||
MessageDlg .msgdlg -parent . -message "Error : IMG file associated to BIN volume file not found in same directory !" -type ok -icon info
|
||||
} else {
|
||||
|
||||
#creamos datain a partir de los parametros de entrada
|
||||
# set dirJP3Dencoder [mk_relativepath $VMEncoder::JP3Dencoder]
|
||||
set dirJP3Dencoder $VMEncoder::JP3Dencoder
|
||||
set datain [concat " $dirJP3Dencoder -i [mk_relativepath $source] "]
|
||||
if {$cond3 == 1} {
|
||||
set datain [concat " $datain -m [mk_relativepath $pattern] "]
|
||||
}
|
||||
set datain [concat " $datain -o [mk_relativepath $destination] "]
|
||||
if {$VMEncoder::var(encoding) != "2EB"} {
|
||||
set datain [concat " $datain -C $VMEncoder::var(encoding) "]
|
||||
}
|
||||
if {$VMEncoder::var(transform) == "2DWT"} {
|
||||
set datain [concat " $datain -n $VMEncoder::var(resX),$VMEncoder::var(resY) "]
|
||||
} elseif {$VMEncoder::var(transform) == "3DWT"} {
|
||||
set datain [concat " $datain -n $VMEncoder::var(resX),$VMEncoder::var(resY),$VMEncoder::var(resZ) "]
|
||||
}
|
||||
|
||||
set datain [concat " $datain -r $VMEncoder::var(rate) "]
|
||||
|
||||
if {$VMEncoder::var(atk) == "I9.7"} {
|
||||
set datain [concat " $datain -I "]
|
||||
}
|
||||
if {$VMEncoder::var(sop) == 1} {
|
||||
set datain [concat " $datain -SOP "]
|
||||
}
|
||||
if {$VMEncoder::var(eph) == 1} {
|
||||
set datain [concat " $datain -EPH "]
|
||||
}
|
||||
if {$VMEncoder::var(progorder) != "LRCP"} {
|
||||
set datain [concat " $datain -p $VMEncoder::var(progorder) "]
|
||||
}
|
||||
if {$VMEncoder::var(cblksize) != "64,64,64"} {
|
||||
set datain [concat " $datain -b $VMEncoder::var(cblksize) "]
|
||||
}
|
||||
|
||||
|
||||
#Making this work would be great !!!
|
||||
set VMEncoder::var(progval) 10
|
||||
ProgressDlg .progress -parent . -title "Wait..." \
|
||||
-type infinite \
|
||||
-width 20 \
|
||||
-textvariable "Compute in progress..."\
|
||||
-variable VMEncoder::progval \
|
||||
-stop "Stop" \
|
||||
-command {destroy .progress}
|
||||
after 200 set VMEncoder::var(progval) 2
|
||||
set fp [open "| $datain " r+]
|
||||
fconfigure $fp -buffering line
|
||||
set jp3dVM::dataout [concat "EXECUTED PROGRAM:\n\t$datain"]
|
||||
while {-1 != [gets $fp tmp]} {
|
||||
set jp3dVM::dataout [concat "$jp3dVM::dataout\n$tmp"]
|
||||
}
|
||||
destroy .progress
|
||||
set cond [string first "ERROR" $jp3dVM::dataout]
|
||||
set cond2 [string first "RESULT" $jp3dVM::dataout]
|
||||
if {$cond != -1} {
|
||||
MessageDlg .msgdlg -parent . -message [string range $jp3dVM::dataout [expr $cond-1] end] -type ok -icon error
|
||||
} elseif {$cond2 != -1} {
|
||||
MessageDlg .msgdlg -parent . -message [string range $jp3dVM::dataout [expr $cond2+7] end] -type ok -icon info
|
||||
close $fp
|
||||
} else {
|
||||
#Must do something with this !!! [pid $fp]
|
||||
close $fp
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
proc VMEncoder::_reset { framesrc framedst frametrf framecod} {
|
||||
|
||||
variable var
|
||||
|
||||
#Restore defaults values
|
||||
set VMEncoder::var(transform) 2DWT
|
||||
set VMEncoder::var(encoding) 2EB
|
||||
set VMEncoder::var(atk) "R5.3"
|
||||
set VMEncoder::var(progorder) "LRCP"
|
||||
set atk $frametrf.labres.f.frameatk.atk
|
||||
set resX $frametrf.labres.f.frameres2.spinresX
|
||||
set resY $frametrf.labres.f.frameres2.spinresY
|
||||
set resZ $frametrf.labres.f.frameres2.spinresZ
|
||||
disable3RLS 2DWT $atk $resX $resY $resZ
|
||||
set labcblk $framecod.labcod.f.framecblk.labcblk
|
||||
set progorder $framecod.labcod.f.framepoc.progorder
|
||||
set labrate $framecod.labcod.f.framerate.labrate
|
||||
set chksop $framecod.labcod.f.framesop.chksop
|
||||
set chkeph $framecod.labcod.f.frameeph.chkeph
|
||||
disableGR 3EB $labcblk $progorder $labrate $chksop $chkeph
|
||||
|
||||
$framesrc.labsrc.f.entrysrc delete 0 end
|
||||
$framedst.labdst.f.entrydst delete 0 end
|
||||
}
|
||||
|
||||
proc fileDialogE {w ent operation} {
|
||||
|
||||
variable file
|
||||
variable i j
|
||||
|
||||
if {$operation == "open"} {
|
||||
set types {
|
||||
{"Source Image Files" {.pgx .bin} }
|
||||
{"All files" *}
|
||||
}
|
||||
set file [tk_getOpenFile -filetypes $types -parent $w]
|
||||
if {[string compare $file ""]} {
|
||||
$ent delete 0 end
|
||||
$ent insert end $file
|
||||
$ent xview moveto 1
|
||||
}
|
||||
} else {
|
||||
set types {
|
||||
{"JP3D Files" {.jp3d} }
|
||||
{"JPEG2000 Files" {.j2k} }
|
||||
{"All files" *}
|
||||
}
|
||||
set file [tk_getSaveFile -filetypes $types -parent $w \
|
||||
-initialfile Untitled -defaultextension .jp3d]
|
||||
if {[string compare $file ""]} {
|
||||
$ent delete 0 end
|
||||
$ent insert end $file
|
||||
$ent xview moveto 1
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
proc mk_relativepath {abspath} {
|
||||
|
||||
set mydir [split [string trimleft [pwd] {/}] {/}]
|
||||
set abspathcomps [split [string trimleft $abspath {/}] {/}]
|
||||
|
||||
set i 0
|
||||
while {$i<[llength $mydir]} {
|
||||
if {![string compare [lindex $abspathcomps $i] [lindex $mydir $i]]} {
|
||||
incr i
|
||||
} else {
|
||||
break
|
||||
}
|
||||
}
|
||||
set h [expr [llength $mydir]-$i]
|
||||
set j [expr [llength $abspathcomps]-$i]
|
||||
|
||||
if {!$h} {
|
||||
set relpath "./"
|
||||
} else {
|
||||
set relpath ""
|
||||
while { $h > 0 } {
|
||||
set relpath "../$relpath"
|
||||
incr h -1
|
||||
}
|
||||
}
|
||||
|
||||
set h [llength $abspathcomps]
|
||||
while { $h > $i } {
|
||||
set relpath [concat $relpath[lindex $abspathcomps [expr [llength $abspathcomps]-$j]]/]
|
||||
incr h -1
|
||||
incr j -1
|
||||
}
|
||||
return [string trim $relpath {/}]
|
||||
}
|
||||
|
||||
proc disable3RLS {flag atk resX resY resZ} {
|
||||
|
||||
if {$flag == "3RLS"} {
|
||||
$atk configure -state disabled
|
||||
$resX configure -state disabled
|
||||
$resY configure -state disabled
|
||||
$resZ configure -state disabled
|
||||
} elseif {$flag == "2DWT"} {
|
||||
$atk configure -state normal
|
||||
$resX configure -state normal
|
||||
$resY configure -state normal
|
||||
$resZ configure -state disabled
|
||||
} elseif {$flag == "3DWT"} {
|
||||
$atk configure -state normal
|
||||
$resX configure -state normal
|
||||
$resY configure -state normal
|
||||
$resZ configure -state normal
|
||||
}
|
||||
}
|
||||
|
||||
proc disableGR {flag labcblk progorder labrate chksop chkeph} {
|
||||
|
||||
if {$flag == "2EB"} {
|
||||
$labcblk configure -state normal
|
||||
$progorder configure -state normal
|
||||
$labrate configure -state normal
|
||||
$chksop configure -state normal
|
||||
$chkeph configure -state normal
|
||||
set VMEncoder::var(cblksize) "64,64,64"
|
||||
set VMEncoder::var(tilesize) "512,512,512"
|
||||
} elseif {$flag == "3EB"} {
|
||||
$labcblk configure -state normal
|
||||
$progorder configure -state normal
|
||||
$labrate configure -state normal
|
||||
$chksop configure -state normal
|
||||
$chkeph configure -state normal
|
||||
set VMEncoder::var(cblksize) "64,64,64"
|
||||
set VMEncoder::var(tilesize) "512,512,512"
|
||||
} else {
|
||||
$labcblk configure -state disabled
|
||||
$progorder configure -state disabled
|
||||
$labrate configure -state disabled
|
||||
$chksop configure -state disabled
|
||||
$chkeph configure -state disabled
|
||||
}
|
||||
}
|
Binary file not shown.
Before Width: | Height: | Size: 5.1 KiB |
|
@ -1,679 +0,0 @@
|
|||
/*
|
||||
* uce-dirent.h - operating system independent dirent implementation
|
||||
*
|
||||
* Copyright (C) 1998-2002 Toni Ronkko
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* ``Software''), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sublicense, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included
|
||||
* in all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
* IN NO EVENT SHALL TONI RONKKO BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
*
|
||||
* May 28 1998, Toni Ronkko <tronkko@messi.uku.fi>
|
||||
*
|
||||
* $Id: uce-dirent.h,v 1.7 2002/05/13 10:48:35 tr Exp $
|
||||
*
|
||||
* $Log: uce-dirent.h,v $
|
||||
* Revision 1.7 2002/05/13 10:48:35 tr
|
||||
* embedded some source code directly to the header so that no source
|
||||
* modules need to be included in the MS Visual C project using the
|
||||
* interface, removed all the dependencies to other headers of the `uce'
|
||||
* library so that the header can be made public
|
||||
*
|
||||
* Revision 1.6 2002/04/12 16:22:04 tr
|
||||
* Unified Compiling Environment (UCE) replaced `std' library
|
||||
*
|
||||
* Revision 1.5 2001/07/20 16:33:40 tr
|
||||
* moved to `std' library and re-named defines accordingly
|
||||
*
|
||||
* Revision 1.4 2001/07/10 16:47:18 tronkko
|
||||
* revised comments
|
||||
*
|
||||
* Revision 1.3 2001/01/11 13:16:43 tr
|
||||
* using ``uce-machine.h'' for finding out defines such as `FREEBSD'
|
||||
*
|
||||
* Revision 1.2 2000/10/08 16:00:41 tr
|
||||
* copy of FreeBSD man page
|
||||
*
|
||||
* Revision 1.1 2000/07/10 05:53:16 tr
|
||||
* Initial revision
|
||||
*
|
||||
* Revision 1.2 1998/07/19 18:29:14 tr
|
||||
* Added error reporting capabilities and some asserts.
|
||||
*
|
||||
* Revision 1.1 1998/07/04 16:27:51 tr
|
||||
* Initial revision
|
||||
*
|
||||
*
|
||||
* MSVC 1.0 scans automatic dependencies incorrectly when your project
|
||||
* contains this very header. The problem is that MSVC cannot handle
|
||||
* include directives inside #if..#endif block those are never entered.
|
||||
* Since this header ought to compile in many different operating systems,
|
||||
* there had to be several conditional blocks that are compiled only in
|
||||
* operating systems for what they were designed for. MSVC 1.0 cannot
|
||||
* handle inclusion of sys/dir.h in a part that is compiled only in Apollo
|
||||
* operating system. To fix the problem you need to insert DIR.H into
|
||||
* SYSINCL.DAT located in MSVC\BIN directory and restart visual C++.
|
||||
* Consult manuals for more informaton about the problem.
|
||||
*
|
||||
* Since many UNIX systems have dirent.h we assume to have one also.
|
||||
* However, if your UNIX system does not have dirent.h you can download one
|
||||
* for example at: http://ftp.uni-mannheim.de/ftp/GNU/dirent/dirent.tar.gz.
|
||||
* You can also see if you have one of dirent.h, direct.h, dir.h, ndir.h,
|
||||
* sys/dir.h and sys/ndir.h somewhere. Try defining HAVE_DIRENT_H,
|
||||
* HAVE_DIRECT_H, HAVE_DIR_H, HAVE_NDIR_H, HAVE_SYS_DIR_H and
|
||||
* HAVE_SYS_NDIR_H according to the files found.
|
||||
*/
|
||||
#ifndef DIRENT_H
|
||||
#define DIRENT_H
|
||||
#define DIRENT_H_INCLUDED
|
||||
|
||||
/* find out platform */
|
||||
#if defined(MSDOS) /* MS-DOS */
|
||||
#elif defined(__MSDOS__) /* Turbo C/Borland */
|
||||
# define MSDOS
|
||||
#elif defined(__DOS__) /* Watcom */
|
||||
# define MSDOS
|
||||
#endif
|
||||
|
||||
#if defined(WIN32) /* MS-Windows */
|
||||
#elif defined(__NT__) /* Watcom */
|
||||
# define WIN32
|
||||
#elif defined(_WIN32) /* Microsoft */
|
||||
# define WIN32
|
||||
#elif defined(__WIN32__) /* Borland */
|
||||
# define WIN32
|
||||
#endif
|
||||
|
||||
/*
|
||||
* See what kind of dirent interface we have unless autoconf has already
|
||||
* determinated that.
|
||||
*/
|
||||
#if !defined(HAVE_DIRENT_H) && !defined(HAVE_DIRECT_H) && !defined(HAVE_SYS_DIR_H) && !defined(HAVE_NDIR_H) && !defined(HAVE_SYS_NDIR_H) && !defined(HAVE_DIR_H)
|
||||
# if defined(_MSC_VER) /* Microsoft C/C++ */
|
||||
/* no dirent.h */
|
||||
# elif defined(__MINGW32__) /* MinGW */
|
||||
/* 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 referring 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 although
|
||||
* 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 occurred */
|
||||
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*/
|
|
@ -1,62 +0,0 @@
|
|||
# jpwl apps
|
||||
|
||||
# First thing define the common source:
|
||||
set(common_SRCS
|
||||
convert.c
|
||||
index.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/bin/common/color.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/bin/common/opj_getopt.c
|
||||
)
|
||||
|
||||
# Headers file are located here:
|
||||
include_directories(
|
||||
${OPENJPEG_BINARY_DIR}/src/lib/openjp2 # opj_config.h
|
||||
${OPENJPEG_BINARY_DIR}/src/bin/common # opj_apps_config.h
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2
|
||||
${OPENJPEG_SOURCE_DIR}/src/bin/common
|
||||
${LCMS_INCLUDE_DIRNAME}
|
||||
${Z_INCLUDE_DIRNAME}
|
||||
${PNG_INCLUDE_DIRNAME}
|
||||
${TIFF_INCLUDE_DIRNAME}
|
||||
)
|
||||
|
||||
if(WIN32)
|
||||
if(BUILD_SHARED_LIBS)
|
||||
add_definitions(-DOPJ_EXPORTS)
|
||||
else()
|
||||
add_definitions(-DOPJ_STATIC)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
add_definitions(-DOPJ_USE_LEGACY)
|
||||
foreach(exe decompress compress)
|
||||
set(jpwl_exe opj_jpwl_${exe})
|
||||
set(jp2_exe opj_${exe})
|
||||
add_executable(${jpwl_exe}
|
||||
#../jp2/${jp2_exe}.c
|
||||
${jpwl_exe}.c
|
||||
${common_SRCS}
|
||||
)
|
||||
set_property(
|
||||
TARGET ${jpwl_exe}
|
||||
APPEND PROPERTY COMPILE_DEFINITIONS USE_JPWL
|
||||
)
|
||||
|
||||
target_link_libraries(${jpwl_exe} openjpwl
|
||||
${LCMS_LIBNAME} ${PNG_LIBNAME} ${TIFF_LIBNAME})
|
||||
|
||||
# To support universal exe:
|
||||
if(ZLIB_FOUND AND APPLE)
|
||||
target_link_libraries(${jpwl_exe} z)
|
||||
else(ZLIB_FOUND AND APPLE)
|
||||
target_link_libraries(${jpwl_exe} ${Z_LIBNAME})
|
||||
endif()
|
||||
|
||||
if(UNIX)
|
||||
target_link_libraries(${jpwl_exe} m)
|
||||
endif()
|
||||
|
||||
install(TARGETS ${jpwl_exe}
|
||||
DESTINATION ${OPENJPEG_INSTALL_BIN_DIR} COMPONENT Applications
|
||||
)
|
||||
endforeach()
|
File diff suppressed because it is too large
Load Diff
|
@ -1,90 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2014, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux
|
||||
* Copyright (c) 2003-2014, Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* 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 */
|
||||
opj_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 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);
|
||||
|
||||
/* PNG conversion*/
|
||||
extern int imagetopng(opj_image_t *image, const char *write_idf);
|
||||
extern opj_image_t* pngtoimage(const char *filename,
|
||||
opj_cparameters_t *parameters);
|
||||
|
||||
#endif /* __J2K_CONVERT_H */
|
||||
|
|
@ -1,454 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2014, Professor Benoit Macq
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include "openjpeg.h"
|
||||
#include "index.h"
|
||||
|
||||
/* ------------------------------------------------------------------------------------ */
|
||||
|
||||
/**
|
||||
Write a structured index to a file
|
||||
@param cstr_info Codestream information
|
||||
@param index Index filename
|
||||
@return Returns 0 if successful, returns 1 otherwise
|
||||
*/
|
||||
int write_index_file(opj_codestream_info_t *cstr_info, char *index)
|
||||
{
|
||||
int tileno, compno, layno, resno, precno, pack_nb, x, y;
|
||||
FILE *stream = NULL;
|
||||
double total_disto = 0;
|
||||
/* UniPG>> */
|
||||
int tilepartno;
|
||||
char disto_on, numpix_on;
|
||||
|
||||
#ifdef USE_JPWL
|
||||
if (!strcmp(index, JPWL_PRIVATEINDEX_NAME)) {
|
||||
return 0;
|
||||
}
|
||||
#endif /* USE_JPWL */
|
||||
/* <<UniPG */
|
||||
|
||||
if (!cstr_info) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
stream = fopen(index, "w");
|
||||
if (!stream) {
|
||||
fprintf(stderr, "failed to open index file [%s] for writing\n", index);
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (cstr_info->tile[0].distotile) {
|
||||
disto_on = 1;
|
||||
} else {
|
||||
disto_on = 0;
|
||||
}
|
||||
|
||||
if (cstr_info->tile[0].numpix) {
|
||||
numpix_on = 1;
|
||||
} else {
|
||||
numpix_on = 0;
|
||||
}
|
||||
|
||||
fprintf(stream, "%d %d\n", cstr_info->image_w, cstr_info->image_h);
|
||||
fprintf(stream, "%d\n", cstr_info->prog);
|
||||
fprintf(stream, "%d %d\n", cstr_info->tile_x, cstr_info->tile_y);
|
||||
fprintf(stream, "%d %d\n", cstr_info->tw, cstr_info->th);
|
||||
fprintf(stream, "%d\n", cstr_info->numcomps);
|
||||
fprintf(stream, "%d\n", cstr_info->numlayers);
|
||||
fprintf(stream, "%d\n", cstr_info->numdecompos[0]); /* based on component 0 */
|
||||
|
||||
for (resno = cstr_info->numdecompos[0]; resno >= 0; resno--) {
|
||||
fprintf(stream, "[%d,%d] ",
|
||||
(1 << cstr_info->tile[0].pdx[resno]),
|
||||
(1 << cstr_info->tile[0].pdx[resno])); /* based on tile 0 and component 0 */
|
||||
}
|
||||
|
||||
fprintf(stream, "\n");
|
||||
/* UniPG>> */
|
||||
fprintf(stream, "%d\n", cstr_info->main_head_start);
|
||||
/* <<UniPG */
|
||||
fprintf(stream, "%d\n", cstr_info->main_head_end);
|
||||
fprintf(stream, "%d\n", cstr_info->codestream_size);
|
||||
|
||||
fprintf(stream, "\nINFO ON TILES\n");
|
||||
fprintf(stream, "tileno start_pos end_hd end_tile nbparts");
|
||||
if (disto_on) {
|
||||
fprintf(stream, " disto");
|
||||
}
|
||||
if (numpix_on) {
|
||||
fprintf(stream, " nbpix");
|
||||
}
|
||||
if (disto_on && numpix_on) {
|
||||
fprintf(stream, " disto/nbpix");
|
||||
}
|
||||
fprintf(stream, "\n");
|
||||
|
||||
for (tileno = 0; tileno < cstr_info->tw * cstr_info->th; tileno++) {
|
||||
fprintf(stream, "%4d %9d %9d %9d %9d",
|
||||
cstr_info->tile[tileno].tileno,
|
||||
cstr_info->tile[tileno].start_pos,
|
||||
cstr_info->tile[tileno].end_header,
|
||||
cstr_info->tile[tileno].end_pos,
|
||||
cstr_info->tile[tileno].num_tps);
|
||||
if (disto_on) {
|
||||
fprintf(stream, " %9e", cstr_info->tile[tileno].distotile);
|
||||
}
|
||||
if (numpix_on) {
|
||||
fprintf(stream, " %9d", cstr_info->tile[tileno].numpix);
|
||||
}
|
||||
if (disto_on && numpix_on) {
|
||||
fprintf(stream, " %9e", cstr_info->tile[tileno].distotile /
|
||||
cstr_info->tile[tileno].numpix);
|
||||
}
|
||||
fprintf(stream, "\n");
|
||||
}
|
||||
|
||||
for (tileno = 0; tileno < cstr_info->tw * cstr_info->th; tileno++) {
|
||||
int start_pos, end_ph_pos, end_pos;
|
||||
double disto = 0;
|
||||
int max_numdecompos = 0;
|
||||
pack_nb = 0;
|
||||
|
||||
for (compno = 0; compno < cstr_info->numcomps; compno++) {
|
||||
if (max_numdecompos < cstr_info->numdecompos[compno]) {
|
||||
max_numdecompos = cstr_info->numdecompos[compno];
|
||||
}
|
||||
}
|
||||
|
||||
fprintf(stream, "\nTILE %d DETAILS\n", tileno);
|
||||
fprintf(stream,
|
||||
"part_nb tileno start_pack num_packs start_pos end_tph_pos end_pos\n");
|
||||
for (tilepartno = 0; tilepartno < cstr_info->tile[tileno].num_tps; tilepartno++)
|
||||
fprintf(stream, "%4d %9d %9d %9d %9d %11d %9d\n",
|
||||
tilepartno, tileno,
|
||||
cstr_info->tile[tileno].tp[tilepartno].tp_start_pack,
|
||||
cstr_info->tile[tileno].tp[tilepartno].tp_numpacks,
|
||||
cstr_info->tile[tileno].tp[tilepartno].tp_start_pos,
|
||||
cstr_info->tile[tileno].tp[tilepartno].tp_end_header,
|
||||
cstr_info->tile[tileno].tp[tilepartno].tp_end_pos
|
||||
);
|
||||
|
||||
if (cstr_info->prog == LRCP) { /* LRCP */
|
||||
fprintf(stream,
|
||||
"LRCP\npack_nb tileno layno resno compno precno start_pos end_ph_pos end_pos");
|
||||
if (disto_on) {
|
||||
fprintf(stream, " disto");
|
||||
}
|
||||
fprintf(stream, "\n");
|
||||
|
||||
for (layno = 0; layno < cstr_info->numlayers; layno++) {
|
||||
for (resno = 0; resno < max_numdecompos + 1; resno++) {
|
||||
for (compno = 0; compno < cstr_info->numcomps; compno++) {
|
||||
int prec_max;
|
||||
if (resno > cstr_info->numdecompos[compno]) {
|
||||
break;
|
||||
}
|
||||
prec_max = cstr_info->tile[tileno].pw[resno] *
|
||||
cstr_info->tile[tileno].ph[resno];
|
||||
for (precno = 0; precno < prec_max; precno++) {
|
||||
start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;
|
||||
end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;
|
||||
end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;
|
||||
disto = cstr_info->tile[tileno].packet[pack_nb].disto;
|
||||
fprintf(stream, "%4d %6d %7d %5d %6d %6d %6d %6d %7d",
|
||||
pack_nb, tileno, layno, resno, compno, precno, start_pos, end_ph_pos, end_pos);
|
||||
if (disto_on) {
|
||||
fprintf(stream, " %8e", disto);
|
||||
}
|
||||
fprintf(stream, "\n");
|
||||
total_disto += disto;
|
||||
pack_nb++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} /* LRCP */
|
||||
|
||||
else if (cstr_info->prog == RLCP) { /* RLCP */
|
||||
fprintf(stream,
|
||||
"RLCP\npack_nb tileno resno layno compno precno start_pos end_ph_pos end_pos\n");
|
||||
if (disto_on) {
|
||||
fprintf(stream, " disto");
|
||||
}
|
||||
fprintf(stream, "\n");
|
||||
|
||||
for (resno = 0; resno < max_numdecompos + 1; resno++) {
|
||||
for (layno = 0; layno < cstr_info->numlayers; layno++) {
|
||||
for (compno = 0; compno < cstr_info->numcomps; compno++) {
|
||||
int prec_max;
|
||||
if (resno > cstr_info->numdecompos[compno]) {
|
||||
break;
|
||||
}
|
||||
prec_max = cstr_info->tile[tileno].pw[resno] *
|
||||
cstr_info->tile[tileno].ph[resno];
|
||||
for (precno = 0; precno < prec_max; precno++) {
|
||||
start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;
|
||||
end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;
|
||||
end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;
|
||||
disto = cstr_info->tile[tileno].packet[pack_nb].disto;
|
||||
fprintf(stream, "%4d %6d %5d %7d %6d %6d %9d %9d %7d",
|
||||
pack_nb, tileno, resno, layno, compno, precno, start_pos, end_ph_pos, end_pos);
|
||||
if (disto_on) {
|
||||
fprintf(stream, " %8e", disto);
|
||||
}
|
||||
fprintf(stream, "\n");
|
||||
total_disto += disto;
|
||||
pack_nb++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} /* RLCP */
|
||||
|
||||
else if (cstr_info->prog == RPCL) { /* RPCL */
|
||||
|
||||
fprintf(stream,
|
||||
"RPCL\npack_nb tileno resno precno compno layno start_pos end_ph_pos end_pos");
|
||||
if (disto_on) {
|
||||
fprintf(stream, " disto");
|
||||
}
|
||||
fprintf(stream, "\n");
|
||||
|
||||
for (resno = 0; resno < max_numdecompos + 1; resno++) {
|
||||
int numprec = cstr_info->tile[tileno].pw[resno] *
|
||||
cstr_info->tile[tileno].ph[resno];
|
||||
for (precno = 0; precno < numprec; precno++) {
|
||||
/* I suppose components have same XRsiz, YRsiz */
|
||||
int x0 = cstr_info->tile_Ox + tileno - (int)floor((float)tileno /
|
||||
(float)cstr_info->tw) * cstr_info->tw * cstr_info->tile_x;
|
||||
int y0 = cstr_info->tile_Ox + (int)floor((float)tileno /
|
||||
(float)cstr_info->tw) * cstr_info->tile_y;
|
||||
int x1 = x0 + cstr_info->tile_x;
|
||||
int y1 = y0 + cstr_info->tile_y;
|
||||
for (compno = 0; compno < cstr_info->numcomps; compno++) {
|
||||
int pcnx = cstr_info->tile[tileno].pw[resno];
|
||||
int pcx = (int) pow(2, cstr_info->tile[tileno].pdx[resno] +
|
||||
cstr_info->numdecompos[compno] - resno);
|
||||
int pcy = (int) pow(2, cstr_info->tile[tileno].pdy[resno] +
|
||||
cstr_info->numdecompos[compno] - resno);
|
||||
int precno_x = precno - (int) floor((float)precno / (float)pcnx) * pcnx;
|
||||
int precno_y = (int) floor((float)precno / (float)pcnx);
|
||||
if (resno > cstr_info->numdecompos[compno]) {
|
||||
break;
|
||||
}
|
||||
for (y = y0; y < y1; y++) {
|
||||
if (precno_y * pcy == y) {
|
||||
for (x = x0; x < x1; x++) {
|
||||
if (precno_x * pcx == x) {
|
||||
for (layno = 0; layno < cstr_info->numlayers; layno++) {
|
||||
start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;
|
||||
end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;
|
||||
end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;
|
||||
disto = cstr_info->tile[tileno].packet[pack_nb].disto;
|
||||
fprintf(stream, "%4d %6d %5d %6d %6d %7d %9d %9d %7d",
|
||||
pack_nb, tileno, resno, precno, compno, layno, start_pos, end_ph_pos, end_pos);
|
||||
if (disto_on) {
|
||||
fprintf(stream, " %8e", disto);
|
||||
}
|
||||
fprintf(stream, "\n");
|
||||
total_disto += disto;
|
||||
pack_nb++;
|
||||
}
|
||||
}
|
||||
}/* x = x0..x1 */
|
||||
}
|
||||
} /* y = y0..y1 */
|
||||
} /* precno */
|
||||
} /* compno */
|
||||
} /* resno */
|
||||
} /* RPCL */
|
||||
|
||||
else if (cstr_info->prog == PCRL) { /* PCRL */
|
||||
/* I suppose components have same XRsiz, YRsiz */
|
||||
int x0 = cstr_info->tile_Ox + tileno - (int)floor((float)tileno /
|
||||
(float)cstr_info->tw) * cstr_info->tw * cstr_info->tile_x;
|
||||
int y0 = cstr_info->tile_Ox + (int)floor((float)tileno /
|
||||
(float)cstr_info->tw) * cstr_info->tile_y;
|
||||
int x1 = x0 + cstr_info->tile_x;
|
||||
int y1 = y0 + cstr_info->tile_y;
|
||||
|
||||
/* Count the maximum number of precincts */
|
||||
int max_numprec = 0;
|
||||
for (resno = 0; resno < max_numdecompos + 1; resno++) {
|
||||
int numprec = cstr_info->tile[tileno].pw[resno] *
|
||||
cstr_info->tile[tileno].ph[resno];
|
||||
if (numprec > max_numprec) {
|
||||
max_numprec = numprec;
|
||||
}
|
||||
}
|
||||
|
||||
fprintf(stream,
|
||||
"PCRL\npack_nb tileno precno compno resno layno start_pos end_ph_pos end_pos");
|
||||
if (disto_on) {
|
||||
fprintf(stream, " disto");
|
||||
}
|
||||
fprintf(stream, "\n");
|
||||
|
||||
for (precno = 0; precno < max_numprec; precno++) {
|
||||
for (compno = 0; compno < cstr_info->numcomps; compno++) {
|
||||
for (resno = 0; resno < cstr_info->numdecompos[compno] + 1; resno++) {
|
||||
int numprec = cstr_info->tile[tileno].pw[resno] *
|
||||
cstr_info->tile[tileno].ph[resno];
|
||||
int pcnx = cstr_info->tile[tileno].pw[resno];
|
||||
int pcx = (int) pow(2, cstr_info->tile[tileno].pdx[resno] +
|
||||
cstr_info->numdecompos[compno] - resno);
|
||||
int pcy = (int) pow(2, cstr_info->tile[tileno].pdy[resno] +
|
||||
cstr_info->numdecompos[compno] - resno);
|
||||
int precno_x = precno - (int) floor((float)precno / (float)pcnx) * pcnx;
|
||||
int precno_y = (int) floor((float)precno / (float)pcnx);
|
||||
if (precno >= numprec) {
|
||||
continue;
|
||||
}
|
||||
for (y = y0; y < y1; y++) {
|
||||
if (precno_y * pcy == y) {
|
||||
for (x = x0; x < x1; x++) {
|
||||
if (precno_x * pcx == x) {
|
||||
for (layno = 0; layno < cstr_info->numlayers; layno++) {
|
||||
start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;
|
||||
end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;
|
||||
end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;
|
||||
disto = cstr_info->tile[tileno].packet[pack_nb].disto;
|
||||
fprintf(stream, "%4d %6d %6d %6d %5d %7d %9d %9d %7d",
|
||||
pack_nb, tileno, precno, compno, resno, layno, start_pos, end_ph_pos, end_pos);
|
||||
if (disto_on) {
|
||||
fprintf(stream, " %8e", disto);
|
||||
}
|
||||
fprintf(stream, "\n");
|
||||
total_disto += disto;
|
||||
pack_nb++;
|
||||
}
|
||||
}
|
||||
}/* x = x0..x1 */
|
||||
}
|
||||
} /* y = y0..y1 */
|
||||
} /* resno */
|
||||
} /* compno */
|
||||
} /* precno */
|
||||
} /* PCRL */
|
||||
|
||||
else { /* CPRL */
|
||||
/* Count the maximum number of precincts */
|
||||
int max_numprec = 0;
|
||||
for (resno = 0; resno < max_numdecompos + 1; resno++) {
|
||||
int numprec = cstr_info->tile[tileno].pw[resno] *
|
||||
cstr_info->tile[tileno].ph[resno];
|
||||
if (numprec > max_numprec) {
|
||||
max_numprec = numprec;
|
||||
}
|
||||
}
|
||||
|
||||
fprintf(stream,
|
||||
"CPRL\npack_nb tileno compno precno resno layno start_pos end_ph_pos end_pos");
|
||||
if (disto_on) {
|
||||
fprintf(stream, " disto");
|
||||
}
|
||||
fprintf(stream, "\n");
|
||||
|
||||
for (compno = 0; compno < cstr_info->numcomps; compno++) {
|
||||
/* I suppose components have same XRsiz, YRsiz */
|
||||
int x0 = cstr_info->tile_Ox + tileno - (int)floor((float)tileno /
|
||||
(float)cstr_info->tw) * cstr_info->tw * cstr_info->tile_x;
|
||||
int y0 = cstr_info->tile_Ox + (int)floor((float)tileno /
|
||||
(float)cstr_info->tw) * cstr_info->tile_y;
|
||||
int x1 = x0 + cstr_info->tile_x;
|
||||
int y1 = y0 + cstr_info->tile_y;
|
||||
|
||||
for (precno = 0; precno < max_numprec; precno++) {
|
||||
for (resno = 0; resno < cstr_info->numdecompos[compno] + 1; resno++) {
|
||||
int numprec = cstr_info->tile[tileno].pw[resno] *
|
||||
cstr_info->tile[tileno].ph[resno];
|
||||
int pcnx = cstr_info->tile[tileno].pw[resno];
|
||||
int pcx = (int) pow(2, cstr_info->tile[tileno].pdx[resno] +
|
||||
cstr_info->numdecompos[compno] - resno);
|
||||
int pcy = (int) pow(2, cstr_info->tile[tileno].pdy[resno] +
|
||||
cstr_info->numdecompos[compno] - resno);
|
||||
int precno_x = precno - (int) floor((float)precno / (float)pcnx) * pcnx;
|
||||
int precno_y = (int) floor((float)precno / (float)pcnx);
|
||||
if (precno >= numprec) {
|
||||
continue;
|
||||
}
|
||||
|
||||
for (y = y0; y < y1; y++) {
|
||||
if (precno_y * pcy == y) {
|
||||
for (x = x0; x < x1; x++) {
|
||||
if (precno_x * pcx == x) {
|
||||
for (layno = 0; layno < cstr_info->numlayers; layno++) {
|
||||
start_pos = cstr_info->tile[tileno].packet[pack_nb].start_pos;
|
||||
end_ph_pos = cstr_info->tile[tileno].packet[pack_nb].end_ph_pos;
|
||||
end_pos = cstr_info->tile[tileno].packet[pack_nb].end_pos;
|
||||
disto = cstr_info->tile[tileno].packet[pack_nb].disto;
|
||||
fprintf(stream, "%4d %6d %6d %6d %5d %7d %9d %9d %7d",
|
||||
pack_nb, tileno, compno, precno, resno, layno, start_pos, end_ph_pos, end_pos);
|
||||
if (disto_on) {
|
||||
fprintf(stream, " %8e", disto);
|
||||
}
|
||||
fprintf(stream, "\n");
|
||||
total_disto += disto;
|
||||
pack_nb++;
|
||||
}
|
||||
}
|
||||
}/* x = x0..x1 */
|
||||
}
|
||||
} /* y = y0..y1 */
|
||||
} /* resno */
|
||||
} /* precno */
|
||||
} /* compno */
|
||||
} /* CPRL */
|
||||
} /* tileno */
|
||||
|
||||
if (disto_on) {
|
||||
fprintf(stream, "%8e\n", cstr_info->D_max); /* SE max */
|
||||
fprintf(stream, "%.8e\n", total_disto); /* SE totale */
|
||||
}
|
||||
/* UniPG>> */
|
||||
/* print the markers' list */
|
||||
if (cstr_info->marknum) {
|
||||
fprintf(stream, "\nMARKER LIST\n");
|
||||
fprintf(stream, "%d\n", cstr_info->marknum);
|
||||
fprintf(stream, "type\tstart_pos length\n");
|
||||
for (x = 0; x < cstr_info->marknum; x++) {
|
||||
fprintf(stream, "%X\t%9d %9d\n", cstr_info->marker[x].type,
|
||||
cstr_info->marker[x].pos, cstr_info->marker[x].len);
|
||||
}
|
||||
}
|
||||
/* <<UniPG */
|
||||
fclose(stream);
|
||||
|
||||
fprintf(stderr, "Generated index file %s\n", index);
|
||||
|
||||
return 0;
|
||||
}
|
|
@ -1,54 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2014, Professor Benoit Macq
|
||||
* Copyright (c) 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 */
|
||||
|
File diff suppressed because it is too large
Load Diff
|
@ -1,900 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2014, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux
|
||||
* Copyright (c) 2003-2014, Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 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 <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
|
||||
#ifdef _WIN32
|
||||
#include "windirent.h"
|
||||
#else
|
||||
#include <dirent.h>
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <strings.h>
|
||||
#define _stricmp strcasecmp
|
||||
#define _strnicmp strncasecmp
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#include "opj_apps_config.h"
|
||||
#include "openjpeg.h"
|
||||
#include "opj_getopt.h"
|
||||
#include "convert.h"
|
||||
#include "index.h"
|
||||
|
||||
#ifdef OPJ_HAVE_LIBLCMS2
|
||||
#include <lcms2.h>
|
||||
#endif
|
||||
#ifdef OPJ_HAVE_LIBLCMS1
|
||||
#include <lcms.h>
|
||||
#endif
|
||||
#include "color.h"
|
||||
|
||||
#include "format_defs.h"
|
||||
|
||||
typedef struct dircnt {
|
||||
/** Buffer for holding images read from Directory*/
|
||||
char *filename_buf;
|
||||
/** Pointer to the buffer*/
|
||||
char **filename;
|
||||
} dircnt_t;
|
||||
|
||||
|
||||
typedef struct img_folder {
|
||||
/** The directory path of the folder containing input images*/
|
||||
char *imgdirpath;
|
||||
/** Output format*/
|
||||
const char *out_format;
|
||||
/** Enable option*/
|
||||
char set_imgdir;
|
||||
/** Enable Cod Format for output*/
|
||||
char set_out_format;
|
||||
|
||||
} img_fol_t;
|
||||
|
||||
void decode_help_display(void)
|
||||
{
|
||||
fprintf(stdout, "HELP for j2k_to_image\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, PNG, 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, PNG, 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", "png", "j2k", "jp2", "jpt", "j2c", "jpc" };
|
||||
static const int format[] = { PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT, TIF_DFMT, RAW_DFMT, TGA_DFMT, PNG_DFMT, J2K_CFMT, JP2_CFMT, JPT_CFMT, J2K_CFMT, J2K_CFMT };
|
||||
char * ext = strrchr(filename, '.');
|
||||
if (ext == NULL) {
|
||||
return -1;
|
||||
}
|
||||
ext++;
|
||||
if (ext) {
|
||||
for (i = 0; i < sizeof(format) / sizeof(*format); i++) {
|
||||
if (_strnicmp(ext, extension[i], 3) == 0) {
|
||||
return format[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
char get_next_file(int imageno, dircnt_t *dirptr, img_fol_t *img_fol,
|
||||
opj_dparameters_t *parameters)
|
||||
{
|
||||
char image_filename[OPJ_PATH_LEN], infilename[OPJ_PATH_LEN],
|
||||
outfilename[OPJ_PATH_LEN], temp_ofname[OPJ_PATH_LEN];
|
||||
char *temp_p, temp1[OPJ_PATH_LEN] = "";
|
||||
|
||||
strcpy(image_filename, dirptr->filename[imageno]);
|
||||
fprintf(stderr, "File Number %d \"%s\"\n", imageno, image_filename);
|
||||
parameters->decod_format = get_file_format(image_filename);
|
||||
if (parameters->decod_format == -1) {
|
||||
return 1;
|
||||
}
|
||||
sprintf(infilename, "%s/%s", img_fol->imgdirpath, image_filename);
|
||||
strncpy(parameters->infile, infilename, sizeof(infilename));
|
||||
|
||||
/*Set output file*/
|
||||
strcpy(temp_ofname, strtok(image_filename, "."));
|
||||
while ((temp_p = strtok(NULL, ".")) != NULL) {
|
||||
strcat(temp_ofname, temp1);
|
||||
sprintf(temp1, ".%s", temp_p);
|
||||
}
|
||||
if (img_fol->set_out_format == 1) {
|
||||
sprintf(outfilename, "%s/%s.%s", img_fol->imgdirpath, temp_ofname,
|
||||
img_fol->out_format);
|
||||
strncpy(parameters->outfile, outfilename, sizeof(outfilename));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
int parse_cmdline_decoder(int argc, char **argv, opj_dparameters_t *parameters,
|
||||
img_fol_t *img_fol, char *indexfilename)
|
||||
{
|
||||
/* parse the command line */
|
||||
int totlen, c;
|
||||
opj_option_t long_option[] = {
|
||||
{"ImgDir", REQ_ARG, NULL, 'y'},
|
||||
{"OutFor", REQ_ARG, NULL, 'O'},
|
||||
};
|
||||
|
||||
const char optlist[] = "i:o:r:l:x:"
|
||||
|
||||
/* UniPG>> */
|
||||
#ifdef USE_JPWL
|
||||
"W:"
|
||||
#endif /* USE_JPWL */
|
||||
/* <<UniPG */
|
||||
"h" ;
|
||||
totlen = sizeof(long_option);
|
||||
img_fol->set_out_format = 0;
|
||||
do {
|
||||
c = opj_getopt_long(argc, argv, optlist, long_option, totlen);
|
||||
if (c == -1) {
|
||||
break;
|
||||
}
|
||||
switch (c) {
|
||||
case 'i': { /* input file */
|
||||
char *infile = opj_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 = opj_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:
|
||||
case PNG_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 = opj_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;
|
||||
case PNG_DFMT:
|
||||
img_fol->out_format = "png";
|
||||
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(opj_optarg, "%d", ¶meters->cp_reduce);
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
|
||||
|
||||
case 'l': { /* layering option */
|
||||
sscanf(opj_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(opj_optarg) + 1);
|
||||
strcpy(img_fol->imgdirpath, opj_optarg);
|
||||
img_fol->set_imgdir = 1;
|
||||
}
|
||||
break;
|
||||
/* ----------------------------------------------------- */
|
||||
case 'x': { /* Creation of index file */
|
||||
char *index = opj_optarg;
|
||||
strncpy(indexfilename, index, OPJ_PATH_LEN);
|
||||
}
|
||||
break;
|
||||
/* ----------------------------------------------------- */
|
||||
/* UniPG>> */
|
||||
#ifdef USE_JPWL
|
||||
|
||||
case 'W': { /* activate JPWL correction */
|
||||
char *token = NULL;
|
||||
|
||||
token = strtok(opj_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 = OPJ_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,
|
||||
opj_optarg);
|
||||
break;
|
||||
}
|
||||
} while (c != -1);
|
||||
|
||||
/* 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, "Example: %s -i image.j2k -o image.pgm\n", argv[0]);
|
||||
fprintf(stderr, " Try: %s -h\n", argv[0]);
|
||||
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_event_mgr_t event_mgr; /* event manager */
|
||||
opj_image_t *image = NULL;
|
||||
FILE *fsrc = NULL;
|
||||
unsigned char *src = NULL;
|
||||
int file_length;
|
||||
int num_images;
|
||||
int i, imageno;
|
||||
dircnt_t *dirptr = NULL;
|
||||
opj_dinfo_t* dinfo = NULL; /* handle to a decompressor */
|
||||
opj_cio_t *cio = NULL;
|
||||
opj_codestream_info_t cstr_info; /* Codestream information structure */
|
||||
char indexfilename[OPJ_PATH_LEN]; /* index file name */
|
||||
|
||||
/* configure the event callbacks (not required) */
|
||||
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
|
||||
event_mgr.error_handler = error_callback;
|
||||
event_mgr.warning_handler = warning_callback;
|
||||
event_mgr.info_handler = info_callback;
|
||||
|
||||
/* 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*/
|
||||
if (!dirptr->filename_buf) {
|
||||
free(dirptr);
|
||||
return 1;
|
||||
}
|
||||
dirptr->filename = (char**) malloc(num_images * sizeof(char*));
|
||||
if (!dirptr->filename) {
|
||||
free(dirptr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
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 1;
|
||||
}
|
||||
if (num_images == 0) {
|
||||
fprintf(stdout, "Folder is empty\n");
|
||||
return 1;
|
||||
}
|
||||
} 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;
|
||||
}
|
||||
fseek(fsrc, 0, SEEK_END);
|
||||
file_length = ftell(fsrc);
|
||||
fseek(fsrc, 0, SEEK_SET);
|
||||
src = (unsigned char *) malloc(file_length);
|
||||
if (fread(src, 1, file_length, fsrc) != (size_t)file_length) {
|
||||
free(src);
|
||||
fclose(fsrc);
|
||||
fprintf(stderr,
|
||||
"\nERROR: fread return a number of element different from the expected.\n");
|
||||
return 1;
|
||||
}
|
||||
fclose(fsrc);
|
||||
|
||||
/* decode the code-stream */
|
||||
/* ---------------------- */
|
||||
|
||||
switch (parameters.decod_format) {
|
||||
case J2K_CFMT: {
|
||||
/* JPEG-2000 codestream */
|
||||
|
||||
/* get a decoder handle */
|
||||
dinfo = opj_create_decompress(CODEC_J2K);
|
||||
|
||||
/* catch events using our callbacks and give a local context */
|
||||
opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, stderr);
|
||||
|
||||
/* setup the decoder decoding parameters using user parameters */
|
||||
opj_setup_decoder(dinfo, ¶meters);
|
||||
|
||||
/* open a byte stream */
|
||||
cio = opj_cio_open((opj_common_ptr)dinfo, src, file_length);
|
||||
|
||||
/* 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 {
|
||||
image = opj_decode(dinfo, cio);
|
||||
}
|
||||
if (!image) {
|
||||
fprintf(stderr, "ERROR -> j2k_to_image: failed to decode image!\n");
|
||||
opj_destroy_decompress(dinfo);
|
||||
opj_cio_close(cio);
|
||||
free(src);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* close the byte stream */
|
||||
opj_cio_close(cio);
|
||||
|
||||
/* Write the index to disk */
|
||||
if (*indexfilename) {
|
||||
opj_bool bSuccess;
|
||||
bSuccess = write_index_file(&cstr_info, indexfilename);
|
||||
if (bSuccess) {
|
||||
fprintf(stderr, "Failed to output index file\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case JP2_CFMT: {
|
||||
/* JPEG 2000 compressed image data */
|
||||
|
||||
/* get a decoder handle */
|
||||
dinfo = opj_create_decompress(CODEC_JP2);
|
||||
|
||||
/* catch events using our callbacks and give a local context */
|
||||
opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, stderr);
|
||||
|
||||
/* setup the decoder decoding parameters using the current image and user parameters */
|
||||
opj_setup_decoder(dinfo, ¶meters);
|
||||
|
||||
/* open a byte stream */
|
||||
cio = opj_cio_open((opj_common_ptr)dinfo, src, file_length);
|
||||
|
||||
/* 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 {
|
||||
image = opj_decode(dinfo, cio);
|
||||
}
|
||||
if (!image) {
|
||||
fprintf(stderr, "ERROR -> j2k_to_image: failed to decode image!\n");
|
||||
opj_destroy_decompress(dinfo);
|
||||
opj_cio_close(cio);
|
||||
free(src);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* close the byte stream */
|
||||
opj_cio_close(cio);
|
||||
|
||||
/* Write the index to disk */
|
||||
if (*indexfilename) {
|
||||
opj_bool bSuccess;
|
||||
bSuccess = write_index_file(&cstr_info, indexfilename);
|
||||
if (bSuccess) {
|
||||
fprintf(stderr, "Failed to output index file\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case JPT_CFMT: {
|
||||
/* JPEG 2000, JPIP */
|
||||
|
||||
/* get a decoder handle */
|
||||
dinfo = opj_create_decompress(CODEC_JPT);
|
||||
|
||||
/* catch events using our callbacks and give a local context */
|
||||
opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, stderr);
|
||||
|
||||
/* setup the decoder decoding parameters using user parameters */
|
||||
opj_setup_decoder(dinfo, ¶meters);
|
||||
|
||||
/* open a byte stream */
|
||||
cio = opj_cio_open((opj_common_ptr)dinfo, src, file_length);
|
||||
|
||||
/* 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 {
|
||||
image = opj_decode(dinfo, cio);
|
||||
}
|
||||
if (!image) {
|
||||
fprintf(stderr, "ERROR -> j2k_to_image: failed to decode image!\n");
|
||||
opj_destroy_decompress(dinfo);
|
||||
opj_cio_close(cio);
|
||||
free(src);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* close the byte stream */
|
||||
opj_cio_close(cio);
|
||||
|
||||
/* Write the index to disk */
|
||||
if (*indexfilename) {
|
||||
opj_bool bSuccess;
|
||||
bSuccess = write_index_file(&cstr_info, indexfilename);
|
||||
if (bSuccess) {
|
||||
fprintf(stderr, "Failed to output index file\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
fprintf(stderr, "skipping file..\n");
|
||||
continue;
|
||||
}
|
||||
|
||||
/* free the memory containing the code-stream */
|
||||
free(src);
|
||||
src = NULL;
|
||||
|
||||
if (image->color_space == CLRSPC_SYCC) {
|
||||
color_sycc_to_rgb(image);
|
||||
}
|
||||
|
||||
if (image->icc_profile_buf) {
|
||||
#if defined(OPJ_HAVE_LIBLCMS1) || defined(OPJ_HAVE_LIBLCMS2)
|
||||
color_apply_icc_profile(image);
|
||||
#endif
|
||||
|
||||
free(image->icc_profile_buf);
|
||||
image->icc_profile_buf = NULL;
|
||||
image->icc_profile_len = 0;
|
||||
}
|
||||
|
||||
/* 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;
|
||||
#ifdef OPJ_HAVE_LIBTIFF
|
||||
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;
|
||||
#endif /* OPJ_HAVE_LIBTIFF */
|
||||
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;
|
||||
#ifdef OPJ_HAVE_LIBPNG
|
||||
case PNG_DFMT: /* PNG */
|
||||
if (imagetopng(image, parameters.outfile)) {
|
||||
fprintf(stdout, "Error generating png file. Outfile %s not generated\n",
|
||||
parameters.outfile);
|
||||
} else {
|
||||
fprintf(stdout, "Successfully generated Outfile %s\n", parameters.outfile);
|
||||
}
|
||||
break;
|
||||
#endif /* OPJ_HAVE_LIBPNG */
|
||||
/* Can happen if output file is TIFF or PNG
|
||||
* and OPJ_HAVE_LIBTIF or OPJ_HAVE_LIBPNG is undefined
|
||||
*/
|
||||
default:
|
||||
fprintf(stderr, "Outfile %s not generated\n", parameters.outfile);
|
||||
}
|
||||
|
||||
/* free remaining structures */
|
||||
if (dinfo) {
|
||||
opj_destroy_decompress(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*/
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,680 +0,0 @@
|
|||
|
||||
/*
|
||||
* uce-dirent.h - operating system independent dirent implementation
|
||||
*
|
||||
* Copyright (C) 1998-2002 Toni Ronkko
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* ``Software''), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sublicense, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included
|
||||
* in all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
* IN NO EVENT SHALL TONI RONKKO BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
*
|
||||
* May 28 1998, Toni Ronkko <tronkko@messi.uku.fi>
|
||||
*
|
||||
* $Id: uce-dirent.h,v 1.7 2002/05/13 10:48:35 tr Exp $
|
||||
*
|
||||
* $Log: uce-dirent.h,v $
|
||||
* Revision 1.7 2002/05/13 10:48:35 tr
|
||||
* embedded some source code directly to the header so that no source
|
||||
* modules need to be included in the MS Visual C project using the
|
||||
* interface, removed all the dependencies to other headers of the `uce'
|
||||
* library so that the header can be made public
|
||||
*
|
||||
* Revision 1.6 2002/04/12 16:22:04 tr
|
||||
* Unified Compiling Environment (UCE) replaced `std' library
|
||||
*
|
||||
* Revision 1.5 2001/07/20 16:33:40 tr
|
||||
* moved to `std' library and re-named defines accordingly
|
||||
*
|
||||
* Revision 1.4 2001/07/10 16:47:18 tronkko
|
||||
* revised comments
|
||||
*
|
||||
* Revision 1.3 2001/01/11 13:16:43 tr
|
||||
* using ``uce-machine.h'' for finding out defines such as `FREEBSD'
|
||||
*
|
||||
* Revision 1.2 2000/10/08 16:00:41 tr
|
||||
* copy of FreeBSD man page
|
||||
*
|
||||
* Revision 1.1 2000/07/10 05:53:16 tr
|
||||
* Initial revision
|
||||
*
|
||||
* Revision 1.2 1998/07/19 18:29:14 tr
|
||||
* Added error reporting capabilities and some asserts.
|
||||
*
|
||||
* Revision 1.1 1998/07/04 16:27:51 tr
|
||||
* Initial revision
|
||||
*
|
||||
*
|
||||
* MSVC 1.0 scans automatic dependencies incorrectly when your project
|
||||
* contains this very header. The problem is that MSVC cannot handle
|
||||
* include directives inside #if..#endif block those are never entered.
|
||||
* Since this header ought to compile in many different operating systems,
|
||||
* there had to be several conditional blocks that are compiled only in
|
||||
* operating systems for what they were designed for. MSVC 1.0 cannot
|
||||
* handle inclusion of sys/dir.h in a part that is compiled only in Apollo
|
||||
* operating system. To fix the problem you need to insert DIR.H into
|
||||
* SYSINCL.DAT located in MSVC\BIN directory and restart visual C++.
|
||||
* Consult manuals for more informaton about the problem.
|
||||
*
|
||||
* Since many UNIX systems have dirent.h we assume to have one also.
|
||||
* However, if your UNIX system does not have dirent.h you can download one
|
||||
* for example at: http://ftp.uni-mannheim.de/ftp/GNU/dirent/dirent.tar.gz.
|
||||
* You can also see if you have one of dirent.h, direct.h, dir.h, ndir.h,
|
||||
* sys/dir.h and sys/ndir.h somewhere. Try defining HAVE_DIRENT_H,
|
||||
* HAVE_DIRECT_H, HAVE_DIR_H, HAVE_NDIR_H, HAVE_SYS_DIR_H and
|
||||
* HAVE_SYS_NDIR_H according to the files found.
|
||||
*/
|
||||
#ifndef DIRENT_H
|
||||
#define DIRENT_H
|
||||
#define DIRENT_H_INCLUDED
|
||||
|
||||
/* find out platform */
|
||||
#if defined(MSDOS) /* MS-DOS */
|
||||
#elif defined(__MSDOS__) /* Turbo C/Borland */
|
||||
# define MSDOS
|
||||
#elif defined(__DOS__) /* Watcom */
|
||||
# define MSDOS
|
||||
#endif
|
||||
|
||||
#if defined(WIN32) /* MS-Windows */
|
||||
#elif defined(__NT__) /* Watcom */
|
||||
# define WIN32
|
||||
#elif defined(_WIN32) /* Microsoft */
|
||||
# define WIN32
|
||||
#elif defined(__WIN32__) /* Borland */
|
||||
# define WIN32
|
||||
#endif
|
||||
|
||||
/*
|
||||
* See what kind of dirent interface we have unless autoconf has already
|
||||
* determinated that.
|
||||
*/
|
||||
#if !defined(HAVE_DIRENT_H) && !defined(HAVE_DIRECT_H) && !defined(HAVE_SYS_DIR_H) && !defined(HAVE_NDIR_H) && !defined(HAVE_SYS_NDIR_H) && !defined(HAVE_DIR_H)
|
||||
# if defined(_MSC_VER) /* Microsoft C/C++ */
|
||||
/* no dirent.h */
|
||||
# elif defined(__MINGW32__) /* MinGW */
|
||||
/* no dirent.h */
|
||||
# elif defined(__BORLANDC__) /* Borland C/C++ */
|
||||
# define HAVE_DIRENT_H
|
||||
# define VOID_CLOSEDIR
|
||||
# elif defined(__TURBOC__) /* Borland Turbo C */
|
||||
/* no dirent.h */
|
||||
# elif defined(__WATCOMC__) /* Watcom C/C++ */
|
||||
# define HAVE_DIRECT_H
|
||||
# elif defined(__apollo) /* Apollo */
|
||||
# define HAVE_SYS_DIR_H
|
||||
# elif defined(__hpux) /* HP-UX */
|
||||
# define HAVE_DIRENT_H
|
||||
# elif (defined(__alpha) || defined(__alpha__)) && !defined(__linux__) /* Alpha OSF1 */
|
||||
# error "not implemented"
|
||||
# elif defined(__sgi) /* Silicon Graphics */
|
||||
# define HAVE_DIRENT_H
|
||||
# elif defined(sun) || defined(__sun) /* Sun Solaris */
|
||||
# define HAVE_DIRENT_H
|
||||
# elif defined(__FreeBSD__) /* FreeBSD */
|
||||
# define HAVE_DIRENT_H
|
||||
# elif defined(__linux__) /* Linux */
|
||||
# define HAVE_DIRENT_H
|
||||
# elif defined(__GNUC__) /* GNU C/C++ */
|
||||
# define HAVE_DIRENT_H
|
||||
# else
|
||||
# error "not implemented"
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* include proper interface headers */
|
||||
#if defined(HAVE_DIRENT_H)
|
||||
# include <dirent.h>
|
||||
# ifdef FREEBSD
|
||||
# define NAMLEN(dp) ((int)((dp)->d_namlen))
|
||||
# else
|
||||
# define NAMLEN(dp) ((int)(strlen((dp)->d_name)))
|
||||
# endif
|
||||
|
||||
#elif defined(HAVE_NDIR_H)
|
||||
# include <ndir.h>
|
||||
# define NAMLEN(dp) ((int)((dp)->d_namlen))
|
||||
|
||||
#elif defined(HAVE_SYS_NDIR_H)
|
||||
# include <sys/ndir.h>
|
||||
# define NAMLEN(dp) ((int)((dp)->d_namlen))
|
||||
|
||||
#elif defined(HAVE_DIRECT_H)
|
||||
# include <direct.h>
|
||||
# define NAMLEN(dp) ((int)((dp)->d_namlen))
|
||||
|
||||
#elif defined(HAVE_DIR_H)
|
||||
# include <dir.h>
|
||||
# define NAMLEN(dp) ((int)((dp)->d_namlen))
|
||||
|
||||
#elif defined(HAVE_SYS_DIR_H)
|
||||
# include <sys/types.h>
|
||||
# include <sys/dir.h>
|
||||
# ifndef dirent
|
||||
# define dirent direct
|
||||
# endif
|
||||
# define NAMLEN(dp) ((int)((dp)->d_namlen))
|
||||
|
||||
#elif defined(MSDOS) || defined(WIN32)
|
||||
|
||||
/* figure out type of underlaying directory interface to be used */
|
||||
# if defined(WIN32)
|
||||
# define DIRENT_WIN32_INTERFACE
|
||||
# elif defined(MSDOS)
|
||||
# define DIRENT_MSDOS_INTERFACE
|
||||
# else
|
||||
# error "missing native dirent interface"
|
||||
# endif
|
||||
|
||||
/*** WIN32 specifics ***/
|
||||
# if defined(DIRENT_WIN32_INTERFACE)
|
||||
# include <windows.h>
|
||||
# if !defined(DIRENT_MAXNAMLEN)
|
||||
# define DIRENT_MAXNAMLEN (MAX_PATH)
|
||||
# endif
|
||||
|
||||
|
||||
/*** MS-DOS specifics ***/
|
||||
# elif defined(DIRENT_MSDOS_INTERFACE)
|
||||
# include <dos.h>
|
||||
|
||||
/* Borland defines file length macros in dir.h */
|
||||
# if defined(__BORLANDC__)
|
||||
# include <dir.h>
|
||||
# if !defined(DIRENT_MAXNAMLEN)
|
||||
# define DIRENT_MAXNAMLEN ((MAXFILE)+(MAXEXT))
|
||||
# endif
|
||||
# if !defined(_find_t)
|
||||
# define _find_t find_t
|
||||
# endif
|
||||
|
||||
/* Turbo C defines ffblk structure in dir.h */
|
||||
# elif defined(__TURBOC__)
|
||||
# include <dir.h>
|
||||
# if !defined(DIRENT_MAXNAMLEN)
|
||||
# define DIRENT_MAXNAMLEN ((MAXFILE)+(MAXEXT))
|
||||
# endif
|
||||
# define DIRENT_USE_FFBLK
|
||||
|
||||
/* MSVC */
|
||||
# elif defined(_MSC_VER)
|
||||
# if !defined(DIRENT_MAXNAMLEN)
|
||||
# define DIRENT_MAXNAMLEN (12)
|
||||
# endif
|
||||
|
||||
/* Watcom */
|
||||
# elif defined(__WATCOMC__)
|
||||
# if !defined(DIRENT_MAXNAMLEN)
|
||||
# if defined(__OS2__) || defined(__NT__)
|
||||
# define DIRENT_MAXNAMLEN (255)
|
||||
# else
|
||||
# define DIRENT_MAXNAMLEN (12)
|
||||
# endif
|
||||
# endif
|
||||
|
||||
# endif
|
||||
# endif
|
||||
|
||||
/*** generic MS-DOS and MS-Windows stuff ***/
|
||||
# if !defined(NAME_MAX) && defined(DIRENT_MAXNAMLEN)
|
||||
# define NAME_MAX DIRENT_MAXNAMLEN
|
||||
# endif
|
||||
# if NAME_MAX < DIRENT_MAXNAMLEN
|
||||
# error "assertion failed: NAME_MAX >= DIRENT_MAXNAMLEN"
|
||||
# endif
|
||||
|
||||
|
||||
/*
|
||||
* Substitute for real dirent structure. Note that `d_name' field is a
|
||||
* true character array although we have it copied in the implementation
|
||||
* dependent data. We could save some memory if we had declared `d_name'
|
||||
* as a pointer referring 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 although
|
||||
* 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 occurred */
|
||||
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*/
|
|
@ -1,47 +0,0 @@
|
|||
# Makefile for the MJ2 codecs of the OpenJPEG library: frames_to_mj2, mj2_to_frames, extract_j2k_from_mj2 and wrap_j2k_in_mj2
|
||||
|
||||
set(common_SRCS ${OPENJPEG_SOURCE_DIR}/src/bin/common/opj_getopt.c)
|
||||
|
||||
if(WIN32)
|
||||
if(BUILD_SHARED_LIBS)
|
||||
add_definitions(-DOPJ_EXPORTS)
|
||||
else()
|
||||
add_definitions(-DOPJ_STATIC)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# Headers file are located here:
|
||||
include_directories(
|
||||
${OPENJPEG_BINARY_DIR}/src/lib/openjp2 # opj_config.h
|
||||
${OPENJPEG_BINARY_DIR}/src/bin/common # opj_apps_config.h
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2
|
||||
${OPENJPEG_SOURCE_DIR}/src/bin/common
|
||||
${LCMS_INCLUDE_DIRNAME}
|
||||
)
|
||||
|
||||
foreach(exe
|
||||
opj_mj2_wrap
|
||||
opj_mj2_extract
|
||||
opj_mj2_decompress
|
||||
opj_mj2_compress
|
||||
)
|
||||
add_definitions(-DOPJ_USE_LEGACY)
|
||||
add_executable(${exe}
|
||||
${exe}.c
|
||||
${common_SRCS}
|
||||
${MJ2_SRCS}
|
||||
${OPENJPEG_SOURCE_DIR}/src/bin/common/color.c
|
||||
)
|
||||
set_property(
|
||||
TARGET ${exe}
|
||||
APPEND PROPERTY COMPILE_DEFINITIONS USE_MJ2
|
||||
)
|
||||
target_link_libraries(${exe} ${LCMS_LIBNAME} openmj2)
|
||||
|
||||
if(UNIX)
|
||||
target_link_libraries(${exe} m)
|
||||
endif()
|
||||
|
||||
install(TARGETS ${exe}
|
||||
DESTINATION ${OPENJPEG_INSTALL_BIN_DIR})
|
||||
endforeach()
|
File diff suppressed because it is too large
Load Diff
|
@ -1,14 +0,0 @@
|
|||
/* meta_out.h */
|
||||
/* Dump MJ2, JP2 metadata (partial so far) to xml file */
|
||||
/* Callable from mj2_to_metadata */
|
||||
/* Contributed to Open JPEG by Glenn Pearson, U.S. National Library of Medicine */
|
||||
|
||||
#define BOOL int
|
||||
#define FALSE 0
|
||||
#define TRUE 1
|
||||
|
||||
void xml_write_init(BOOL n, BOOL t, BOOL r, BOOL d);
|
||||
|
||||
int xml_write_struct(FILE *file, FILE *xmlout, opj_mj2_t * movie,
|
||||
unsigned int sampleframe, char* stringDTD, opj_event_mgr_t *event_mgr);
|
||||
|
|
@ -1,350 +0,0 @@
|
|||
/* mj2_to_metadata.c */
|
||||
/* Dump MJ2, JP2 metadata (partial so far) to xml file */
|
||||
/* Contributed to Open JPEG by Glenn Pearson, contract software developer, U.S. National Library of Medicine.
|
||||
|
||||
The base code in this file was developed by the author as part of a video archiving
|
||||
project for the U.S. National Library of Medicine, Bethesda, MD.
|
||||
It is the policy of NLM (and U.S. government) to not assert copyright.
|
||||
|
||||
A non-exclusive copy of this code has been contributed to the Open JPEG project.
|
||||
Except for copyright, inclusion of the code within Open JPEG for distribution and use
|
||||
can be bound by the Open JPEG open-source license and disclaimer, expressed elsewhere.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
#include "mj2.h"
|
||||
|
||||
#include "mj2_to_metadata.h"
|
||||
#include <string.h>
|
||||
#include "opj_getopt.h"
|
||||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
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);
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
|
||||
|
||||
/* ------------- */
|
||||
|
||||
void help_display()
|
||||
{
|
||||
/* "1234567890123456789012345678901234567890123456789012345678901234567890123456789" */
|
||||
fprintf(stdout, " Help for the 'mj2_to_metadata' Program\n");
|
||||
fprintf(stdout, " ======================================\n");
|
||||
fprintf(stdout, "The -h option displays this information on screen.\n\n");
|
||||
|
||||
fprintf(stdout,
|
||||
"mj2_to_metadata generates an XML file from a Motion JPEG 2000 file.\n");
|
||||
fprintf(stdout,
|
||||
"The generated XML shows the structural, but not (yet) curatorial,\n");
|
||||
fprintf(stdout,
|
||||
"metadata from the movie header and from the JPEG 2000 image and tile\n");
|
||||
fprintf(stdout,
|
||||
"headers of a sample frame. Excluded: low-level packed-bits image data.\n\n");
|
||||
|
||||
fprintf(stdout, "By Default\n");
|
||||
fprintf(stdout, "----------\n");
|
||||
fprintf(stdout,
|
||||
"The metadata includes the jp2 image and tile headers of the first frame.\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout,
|
||||
"Metadata values are shown in 'raw' form (e.g., hexadecimal) as stored in the\n");
|
||||
fprintf(stdout,
|
||||
"file, and, if apt, in a 'derived' form that is more quickly grasped.\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout,
|
||||
"Notes explaining the XML are embedded as terse comments. These include\n");
|
||||
fprintf(stdout, " meaning of non-obvious tag abbreviations;\n");
|
||||
fprintf(stdout, " range and precision of valid values;\n");
|
||||
fprintf(stdout, " interpretations of values, such as enumerations; and\n");
|
||||
fprintf(stdout, " current implementation limitations.\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout,
|
||||
"The sample-size and chunk-offset tables, each with 1 row per frame, are not reported.\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout,
|
||||
"The file is self-contained and no verification (e.g., against a DTD) is requested.\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "Required Parameters (except with -h)\n");
|
||||
fprintf(stdout, "------------------------------------\n");
|
||||
fprintf(stdout,
|
||||
"[Caution: file strings that contain spaces should be wrapped with quotes.]\n");
|
||||
fprintf(stdout,
|
||||
"-i input.mj2 : where 'input' is any source file name or path.\n");
|
||||
fprintf(stdout,
|
||||
" MJ2 files created with 'frames_to_mj2' are supported so far.\n");
|
||||
fprintf(stdout,
|
||||
" These are silent, single-track, 'MJ2 Simple Profile' videos.\n");
|
||||
fprintf(stdout,
|
||||
"-o output.xml : where 'output' is any destination file name or path.\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "Optional Parameters\n");
|
||||
fprintf(stdout, "-------------------\n");
|
||||
fprintf(stdout, "-h : Display this help information.\n");
|
||||
fprintf(stdout, "-n : Suppress all mj2_to_metadata notes.\n");
|
||||
fprintf(stdout,
|
||||
"-t : Include sample-size and chunk-offset tables.\n");
|
||||
fprintf(stdout,
|
||||
"-f n : where n > 0. Include jp2 header info for frame n [default=1].\n");
|
||||
fprintf(stdout, "-f 0 : No jp2 header info.\n");
|
||||
fprintf(stdout,
|
||||
"-r : Suppress all 'raw' data for which a 'derived' form exists.\n");
|
||||
fprintf(stdout, "-d : Suppress all 'derived' data.\n");
|
||||
fprintf(stdout,
|
||||
" (If both -r and -d given, -r will be ignored.)\n");
|
||||
fprintf(stdout,
|
||||
"-v string : Verify against the DTD file located by the string.\n");
|
||||
fprintf(stdout,
|
||||
" Prepend quoted 'string' with either SYSTEM or PUBLIC keyword.\n");
|
||||
fprintf(stdout,
|
||||
" Thus, for the distributed DTD placed in the same directory as\n");
|
||||
fprintf(stdout,
|
||||
" the output file: -v \"SYSTEM mj2_to_metadata.dtd\"\n");
|
||||
fprintf(stdout,
|
||||
" \"PUBLIC\" is used with an access protocol (e.g., http:) + URL.\n");
|
||||
/* More to come */
|
||||
fprintf(stdout, "\n");
|
||||
/* "1234567890123456789012345678901234567890123456789012345678901234567890123456789" */
|
||||
}
|
||||
|
||||
/* ------------- */
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
|
||||
opj_dinfo_t* dinfo;
|
||||
opj_event_mgr_t event_mgr; /* event manager */
|
||||
|
||||
FILE *file, *xmlout;
|
||||
/* char xmloutname[50]; */
|
||||
opj_mj2_t *movie;
|
||||
|
||||
char* infile = 0;
|
||||
char* outfile = 0;
|
||||
char* s, S1, S2, S3;
|
||||
int len;
|
||||
unsigned int sampleframe = 1; /* First frame */
|
||||
char* stringDTD = NULL;
|
||||
BOOL notes = TRUE;
|
||||
BOOL sampletables = FALSE;
|
||||
BOOL raw = TRUE;
|
||||
BOOL derived = TRUE;
|
||||
mj2_dparameters_t parameters;
|
||||
|
||||
while (TRUE) {
|
||||
/* ':' after letter means it takes an argument */
|
||||
int c = getopt(argc, argv, "i:o:f:v:hntrd");
|
||||
/* FUTURE: Reserve 'p' for pruning file (which will probably make -t redundant) */
|
||||
if (c == -1) {
|
||||
break;
|
||||
}
|
||||
switch (c) {
|
||||
case 'i': /* IN file */
|
||||
infile = optarg;
|
||||
s = optarg;
|
||||
while (*s) {
|
||||
s++; /* Run to filename end */
|
||||
}
|
||||
s--;
|
||||
S3 = *s;
|
||||
s--;
|
||||
S2 = *s;
|
||||
s--;
|
||||
S1 = *s;
|
||||
|
||||
if ((S1 == 'm' && S2 == 'j' && S3 == '2')
|
||||
|| (S1 == 'M' && S2 == 'J' && S3 == '2')) {
|
||||
break;
|
||||
}
|
||||
fprintf(stderr, "Input file name must have .mj2 extension, not .%c%c%c.\n", S1,
|
||||
S2, S3);
|
||||
return 1;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
case 'o': /* OUT file */
|
||||
outfile = optarg;
|
||||
while (*outfile) {
|
||||
outfile++; /* Run to filename end */
|
||||
}
|
||||
outfile--;
|
||||
S3 = *outfile;
|
||||
outfile--;
|
||||
S2 = *outfile;
|
||||
outfile--;
|
||||
S1 = *outfile;
|
||||
|
||||
outfile = optarg;
|
||||
|
||||
if ((S1 == 'x' && S2 == 'm' && S3 == 'l')
|
||||
|| (S1 == 'X' && S2 == 'M' && S3 == 'L')) {
|
||||
break;
|
||||
}
|
||||
|
||||
fprintf(stderr,
|
||||
"Output file name must have .xml extension, not .%c%c%c\n", S1, S2, S3);
|
||||
return 1;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
case 'f': /* Choose sample frame. 0 = none */
|
||||
sscanf(optarg, "%u", &sampleframe);
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
case 'v': /* Verification by DTD. */
|
||||
stringDTD = optarg;
|
||||
/* We will not insist upon last 3 chars being "dtd", since non-file
|
||||
access protocol may be used. */
|
||||
if (strchr(stringDTD, '"') != NULL) {
|
||||
fprintf(stderr,
|
||||
"-D's string must not contain any embedded double-quote characters.\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (strncmp(stringDTD, "PUBLIC ", 7) == 0 ||
|
||||
strncmp(stringDTD, "SYSTEM ", 7) == 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
fprintf(stderr, "-D's string must start with \"PUBLIC \" or \"SYSTEM \"\n");
|
||||
return 1;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
case 'n': /* Suppress comments */
|
||||
notes = FALSE;
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
case 't': /* Show sample size and chunk offset tables */
|
||||
sampletables = TRUE;
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
case 'h': /* Display an help description */
|
||||
help_display();
|
||||
return 0;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
case 'r': /* Suppress raw data */
|
||||
raw = FALSE;
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
case 'd': /* Suppress derived data */
|
||||
derived = FALSE;
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
default:
|
||||
return 1;
|
||||
} /* switch */
|
||||
} /* while */
|
||||
|
||||
if (!raw && !derived) {
|
||||
raw = TRUE; /* At least one of 'raw' and 'derived' must be true */
|
||||
}
|
||||
|
||||
/* Error messages */
|
||||
/* -------------- */
|
||||
if (!infile || !outfile) {
|
||||
fprintf(stderr,
|
||||
"Correct usage: mj2_to_metadata -i mj2-file -o xml-file (plus options)\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* was:
|
||||
if (argc != 3) {
|
||||
printf("Bad syntax: Usage: MJ2_to_metadata inputfile.mj2 outputfile.xml\n");
|
||||
printf("Example: MJ2_to_metadata foreman.mj2 foreman.xml\n");
|
||||
return 1;
|
||||
}
|
||||
*/
|
||||
len = strlen(infile);
|
||||
if (infile[0] == ' ') {
|
||||
infile++; /* There may be a leading blank if user put space after -i */
|
||||
}
|
||||
|
||||
file = fopen(infile, "rb"); /* was: argv[1] */
|
||||
|
||||
if (!file) {
|
||||
fprintf(stderr, "Failed to open %s for reading.\n", infile); /* was: argv[1] */
|
||||
return 1;
|
||||
}
|
||||
|
||||
len = strlen(outfile);
|
||||
if (outfile[0] == ' ') {
|
||||
outfile++; /* There may be a leading blank if user put space after -o */
|
||||
}
|
||||
|
||||
// Checking output file
|
||||
xmlout = fopen(outfile, "w"); /* was: argv[2] */
|
||||
if (!xmlout) {
|
||||
fprintf(stderr, "Failed to open %s for writing.\n", outfile); /* was: argv[2] */
|
||||
fclose(file);
|
||||
return 1;
|
||||
}
|
||||
// Leave it open
|
||||
|
||||
/*
|
||||
configure the event callbacks (not required)
|
||||
setting of each callback is optional
|
||||
*/
|
||||
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
|
||||
event_mgr.error_handler = error_callback;
|
||||
event_mgr.warning_handler = warning_callback;
|
||||
event_mgr.info_handler = info_callback;
|
||||
|
||||
/* get a MJ2 decompressor handle */
|
||||
dinfo = mj2_create_decompress();
|
||||
|
||||
/* catch events using our callbacks and give a local context */
|
||||
opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, stderr);
|
||||
|
||||
/* setup the decoder decoding parameters using user parameters */
|
||||
movie = (opj_mj2_t*) dinfo->mj2_handle;
|
||||
mj2_setup_decoder(dinfo->mj2_handle, ¶meters);
|
||||
|
||||
if (mj2_read_struct(file, movie)) { // Creating the movie structure
|
||||
fclose(xmlout);
|
||||
return 1;
|
||||
}
|
||||
|
||||
xml_write_init(notes, sampletables, raw, derived);
|
||||
xml_write_struct(file, xmlout, movie, sampleframe, stringDTD, &event_mgr);
|
||||
fclose(xmlout);
|
||||
|
||||
fprintf(stderr, "Metadata correctly extracted to XML file \n");;
|
||||
|
||||
/* free remaining structures */
|
||||
if (dinfo) {
|
||||
mj2_destroy_decompress((opj_mj2_t*)dinfo->mj2_handle);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1,425 +0,0 @@
|
|||
<!--
|
||||
Preliminary DTD for Open JPEG "mj2_to_metadata" function.
|
||||
Last revised: April 20, 2005
|
||||
Author: Glenn Pearson, at U.S. National Library of Medicine.
|
||||
See mj2_to_metadata.c regarding copyright, license, disclaimer status.
|
||||
|
||||
While the vocabulary of this DTD is based on the relevant portions of the
|
||||
ISO/IEC JPEG 200 standard, the detailed representation is the author's own.
|
||||
It is neither an ISO/IEC nor NLM official or consensus representation.
|
||||
Furthermore, it deviates from a pure representation of the ISO/IEC standard
|
||||
in these aspects:
|
||||
|
||||
- it is incomplete in a number of ways (which to some extent may be
|
||||
addressed over time);
|
||||
- it has extensions for "derived" data and "statistics";
|
||||
- it is more flexible. That is, some elements are marked as optional
|
||||
not because they are optional in an MJ2 file, but because reporting
|
||||
of them is optional based on current or projected mj2_to_metadata
|
||||
command-line flags.
|
||||
-->
|
||||
<!ELEMENT MJ2_File (JP2?, FileType?, MovieBox?)>
|
||||
<!ELEMENT JP2 EMPTY>
|
||||
<!ATTLIST JP2 BoxType CDATA #FIXED "jP[space][space]">
|
||||
<!ATTLIST JP2 Signature CDATA #FIXED "0x0d0a870a">
|
||||
<!ELEMENT FileType (Brand, MinorVersion, CompatibilityList)>
|
||||
<!ATTLIST FileType BoxType CDATA #FIXED "ftyp">
|
||||
<!ELEMENT Brand (#PCDATA)> <!-- 4 characters max -->
|
||||
<!ELEMENT MinorVersion (#PCDATA)> <!-- 4 chararcters max -->
|
||||
<!ELEMENT CompatibilityList (CompatibleBrand)*>
|
||||
<!ATTLIST CompatibilityList Count CDATA #REQUIRED> <!-- Count >= 0 -->
|
||||
<!ELEMENT CompatibleBrand (#PCDATA)> <!-- 4 characters max -->
|
||||
<!ELEMENT MovieBox (MovieHeader, Statistics?, Track*)>
|
||||
<!ATTLIST MovieBox BoxType CDATA #FIXED "moov">
|
||||
<!ELEMENT MovieHeader (CreationTime, ModificationTime, Timescale, Rate, Duration, Volume, TransformationMatrix)>
|
||||
<!ATTLIST MovieHeader BoxType CDATA #FIXED "mvhd">
|
||||
<!ELEMENT CreationTime (InSeconds?,AsLocalTime?)>
|
||||
<!ELEMENT InSeconds (#PCDATA)>
|
||||
<!ELEMENT AsLocalTime (#PCDATA)>
|
||||
<!ELEMENT ModificationTime (InSeconds?,AsLocalTime?)>
|
||||
<!ELEMENT Timescale (#PCDATA)> <!-- Timescale defines time units in one second -->
|
||||
<!ELEMENT Rate (AsHex | (AsHex, AsDecimal) | AsDecimal)> <!-- Decimal is Approximation; Optional on input. -->
|
||||
<!ELEMENT AsHex (#PCDATA)>
|
||||
<!ELEMENT AsDecimal (#PCDATA)>
|
||||
<!ELEMENT Duration (InTimeUnits | (InTimeUnits, InSeconds) | InSeconds)> <!-- InSeconds Optional on input. -->
|
||||
<!ELEMENT InTimeUnits (#PCDATA)>
|
||||
<!ELEMENT Volume (AsHex | (AsHex, AsDecimal) | AsDecimal)> <!-- hex default = 0x0100 -->
|
||||
<!-- Fixed 8.8 value of audio volume. Full, normal value is 1.0 (0x0100) -->
|
||||
<!ELEMENT TransformationMatrix (TMa,TMb,TMu,TMc,TMd,TMv,TMx,TMy,TMw)> <!-- for video -->
|
||||
<!-- 3 x 3 Video Transformation Matrix {a,b,u,c,d,v,x,y,w}. Required: u=0, v=0, w=1 -->
|
||||
<!-- Maps decompressed point (p,q) to rendered point (ap + cq + x, bp + dq + y) -->
|
||||
<!-- Stored as Fixed Point Hex: all are 16.16, except u,v,w are 2.30 -->
|
||||
<!-- Unity = 0x00010000,0,0,0,0x00010000,0,0,0,0x40000000 -->
|
||||
<!ELEMENT TMa (#PCDATA)>
|
||||
<!ELEMENT TMb (#PCDATA)>
|
||||
<!ELEMENT TMu (#PCDATA)> <!--Always "0x00000000" -->
|
||||
<!ELEMENT TMc (#PCDATA)>
|
||||
<!ELEMENT TMd (#PCDATA)>
|
||||
<!ELEMENT TMv (#PCDATA)> <!--Always "0x00000000" -->
|
||||
<!ELEMENT TMx (#PCDATA)>
|
||||
<!ELEMENT TMy (#PCDATA)>
|
||||
<!ELEMENT TMw (#PCDATA)> <!--Always "0x40000000" -->
|
||||
|
||||
<!ELEMENT Statistics (TracksFound)>
|
||||
<!ELEMENT TracksFound (Video,Audio,Hint)>
|
||||
<!ELEMENT Video (#PCDATA)>
|
||||
<!ELEMENT Audio (#PCDATA)>
|
||||
<!ELEMENT Hint (#PCDATA)>
|
||||
|
||||
|
||||
<!-- For now, output info on at most one video track -->
|
||||
|
||||
|
||||
<!ELEMENT Track (TrackHeader, TrackReferenceContainer?, EditListContainer?, Media, JP2_Frame?)> <!-- JP2_Frame is mj2_to_metadata extension -->
|
||||
<!ATTLIST Track BoxType CDATA #FIXED "trak">
|
||||
<!ATTLIST Track Instance CDATA #REQUIRED>
|
||||
<!ELEMENT TrackHeader (TrackID, TrackLayer?, Volume?, TransformationMatrix?, Width?, Height?)>
|
||||
<!ATTLIST TrackHeader BoxType CDATA #FIXED "tkhd">
|
||||
<!-- Not shown here: CreationTime, ModificationTime, Duration. -->
|
||||
<!-- These 3 fields are reported under MediaHeader below. When reading these 3, -->
|
||||
<!-- m2j_to_metadata currently doesn't distinguish between TrackHeader and MediaHeader source. -->
|
||||
<!-- If both found, value read from MediaHeader is used. -->
|
||||
<!ELEMENT TrackID (#PCDATA)>
|
||||
<!ELEMENT TrackLayer (#PCDATA)> <!-- front-to-back ordering of video tracks. 0 = normal, -1 is closer, etc. -->
|
||||
<!-- "Volume" element described above; here it is for particular audio track. Full, normal (default = 0x0100) -->
|
||||
<!-- "TransformationMatrix" element described above; matrix here is applied before MovieHeader one. -->
|
||||
<!ELEMENT Width (AsHex | (AsHex, AsDecimal) | AsDecimal)>
|
||||
<!ELEMENT Height (AsHex | (AsHex, AsDecimal) | AsDecimal)>
|
||||
<!-- AsHex, AsDecimal already defined above -->
|
||||
<!-- Width and Height are for the presentation; frames will be scaled to this -->
|
||||
<!-- /TrackHeader -->
|
||||
<!ELEMENT TrackReferenceContainer ANY> <!-- TO DO: TrackReferenceContainer 'tref' just used in hint track -->
|
||||
<!ELEMENT EditListContainer ANY> <!-- TO DO: EditListContainer 'edts', contains EditList 'elst' with media-time, segment-duration, media-rate -->
|
||||
<!ELEMENT Media (MediaHeader, HandlerReference,MediaInfoContainer)>
|
||||
<!ATTLIST Media BoxType CDATA #FIXED "mdia">
|
||||
<!ELEMENT MediaHeader (CreationTime,ModificationTime,Timescale,Duration,Language)>
|
||||
<!ATTLIST MediaHeader BoxType CDATA #FIXED "mdhd">
|
||||
<!-- Elements already defined above: CreationTime, ModificationTime, Timescale, Duration -->
|
||||
<!ELEMENT Language (#PCDATA)> <!-- 3 chars max. There's an enumeration available -->
|
||||
<!ELEMENT HandlerReference (HandlerType)>
|
||||
<!ATTLIST HandlerReference BoxType CDATA #FIXED "hdlr">
|
||||
<!ELEMENT HandlerType (#PCDATA)>
|
||||
<!ATTLIST HandlerType Code ( vide | soun | hint ) "vide">
|
||||
|
||||
<!-- make the media headers multiple? -->
|
||||
<!ELEMENT MediaInfoContainer ((VideoMediaHeader | SoundMediaHeader | HintMediaHeader), DataInfo, SampleTable)>
|
||||
<!ATTLIST MediaInfoContainer BoxType CDATA #FIXED "minf">
|
||||
<!ELEMENT VideoMediaHeader (GraphicsMode, Opcolor)>
|
||||
<!ATTLIST VideoMediaHeader BoxType CDATA #FIXED "vmhd">
|
||||
<!ELEMENT GraphicsMode (#PCDATA)>
|
||||
<!-- Enumerated values of graphics mode: -->
|
||||
<!-- 0x00 = copy (over existing image); -->
|
||||
<!-- 0x24 = transparent; 'blue-screen' this image using opcolor; -->
|
||||
<!-- 0x100 = alpha; alpha-blend this image -->
|
||||
<!-- 0x101 = whitealpha; alpha-blend this image, which has been blended with white; -->
|
||||
<!-- 0x102 = blackalpha; alpha-blend this image, which has been blended with black. -->
|
||||
<!ELEMENT Opcolor (Red,Green,Blue)>
|
||||
<!ELEMENT Red (#PCDATA)>
|
||||
<!ELEMENT Green (#PCDATA)>
|
||||
<!ELEMENT Blue (#PCDATA)>
|
||||
<!ELEMENT SoundMediaHeader (Balance)>
|
||||
<!ATTLIST SoundMediaHeader BoxType CDATA #FIXED "smhd">
|
||||
<!ELEMENT Balance (#PCDATA)>
|
||||
<!-- Fixed Point 8.8, fixes mono track in stereo space. -->
|
||||
<!-- 0.0 = center, -1.0 = full left, 1.0 = full right -->
|
||||
<!ELEMENT HintMediaHeader (MaxPDU_Size, AvgPDU_Size, MaxBitRate, AvgBitRate, SlidingAvgBitRate)>
|
||||
<!ATTLIST HintMediaHeader BoxType CDATA #FIXED "hmhd">
|
||||
<!ELEMENT MaxPDU_Size (#PCDATA)>
|
||||
<!-- Size in bytes of largest PDU in this hint stream. -->
|
||||
<!ELEMENT AvgPDU_Size (#PCDATA)>
|
||||
<!-- Average size in bytes of a PDU over the entire presentation. -->
|
||||
<!ELEMENT MaxBitRate (#PCDATA)>
|
||||
<!-- Maximum rate in bits per second over any window of 1 second. -->
|
||||
<!ELEMENT AvgBitRate (#PCDATA)>
|
||||
<!-- Averate rate in bits per second over the entire presentation. -->
|
||||
<!ELEMENT SlidingAvgBit (#PCDATA)>
|
||||
<!-- Maximum rate in bits per second over any window of one minute. -->
|
||||
|
||||
<!ELEMENT DataInfo (DataReference)>
|
||||
<!ATTLIST DataInfo BoxType CDATA #FIXED "dinf">
|
||||
<!ELEMENT DataReference (DataEntryUrlBox | DataEntryUrnBox )*>
|
||||
<!ATTLIST DataReference BoxType CDATA #FIXED "dref">
|
||||
<!ATTLIST DataReference URL_Count CDATA #REQUIRED>
|
||||
<!ATTLIST DataReference URN_Count CDATA #REQUIRED> <!-- table w. flags, URLs, URNs -->
|
||||
<!-- // Data structure does not distinguish between single URL, single URN, or DREF table or URLs & URNs.
|
||||
// We could infer those, but for now just present everything as a DREF table.
|
||||
-->
|
||||
<!-- No entries here mean that file is self-contained, as required by Simple Profile. -->
|
||||
|
||||
<!ELEMENT DataEntryUrlBox (Location)>
|
||||
<!ATTLIST DataEntryUrlBox BoxType CDATA #FIXED "url[space]"> <!-- table w. flags, URLs, URNs -->
|
||||
<!-- Only the first 16 bytes of URL location are recorded in mj2_to_metadata data structure. -->
|
||||
<!ELEMENT DataEntryUrnBox (Name, Location?)>
|
||||
<!ATTLIST DataEntryUrnBox BoxType CDATA #FIXED "urn[space]\">
|
||||
<!-- Only the first 16 bytes each of URN name and optional location are recorded in mj2_to_metadata data structure. -->
|
||||
|
||||
<!ELEMENT SampleTable (VisualSampleEntry,TimeToSample,SampleToChunk,SampleSize,ChunkOffset)> <!-- structure doesn't do non-visual sample entry yet -->
|
||||
<!ATTLIST SampleTable BoxType CDATA #FIXED "stbl"> <!-- to add: entry count -->
|
||||
<!-- Next are instances of generic SampleDescription BoxType=\"stsd\" -->
|
||||
|
||||
<!-- There could be multiple instances of this, but "entry_count" is just a local at read-time.
|
||||
And it's used wrong, too, as count of just visual type, when it's really all 3 types.
|
||||
This is referred to as "smj2" within mj2.c -->
|
||||
<!ELEMENT VisualSampleEntry (WidthAsInteger, HeightAsInteger, HorizontalRes, VerticalRes, CompressorName, Depth, JP2Header?, FieldCoding?, MJP2_Profile?, MJP2_Prefix?, MJP2_SubSampling?, MJP2_OriginalFormat?)>
|
||||
<!ATTLIST VisualSampleEntry BoxType CDATA #FIXED "mjp2">
|
||||
<!-- If multiple instances of this, only first is shown here. -->
|
||||
<!ELEMENT WidthAsInteger (#PCDATA)>
|
||||
<!ELEMENT HeightAsInteger (#PCDATA)>
|
||||
<!ELEMENT HorizontalRes (AsHex | (AsHex, AsDecimal) | AsDecimal)>
|
||||
<!ELEMENT VerticalRes (AsHex | (AsHex, AsDecimal) | AsDecimal)>
|
||||
<!-- Typical value for both resolution is 72 (0x00480000) -->
|
||||
<!ELEMENT CompressorName (#PCDATA)>
|
||||
<!-- Compressor name for debugging. Standard restricts max length to 31 bytes. -->
|
||||
<!-- Usually blank or \"Motion JPEG2000\" -->
|
||||
<!ELEMENT Depth (#PCDATA)>
|
||||
<!-- Depth is: -->
|
||||
<!-- 0x20: alpha channels present (color or grayscale) -->
|
||||
<!-- 0x28: grayscale without alpha -->
|
||||
<!-- 0x18: color without alpha -->
|
||||
|
||||
<!-- TODO somewhere: tk->jp2_struct.numcomps -->
|
||||
<!ELEMENT JP2Header (ImageHeader, ColourSpecification)>
|
||||
<!ATTLIST JP2Header BoxType CDATA #FIXED "jp2h">
|
||||
<!ELEMENT ImageHeader (HEIGHT, WIDTH, NC, BPC, C, UnkC, IPR)>
|
||||
<!ATTLIST ImageHeader BoxType CDATA #FIXED "ihdr">
|
||||
<!ELEMENT HEIGHT (#PCDATA)> <!-- If 2 fields/frame, total deinterlaced height -->
|
||||
<!ELEMENT WIDTH (#PCDATA)>
|
||||
<!ELEMENT NC (#PCDATA)> <!-- number of components -->
|
||||
<!ELEMENT BPC (AsHex | (AsHex,BitsPerPixel,Signed) | (BitsPerPixel,Signed))>
|
||||
<!ELEMENT BitsPerPixel (#PCDATA)>
|
||||
<!ELEMENT Signed (#PCDATA)>
|
||||
<!ELEMENT C (#PCDATA)> <!-- Compression type. Only "7" defined -->
|
||||
<!ELEMENT UnkC (#PCDATA)> <!-- Colourspace Unknown. 1 = unknown, 0 = known -->
|
||||
<!ELEMENT IPR (#PCDATA)> <!-- 1 = frame has Intellectual Prop. box; otherwise 0 -->
|
||||
<!ELEMENT ColourSpecification (METH, PREC, APPROX, EnumCS)>
|
||||
<!ATTLIST ColourSpecification BoxType CDATA #FIXED "colr">
|
||||
<!ELEMENT METH (#PCDATA)> <!-- 1 = EnumCS field; 2 = PROFILE field (not yet generated) -->
|
||||
<!ELEMENT PREC (#PCDATA)> <!-- precedence must be 0 so far -->
|
||||
<!ELEMENT APPROX (#PCDATA)> <!-- colourspace approximation must be 0 so far -->
|
||||
<!ELEMENT EnumCS (#PCDATA)> <!-- Valid enumerated MJ2 colourspaces: 16 (sRGB), 17 (grey sRGB), 18 (YCC) -->
|
||||
|
||||
<!-- Following subboxes are optional -->
|
||||
<!ELEMENT FieldCoding (FieldCount, FieldOrder)>
|
||||
<!ATTLIST FieldCoding BoxType CDATA #FIXED "fiel">
|
||||
<!ELEMENT FieldCount (#PCDATA)>
|
||||
<!-- Must be either 1 or 2 -->
|
||||
<!ELEMENT FieldOrder (#PCDATA)>
|
||||
<!-- When FieldCount=2, FieldOrder means: -->
|
||||
<!-- 0: Field coding unknown -->
|
||||
<!-- 1: Field with topmost line is stored first in sample; fields are in temporal order -->
|
||||
<!-- 6: Field with topmost line is stored second in sample; fields are in temporal order -->
|
||||
<!-- Defaults: FieldCount=1, FieldOrder=0 if FieldCoding box not present -->
|
||||
<!-- Current implementation doesn't retain whether box was actually present. -->
|
||||
|
||||
<!ELEMENT MJP2_Profile (CompatibleBrand*)>
|
||||
<!ATTLIST MJP2_Profile BoxType CDATA #FIXED "jp2p">
|
||||
<!ATTLIST MJP2_Profile Count CDATA #REQUIRED>
|
||||
|
||||
<!ELEMENT MJP2_Prefix (Data*)>
|
||||
<!ATTLIST MJP2_Prefix BoxType CDATA #FIXED "jp2x">
|
||||
<!ATTLIST MJP2_Prefix Count CDATA #REQUIRED>
|
||||
<!-- We'll probably need better formatting than this -->
|
||||
<!ELEMENT Data (#PCDATA)> <!-- Multiple. Each entry is single byte -->
|
||||
|
||||
<!ELEMENT MJP2_SubSampling (HorizontalSub, VerticalSub, HorizontalOffset, VerticalOffset)>
|
||||
<!ATTLIST MJP2_SubSampling BoxType CDATA #FIXED "jsub">
|
||||
<!-- These values are all 1 byte -->
|
||||
<!-- Typical subsample value is 2 for 4:2:0 -->
|
||||
<!ELEMENT HorizontalSub (#PCDATA)>
|
||||
<!ELEMENT VerticalSub (#PCDATA)>
|
||||
<!ELEMENT HorizontalOffset (#PCDATA)>
|
||||
<!ELEMENT VerticalOffset (#PCDATA)>
|
||||
|
||||
<!ELEMENT MJP2_OriginalFormat (OriginalFieldCount, OriginalFieldOrder)>
|
||||
<!ATTLIST MJP2_OriginalFormat BoxType CDATA #FIXED "orfo"> <!-- Part III Appx. 2 -->
|
||||
<!ELEMENT OriginalFieldCount (#PCDATA)>
|
||||
<!-- In original material before encoding. Must be either 1 or 2 -->
|
||||
<!ELEMENT OriginalFieldOrder (#PCDATA)>
|
||||
<!-- When FieldCount=2, FieldOrder means: -->
|
||||
<!-- 0: Field coding unknown -->
|
||||
<!-- 11: Topmost line came from the earlier field; -->
|
||||
<!-- 16: Topmost line came form the later field. -->
|
||||
<!-- Defaults: FieldCount=1, FieldOrder=0 if FieldCoding box not present -->
|
||||
<!-- Current implementation doesn't retain whether box was actually present. -->
|
||||
|
||||
|
||||
<!-- mj2_to_metadata's data structure doesn't record Audio and Hint sample data currently. -->
|
||||
|
||||
<!-- Within SampleTable: -->
|
||||
<!ELEMENT TimeToSample (SampleStatistics, SampleEntries)>
|
||||
<!ATTLIST TimeToSample BoxType CDATA #FIXED "stts">
|
||||
<!ELEMENT SampleStatistics (TotalSamples)> <!-- Not part of standard -->
|
||||
<!ELEMENT TotalSamples (#PCDATA)>
|
||||
<!-- For video, gives the total frames in the track, by summing all entries in the Sample Table -->
|
||||
|
||||
<!ELEMENT SampleEntries (Table*)>
|
||||
<!ATTLIST SampleEntries EntryCount CDATA #REQUIRED>
|
||||
<!ELEMENT Table EMPTY> <!-- Multiple. Attributes have values -->
|
||||
<!ATTLIST Table Entry CDATA #REQUIRED>
|
||||
<!ATTLIST Table SampleCount CDATA #REQUIRED>
|
||||
<!ATTLIST Table SampleDelta CDATA #REQUIRED>
|
||||
|
||||
<!-- Within SampleTable: -->
|
||||
<!ELEMENT SampleToChunk (FirstChunk,SamplesPerChunk,SampleDescrIndex)>
|
||||
<!ATTLIST SampleToChunk BoxType CDATA #FIXED "stsc">
|
||||
<!ATTLIST SampleToChunk Count CDATA #REQUIRED>
|
||||
<!ELEMENT FirstChunk (#PCDATA)>
|
||||
<!ELEMENT SamplesPerChunk (#PCDATA)>
|
||||
<!ELEMENT SampleDescrIndex (#PCDATA)>
|
||||
<!ELEMENT SampleSize (Sample_Size,Sample_Count,EntrySize*)>
|
||||
<!ATTLIST SampleSize BoxType CDATA #FIXED "stsz">
|
||||
<!ELEMENT Sample_Size (#PCDATA)>
|
||||
<!ELEMENT Sample_Count (#PCDATA)>
|
||||
<!ELEMENT EntrySize (#PCDATA)> <!-- appears multiply, but only with mj2_to_metadata option -t -->
|
||||
<!ATTLIST EntrySize Num CDATA #REQUIRED>
|
||||
<!ELEMENT ChunkOffset (EntryCount, Chunk_Offset*)>
|
||||
<!ATTLIST ChunkOffset BoxType CDATA #FIXED "stco">
|
||||
<!ELEMENT EntryCount (#PCDATA)>
|
||||
<!ELEMENT Chunk_Offset (#PCDATA)> <!-- appears multiply, but only with mj2_to_metadata option -t -->
|
||||
<!ATTLIST Chunk_Offset Num CDATA #REQUIRED>
|
||||
<!-- </SampleTable> </MediaInfoContainer> </Media> -->
|
||||
|
||||
<!-- TO DO: optional UserData 'udat', can contain multiple Copyright 'cprt' -->
|
||||
|
||||
|
||||
<!-- Optional, and only for Visual Track: given individual frame -->
|
||||
<!ELEMENT JP2_Frame (MainHeader, TilePartHeaders)>
|
||||
<!ATTLIST JP2_Frame Num CDATA #REQUIRED>
|
||||
<!ELEMENT MainHeader (StartOfCodestream,ImageAndFileSize,CodingStyleDefault,QuantizationDefault,QuantizationComponent*,RegionOfInterest?,ProgressionOrderChange*)>
|
||||
<!ELEMENT StartOfCodestream EMPTY>
|
||||
<!ATTLIST StartOfCodestream Marker CDATA #FIXED "SOC">
|
||||
<!ELEMENT ImageAndFileSize (Xsiz,Ysiz,XOsiz,YOsiz,XTsiz,YTsiz,XTOsiz,YTOsiz,Csiz,Component+)>
|
||||
<!ATTLIST ImageAndFileSize Marker CDATA #FIXED "SIZ">
|
||||
<!ELEMENT Xsiz (#PCDATA)>
|
||||
<!ELEMENT Ysiz (#PCDATA)> <!-- Xsiz, Ysiz is the size of the reference grid. -->
|
||||
<!ELEMENT XOsiz (#PCDATA)>
|
||||
<!ELEMENT YOsiz (#PCDATA)> <!-- XOsiz, YOsiz are offsets from grid origin to image origin. -->
|
||||
<!ELEMENT XTsiz (#PCDATA)>
|
||||
<!ELEMENT YTsiz (#PCDATA)> <!-- XTsiz, YTsiz is the size of one tile with respect to the grid. -->
|
||||
<!ELEMENT XTOsiz (#PCDATA)>
|
||||
<!ELEMENT YTOsiz (#PCDATA)> <!-- XTOsiz, YTOsiz are offsets from grid origin to first tile origin. -->
|
||||
<!ELEMENT Csiz (#PCDATA)> <!-- Csiz is the number of components in the image. -->
|
||||
<!-- For image components next -->
|
||||
<!ELEMENT Component (Ssiz,XRsiz,YRsiz,WidthOfData,HeightOfData)>
|
||||
<!ATTLIST Component Num CDATA #REQUIRED>
|
||||
<!ELEMENT Ssiz (AsHex | (AsHex,Signed,PrecisionInBits) | (Signed,PrecisionInBits))>
|
||||
<!-- Signed already defined -->
|
||||
<!ELEMENT PrecisionInBits (#PCDATA)> <!-- Bits per pixel (bpp) or pixel depth. -->
|
||||
<!ELEMENT XRsiz (#PCDATA)>
|
||||
<!ELEMENT YRsiz (#PCDATA)> <!-- XRsiz, YRsiz denote pixel-sample-spacing on the grid, per Part I Annex B. -->
|
||||
<!ELEMENT WidthOfData (#PCDATA)>
|
||||
<!ELEMENT HeightOfData (#PCDATA)> <!-- WidthOfData and HeightOfData are calculated values, e.g.: w = roundup((Xsiz - XOsiz)/ XRsiz) -->
|
||||
<!-- -->
|
||||
<!ELEMENT CodingStyleDefault (Scod,SGcod,SPcod)>
|
||||
<!ATTLIST CodingStyleDefault Marker CDATA #FIXED "COD">
|
||||
<!ELEMENT Scod (#PCDATA)>
|
||||
<!-- For Scod, specific bits mean (where bit 0 is lowest or rightmost): -->
|
||||
<!-- bit 0: Defines entropy coder precincts -->
|
||||
<!-- 0 = (PPx=15, PPy=15); 1 = precincts defined below. -->
|
||||
<!-- bit 1: 1 = SOP marker may be used; 0 = not. -->
|
||||
<!-- bit 2: 1 = EPH marker may be used; 0 = not. -->
|
||||
<!ELEMENT SGcod (ProgressionOrder,NumberOfLayers,MultipleComponentTransformation)>
|
||||
<!ELEMENT ProgressionOrder (#PCDATA)>
|
||||
<!-- Defined Progression Order Values are: -->
|
||||
<!-- 0 = LRCP; 1 = RLCP; 2 = RPCL; 3 = PCRL; 4 = CPRL -->
|
||||
<!-- where L = "layer", R = "resolution level", C = "component", P = "position". -->
|
||||
<!ELEMENT NumberOfLayers (#PCDATA)>
|
||||
<!ELEMENT MultipleComponentTransformation (#PCDATA)>
|
||||
<!-- For MCT, 0 = none, 1 = transform first 3 components for efficiency, per Part I Annex G -->
|
||||
<!ELEMENT SPcod (NumberOfDecompositionLevels,CodeblockWidth,CodeblockHeight,CodeblockStyle,Transformation)>
|
||||
<!ELEMENT NumberOfDecompositionLevels (#PCDATA)>
|
||||
<!ELEMENT CodeblockWidth (#PCDATA)> <!-- CBW and CBH are non-negative, and summed cannot exceed 8 -->
|
||||
<!ELEMENT CodeblockHeight (#PCDATA)> <!-- Codeblock dimension is 2^(value + 2) -->
|
||||
<!ELEMENT CodeblockStyle (#PCDATA)>
|
||||
<!-- For CodeblockStyle, bits mean (with value 1=feature on, 0=off): -->
|
||||
<!-- bit 0: Selective arithmetic coding bypass. -->
|
||||
<!-- bit 1: Reset context probabilities on coding pass boundaries. -->
|
||||
<!-- bit 2: Termination on each coding pass. -->
|
||||
<!-- bit 3: Vertically causal context. -->
|
||||
<!-- bit 4: Predictable termination. -->
|
||||
<!-- bit 5: Segmentation symbols are used. -->
|
||||
<!ELEMENT Transformation (#PCDATA)> <!-- For Transformation, 0="9-7 irreversible filter", 1="5-3 reversible filter" -->
|
||||
<!-- mj2_to_metadata implementation always reports component[0] as using default COD, -->
|
||||
<!-- and any other component, with main-header style values different from [0], as COC. -->
|
||||
<!ELEMENT QuantizationDefault (Sqcd,SPqcd)>
|
||||
<!ATTLIST QuantizationDefault Marker CDATA #FIXED "QCD">
|
||||
<!ELEMENT Sqcd (AsHex | (AsHex,QuantizationStyle,NumberOfGuardBits) | (QuantizationStyle,NumberOfGuardBits))>
|
||||
<!ELEMENT QuantizationStyle (#PCDATA)> <!-- Default quantization style for all components. -->
|
||||
<!-- Quantization style (in Sqcd's low 5 bits) may be: -->
|
||||
<!-- 0 = No quantization. SPqcd size = 8 bits-->
|
||||
<!-- 1 = Scalar derived (values signaled for N(L)LL subband only). Use Eq. E.5. SPqcd size = 16. -->
|
||||
<!-- 2 = Scalar expounded (values signaled for each subband). SPqcd size = 16. -->
|
||||
<!ELEMENT NumberOfGuardBits (#PCDATA)> <!-- 0-7 guard bits allowed (stored in Sqcd's high 3 bits) -->
|
||||
<!ELEMENT SPqcd (ReversibleStepSizeValue | QuantizationStepSizeValues )> <!-- TO DO: Irreversible choices -->
|
||||
<!ELEMENT ReversibleStepSizeValue (DynamicRangeExponent+)>
|
||||
<!-- Current mj2_to_metadata implementation dumps entire internal table, -->
|
||||
<!-- until an exponent with zero value is reached. -->
|
||||
<!-- Exponent epsilon(b) of reversible dynamic range. -->
|
||||
<!-- Hex value is as stored, in high-order 5 bits. -->
|
||||
<!ELEMENT DynamicRangeExponent (AsHex | (AsHex, AsDecimal) | AsDecimal)>
|
||||
<!ATTLIST DynamicRangeExponent Subband CDATA #REQUIRED>
|
||||
<!ELEMENT QuantizationStepSizeValues (QuantizationValues+, CalculatedExponent*)> <!-- Calculated exponents iff only subband 0 reported -->
|
||||
<!ELEMENT QuantizationValues (AsHex | (AsHex,Exponent,Mantissa) | (Exponent,Mantissa))>
|
||||
<!ATTLIST QuantizationValues Subband CDATA #REQUIRED>
|
||||
<!ELEMENT Exponent (#PCDATA)>
|
||||
<!ELEMENT Mantissa (#PCDATA)>
|
||||
<!ELEMENT CalculatedExponent (#PCDATA)>
|
||||
<!ATTLIST CalculatedExponent Subband CDATA #REQUIRED>
|
||||
<!-- /QuantizationDefault -->
|
||||
<!-- mj2_to_metadata implementation always reports component[0] as using default QCD, -->
|
||||
<!-- and any other component, with main-header quantization values different from [0], as QCC. -->
|
||||
<!ELEMENT QuantizationComponent (Sqcc,SPqcc)>
|
||||
<!ATTLIST QuantizationComponent Marker CDATA #FIXED "QCC">
|
||||
<!ATTLIST QuantizationComponent Component CDATA #REQUIRED>
|
||||
<!ELEMENT Sqcc (AsHex | (AsHex,QuantizationStyle,NumberOfGuardBits) | (QuantizationStyle,NumberOfGuardBits))>
|
||||
<!ELEMENT SPqcc (ReversibleStepSizeValue | QuantizationStepSizeValues )> <!-- TO DO: Irreversible choices -->
|
||||
<!-- /QuantizationComponent -->
|
||||
<!-- Don't know if MJ2 files can have regions of interest. Assume yes -->
|
||||
<!ELEMENT RegionOfInterest (Srgn,Crgn,Sprgn)> <!-- Optional in main header, at most 1 per component -->
|
||||
<!ATTLIST RegionOfInterest Marker CDATA #FIXED "RGN">
|
||||
<!ELEMENT Srgn (#PCDATA)> <!-- ROI style. Only style=0 defined: Implicit ROI (max. shift) -->
|
||||
<!ELEMENT Crgn (#PCDATA)> <!-- Zero-based component number. -->
|
||||
<!ELEMENT SPrgn (#PCDATA)> <!-- Implicit ROI shift, i.e., binary shifting of ROI coefficients above background. -->
|
||||
<!-- </RegionOfInterest> -->
|
||||
<!ELEMENT ProgressionOrderChange (Progression+)> <!-- Optional in main header, at most 1 per component (but impl allows more?) -->
|
||||
<!ATTLIST ProgressionOrderChange Marker CDATA #REQUIRED>
|
||||
<!ELEMENT Progression (RSpoc,CSpoc,LYEpoc,REpoc,CEpoc,Ppoc)>
|
||||
<!ATTLIST Progression Num CDATA #REQUIRED>
|
||||
<!ELEMENT RSpoc (#PCDATA)> <!-- Resolution level index (inclusive) for progression start. Range: 0 to 33 -->
|
||||
<!ELEMENT CSpoc (#PCDATA)> <!-- Component index (inclusive) for progression start. -->
|
||||
<!ELEMENT LYEpoc (#PCDATA)> <!-- Layer index (exclusive) for progression end. -->
|
||||
<!ELEMENT REpoc (#PCDATA)> <!-- Resolution level index (exclusive) for progression end. Range: RSpoc to 33 -->
|
||||
<!ELEMENT CEpoc (#PCDATA)> <!-- Component index (exclusive) for progression end. Minimum: CSpoc -->
|
||||
<!ELEMENT Ppoc (#PCDATA)> <!-- Defined Progression Order Values are: -->
|
||||
<!-- 0 = LRCP; 1 = RLCP; 2 = RPCL; 3 = PCRL; 4 = CPRL -->
|
||||
<!-- where L = "layer", R = "resolution level", C = "component", P = "position". -->
|
||||
<!-- </Progression>, </ProgressionOrderChange -->
|
||||
<!-- /MainHeader -->
|
||||
<!ELEMENT TilePartHeaders (TilePartHeader+)>
|
||||
<!ATTLIST TilePartHeaders Count CDATA #REQUIRED>
|
||||
<!ELEMENT TilePartHeader (StartOfTilePart,CodingStyleDefault,QuantizationDefault,QuantizationComponent*,RegionOfInterest?,ProgressionOrderChange*,StartOfData)>
|
||||
<!ATTLIST TilePartHeader Num CDATA #REQUIRED>
|
||||
<!ATTLIST TilePartHeader ID CDATA #REQUIRED>
|
||||
<!ELEMENT StartOfTilePart EMPTY>
|
||||
<!ATTLIST StartOfTilePart Marker CDATA #FIXED "SOT">
|
||||
<!-- CodingStyleDefault, QuantizationDefault, QuantizationComponent already defined -->
|
||||
<!-- mj2_to_metadata implementation always reports component[0] as using default QCD, -->
|
||||
<!-- and any other component, with tile-part-header quantization values different from [0], as QCC. -->
|
||||
<!ELEMENT StartOfData EMPTY> <!-- always empty for now -->
|
||||
<!ATTLIST StartOfData Marker CDATA #FIXED "SOD">
|
||||
<!-- Tile-part bitstream, not shown, follows tile-part header and SOD marker. -->
|
||||
<!-- /TilePartHeader, /TilePartHeaders, /JP2_Frame -->
|
||||
<!-- </Track> -->
|
||||
|
||||
<!-- to come:
|
||||
<MovieExtends mvek> // possibly not in Simple Profile
|
||||
<UserDataBox udat> contains <CopyrightBox cprt>
|
||||
-->
|
||||
<!-- /MovieBox -->
|
||||
<!-- To come:
|
||||
<mdat>
|
||||
<moof> // probably not in Simple Profile
|
||||
<free>
|
||||
<skip>
|
||||
-->
|
||||
<!-- </MJ2_File> -->
|
|
@ -1,9 +0,0 @@
|
|||
/* mj2_to_metadata.h */
|
||||
/* Dump MJ2, JP2 metadata (partial so far) to xml file */
|
||||
/* Contributed to Open JPEG by Glenn Pearson, U.S. National Library of Medicine */
|
||||
|
||||
#define BOOL int
|
||||
#define FALSE 0
|
||||
#define TRUE 1
|
||||
|
||||
#include "meta_out.h"
|
|
@ -1,29 +0,0 @@
|
|||
|
||||
Microsoft Visual Studio Solution File, Format Version 9.00
|
||||
# Visual Studio 2005
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mj2_to_metadata", "mj2_to_metadata.vcproj", "{69BE42AB-E7CE-4DA1-BBD2-39FEA2C91E0B}"
|
||||
ProjectSection(ProjectDependencies) = postProject
|
||||
{0B1B7713-35B6-40A7-9BFF-A7D0EB06A8BD} = {0B1B7713-35B6-40A7-9BFF-A7D0EB06A8BD}
|
||||
EndProjectSection
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LibOpenJPEG", "..\LibOpenJPEG.vcproj", "{0B1B7713-35B6-40A7-9BFF-A7D0EB06A8BD}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Debug|Win32 = Debug|Win32
|
||||
Release|Win32 = Release|Win32
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||
{69BE42AB-E7CE-4DA1-BBD2-39FEA2C91E0B}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{69BE42AB-E7CE-4DA1-BBD2-39FEA2C91E0B}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{69BE42AB-E7CE-4DA1-BBD2-39FEA2C91E0B}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{69BE42AB-E7CE-4DA1-BBD2-39FEA2C91E0B}.Release|Win32.Build.0 = Release|Win32
|
||||
{0B1B7713-35B6-40A7-9BFF-A7D0EB06A8BD}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{0B1B7713-35B6-40A7-9BFF-A7D0EB06A8BD}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{0B1B7713-35B6-40A7-9BFF-A7D0EB06A8BD}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{0B1B7713-35B6-40A7-9BFF-A7D0EB06A8BD}.Release|Win32.Build.0 = Release|Win32
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
EndGlobalSection
|
||||
EndGlobal
|
|
@ -1,349 +0,0 @@
|
|||
<?xml version="1.0" encoding="Windows-1252"?>
|
||||
<VisualStudioProject
|
||||
ProjectType="Visual C++"
|
||||
Version="8,00"
|
||||
Name="mj2_to_metadata"
|
||||
ProjectGUID="{69BE42AB-E7CE-4DA1-BBD2-39FEA2C91E0B}"
|
||||
>
|
||||
<Platforms>
|
||||
<Platform
|
||||
Name="Win32"
|
||||
/>
|
||||
</Platforms>
|
||||
<ToolFiles>
|
||||
</ToolFiles>
|
||||
<Configurations>
|
||||
<Configuration
|
||||
Name="Debug|Win32"
|
||||
OutputDirectory=".\mj2_to_metadata___Win32_Debug0"
|
||||
IntermediateDirectory=".\mj2_to_metadata___Win32_Debug0"
|
||||
ConfigurationType="1"
|
||||
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC60.vsprops"
|
||||
UseOfMFC="0"
|
||||
ATLMinimizesCRunTimeLibraryUsage="false"
|
||||
CharacterSet="2"
|
||||
>
|
||||
<Tool
|
||||
Name="VCPreBuildEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXMLDataGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCWebServiceProxyGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCMIDLTool"
|
||||
TypeLibraryName=".\mj2_to_metadata___Win32_Debug0/mj2_to_metadata.tlb"
|
||||
HeaderFileName=""
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
Optimization="0"
|
||||
AdditionalIncludeDirectories="../libopenjpeg"
|
||||
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;OPJ_STATIC;_CRT_SECURE_NO_DEPRECATE"
|
||||
MinimalRebuild="true"
|
||||
BasicRuntimeChecks="3"
|
||||
RuntimeLibrary="1"
|
||||
PrecompiledHeaderFile=".\mj2_to_metadata___Win32_Debug0/mj2_to_metadata.pch"
|
||||
AssemblerListingLocation=".\mj2_to_metadata___Win32_Debug0/"
|
||||
ObjectFile=".\mj2_to_metadata___Win32_Debug0/"
|
||||
ProgramDataBaseFileName=".\mj2_to_metadata___Win32_Debug0/"
|
||||
BrowseInformation="1"
|
||||
WarningLevel="3"
|
||||
SuppressStartupBanner="true"
|
||||
DebugInformationFormat="4"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManagedResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCResourceCompilerTool"
|
||||
PreprocessorDefinitions="_DEBUG"
|
||||
Culture="2057"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPreLinkEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCLinkerTool"
|
||||
OutputFile=".\mj2_to_metadata___Win32_Debug0/mj2_to_metadata.exe"
|
||||
LinkIncremental="2"
|
||||
SuppressStartupBanner="true"
|
||||
IgnoreDefaultLibraryNames="LIBCMT"
|
||||
GenerateDebugInformation="true"
|
||||
ProgramDatabaseFile=".\mj2_to_metadata___Win32_Debug0/mj2_to_metadata.pdb"
|
||||
SubSystem="1"
|
||||
TargetMachine="1"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCALinkTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManifestTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXDCMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCBscMakeTool"
|
||||
SuppressStartupBanner="true"
|
||||
OutputFile=".\mj2_to_metadata___Win32_Debug0/mj2_to_metadata.bsc"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCFxCopTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCAppVerifierTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCWebDeploymentTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"
|
||||
/>
|
||||
</Configuration>
|
||||
<Configuration
|
||||
Name="Release|Win32"
|
||||
OutputDirectory=".\Release"
|
||||
IntermediateDirectory=".\Release"
|
||||
ConfigurationType="1"
|
||||
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC60.vsprops"
|
||||
UseOfMFC="0"
|
||||
ATLMinimizesCRunTimeLibraryUsage="false"
|
||||
CharacterSet="2"
|
||||
>
|
||||
<Tool
|
||||
Name="VCPreBuildEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXMLDataGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCWebServiceProxyGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCMIDLTool"
|
||||
TypeLibraryName=".\Release/mj2_to_metadata.tlb"
|
||||
HeaderFileName=""
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
Optimization="2"
|
||||
InlineFunctionExpansion="1"
|
||||
AdditionalIncludeDirectories="../libopenjpeg"
|
||||
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;OPJ_STATIC;_CRT_SECURE_NO_DEPRECATE"
|
||||
StringPooling="true"
|
||||
RuntimeLibrary="0"
|
||||
EnableFunctionLevelLinking="true"
|
||||
PrecompiledHeaderFile=".\Release/mj2_to_metadata.pch"
|
||||
AssemblerListingLocation=".\Release/"
|
||||
ObjectFile=".\Release/"
|
||||
ProgramDataBaseFileName=".\Release/"
|
||||
WarningLevel="3"
|
||||
SuppressStartupBanner="true"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManagedResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCResourceCompilerTool"
|
||||
PreprocessorDefinitions="NDEBUG"
|
||||
Culture="2057"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPreLinkEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCLinkerTool"
|
||||
OutputFile=".\Release/mj2_to_metadata.exe"
|
||||
LinkIncremental="1"
|
||||
SuppressStartupBanner="true"
|
||||
IgnoreDefaultLibraryNames="libcmtd"
|
||||
ProgramDatabaseFile=".\Release/mj2_to_metadata.pdb"
|
||||
SubSystem="1"
|
||||
TargetMachine="1"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCALinkTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManifestTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXDCMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCBscMakeTool"
|
||||
SuppressStartupBanner="true"
|
||||
OutputFile=".\Release/mj2_to_metadata.bsc"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCFxCopTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCAppVerifierTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCWebDeploymentTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"
|
||||
/>
|
||||
</Configuration>
|
||||
</Configurations>
|
||||
<References>
|
||||
</References>
|
||||
<Files>
|
||||
<Filter
|
||||
Name="MJ2"
|
||||
>
|
||||
<Filter
|
||||
Name="MJ2 Header Files"
|
||||
>
|
||||
<File
|
||||
RelativePath="compat\opj_getopt.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="meta_out.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="mj2.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="mj2_convert.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="mj2_to_metadata.h"
|
||||
>
|
||||
</File>
|
||||
</Filter>
|
||||
<Filter
|
||||
Name="MJ2 Source Files"
|
||||
>
|
||||
<File
|
||||
RelativePath="compat\opj_getopt.c"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Debug|Win32"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalIncludeDirectories=""
|
||||
PreprocessorDefinitions=""
|
||||
/>
|
||||
</FileConfiguration>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalIncludeDirectories=""
|
||||
PreprocessorDefinitions=""
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="meta_out.c"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Debug|Win32"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalIncludeDirectories=""
|
||||
PreprocessorDefinitions=""
|
||||
/>
|
||||
</FileConfiguration>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalIncludeDirectories=""
|
||||
PreprocessorDefinitions=""
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="mj2.c"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Debug|Win32"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalIncludeDirectories=""
|
||||
PreprocessorDefinitions=""
|
||||
/>
|
||||
</FileConfiguration>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalIncludeDirectories=""
|
||||
PreprocessorDefinitions=""
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="mj2_convert.c"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Debug|Win32"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalIncludeDirectories=""
|
||||
PreprocessorDefinitions=""
|
||||
/>
|
||||
</FileConfiguration>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalIncludeDirectories=""
|
||||
PreprocessorDefinitions=""
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="mj2_to_metadata.c"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Debug|Win32"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalIncludeDirectories=""
|
||||
PreprocessorDefinitions=""
|
||||
/>
|
||||
</FileConfiguration>
|
||||
<FileConfiguration
|
||||
Name="Release|Win32"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
AdditionalIncludeDirectories=""
|
||||
PreprocessorDefinitions=""
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
</Filter>
|
||||
</Filter>
|
||||
</Files>
|
||||
<Globals>
|
||||
</Globals>
|
||||
</VisualStudioProject>
|
Binary file not shown.
|
@ -1,853 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2003-2004, Francois-Olivier Devaux
|
||||
* Copyright (c) 2002-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "opj_apps_config.h"
|
||||
#include "openjpeg.h"
|
||||
#include "j2k_lib.h"
|
||||
#include "cio.h"
|
||||
#include "j2k.h"
|
||||
#include "jp2.h"
|
||||
#include "mj2.h"
|
||||
#include "mj2_convert.h"
|
||||
#include "opj_getopt.h"
|
||||
|
||||
/**
|
||||
Size of memory first allocated for MOOV box
|
||||
*/
|
||||
#define TEMP_BUF 10000
|
||||
|
||||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
sample error callback expecting a FILE* client object
|
||||
*/
|
||||
static 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
|
||||
*/
|
||||
static void warning_callback(const char *msg, void *client_data)
|
||||
{
|
||||
FILE *stream = (FILE*)client_data;
|
||||
fprintf(stream, "[WARNING] %s", msg);
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
|
||||
static void help_display()
|
||||
{
|
||||
fprintf(stdout, "HELP for frames_to_mj2\n----\n\n");
|
||||
fprintf(stdout, "- the -h option displays this help information on screen\n\n");
|
||||
|
||||
|
||||
fprintf(stdout, "List of parameters for the MJ2 encoder:\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "REMARKS:\n");
|
||||
fprintf(stdout, "---------\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf
|
||||
(stdout, "The markers written to the main_header are : SOC SIZ COD QCD COM.\n");
|
||||
fprintf
|
||||
(stdout, "COD and QCD never appear in the tile_header.\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "By default:\n");
|
||||
fprintf(stdout, "------------\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, " * Lossless\n");
|
||||
fprintf(stdout, " * 1 tile\n");
|
||||
fprintf(stdout, " * Size of precinct : 2^15 x 2^15 (means 1 precinct)\n");
|
||||
fprintf(stdout, " * Size of code-block : 64 x 64\n");
|
||||
fprintf(stdout, " * Number of resolutions: 6\n");
|
||||
fprintf(stdout, " * No SOP marker in the codestream\n");
|
||||
fprintf(stdout, " * No EPH marker in the codestream\n");
|
||||
fprintf(stdout, " * No sub-sampling in x or y direction\n");
|
||||
fprintf(stdout, " * No mode switch activated\n");
|
||||
fprintf(stdout, " * Progression order: LRCP\n");
|
||||
fprintf(stdout, " * No index file\n");
|
||||
fprintf(stdout, " * No ROI upshifted\n");
|
||||
fprintf(stdout, " * No offset of the origin of the image\n");
|
||||
fprintf(stdout, " * No offset of the origin of the tiles\n");
|
||||
fprintf(stdout, " * Reversible DWT 5-3\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "Parameters:\n");
|
||||
fprintf(stdout, "------------\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf
|
||||
(stdout, "Required Parameters (except with -h):\n");
|
||||
fprintf
|
||||
(stdout, "-i : source file (-i source.yuv) \n");
|
||||
fprintf
|
||||
(stdout, "-o : destination file (-o dest.mj2) \n");
|
||||
fprintf
|
||||
(stdout, "Optional Parameters:\n");
|
||||
fprintf(stdout, "-h : display the help information \n");
|
||||
fprintf(stdout,
|
||||
"-r : different compression ratios for successive layers (-r 20,10,5)\n");
|
||||
fprintf(stdout,
|
||||
" - The rate specified for each quality level is the desired \n");
|
||||
fprintf(stdout, " compression factor.\n");
|
||||
fprintf(stdout, " Example: -r 20,10,1 means quality 1: compress 20x, \n");
|
||||
fprintf(stdout,
|
||||
" quality 2: compress 10x and quality 3: compress lossless\n");
|
||||
fprintf(stdout, " (options -r and -q cannot be used together)\n");
|
||||
|
||||
fprintf(stdout, "-q : different psnr for successive layers (-q 30,40,50) \n");
|
||||
fprintf(stdout, " (options -r and -q cannot be used together)\n");
|
||||
|
||||
fprintf(stdout, "-n : number of resolutions (-n 3) \n");
|
||||
fprintf(stdout, "-b : size of code block (-b 32,32) \n");
|
||||
fprintf(stdout, "-c : size of precinct (-c 128,128) \n");
|
||||
fprintf(stdout, "-t : size of tile (-t 512,512) \n");
|
||||
fprintf
|
||||
(stdout, "-p : progression order (-p LRCP) [LRCP, RLCP, RPCL, PCRL, CPRL] \n");
|
||||
fprintf
|
||||
(stdout, "-s : subsampling factor (-s 2,2) [-s X,Y] \n");
|
||||
fprintf(stdout, " Remark: subsampling bigger than 2 can produce error\n");
|
||||
fprintf
|
||||
(stdout, "-S : write SOP marker before each packet \n");
|
||||
fprintf
|
||||
(stdout, "-E : write EPH marker after each header packet \n");
|
||||
fprintf
|
||||
(stdout, "-M : mode switch (-M 3) [1=BYPASS(LAZY) 2=RESET 4=RESTART(TERMALL)\n");
|
||||
fprintf
|
||||
(stdout, " 8=VSC 16=ERTERM(SEGTERM) 32=SEGMARK(SEGSYM)] \n");
|
||||
fprintf
|
||||
(stdout, " Indicate multiple modes by adding their values. \n");
|
||||
fprintf
|
||||
(stdout, " Example: RESTART(4) + RESET(2) + SEGMARK(32) = -M 38\n");
|
||||
fprintf
|
||||
(stdout, "-R : c=%%d,U=%%d : quantization indices upshifted \n");
|
||||
fprintf
|
||||
(stdout, " for component c=%%d [%%d = 0,1,2]\n");
|
||||
fprintf
|
||||
(stdout, " with a value of U=%%d [0 <= %%d <= 37] (i.e. -ROI:c=0,U=25) \n");
|
||||
fprintf
|
||||
(stdout, "-d : offset of the origin of the image (-d 150,300) \n");
|
||||
fprintf
|
||||
(stdout, "-T : offset of the origin of the tiles (-T 100,75) \n");
|
||||
fprintf(stdout, "-I : use the irreversible DWT 9-7 (-I) \n");
|
||||
fprintf(stdout, "-W : image width, height and the dx and dy subsampling \n");
|
||||
fprintf(stdout, " of the Cb and Cr components for YUV files \n");
|
||||
fprintf(stdout,
|
||||
" (default is '352,288,2,2' for CIF format's 352x288 and 4:2:0)\n");
|
||||
fprintf(stdout, "-F : video frame rate (set to 25 by default)\n");
|
||||
fprintf(stdout, "-D : depth, precision in bits [8 .. 16]; default:8\n");
|
||||
fprintf(stdout, "-C : comment\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "IMPORTANT:\n");
|
||||
fprintf(stdout, "-----------\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "The index file has the structure below:\n");
|
||||
fprintf(stdout, "---------------------------------------\n");
|
||||
fprintf(stdout, "\n");
|
||||
fprintf(stdout, "Image_height Image_width\n");
|
||||
fprintf(stdout, "progression order\n");
|
||||
fprintf(stdout, "Tiles_size_X Tiles_size_Y\n");
|
||||
fprintf(stdout, "Components_nb\n");
|
||||
fprintf(stdout, "Layers_nb\n");
|
||||
fprintf(stdout, "decomposition_levels\n");
|
||||
fprintf(stdout, "[Precincts_size_X_res_Nr Precincts_size_Y_res_Nr]...\n");
|
||||
fprintf(stdout, " [Precincts_size_X_res_0 Precincts_size_Y_res_0]\n");
|
||||
fprintf(stdout, "Main_header_end_position\n");
|
||||
fprintf(stdout, "Codestream_size\n");
|
||||
fprintf(stdout,
|
||||
"Tile_0 start_pos end_Theader end_pos TotalDisto NumPix MaxMSE\n");
|
||||
fprintf(stdout,
|
||||
"Tile_1 '' '' '' '' '' ''\n");
|
||||
fprintf(stdout, "...\n");
|
||||
fprintf(stdout,
|
||||
"Tile_Nt '' '' '' '' '' ''\n");
|
||||
fprintf(stdout,
|
||||
"Tpacket_0 Tile layer res. comp. prec. start_pos end_pos disto\n");
|
||||
fprintf(stdout, "...\n");
|
||||
fprintf(stdout,
|
||||
"Tpacket_Np '' '' '' '' '' '' '' ''\n");
|
||||
|
||||
fprintf(stdout, "MaxDisto\n");
|
||||
|
||||
fprintf(stdout, "TotalDisto\n\n");
|
||||
}
|
||||
|
||||
static OPJ_PROG_ORDER give_progression(const char progression[5])
|
||||
{
|
||||
if (progression[0] == 'L' && progression[1] == 'R'
|
||||
&& progression[2] == 'C' && progression[3] == 'P') {
|
||||
return LRCP;
|
||||
} else {
|
||||
if (progression[0] == 'R' && progression[1] == 'L'
|
||||
&& progression[2] == 'C' && progression[3] == 'P') {
|
||||
return RLCP;
|
||||
} else {
|
||||
if (progression[0] == 'R' && progression[1] == 'P'
|
||||
&& progression[2] == 'C' && progression[3] == 'L') {
|
||||
return RPCL;
|
||||
} else {
|
||||
if (progression[0] == 'P' && progression[1] == 'C'
|
||||
&& progression[2] == 'R' && progression[3] == 'L') {
|
||||
return PCRL;
|
||||
} else {
|
||||
if (progression[0] == 'C' && progression[1] == 'P'
|
||||
&& progression[2] == 'R' && progression[3] == 'L') {
|
||||
return CPRL;
|
||||
} else {
|
||||
return PROG_UNKNOWN;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
mj2_cparameters_t mj2_parameters; /* MJ2 compression parameters */
|
||||
opj_cparameters_t *j2k_parameters; /* J2K compression parameters */
|
||||
opj_event_mgr_t event_mgr; /* event manager */
|
||||
opj_cio_t *cio;
|
||||
int value;
|
||||
opj_mj2_t *movie;
|
||||
opj_image_t *img;
|
||||
int i, j;
|
||||
char *s, S1, S2, S3;
|
||||
unsigned char *buf;
|
||||
int x1, y1, len;
|
||||
long mdat_initpos, offset;
|
||||
FILE *mj2file;
|
||||
int sampleno;
|
||||
opj_cinfo_t* cinfo;
|
||||
opj_bool bSuccess;
|
||||
int numframes;
|
||||
int prec = 8;/* DEFAULT */
|
||||
double total_time = 0;
|
||||
|
||||
memset(&mj2_parameters, 0, sizeof(mj2_cparameters_t));
|
||||
/* default value */
|
||||
/* ------------- */
|
||||
mj2_parameters.w = 352; /* CIF default value*/
|
||||
mj2_parameters.h = 288; /* CIF default value*/
|
||||
mj2_parameters.CbCr_subsampling_dx = 2; /* CIF default value*/
|
||||
mj2_parameters.CbCr_subsampling_dy = 2; /* CIF default value*/
|
||||
mj2_parameters.frame_rate = 25;
|
||||
mj2_parameters.prec = 8; /* DEFAULT */
|
||||
mj2_parameters.enumcs = ENUMCS_SYCC; /* FIXME: ENUMCS_YUV420 */
|
||||
mj2_parameters.meth = 1; /* enumerated color space */
|
||||
|
||||
/*
|
||||
configure the event callbacks (not required)
|
||||
setting of each callback is optional
|
||||
*/
|
||||
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
|
||||
event_mgr.error_handler = error_callback;
|
||||
event_mgr.warning_handler = warning_callback;
|
||||
event_mgr.info_handler = NULL;
|
||||
|
||||
/* set J2K encoding parameters to default values */
|
||||
opj_set_default_encoder_parameters(&mj2_parameters.j2k_parameters);
|
||||
j2k_parameters = &mj2_parameters.j2k_parameters;
|
||||
|
||||
/* Create comment for codestream */
|
||||
if (j2k_parameters->cp_comment == NULL) {
|
||||
const char comment[] = "Created by OpenJPEG version ";
|
||||
const size_t clen = strlen(comment);
|
||||
const char *version = opj_version();
|
||||
j2k_parameters->cp_comment = (char*)malloc(clen + strlen(version) + 1);
|
||||
sprintf(j2k_parameters->cp_comment, "%s%s", comment, version);
|
||||
}
|
||||
|
||||
while (1) {
|
||||
int c = opj_getopt(argc, argv,
|
||||
"i:o:r:q:f:t:n:c:b:p:s:d:P:S:E:M:R:T:C:I:W:F:D:h");
|
||||
if (c == -1) {
|
||||
break;
|
||||
}
|
||||
switch (c) {
|
||||
case 'i': { /* IN fill */
|
||||
char *infile = opj_optarg;
|
||||
s = opj_optarg;
|
||||
while (*s) {
|
||||
s++;
|
||||
}
|
||||
s--;
|
||||
S3 = *s;
|
||||
s--;
|
||||
S2 = *s;
|
||||
s--;
|
||||
S1 = *s;
|
||||
|
||||
if ((S1 == 'y' && S2 == 'u' && S3 == 'v')
|
||||
|| (S1 == 'Y' && S2 == 'U' && S3 == 'V')) {
|
||||
mj2_parameters.decod_format = YUV_DFMT;
|
||||
} else {
|
||||
fprintf(stderr,
|
||||
"!! Unrecognized format for infile : %c%c%c [accept only *.yuv] !!\n\n",
|
||||
S1, S2, S3);
|
||||
return 1;
|
||||
}
|
||||
strncpy(mj2_parameters.infile, infile, sizeof(mj2_parameters.infile) - 1);
|
||||
}
|
||||
break;
|
||||
/* ----------------------------------------------------- */
|
||||
case 'o': { /* OUT fill */
|
||||
char *outfile = opj_optarg;
|
||||
while (*outfile) {
|
||||
outfile++;
|
||||
}
|
||||
outfile--;
|
||||
S3 = *outfile;
|
||||
outfile--;
|
||||
S2 = *outfile;
|
||||
outfile--;
|
||||
S1 = *outfile;
|
||||
|
||||
outfile = opj_optarg;
|
||||
|
||||
if ((S1 == 'm' && S2 == 'j' && S3 == '2')
|
||||
|| (S1 == 'M' && S2 == 'J' && S3 == '2')) {
|
||||
mj2_parameters.cod_format = MJ2_CFMT;
|
||||
} else {
|
||||
fprintf(stderr,
|
||||
"Unknown output format image *.%c%c%c [only *.mj2]!! \n",
|
||||
S1, S2, S3);
|
||||
return 1;
|
||||
}
|
||||
strncpy(mj2_parameters.outfile, outfile, sizeof(mj2_parameters.outfile) - 1);
|
||||
}
|
||||
break;
|
||||
/* ----------------------------------------------------- */
|
||||
case 'r': { /* rates rates/distorsion */
|
||||
float rate;
|
||||
s = opj_optarg;
|
||||
while (sscanf(s, "%f", &rate) == 1) {
|
||||
j2k_parameters->tcp_rates[j2k_parameters->tcp_numlayers] = rate * 2;
|
||||
j2k_parameters->tcp_numlayers++;
|
||||
while (*s && *s != ',') {
|
||||
s++;
|
||||
}
|
||||
if (!*s) {
|
||||
break;
|
||||
}
|
||||
s++;
|
||||
}
|
||||
j2k_parameters->cp_disto_alloc = 1;
|
||||
}
|
||||
break;
|
||||
/* ----------------------------------------------------- */
|
||||
case 'q': /* add fixed_quality */
|
||||
s = opj_optarg;
|
||||
while (sscanf(s, "%f",
|
||||
&j2k_parameters->tcp_distoratio[j2k_parameters->tcp_numlayers]) == 1) {
|
||||
j2k_parameters->tcp_numlayers++;
|
||||
while (*s && *s != ',') {
|
||||
s++;
|
||||
}
|
||||
if (!*s) {
|
||||
break;
|
||||
}
|
||||
s++;
|
||||
}
|
||||
j2k_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;
|
||||
|
||||
s = opj_optarg;
|
||||
sscanf(s, "%d", &numlayers);
|
||||
s++;
|
||||
if (numlayers > 9) {
|
||||
s++;
|
||||
}
|
||||
|
||||
j2k_parameters->tcp_numlayers = numlayers;
|
||||
numresolution = j2k_parameters->numresolution;
|
||||
matrix_width = numresolution * 3;
|
||||
j2k_parameters->cp_matrice = (int *) malloc(numlayers * matrix_width * sizeof(
|
||||
int));
|
||||
s = s + 2;
|
||||
|
||||
for (i = 0; i < numlayers; i++) {
|
||||
row = &j2k_parameters->cp_matrice[i * matrix_width];
|
||||
col = row;
|
||||
j2k_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++;
|
||||
}
|
||||
}
|
||||
j2k_parameters->cp_fixed_alloc = 1;
|
||||
}
|
||||
break;
|
||||
/* ----------------------------------------------------- */
|
||||
case 't': /* tiles */
|
||||
sscanf(opj_optarg, "%d,%d", &j2k_parameters->cp_tdx, &j2k_parameters->cp_tdy);
|
||||
j2k_parameters->tile_size_on = OPJ_TRUE;
|
||||
break;
|
||||
/* ----------------------------------------------------- */
|
||||
case 'n': /* resolution */
|
||||
sscanf(opj_optarg, "%d", &j2k_parameters->numresolution);
|
||||
break;
|
||||
/* ----------------------------------------------------- */
|
||||
case 'c': { /* precinct dimension */
|
||||
char sep;
|
||||
int res_spec = 0;
|
||||
|
||||
char *s = opj_optarg;
|
||||
do {
|
||||
sep = 0;
|
||||
sscanf(s, "[%d,%d]%c", &j2k_parameters->prcw_init[res_spec],
|
||||
&j2k_parameters->prch_init[res_spec], &sep);
|
||||
j2k_parameters->csty |= 0x01;
|
||||
res_spec++;
|
||||
s = strpbrk(s, "]") + 2;
|
||||
} while (sep == ',');
|
||||
j2k_parameters->res_spec = res_spec;
|
||||
}
|
||||
break;
|
||||
|
||||
/* ----------------------------------------------------- */
|
||||
case 'b': { /* code-block dimension */
|
||||
int cblockw_init = 0, cblockh_init = 0;
|
||||
sscanf(opj_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;
|
||||
}
|
||||
j2k_parameters->cblockw_init = cblockw_init;
|
||||
j2k_parameters->cblockh_init = cblockh_init;
|
||||
}
|
||||
break;
|
||||
/* ----------------------------------------------------- */
|
||||
case 'p': { /* progression order */
|
||||
char progression[5];
|
||||
|
||||
strncpy(progression, opj_optarg, 5);
|
||||
j2k_parameters->prog_order = give_progression(progression);
|
||||
if (j2k_parameters->prog_order == -1) {
|
||||
fprintf(stderr, "Unrecognized progression order "
|
||||
"[LRCP, RLCP, RPCL, PCRL, CPRL] !!\n");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
/* ----------------------------------------------------- */
|
||||
case 's': { /* subsampling factor */
|
||||
if (sscanf(opj_optarg, "%d,%d", &j2k_parameters->subsampling_dx,
|
||||
&j2k_parameters->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(opj_optarg, "%d,%d", &j2k_parameters->image_offset_x0,
|
||||
&j2k_parameters->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 */
|
||||
help_display();
|
||||
return 0;
|
||||
break;
|
||||
/* ----------------------------------------------------- */
|
||||
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 = opj_optarg;
|
||||
POC = j2k_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++;
|
||||
}
|
||||
j2k_parameters->numpocs = numpocs;
|
||||
}
|
||||
break;
|
||||
/* ------------------------------------------------------ */
|
||||
case 'S': /* SOP marker */
|
||||
j2k_parameters->csty |= 0x02;
|
||||
break;
|
||||
/* ------------------------------------------------------ */
|
||||
case 'E': /* EPH marker */
|
||||
j2k_parameters->csty |= 0x04;
|
||||
break;
|
||||
/* ------------------------------------------------------ */
|
||||
case 'M': /* Mode switch pas tous au point !! */
|
||||
if (sscanf(opj_optarg, "%d", &value) == 1) {
|
||||
for (i = 0; i <= 5; i++) {
|
||||
int cache = value & (1 << i);
|
||||
if (cache) {
|
||||
j2k_parameters->mode |= (1 << i);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
/* ------------------------------------------------------ */
|
||||
case 'R': { /* ROI */
|
||||
if (sscanf(opj_optarg, "OI:c=%d,U=%d", &j2k_parameters->roi_compno,
|
||||
&j2k_parameters->roi_shift) != 2) {
|
||||
fprintf(stderr, "ROI error !! [-ROI:c='compno',U='shift']\n");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
/* ------------------------------------------------------ */
|
||||
case 'T': { /* Tile offset */
|
||||
if (sscanf(opj_optarg, "%d,%d", &j2k_parameters->cp_tx0,
|
||||
&j2k_parameters->cp_ty0) != 2) {
|
||||
fprintf(stderr, "-T 'tile offset' argument error !! [-T X0,Y0]");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
/* ------------------------------------------------------ */
|
||||
case 'C': { /* Add a comment */
|
||||
j2k_parameters->cp_comment = (char*)malloc(strlen(opj_optarg) + 1);
|
||||
if (j2k_parameters->cp_comment) {
|
||||
strcpy(j2k_parameters->cp_comment, opj_optarg);
|
||||
}
|
||||
}
|
||||
break;
|
||||
/* ------------------------------------------------------ */
|
||||
case 'I': { /* reversible or not */
|
||||
j2k_parameters->irreversible = 1;
|
||||
}
|
||||
break;
|
||||
/* ------------------------------------------------------ */
|
||||
case 'W': /* Width and Height and Cb and Cr subsampling in case of YUV format files */
|
||||
if (sscanf
|
||||
(opj_optarg, "%d,%d,%d,%d", &mj2_parameters.w, &mj2_parameters.h,
|
||||
&mj2_parameters.CbCr_subsampling_dx,
|
||||
&mj2_parameters.CbCr_subsampling_dy) != 4) {
|
||||
fprintf(stderr, "-W argument error");
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
/* ------------------------------------------------------ */
|
||||
case 'F': /* Video frame rate */
|
||||
if (sscanf(opj_optarg, "%d", &mj2_parameters.frame_rate) != 1) {
|
||||
fprintf(stderr, "-F argument error");
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
/* ------------------------------------------------------ */
|
||||
case 'D': /* Depth: the precision */
|
||||
if (sscanf(opj_optarg, "%d", &prec) != 1) {
|
||||
prec = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
/* Error messages */
|
||||
/* -------------- */
|
||||
if (!mj2_parameters.cod_format || !mj2_parameters.decod_format) {
|
||||
fprintf(stderr,
|
||||
"Usage: %s -i yuv-file -o mj2-file (+ options)\n", argv[0]);
|
||||
return 1;
|
||||
}
|
||||
if (prec < 1 || prec > 16) {
|
||||
fprintf(stderr, "Error: Depth %d must be in the range 8 .. 16\n", prec);
|
||||
return 1;
|
||||
}
|
||||
if ((j2k_parameters->cp_disto_alloc || j2k_parameters->cp_fixed_alloc ||
|
||||
j2k_parameters->cp_fixed_quality)
|
||||
&& (!(j2k_parameters->cp_disto_alloc ^ j2k_parameters->cp_fixed_alloc ^
|
||||
j2k_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 (j2k_parameters->tcp_numlayers == 0) {
|
||||
j2k_parameters->tcp_rates[0] = 0; /* MOD antonin : losslessbug */
|
||||
j2k_parameters->tcp_numlayers++;
|
||||
j2k_parameters->cp_disto_alloc = 1;
|
||||
}
|
||||
|
||||
if ((j2k_parameters->cp_tx0 > j2k_parameters->image_offset_x0) ||
|
||||
(j2k_parameters->cp_ty0 > j2k_parameters->image_offset_y0)) {
|
||||
fprintf(stderr,
|
||||
"Error: Tile offset dimension is unnappropriate --> TX0(%d)<=IMG_X0(%d) TYO(%d)<=IMG_Y0(%d) \n",
|
||||
j2k_parameters->cp_tx0, j2k_parameters->image_offset_x0, j2k_parameters->cp_ty0,
|
||||
j2k_parameters->image_offset_y0);
|
||||
return 1;
|
||||
}
|
||||
|
||||
for (i = 0; i < j2k_parameters->numpocs; i++) {
|
||||
if (j2k_parameters->POC[i].prg == -1) {
|
||||
fprintf(stderr,
|
||||
"Unrecognized progression order in option -P (POC n %d) [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n",
|
||||
i + 1);
|
||||
}
|
||||
}
|
||||
|
||||
if (j2k_parameters->cp_tdx > mj2_parameters.Dim[0] ||
|
||||
j2k_parameters->cp_tdy > mj2_parameters.Dim[1]) {
|
||||
fprintf(stderr,
|
||||
"Error: Tile offset dimension is unnappropriate --> TX0(%d)<=IMG_X0(%d) TYO(%d)<=IMG_Y0(%d) \n",
|
||||
j2k_parameters->cp_tdx, mj2_parameters.Dim[0], j2k_parameters->cp_tdy,
|
||||
mj2_parameters.Dim[1]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* to respect profile - 0 */
|
||||
/* ---------------------- */
|
||||
|
||||
x1 = !mj2_parameters.Dim[0] ? (mj2_parameters.w - 1) *
|
||||
j2k_parameters->subsampling_dx
|
||||
+ 1 : mj2_parameters.Dim[0] + (mj2_parameters.w - 1) *
|
||||
j2k_parameters->subsampling_dx + 1;
|
||||
y1 = !mj2_parameters.Dim[1] ? (mj2_parameters.h - 1) *
|
||||
j2k_parameters->subsampling_dy
|
||||
+ 1 : mj2_parameters.Dim[1] + (mj2_parameters.h - 1) *
|
||||
j2k_parameters->subsampling_dy + 1;
|
||||
mj2_parameters.numcomps = 3; /* YUV files only have 3 components */
|
||||
|
||||
mj2_parameters.prec = prec;
|
||||
|
||||
j2k_parameters->tcp_mct = 0;
|
||||
|
||||
mj2file = fopen(mj2_parameters.outfile, "wb");
|
||||
|
||||
if (!mj2file) {
|
||||
fprintf(stderr, "failed to open %s for writing\n", argv[2]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* get a MJ2 decompressor handle */
|
||||
cinfo = mj2_create_compress();
|
||||
movie = (opj_mj2_t*)cinfo->mj2_handle;
|
||||
|
||||
/* catch events using our callbacks and give a local context */
|
||||
opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
|
||||
|
||||
/* setup encoder parameters */
|
||||
mj2_setup_encoder(movie, &mj2_parameters);
|
||||
|
||||
movie->tk[0].num_samples =
|
||||
yuv_num_frames(&movie->tk[0], mj2_parameters.infile);
|
||||
|
||||
if (movie->tk[0].num_samples == 0) {
|
||||
fclose(mj2file);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* One sample per chunk*/
|
||||
movie->tk[0].chunk = (mj2_chunk_t*)
|
||||
malloc(movie->tk[0].num_samples * sizeof(mj2_chunk_t));
|
||||
movie->tk[0].sample = (mj2_sample_t*)
|
||||
malloc(movie->tk[0].num_samples * sizeof(mj2_sample_t));
|
||||
|
||||
if (mj2_init_stdmovie(movie)) {
|
||||
fprintf(stderr, "Error with movie initialization");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Writing JP, FTYP and MDAT boxes */
|
||||
/* Assuming that the JP and FTYP boxes won't be longer than 300 bytes:*/
|
||||
buf = (unsigned char*)
|
||||
malloc(300 * sizeof(unsigned char));
|
||||
|
||||
cio = opj_cio_open((opj_common_ptr)movie->cinfo, buf, 300);
|
||||
|
||||
mj2_write_jp(cio);
|
||||
mj2_write_ftyp(movie, cio);
|
||||
|
||||
mdat_initpos = cio_tell(cio);
|
||||
cio_skip(cio, 4);
|
||||
|
||||
cio_write(cio, MJ2_MDAT, 4);
|
||||
|
||||
fwrite(buf, cio_tell(cio), 1, mj2file);
|
||||
|
||||
offset = cio_tell(cio);
|
||||
opj_cio_close(cio);
|
||||
free(buf);
|
||||
|
||||
for (i = 0; i < movie->num_stk + movie->num_htk + movie->num_vtk; i++) {
|
||||
if (movie->tk[i].track_type != 0) {
|
||||
fprintf(stderr, "Unable to write sound or hint tracks\n");
|
||||
} else {
|
||||
mj2_tk_t *tk;
|
||||
int buflen = 0;
|
||||
|
||||
tk = &movie->tk[i];
|
||||
tk->num_chunks = tk->num_samples;
|
||||
numframes = tk->num_samples;
|
||||
tk->depth = prec;
|
||||
|
||||
fprintf(stderr, "Video Track number %d\n", i);
|
||||
|
||||
img = mj2_image_create(tk, j2k_parameters);
|
||||
|
||||
buflen = 2 * (tk->w * tk->h * 8);
|
||||
buf = (unsigned char *) malloc(buflen * sizeof(unsigned char));
|
||||
|
||||
for (sampleno = 0; sampleno < numframes; sampleno++) {
|
||||
double init_time = opj_clock();
|
||||
double elapsed_time;
|
||||
|
||||
if (yuvtoimage(tk, img, sampleno, j2k_parameters,
|
||||
mj2_parameters.infile)) {
|
||||
fprintf(stderr, "Error with frame number %d in YUV file\n", sampleno);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* setup the encoder parameters using the current image and user parameters */
|
||||
opj_setup_encoder(cinfo, j2k_parameters, img);
|
||||
|
||||
cio = opj_cio_open((opj_common_ptr)movie->cinfo, buf, buflen);
|
||||
|
||||
cio_skip(cio, 4);
|
||||
cio_write(cio, JP2_JP2C, 4); /* JP2C*/
|
||||
|
||||
/* encode the image */
|
||||
bSuccess = opj_encode(cinfo, cio, img, NULL);
|
||||
|
||||
if (!bSuccess) {
|
||||
opj_cio_close(cio);
|
||||
fprintf(stderr, "failed to encode image\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
len = cio_tell(cio) - 8;
|
||||
cio_seek(cio, 0);
|
||||
cio_write(cio, len + 8, 4);
|
||||
opj_cio_close(cio);
|
||||
|
||||
tk->sample[sampleno].sample_size = len + 8;
|
||||
tk->sample[sampleno].offset = offset;
|
||||
tk->chunk[sampleno].offset = offset; /* There is one sample per chunk */
|
||||
fwrite(buf, 1, len + 8, mj2file);
|
||||
offset += len + 8;
|
||||
|
||||
elapsed_time = opj_clock() - init_time;
|
||||
fprintf(stderr, "Frame number %d/%d encoded in %.2f mseconds\n",
|
||||
sampleno + 1, numframes, elapsed_time * 1000);
|
||||
total_time += elapsed_time;
|
||||
} /* for(sampleno */
|
||||
|
||||
free(buf);
|
||||
opj_image_destroy(img);
|
||||
}
|
||||
}/* for(i */
|
||||
|
||||
fseek(mj2file, mdat_initpos, SEEK_SET);
|
||||
|
||||
buf = (unsigned char*) malloc(4 * sizeof(unsigned char));
|
||||
|
||||
/* Init a cio to write box length variable in a little endian way */
|
||||
cio = opj_cio_open(NULL, buf, 4);
|
||||
cio_write(cio, offset - mdat_initpos, 4);
|
||||
fwrite(buf, 4, 1, mj2file);
|
||||
fseek(mj2file, 0, SEEK_END);
|
||||
free(buf);
|
||||
|
||||
/* Writing MOOV box */
|
||||
buf = (unsigned char*)
|
||||
malloc((TEMP_BUF + numframes * 20) * sizeof(unsigned char));
|
||||
cio = opj_cio_open(movie->cinfo, buf, (TEMP_BUF + numframes * 20));
|
||||
mj2_write_moov(movie, cio);
|
||||
fwrite(buf, cio_tell(cio), 1, mj2file);
|
||||
free(buf);
|
||||
|
||||
fprintf(stdout, "Total encoding time: %.2f s for %d frames (%.1f fps)\n",
|
||||
total_time, numframes, (float)numframes / total_time);
|
||||
|
||||
/* Ending program */
|
||||
|
||||
fclose(mj2file);
|
||||
/* free remaining compression structures */
|
||||
mj2_destroy_compress(movie);
|
||||
free(cinfo);
|
||||
|
||||
if (j2k_parameters->cp_comment) {
|
||||
free(j2k_parameters->cp_comment);
|
||||
}
|
||||
if (j2k_parameters->cp_matrice) {
|
||||
free(j2k_parameters->cp_matrice);
|
||||
}
|
||||
opj_cio_close(cio);
|
||||
|
||||
return 0;
|
||||
}
|
|
@ -1,260 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2003-2004, Francois-Olivier Devaux
|
||||
* Copyright (c) 2002-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "opj_apps_config.h"
|
||||
#include "openjpeg.h"
|
||||
#include "j2k_lib.h"
|
||||
#include "cio.h"
|
||||
#include "j2k.h"
|
||||
#include "jp2.h"
|
||||
#include "mj2.h"
|
||||
#include "mj2_convert.h"
|
||||
|
||||
#ifdef OPJ_HAVE_LIBLCMS2
|
||||
#include <lcms2.h>
|
||||
#endif
|
||||
#ifdef OPJ_HAVE_LIBLCMS1
|
||||
#include <lcms.h>
|
||||
#endif
|
||||
#include "color.h"
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
sample error callback expecting a FILE* client object
|
||||
*/
|
||||
static 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
|
||||
*/
|
||||
static void warning_callback(const char *msg, void *client_data)
|
||||
{
|
||||
FILE *stream = (FILE*)client_data;
|
||||
fprintf(stream, "[WARNING] %s", msg);
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
mj2_dparameters_t mj2_parameters; /* decompression parameters */
|
||||
opj_dinfo_t* dinfo;
|
||||
opj_event_mgr_t event_mgr; /* event manager */
|
||||
opj_cio_t *cio = NULL;
|
||||
unsigned int tnum, snum;
|
||||
opj_mj2_t *movie;
|
||||
mj2_tk_t *track;
|
||||
mj2_sample_t *sample;
|
||||
unsigned char* frame_codestream;
|
||||
FILE *file, *outfile;
|
||||
char outfilename[50];
|
||||
opj_image_t *img = NULL;
|
||||
unsigned int max_codstrm_size = 0;
|
||||
double total_time = 0;
|
||||
unsigned int numframes = 0;
|
||||
|
||||
if (argc != 3) {
|
||||
printf("Usage: %s inputfile.mj2 outputfile.yuv\n", argv[0]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
file = fopen(argv[1], "rb");
|
||||
|
||||
if (!file) {
|
||||
fprintf(stderr, "failed to open %s for reading\n", argv[1]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Checking output file */
|
||||
outfile = fopen(argv[2], "w");
|
||||
if (!outfile) {
|
||||
fprintf(stderr, "failed to open %s for writing\n", argv[2]);
|
||||
fclose(file);
|
||||
return 1;
|
||||
}
|
||||
fclose(outfile);
|
||||
|
||||
/*
|
||||
configure the event callbacks (not required)
|
||||
setting of each callback is optional
|
||||
*/
|
||||
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
|
||||
event_mgr.error_handler = error_callback;
|
||||
event_mgr.warning_handler = warning_callback;
|
||||
event_mgr.info_handler = NULL;
|
||||
|
||||
/* get a MJ2 decompressor handle */
|
||||
dinfo = mj2_create_decompress();
|
||||
movie = (opj_mj2_t*)dinfo->mj2_handle;
|
||||
|
||||
/* catch events using our callbacks and give a local context */
|
||||
opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, stderr);
|
||||
|
||||
memset(&mj2_parameters, 0, sizeof(mj2_dparameters_t));
|
||||
/* set J2K decoding parameters to default values */
|
||||
opj_set_default_decoder_parameters(&mj2_parameters.j2k_parameters);
|
||||
|
||||
/* setup the decoder decoding parameters using user parameters */
|
||||
mj2_setup_decoder(movie, &mj2_parameters);
|
||||
|
||||
if (mj2_read_struct(file, movie)) { /* Creating the movie structure */
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Decode first video track */
|
||||
for (tnum = 0;
|
||||
tnum < (unsigned int)(movie->num_htk + movie->num_stk + movie->num_vtk);
|
||||
tnum++) {
|
||||
if (movie->tk[tnum].track_type == 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (movie->tk[tnum].track_type != 0) {
|
||||
printf("Error. Movie does not contain any video track\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
track = &movie->tk[tnum];
|
||||
|
||||
/* Output info on first video tracl */
|
||||
fprintf(stdout,
|
||||
"The first video track contains %d frames.\nWidth: %d, Height: %d \n\n",
|
||||
track->num_samples, track->w, track->h);
|
||||
|
||||
max_codstrm_size = track->sample[0].sample_size - 8;
|
||||
frame_codestream = (unsigned char*) malloc(max_codstrm_size * sizeof(
|
||||
unsigned char));
|
||||
|
||||
numframes = track->num_samples;
|
||||
|
||||
for (snum = 0; snum < numframes; snum++) {
|
||||
double init_time = opj_clock();
|
||||
double elapsed_time;
|
||||
|
||||
sample = &track->sample[snum];
|
||||
if (sample->sample_size - 8 > max_codstrm_size) {
|
||||
max_codstrm_size = sample->sample_size - 8;
|
||||
if ((frame_codestream = (unsigned char*)
|
||||
realloc(frame_codestream, max_codstrm_size)) == NULL) {
|
||||
printf("Error reallocation memory\n");
|
||||
free(frame_codestream);
|
||||
return 1;
|
||||
};
|
||||
}
|
||||
fseek(file, sample->offset + 8, SEEK_SET);
|
||||
fread(frame_codestream, sample->sample_size - 8, 1,
|
||||
file); /* Assuming that jp and ftyp markers size do */
|
||||
|
||||
/* open a byte stream */
|
||||
cio = opj_cio_open((opj_common_ptr)dinfo, frame_codestream,
|
||||
sample->sample_size - 8);
|
||||
|
||||
img = opj_decode(dinfo, cio); /* Decode J2K to image */
|
||||
|
||||
#ifdef WANT_SYCC_TO_RGB
|
||||
if (img->color_space == CLRSPC_SYCC) {
|
||||
color_sycc_to_rgb(img);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (img->icc_profile_buf) {
|
||||
#if defined(OPJ_HAVE_LIBLCMS1) || defined(OPJ_HAVE_LIBLCMS2)
|
||||
color_apply_icc_profile(img);
|
||||
#endif
|
||||
|
||||
free(img->icc_profile_buf);
|
||||
img->icc_profile_buf = NULL;
|
||||
img->icc_profile_len = 0;
|
||||
}
|
||||
|
||||
if (((img->numcomps == 3) && (img->comps[0].dx == img->comps[1].dx / 2)
|
||||
&& (img->comps[0].dx == img->comps[2].dx / 2) && (img->comps[0].dx == 1))
|
||||
|| (img->numcomps == 1)) {
|
||||
|
||||
if (!imagetoyuv(img, argv[2])) { /* Convert image to YUV */
|
||||
return 1;
|
||||
}
|
||||
} else if ((img->numcomps == 3) &&
|
||||
(img->comps[0].dx == 1) && (img->comps[1].dx == 1) &&
|
||||
(img->comps[2].dx == 1)) { /* If YUV 4:4:4 input --> to bmp */
|
||||
fprintf(stdout,
|
||||
"The frames will be output in a bmp format (output_1.bmp, ...)\n");
|
||||
sprintf(outfilename, "output_%d.bmp", snum);
|
||||
if (imagetobmp(img, outfilename)) { /* Convert image to BMP */
|
||||
return 1;
|
||||
}
|
||||
|
||||
} else {
|
||||
fprintf(stdout,
|
||||
"Image component dimensions are unknown. Unable to output image\n");
|
||||
fprintf(stdout,
|
||||
"The frames will be output in a j2k file (output_1.j2k, ...)\n");
|
||||
|
||||
sprintf(outfilename, "output_%d.j2k", snum);
|
||||
outfile = fopen(outfilename, "wb");
|
||||
if (!outfile) {
|
||||
fprintf(stderr, "failed to open %s for writing\n", outfilename);
|
||||
return 1;
|
||||
}
|
||||
fwrite(frame_codestream, sample->sample_size - 8, 1, outfile);
|
||||
fclose(outfile);
|
||||
}
|
||||
/* close the byte stream */
|
||||
opj_cio_close(cio);
|
||||
/* free image data structure */
|
||||
opj_image_destroy(img);
|
||||
elapsed_time = opj_clock() - init_time;
|
||||
fprintf(stderr, "Frame number %d/%d decoded in %.2f mseconds\n", snum + 1,
|
||||
numframes, elapsed_time * 1000);
|
||||
total_time += elapsed_time;
|
||||
|
||||
}
|
||||
|
||||
free(frame_codestream);
|
||||
fclose(file);
|
||||
|
||||
/* free remaining structures */
|
||||
if (dinfo) {
|
||||
mj2_destroy_decompress((opj_mj2_t*)dinfo->mj2_handle);
|
||||
}
|
||||
free(dinfo);
|
||||
|
||||
fprintf(stdout, "%d frame(s) correctly decompressed\n", snum);
|
||||
fprintf(stdout, "Total decoding time: %.2f seconds (%.1f fps)\n", total_time,
|
||||
(float)numframes / total_time);
|
||||
|
||||
return 0;
|
||||
}
|
|
@ -1,178 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2014, Professor Benoit Macq
|
||||
* Copyright (c) 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 <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "openjpeg.h"
|
||||
#include "cio.h"
|
||||
#include "j2k.h"
|
||||
#include "jp2.h"
|
||||
#include "mj2.h"
|
||||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
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[])
|
||||
{
|
||||
opj_dinfo_t* dinfo;
|
||||
opj_event_mgr_t event_mgr; /* event manager */
|
||||
int tnum;
|
||||
unsigned int snum;
|
||||
opj_mj2_t *movie;
|
||||
mj2_tk_t *track;
|
||||
mj2_sample_t *sample;
|
||||
unsigned char* frame_codestream;
|
||||
FILE *file, *outfile;
|
||||
char outfilename[FILENAME_MAX];
|
||||
mj2_dparameters_t parameters;
|
||||
|
||||
if (argc != 3) {
|
||||
printf("Usage: %s mj2filename output_prefix\n", argv[0]);
|
||||
printf("Example: %s foreman.mj2 output/foreman\n", argv[0]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (strlen(argv[2]) + 11 > sizeof(outfilename)) {
|
||||
fprintf(stderr, "filename %d too long\n", strlen(argv[2]) + 11);
|
||||
return 1;
|
||||
}
|
||||
|
||||
file = fopen(argv[1], "rb");
|
||||
|
||||
if (!file) {
|
||||
fprintf(stderr, "failed to open %s for reading\n", argv[1]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
configure the event callbacks (not required)
|
||||
setting of each callback is optional
|
||||
*/
|
||||
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
|
||||
event_mgr.error_handler = error_callback;
|
||||
event_mgr.warning_handler = warning_callback;
|
||||
event_mgr.info_handler = info_callback;
|
||||
|
||||
/* get a MJ2 decompressor handle */
|
||||
dinfo = mj2_create_decompress();
|
||||
|
||||
/* catch events using our callbacks and give a local context */
|
||||
opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, stderr);
|
||||
|
||||
/* setup the decoder decoding parameters using user parameters */
|
||||
memset(¶meters, 0, sizeof(mj2_dparameters_t));
|
||||
movie = (opj_mj2_t*) dinfo->mj2_handle;
|
||||
mj2_setup_decoder(movie, ¶meters);
|
||||
|
||||
if (mj2_read_struct(file, movie)) { /* Creating the movie structure*/
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Decode first video track */
|
||||
tnum = 0;
|
||||
while (movie->tk[tnum].track_type != 0) {
|
||||
tnum ++;
|
||||
}
|
||||
|
||||
track = &movie->tk[tnum];
|
||||
|
||||
fprintf(stdout, "Extracting %d frames from file...\n", track->num_samples);
|
||||
|
||||
for (snum = 0; snum < track->num_samples; snum++) {
|
||||
sample = &track->sample[snum];
|
||||
frame_codestream = (unsigned char*) malloc(sample->sample_size -
|
||||
8); /* Skipping JP2C marker*/
|
||||
fseek(file, sample->offset + 8, SEEK_SET);
|
||||
fread(frame_codestream, sample->sample_size - 8, 1,
|
||||
file); /* Assuming that jp and ftyp markers size do*/
|
||||
|
||||
{
|
||||
int num = snprintf(outfilename, sizeof(outfilename),
|
||||
"%s_%05d.j2k", argv[2],
|
||||
snum);
|
||||
if (num >= sizeof(outfilename)) {
|
||||
fprintf(stderr, "maximum length of output prefix exceeded\n");
|
||||
free(frame_codestream);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
outfile = fopen(outfilename, "wb");
|
||||
if (!outfile) {
|
||||
fprintf(stderr, "failed to open %s for writing\n", outfilename);
|
||||
free(frame_codestream);
|
||||
return 1;
|
||||
}
|
||||
fwrite(frame_codestream, sample->sample_size - 8, 1, outfile);
|
||||
fclose(outfile);
|
||||
free(frame_codestream);
|
||||
}
|
||||
fclose(file);
|
||||
fprintf(stdout, "%d frames correctly extracted\n", snum);
|
||||
|
||||
/* free remaining structures */
|
||||
if (dinfo) {
|
||||
mj2_destroy_decompress((opj_mj2_t*)dinfo->mj2_handle);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
|
@ -1,537 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2014, Professor Benoit Macq
|
||||
* Copyright (c) 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 <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "openjpeg.h"
|
||||
#include "cio.h"
|
||||
#include "j2k.h"
|
||||
#include "jp2.h"
|
||||
#include "mj2.h"
|
||||
|
||||
static int int_ceildiv(int a, int b)
|
||||
{
|
||||
return (a + b - 1) / b;
|
||||
}
|
||||
|
||||
/**
|
||||
Size of memory first allocated for MOOV box
|
||||
*/
|
||||
#define TEMP_BUF 10000
|
||||
|
||||
#define J2K_CODESTREAM_MAGIC "\xff\x4f\xff\x51"
|
||||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
static int test_image(const char *fname, mj2_cparameters_t *cp)
|
||||
{
|
||||
FILE *reader;
|
||||
opj_image_t *image;
|
||||
unsigned char *src;
|
||||
opj_dinfo_t *dinfo;
|
||||
opj_cio_t *cio;
|
||||
opj_dparameters_t dparameters;
|
||||
int success;
|
||||
long src_len;
|
||||
|
||||
success = 0;
|
||||
|
||||
if ((reader = fopen(fname, "rb")) == NULL) {
|
||||
return success;
|
||||
}
|
||||
|
||||
fseek(reader, 0, SEEK_END);
|
||||
src_len = ftell(reader);
|
||||
fseek(reader, 0, SEEK_SET);
|
||||
src = (unsigned char*) malloc(src_len);
|
||||
fread(src, 1, src_len, reader);
|
||||
fclose(reader);
|
||||
|
||||
if (memcmp(src, J2K_CODESTREAM_MAGIC, 4) != 0) {
|
||||
free(src);
|
||||
return success;
|
||||
}
|
||||
memset(&dparameters, 0, sizeof(opj_dparameters_t));
|
||||
|
||||
opj_set_default_decoder_parameters(&dparameters);
|
||||
|
||||
dinfo = opj_create_decompress(CODEC_J2K);
|
||||
|
||||
opj_setup_decoder(dinfo, &dparameters);
|
||||
|
||||
cio = opj_cio_open((opj_common_ptr)dinfo, src, src_len);
|
||||
|
||||
image = opj_decode(dinfo, cio);
|
||||
|
||||
free(src);
|
||||
cio->buffer = NULL;
|
||||
opj_cio_close(cio);
|
||||
|
||||
if (image == NULL) {
|
||||
goto fin;
|
||||
}
|
||||
|
||||
cp->numcomps = image->numcomps;
|
||||
cp->w = image->comps[0].w;
|
||||
cp->h = image->comps[0].h;
|
||||
cp->prec = image->comps[0].prec;
|
||||
|
||||
if (image->numcomps > 2) {
|
||||
if ((image->comps[0].dx == 1)
|
||||
&& (image->comps[1].dx == 2)
|
||||
&& (image->comps[2].dx == 2)
|
||||
&& (image->comps[0].dy == 1)
|
||||
&& (image->comps[1].dy == 2)
|
||||
&& (image->comps[2].dy == 2)) { /* horizontal and vertical*/
|
||||
/* Y420*/
|
||||
cp->enumcs = ENUMCS_SYCC;
|
||||
cp->CbCr_subsampling_dx = 2;
|
||||
cp->CbCr_subsampling_dy = 2;
|
||||
} else if ((image->comps[0].dx == 1)
|
||||
&& (image->comps[1].dx == 2)
|
||||
&& (image->comps[2].dx == 2)
|
||||
&& (image->comps[0].dy == 1)
|
||||
&& (image->comps[1].dy == 1)
|
||||
&& (image->comps[2].dy == 1)) { /* horizontal only*/
|
||||
/* Y422*/
|
||||
cp->enumcs = ENUMCS_SYCC;
|
||||
cp->CbCr_subsampling_dx = 2;
|
||||
cp->CbCr_subsampling_dy = 1;
|
||||
} else if ((image->comps[0].dx == 1)
|
||||
&& (image->comps[1].dx == 1)
|
||||
&& (image->comps[2].dx == 1)
|
||||
&& (image->comps[0].dy == 1)
|
||||
&& (image->comps[1].dy == 1)
|
||||
&& (image->comps[2].dy == 1)) {
|
||||
/* Y444 or RGB */
|
||||
|
||||
if (image->color_space == CLRSPC_SRGB) {
|
||||
cp->enumcs = ENUMCS_SRGB;
|
||||
|
||||
/* cp->CbCr_subsampling_dx = 0; */
|
||||
/* cp->CbCr_subsampling_dy = 0; */
|
||||
} else {
|
||||
cp->enumcs = ENUMCS_SYCC;
|
||||
|
||||
cp->CbCr_subsampling_dx = 1;
|
||||
cp->CbCr_subsampling_dy = 1;
|
||||
}
|
||||
} else {
|
||||
goto fin;
|
||||
}
|
||||
} else {
|
||||
cp->enumcs = ENUMCS_GRAY;
|
||||
/* cp->CbCr_subsampling_dx = 0; */
|
||||
/* cp->CbCr_subsampling_dy = 0; */
|
||||
}
|
||||
if (image->icc_profile_buf) {
|
||||
cp->meth = 2;
|
||||
free(image->icc_profile_buf);
|
||||
image->icc_profile_buf = NULL;
|
||||
} else {
|
||||
cp->meth = 1;
|
||||
}
|
||||
|
||||
success = 1;
|
||||
fin:
|
||||
if (dinfo) {
|
||||
opj_destroy_decompress(dinfo);
|
||||
}
|
||||
|
||||
if (image) {
|
||||
opj_image_destroy(image);
|
||||
}
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
/**
|
||||
sample error callback expecting a FILE* client object
|
||||
*/
|
||||
static 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
|
||||
*/
|
||||
static 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
|
||||
*/
|
||||
static void info_callback(const char *msg, void *client_data)
|
||||
{
|
||||
FILE *stream = (FILE*)client_data;
|
||||
fprintf(stream, "[INFO] %s", msg);
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------------- */
|
||||
|
||||
|
||||
|
||||
static void read_siz_marker(FILE *file, opj_image_t *image)
|
||||
{
|
||||
int len, i;
|
||||
char buf, buf2[2];
|
||||
unsigned char *siz_buffer;
|
||||
opj_cio_t *cio;
|
||||
|
||||
fseek(file, 0, SEEK_SET);
|
||||
do {
|
||||
fread(&buf, 1, 1, file);
|
||||
if (buf == (char)0xff) {
|
||||
fread(&buf, 1, 1, file);
|
||||
}
|
||||
} while (!(buf == (char)0x51));
|
||||
|
||||
fread(buf2, 2, 1, file); /* Lsiz */
|
||||
len = ((buf2[0]) << 8) + buf2[1];
|
||||
|
||||
siz_buffer = (unsigned char*) malloc(len * sizeof(unsigned char));
|
||||
fread(siz_buffer, len, 1, file);
|
||||
cio = opj_cio_open(NULL, siz_buffer, len);
|
||||
|
||||
cio_read(cio, 2); /* Rsiz (capabilities) */
|
||||
image->x1 = cio_read(cio, 4); /* Xsiz */
|
||||
image->y1 = cio_read(cio, 4); /* Ysiz */
|
||||
image->x0 = cio_read(cio, 4); /* X0siz */
|
||||
image->y0 = cio_read(cio, 4); /* Y0siz */
|
||||
cio_skip(cio, 16); /* XTsiz, YTsiz, XT0siz, YT0siz */
|
||||
|
||||
image->numcomps = cio_read(cio, 2); /* Csiz */
|
||||
image->comps =
|
||||
(opj_image_comp_t *) malloc(image->numcomps * sizeof(opj_image_comp_t));
|
||||
|
||||
for (i = 0; i < image->numcomps; i++) {
|
||||
int tmp;
|
||||
tmp = cio_read(cio, 1); /* Ssiz_i */
|
||||
image->comps[i].prec = (tmp & 0x7f) + 1;
|
||||
image->comps[i].sgnd = tmp >> 7;
|
||||
image->comps[i].dx = cio_read(cio, 1); /* XRsiz_i */
|
||||
image->comps[i].dy = cio_read(cio, 1); /* YRsiz_i */
|
||||
image->comps[i].resno_decoded = 0; /* number of resolution decoded */
|
||||
image->comps[i].factor = 0; /* reducing factor by component */
|
||||
}
|
||||
fseek(file, 0, SEEK_SET);
|
||||
opj_cio_close(cio);
|
||||
free(siz_buffer);
|
||||
}
|
||||
|
||||
static void setparams(opj_mj2_t *movie, opj_image_t *image)
|
||||
{
|
||||
int i, depth_0, depth, sign;
|
||||
|
||||
movie->tk[0].w = int_ceildiv(image->x1 - image->x0, image->comps[0].dx);
|
||||
movie->tk[0].h = int_ceildiv(image->y1 - image->y0, image->comps[0].dy);
|
||||
mj2_init_stdmovie(movie);
|
||||
|
||||
movie->tk[0].depth = image->comps[0].prec;
|
||||
|
||||
if (image->numcomps == 3) {
|
||||
if ((image->comps[0].dx == 1)
|
||||
&& (image->comps[1].dx == 1)
|
||||
&& (image->comps[2].dx == 1)) {
|
||||
movie->tk[0].CbCr_subsampling_dx = 1;
|
||||
} else if ((image->comps[0].dx == 1)
|
||||
&& (image->comps[1].dx == 2)
|
||||
&& (image->comps[2].dx == 2)) {
|
||||
movie->tk[0].CbCr_subsampling_dx = 2;
|
||||
} else {
|
||||
fprintf(stderr, "Image component sizes are incoherent\n");
|
||||
}
|
||||
|
||||
if ((image->comps[0].dy == 1)
|
||||
&& (image->comps[1].dy == 1)
|
||||
&& (image->comps[2].dy == 1)) {
|
||||
movie->tk[0].CbCr_subsampling_dy = 1;
|
||||
} else if ((image->comps[0].dy == 1)
|
||||
&& (image->comps[1].dy == 2)
|
||||
&& (image->comps[2].dy == 2)) {
|
||||
movie->tk[0].CbCr_subsampling_dy = 2;
|
||||
} else {
|
||||
fprintf(stderr, "Image component sizes are incoherent\n");
|
||||
}
|
||||
}
|
||||
|
||||
movie->tk[0].sample_rate = 25;
|
||||
|
||||
movie->tk[0].jp2_struct.numcomps = image->numcomps; /* NC */
|
||||
|
||||
/* Init Standard jp2 structure */
|
||||
|
||||
movie->tk[0].jp2_struct.comps =
|
||||
(opj_jp2_comps_t *) malloc(movie->tk[0].jp2_struct.numcomps * sizeof(
|
||||
opj_jp2_comps_t));
|
||||
movie->tk[0].jp2_struct.precedence = 0; /* PRECEDENCE*/
|
||||
movie->tk[0].jp2_struct.approx = 0; /* APPROX*/
|
||||
movie->tk[0].jp2_struct.brand = JP2_JP2; /* BR */
|
||||
movie->tk[0].jp2_struct.minversion = 0; /* MinV */
|
||||
movie->tk[0].jp2_struct.numcl = 1;
|
||||
movie->tk[0].jp2_struct.cl = (unsigned int *) malloc(
|
||||
movie->tk[0].jp2_struct.numcl * sizeof(int));
|
||||
movie->tk[0].jp2_struct.cl[0] = JP2_JP2; /* CL0 : JP2 */
|
||||
movie->tk[0].jp2_struct.C = 7; /* C : Always 7*/
|
||||
movie->tk[0].jp2_struct.UnkC =
|
||||
0; /* UnkC, colorspace specified in colr box*/
|
||||
movie->tk[0].jp2_struct.IPR = 0; /* IPR, no intellectual property*/
|
||||
movie->tk[0].jp2_struct.w = int_ceildiv(image->x1 - image->x0,
|
||||
image->comps[0].dx);
|
||||
movie->tk[0].jp2_struct.h = int_ceildiv(image->y1 - image->y0,
|
||||
image->comps[0].dy);
|
||||
|
||||
depth_0 = image->comps[0].prec - 1;
|
||||
sign = image->comps[0].sgnd;
|
||||
movie->tk[0].jp2_struct.bpc = depth_0 + (sign << 7);
|
||||
|
||||
for (i = 1; i < image->numcomps; i++) {
|
||||
depth = image->comps[i].prec - 1;
|
||||
sign = image->comps[i].sgnd;
|
||||
if (depth_0 != depth) {
|
||||
movie->tk[0].jp2_struct.bpc = 255;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < image->numcomps; i++)
|
||||
movie->tk[0].jp2_struct.comps[i].bpcc =
|
||||
image->comps[i].prec - 1 + (image->comps[i].sgnd << 7);
|
||||
|
||||
if ((image->numcomps == 1 || image->numcomps == 3)
|
||||
&& (movie->tk[0].jp2_struct.bpc != 255)) {
|
||||
movie->tk[0].jp2_struct.meth = 1;
|
||||
} else {
|
||||
movie->tk[0].jp2_struct.meth = 2;
|
||||
}
|
||||
|
||||
if (image->numcomps == 1) {
|
||||
movie->tk[0].jp2_struct.enumcs = 17; /* Grayscale */
|
||||
}
|
||||
|
||||
else if ((image->comps[0].dx == 1)
|
||||
&& (image->comps[1].dx == 1)
|
||||
&& (image->comps[2].dx == 1)
|
||||
&& (image->comps[0].dy == 1)
|
||||
&& (image->comps[1].dy == 1)
|
||||
&& (image->comps[2].dy == 1)) {
|
||||
movie->tk[0].jp2_struct.enumcs = 16; /* RGB */
|
||||
}
|
||||
|
||||
else if ((image->comps[0].dx == 1)
|
||||
&& (image->comps[1].dx == 2)
|
||||
&& (image->comps[2].dx == 2)
|
||||
&& (image->comps[0].dy == 1)
|
||||
&& (image->comps[1].dy == 2)
|
||||
&& (image->comps[2].dy == 2)) {
|
||||
movie->tk[0].jp2_struct.enumcs = 18; /* YUV */
|
||||
}
|
||||
|
||||
else {
|
||||
movie->tk[0].jp2_struct.enumcs = 0; /* Unknown profile */
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
opj_cinfo_t* cinfo;
|
||||
opj_event_mgr_t event_mgr; /* event manager */
|
||||
unsigned int snum;
|
||||
opj_mj2_t *movie;
|
||||
mj2_sample_t *sample;
|
||||
unsigned char* frame_codestream;
|
||||
FILE *mj2file, *j2kfile;
|
||||
char *j2kfilename;
|
||||
unsigned char *buf;
|
||||
int offset, mdat_initpos;
|
||||
opj_image_t img;
|
||||
opj_cio_t *cio;
|
||||
mj2_cparameters_t parameters;
|
||||
|
||||
if (argc != 3) {
|
||||
printf("Usage: %s source_location mj2_filename\n", argv[0]);
|
||||
printf("Example: %s input/input output.mj2\n", argv[0]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
mj2file = fopen(argv[2], "wb");
|
||||
|
||||
if (!mj2file) {
|
||||
fprintf(stderr, "failed to open %s for writing\n", argv[2]);
|
||||
return 1;
|
||||
}
|
||||
memset(&img, 0, sizeof(opj_image_t));
|
||||
/*
|
||||
configure the event callbacks (not required)
|
||||
setting of each callback is optional
|
||||
*/
|
||||
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
|
||||
event_mgr.error_handler = error_callback;
|
||||
event_mgr.warning_handler = warning_callback;
|
||||
event_mgr.info_handler = info_callback;
|
||||
|
||||
/* get a MJ2 decompressor handle */
|
||||
cinfo = mj2_create_compress();
|
||||
|
||||
/* catch events using our callbacks and give a local context */
|
||||
opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
|
||||
|
||||
/* setup the decoder encoding parameters using user parameters */
|
||||
memset(¶meters, 0, sizeof(mj2_cparameters_t));
|
||||
movie = (opj_mj2_t*) cinfo->mj2_handle;
|
||||
|
||||
j2kfilename = (char*)malloc(strlen(argv[1]) + 12);/* max. '%6d' */
|
||||
sprintf(j2kfilename, "%s_00001.j2k", argv[1]);
|
||||
|
||||
if (test_image(j2kfilename, ¶meters) == 0) {
|
||||
goto fin;
|
||||
}
|
||||
|
||||
parameters.frame_rate = 25; /* DEFAULT */
|
||||
|
||||
mj2_setup_encoder(movie, ¶meters);
|
||||
|
||||
|
||||
/* Writing JP, FTYP and MDAT boxes
|
||||
Assuming that the JP and FTYP boxes won't be longer than 300 bytes */
|
||||
|
||||
buf = (unsigned char*) malloc(300 * sizeof(unsigned char));
|
||||
cio = opj_cio_open(movie->cinfo, buf, 300);
|
||||
mj2_write_jp(cio);
|
||||
mj2_write_ftyp(movie, cio);
|
||||
mdat_initpos = cio_tell(cio);
|
||||
cio_skip(cio, 4);
|
||||
cio_write(cio, MJ2_MDAT, 4);
|
||||
fwrite(buf, cio_tell(cio), 1, mj2file);
|
||||
free(buf);
|
||||
|
||||
/* Insert each j2k codestream in a JP2C box */
|
||||
snum = 0;
|
||||
offset = 0;
|
||||
while (1) {
|
||||
mj2_sample_t * new_sample;
|
||||
mj2_chunk_t * new_chunk;
|
||||
sample = &movie->tk[0].sample[snum];
|
||||
sprintf(j2kfilename, "%s_%05d.j2k", argv[1], snum);
|
||||
j2kfile = fopen(j2kfilename, "rb");
|
||||
if (!j2kfile) {
|
||||
if (snum == 0) { /* Could not open a single codestream */
|
||||
fprintf(stderr, "failed to open %s for reading\n", j2kfilename);
|
||||
return 1;
|
||||
} else { /* Tried to open a inexistent codestream */
|
||||
fprintf(stdout, "%d frames are being added to the MJ2 file\n", snum);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Calculating offset for samples and chunks */
|
||||
offset += cio_tell(cio);
|
||||
sample->offset = offset;
|
||||
movie->tk[0].chunk[snum].offset =
|
||||
offset; /* There will be one sample per chunk */
|
||||
|
||||
/* Calculating sample size */
|
||||
fseek(j2kfile, 0, SEEK_END);
|
||||
sample->sample_size = ftell(j2kfile) +
|
||||
8; /* Sample size is codestream + JP2C box header */
|
||||
fseek(j2kfile, 0, SEEK_SET);
|
||||
|
||||
/* Reading siz marker of j2k image for the first codestream */
|
||||
if (snum == 0) {
|
||||
read_siz_marker(j2kfile, &img);
|
||||
}
|
||||
|
||||
/* Writing JP2C box header */
|
||||
frame_codestream = (unsigned char*) malloc(sample->sample_size + 8);
|
||||
cio = opj_cio_open(movie->cinfo, frame_codestream, sample->sample_size);
|
||||
cio_write(cio, sample->sample_size, 4); /* Sample size */
|
||||
cio_write(cio, JP2_JP2C, 4); /* JP2C */
|
||||
|
||||
/* Writing codestream from J2K file to MJ2 file */
|
||||
fread(frame_codestream + 8, sample->sample_size - 8, 1, j2kfile);
|
||||
fwrite(frame_codestream, sample->sample_size, 1, mj2file);
|
||||
cio_skip(cio, sample->sample_size - 8);
|
||||
|
||||
/* Ending loop */
|
||||
fclose(j2kfile);
|
||||
snum++;
|
||||
new_sample = (mj2_sample_t*)
|
||||
realloc(movie->tk[0].sample, (snum + 1) * sizeof(mj2_sample_t));
|
||||
new_chunk = (mj2_chunk_t*)
|
||||
realloc(movie->tk[0].chunk, (snum + 1) * sizeof(mj2_chunk_t));
|
||||
if (new_sample && new_chunk) {
|
||||
movie->tk[0].sample = new_sample;
|
||||
movie->tk[0].chunk = new_chunk;
|
||||
} else {
|
||||
fprintf(stderr, "Failed to allocate enough memory to read %s\n", j2kfilename);
|
||||
return 1;
|
||||
}
|
||||
free(frame_codestream);
|
||||
}
|
||||
|
||||
/* Writing the MDAT box length in header */
|
||||
offset += cio_tell(cio);
|
||||
buf = (unsigned char*) malloc(4 * sizeof(unsigned char));
|
||||
cio = opj_cio_open(movie->cinfo, buf, 4);
|
||||
cio_write(cio, offset - mdat_initpos, 4);
|
||||
fseek(mj2file, (long)mdat_initpos, SEEK_SET);
|
||||
fwrite(buf, 4, 1, mj2file);
|
||||
fseek(mj2file, 0, SEEK_END);
|
||||
free(buf);
|
||||
|
||||
/* Setting movie parameters */
|
||||
movie->tk[0].num_samples = snum;
|
||||
movie->tk[0].num_chunks = snum;
|
||||
setparams(movie, &img);
|
||||
|
||||
/* Writing MOOV box */
|
||||
buf = (unsigned char*) malloc((TEMP_BUF + snum * 20) * sizeof(unsigned char));
|
||||
cio = opj_cio_open(movie->cinfo, buf, (TEMP_BUF + snum * 20));
|
||||
mj2_write_moov(movie, cio);
|
||||
fwrite(buf, cio_tell(cio), 1, mj2file);
|
||||
|
||||
/* Ending program */
|
||||
free(img.comps);
|
||||
opj_cio_close(cio);
|
||||
|
||||
fin:
|
||||
fclose(mj2file);
|
||||
mj2_destroy_compress(movie);
|
||||
free(j2kfilename);
|
||||
|
||||
return 0;
|
||||
}
|
|
@ -1,3 +0,0 @@
|
|||
Attention : the motion jpeg 2000 files currently only work with OpenJPEG v0.97 that you can find here :
|
||||
|
||||
http://www.openjpeg.org/openjpeg_v097.tar.gz
|
|
@ -2,16 +2,6 @@
|
|||
# Part 1 & 2:
|
||||
add_subdirectory(openjp2)
|
||||
|
||||
# optionals components:
|
||||
if(BUILD_JPWL)
|
||||
add_subdirectory(openjpwl)
|
||||
endif()
|
||||
if(BUILD_MJ2)
|
||||
add_subdirectory(openmj2)
|
||||
endif()
|
||||
if(BUILD_JPIP)
|
||||
add_subdirectory(openjpip)
|
||||
endif()
|
||||
if(BUILD_JP3D)
|
||||
add_subdirectory(openjp3d)
|
||||
endif()
|
||||
|
|
|
@ -1,45 +0,0 @@
|
|||
# openjp3d
|
||||
include_regular_expression("^.*$")
|
||||
|
||||
include_directories(
|
||||
${OPENJPEG_BINARY_DIR}/src/lib/openjp2 # opj_config.h
|
||||
)
|
||||
|
||||
set(OPENJP3D_LIBRARY_NAME openjp3d)
|
||||
# Defines the source code for the library
|
||||
set(OPENJP3D_SRCS
|
||||
bio.c cio.c dwt.c event.c jp3d.c jp3d_lib.c mct.c mqc.c openjp3d.c
|
||||
pi.c raw.c t1.c t1_3d.c t2.c tcd.c tgt.c volume.c
|
||||
)
|
||||
|
||||
# Build the library
|
||||
if(WIN32)
|
||||
if(BUILD_SHARED_LIBS)
|
||||
add_definitions(-DOPJ_EXPORTS)
|
||||
else()
|
||||
add_definitions(-DOPJ_STATIC)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# build jp3d lib:
|
||||
add_library(${OPENJP3D_LIBRARY_NAME} ${OPENJP3D_SRCS})
|
||||
if(UNIX)
|
||||
target_link_libraries(${OPENJP3D_LIBRARY_NAME} m)
|
||||
endif()
|
||||
set_target_properties(${OPENJP3D_LIBRARY_NAME} PROPERTIES ${OPENJPEG_LIBRARY_PROPERTIES})
|
||||
if(NOT ${CMAKE_VERSION} VERSION_LESS "2.8.12")
|
||||
target_compile_options(${OPENJP3D_LIBRARY_NAME} PRIVATE ${OPENJPEG_LIBRARY_COMPILE_OPTIONS})
|
||||
endif()
|
||||
|
||||
# Install library
|
||||
install(TARGETS ${OPENJP3D_LIBRARY_NAME}
|
||||
EXPORT OpenJP3DTargets
|
||||
DESTINATION ${OPENJPEG_INSTALL_LIB_DIR}
|
||||
COMPONENT Libraries
|
||||
)
|
||||
|
||||
# Install includes files
|
||||
install(FILES openjp3d.h
|
||||
DESTINATION ${OPENJPEG_INSTALL_INCLUDE_DIR}
|
||||
COMPONENT Headers
|
||||
)
|
|
@ -1,207 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.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, int b);
|
||||
/**
|
||||
Read a bit
|
||||
@param bio BIO handle
|
||||
@return Returns the read bit
|
||||
*/
|
||||
static int bio_getbit(opj_bio_t *bio);
|
||||
/**
|
||||
Write a byte
|
||||
@param bio BIO handle
|
||||
@return Returns 0 if successful, returns 1 otherwise
|
||||
*/
|
||||
static int bio_byteout(opj_bio_t *bio);
|
||||
/**
|
||||
Read a byte
|
||||
@param bio BIO handle
|
||||
@return Returns 0 if successful, returns 1 otherwise
|
||||
*/
|
||||
static int bio_bytein(opj_bio_t *bio);
|
||||
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
local functions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
static int 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 1;
|
||||
}
|
||||
*bio->bp++ = bio->buf >> 8;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int 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 1;
|
||||
}
|
||||
bio->buf |= *bio->bp++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void bio_putbit(opj_bio_t *bio, int b)
|
||||
{
|
||||
if (bio->ct == 0) {
|
||||
bio_byteout(bio);
|
||||
}
|
||||
bio->ct--;
|
||||
bio->buf |= b << bio->ct;
|
||||
}
|
||||
|
||||
/* MOD antonin */
|
||||
static int bio_getbit(opj_bio_t *bio)
|
||||
{
|
||||
/* DOM */
|
||||
if (bio->ct == 0) {
|
||||
bio_bytein(bio);
|
||||
}
|
||||
bio->ct--;
|
||||
return (bio->buf >> bio->ct) & 1;
|
||||
}
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
Bit Input/Output interface
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
opj_bio_t* bio_create()
|
||||
{
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
int bio_numbytes(opj_bio_t *bio)
|
||||
{
|
||||
return (bio->bp - bio->start);
|
||||
}
|
||||
|
||||
void bio_init_enc(opj_bio_t *bio, unsigned char *bp, int 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, unsigned char *bp, int len)
|
||||
{
|
||||
bio->start = bp;
|
||||
bio->end = bp + len;
|
||||
bio->bp = bp;
|
||||
bio->buf = 0;
|
||||
bio->ct = 0;
|
||||
}
|
||||
|
||||
void bio_write(opj_bio_t *bio, int v, int n)
|
||||
{
|
||||
int i;
|
||||
for (i = n - 1; i >= 0; i--) {
|
||||
bio_putbit(bio, (v >> i) & 1);
|
||||
}
|
||||
}
|
||||
|
||||
int bio_read(opj_bio_t *bio, int n)
|
||||
{
|
||||
int i, v;
|
||||
v = 0;
|
||||
for (i = n - 1; i >= 0; i--) {
|
||||
v += bio_getbit(bio) << i;
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
int bio_flush(opj_bio_t *bio)
|
||||
{
|
||||
bio->ct = 0;
|
||||
if (bio_byteout(bio)) {
|
||||
return 1;
|
||||
}
|
||||
if (bio->ct == 7) {
|
||||
bio->ct = 0;
|
||||
if (bio_byteout(bio)) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int bio_inalign(opj_bio_t *bio)
|
||||
{
|
||||
bio->ct = 0;
|
||||
if ((bio->buf & 0xff) == 0xff) {
|
||||
if (bio_bytein(bio)) {
|
||||
return 1;
|
||||
}
|
||||
bio->ct = 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
|
@ -1,137 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#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.
|
||||
*/
|
||||
|
||||
/** @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 */
|
||||
unsigned char *start;
|
||||
/** pointer to the end of the buffer */
|
||||
unsigned char *end;
|
||||
/** pointer to the present position in the buffer */
|
||||
unsigned char *bp;
|
||||
/** temporary place where each byte is read or written */
|
||||
unsigned int buf;
|
||||
/** coder : number of bits free to write. decoder : number of bits read */
|
||||
int ct;
|
||||
} opj_bio_t;
|
||||
|
||||
/** @name Funciones generales */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
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
|
||||
*/
|
||||
int 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, unsigned char *bp, int len);
|
||||
/**
|
||||
Init decoder
|
||||
@param bio BIO handle
|
||||
@param bp Input buffer
|
||||
@param len Input buffer length
|
||||
*/
|
||||
void bio_init_dec(opj_bio_t *bio, unsigned char *bp, int 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, int v, int n);
|
||||
/**
|
||||
Read bits
|
||||
@param bio BIO handle
|
||||
@param n Number of bits to read
|
||||
@return Returns the corresponding read number
|
||||
*/
|
||||
int bio_read(opj_bio_t *bio, int n);
|
||||
/**
|
||||
Flush bits
|
||||
@param bio BIO handle
|
||||
@return Returns 1 if successful, returns 0 otherwise
|
||||
*/
|
||||
int 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
|
||||
*/
|
||||
int bio_inalign(opj_bio_t *bio);
|
||||
/**
|
||||
Read a bit
|
||||
@param bio BIO handle
|
||||
@return Returns the read bit
|
||||
*/
|
||||
/* MOD antonin */
|
||||
/*int bio_getbit(opj_bio_t *bio);*/
|
||||
/* DOM */
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __BIO_H */
|
||||
|
|
@ -1,240 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
opj_cio_t* OPJ_CALLCONV opj_cio_open(opj_common_ptr cinfo,
|
||||
unsigned char *buffer, int length)
|
||||
{
|
||||
opj_cp_t *cp = NULL;
|
||||
opj_cio_t *cio = (opj_cio_t*)opj_malloc(sizeof(opj_cio_t));
|
||||
if (!cio) {
|
||||
return NULL;
|
||||
}
|
||||
cio->cinfo = cinfo;
|
||||
if (buffer && length) {
|
||||
/* wrap a user buffer containing the encoded image */
|
||||
cio->openmode = OPJ_STREAM_READ;
|
||||
cio->buffer = buffer;
|
||||
cio->length = length;
|
||||
} else if (!buffer && !length && cinfo) {
|
||||
/* allocate a buffer for the encoded image */
|
||||
cio->openmode = OPJ_STREAM_WRITE;
|
||||
switch (cinfo->codec_format) {
|
||||
case CODEC_J3D:
|
||||
case CODEC_J2K:
|
||||
cp = ((opj_j3d_t*)cinfo->j3d_handle)->cp;
|
||||
break;
|
||||
default:
|
||||
opj_free(cio);
|
||||
return NULL;
|
||||
}
|
||||
cio->length = cp->tdx * cp->tdy * cp->tdz * cp->tw * cp->th * cp->tl * 4;
|
||||
cio->buffer = (unsigned char *)opj_malloc(cio->length);
|
||||
if (!cio->buffer) {
|
||||
opj_event_msg(cio->cinfo, EVT_ERROR,
|
||||
"Error allocating memory for compressed bitstream\n");
|
||||
opj_free(cio);
|
||||
return NULL;
|
||||
}
|
||||
} else {
|
||||
opj_free(cio);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Initialize byte IO */
|
||||
cio->start = cio->buffer;
|
||||
cio->end = cio->buffer + cio->length;
|
||||
cio->bp = cio->buffer;
|
||||
|
||||
return cio;
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_cio_close(opj_cio_t *cio)
|
||||
{
|
||||
if (cio) {
|
||||
if (cio->openmode == OPJ_STREAM_WRITE) {
|
||||
/* destroy the allocated buffer */
|
||||
opj_free(cio->buffer);
|
||||
}
|
||||
/* destroy the cio */
|
||||
opj_free(cio);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/*
|
||||
* Get position in byte stream.
|
||||
*/
|
||||
int OPJ_CALLCONV cio_tell(opj_cio_t *cio)
|
||||
{
|
||||
return cio->bp - cio->start;
|
||||
}
|
||||
|
||||
/*
|
||||
* Set position in byte stream.
|
||||
*
|
||||
* pos : position, in number of bytes, from the beginning of the stream
|
||||
*/
|
||||
void OPJ_CALLCONV cio_seek(opj_cio_t *cio, int pos)
|
||||
{
|
||||
cio->bp = cio->start + pos;
|
||||
}
|
||||
|
||||
/*
|
||||
* Number of bytes left before the end of the stream.
|
||||
*/
|
||||
int cio_numbytesleft(opj_cio_t *cio)
|
||||
{
|
||||
return cio->end - cio->bp;
|
||||
}
|
||||
|
||||
/*
|
||||
* Get pointer to the current position in the stream.
|
||||
*/
|
||||
unsigned char *cio_getbp(opj_cio_t *cio)
|
||||
{
|
||||
return cio->bp;
|
||||
}
|
||||
|
||||
/*
|
||||
* Write a byte.
|
||||
*/
|
||||
static bool cio_byteout(opj_cio_t *cio, unsigned char v)
|
||||
{
|
||||
if (cio->bp >= cio->end) {
|
||||
opj_event_msg(cio->cinfo, EVT_ERROR, "write error\n");
|
||||
return false;
|
||||
}
|
||||
*cio->bp++ = v;
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read a byte.
|
||||
*/
|
||||
static unsigned char cio_bytein(opj_cio_t *cio)
|
||||
{
|
||||
if (cio->bp >= cio->end) {
|
||||
opj_event_msg(cio->cinfo, EVT_ERROR, "read error\n");
|
||||
return 0;
|
||||
}
|
||||
return *cio->bp++;
|
||||
}
|
||||
|
||||
/*
|
||||
* Write some bytes.
|
||||
*
|
||||
* v : value to write
|
||||
* n : number of bytes to write
|
||||
*/
|
||||
unsigned int cio_write(opj_cio_t *cio, unsigned int v, int n)
|
||||
{
|
||||
int i;
|
||||
for (i = n - 1; i >= 0; i--) {
|
||||
if (!cio_byteout(cio, (unsigned char)((v >> (i << 3)) & 0xff))) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read some bytes.
|
||||
*
|
||||
* n : number of bytes to read
|
||||
*
|
||||
* return : value of the n bytes read
|
||||
*/
|
||||
unsigned int cio_read(opj_cio_t *cio, int n)
|
||||
{
|
||||
int i;
|
||||
unsigned int v;
|
||||
v = 0;
|
||||
for (i = n - 1; i >= 0; i--) {
|
||||
v += cio_bytein(cio) << (i << 3);
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
/*
|
||||
* Skip some bytes.
|
||||
*
|
||||
* n : number of bytes to skip
|
||||
*/
|
||||
void cio_skip(opj_cio_t *cio, int n)
|
||||
{
|
||||
cio->bp += n;
|
||||
}
|
||||
|
||||
/*
|
||||
* Write some bytes.
|
||||
*
|
||||
* v : value to write
|
||||
* n : number of bytes to write
|
||||
*/
|
||||
int cio_write_int(opj_cio_t *cio, int v, int n)
|
||||
{
|
||||
int i;
|
||||
for (i = n - 1; i >= 0; i--) {
|
||||
if (!cio_byteout(cio, (char)((v >> (i << 3)) & 0xff))) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read some bytes.
|
||||
*
|
||||
* n : number of bytes to read
|
||||
*
|
||||
* return : value of the n bytes read
|
||||
*/
|
||||
int cio_read_int(opj_cio_t *cio, int n)
|
||||
{
|
||||
int i;
|
||||
int v;
|
||||
v = 0;
|
||||
for (i = n - 1; i >= 0; i--) {
|
||||
v += cio_bytein(cio) << (i << 3);
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
|
@ -1,105 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#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 */
|
||||
/*@{*/
|
||||
|
||||
/** @name Funciones generales (see also openjp3d.h) */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Number of bytes left before the end of the stream
|
||||
@param cio CIO handle
|
||||
@return Returns the number of bytes before the end of the stream
|
||||
*/
|
||||
int cio_numbytesleft(opj_cio_t *cio);
|
||||
/**
|
||||
Get pointer to the current position in the stream
|
||||
@param cio CIO handle
|
||||
@return Returns a pointer to the current position
|
||||
*/
|
||||
unsigned char *cio_getbp(opj_cio_t *cio);
|
||||
/**
|
||||
Write some bytes
|
||||
@param cio CIO handle
|
||||
@param v Value to write
|
||||
@param n Number of bytes to write
|
||||
@return Returns the number of bytes written or 0 if an error occurred
|
||||
*/
|
||||
unsigned int cio_write(opj_cio_t *cio, unsigned int v, int n);
|
||||
/**
|
||||
Read some bytes
|
||||
@param cio CIO handle
|
||||
@param n Number of bytes to read
|
||||
@return Returns the value of the n bytes read
|
||||
*/
|
||||
unsigned int cio_read(opj_cio_t *cio, int n);
|
||||
/**
|
||||
Skip some bytes
|
||||
@param cio CIO handle
|
||||
@param n Number of bytes to skip
|
||||
*/
|
||||
void cio_skip(opj_cio_t *cio, int n);
|
||||
/**
|
||||
Write some bytes
|
||||
@param cio CIO handle
|
||||
@param v Signed integer value to write
|
||||
@param n Number of bytes to write
|
||||
@return Returns the number of bytes written or 0 if an error occurred
|
||||
*/
|
||||
int cio_write_int(opj_cio_t *cio, int v, int n);
|
||||
/**
|
||||
Read some bytes
|
||||
@param cio CIO handle
|
||||
@param n Number of bytes to read
|
||||
@return Returns the value of the n bytes read
|
||||
*/
|
||||
int cio_read_int(opj_cio_t *cio, int n);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __CIO_H */
|
||||
|
File diff suppressed because it is too large
Load Diff
|
@ -1,106 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* Copyrigth (c) 2006, Mónica Díez, LPI-UVA, Spain
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/** @defgroup DWT DWT - Implementation of a discrete wavelet transform */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
DCCS-LIWT properties
|
||||
*/
|
||||
|
||||
|
||||
typedef struct opj_wtfilt {
|
||||
double *LPS;
|
||||
int lenLPS;
|
||||
double *HPS;
|
||||
int lenHPS;
|
||||
} opj_wtfilt_t;
|
||||
/** @name Funciones generales */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Forward 5-3 wavelet transform in 3-D.
|
||||
Apply a reversible DWT transform to a component of an volume.
|
||||
@param tilec Tile component information (current tile)
|
||||
@param dwtid Number of identification of wavelet kernel(s) used in DWT in each direction
|
||||
*/
|
||||
void dwt_encode(opj_tcd_tilecomp_t * tilec, int dwtid[3]);
|
||||
/**
|
||||
Inverse 5-3 wavelet transform in 3-D.
|
||||
Apply a reversible inverse DWT transform to a component of an volume.
|
||||
@param tilec Tile component information (current tile)
|
||||
@param stops Number of decoded resolution levels in each dimension
|
||||
@param dwtid Number of identification of wavelet kernel(s) used in DWT in each dimension
|
||||
*/
|
||||
void dwt_decode(opj_tcd_tilecomp_t * tilec, int stops[3], int dwtid[3]);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Get the gain of a subband for the reversible 3-D DWT.
|
||||
@param orient Number that identifies the subband (0->LLL, 1->HLL, 2->LHL, 3->HHL, 4->LLH, 5->HLH, 6->LHH, 7->HHH)
|
||||
@param reversible Wavelet transformation type
|
||||
@return Returns 0 if orient = 0, returns 1 if orient = 1,2 or 4, returns 2 if orient = 3,5 or 6, returns 3 otherwise
|
||||
*/
|
||||
int dwt_getgain(int orient, int reversible);
|
||||
/**
|
||||
Get the norm of a wavelet function of a subband at a specified level for the reversible 5-3 DWT or irreversible 9-7 in 3-D.
|
||||
@param orient Band of the wavelet function
|
||||
@param level Levels of the wavelet function in X,Y,Z axis
|
||||
@param dwtid Wavelet transformation identifier
|
||||
@return Returns the norm of the wavelet function
|
||||
*/
|
||||
double dwt_getnorm(int orient, int level[3], int dwtid[3]);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Calcula el valor del escalón de cuantificación correspondiente a cada subbanda.
|
||||
@param tccp Tile component coding parameters
|
||||
@param prec Precision of data
|
||||
*/
|
||||
void dwt_calc_explicit_stepsizes(opj_tccp_t * tccp, int prec);
|
||||
/*@}*/
|
||||
/*@}*/
|
||||
|
||||
#endif /* __DWT_H */
|
|
@ -1,189 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 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.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/* ==========================================================
|
||||
// Utility functions
|
||||
// ==========================================================*/
|
||||
|
||||
#ifndef _WIN32
|
||||
static char*
|
||||
i2a(unsigned i, char *a, unsigned r)
|
||||
{
|
||||
if (i / r > 0) {
|
||||
a = i2a(i / r, a, r);
|
||||
}
|
||||
*a = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[i % r];
|
||||
return a + 1;
|
||||
}
|
||||
|
||||
/**
|
||||
Transforms integer i into an ascii string and stores the result in a;
|
||||
string is encoded in the base indicated by r.
|
||||
@param i Number to be converted
|
||||
@param a String result
|
||||
@param r Base of value; must be in the range 2 - 36
|
||||
@return Returns a
|
||||
*/
|
||||
static char *
|
||||
_itoa(int i, char *a, int r)
|
||||
{
|
||||
r = ((r < 2) || (r > 36)) ? 10 : r;
|
||||
if (i < 0) {
|
||||
*a = '-';
|
||||
*i2a(-i, a + 1, r) = 0;
|
||||
} else {
|
||||
*i2a(i, a, r) = 0;
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
#endif /* !_WIN32 */
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
opj_event_mgr_t* OPJ_CALLCONV opj_set_event_mgr(opj_common_ptr cinfo,
|
||||
opj_event_mgr_t *event_mgr, void *context)
|
||||
{
|
||||
if (cinfo) {
|
||||
opj_event_mgr_t *previous = cinfo->event_mgr;
|
||||
cinfo->event_mgr = event_mgr;
|
||||
cinfo->client_data = context;
|
||||
return previous;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bool opj_event_msg(opj_common_ptr cinfo, int event_type, const char *fmt, ...)
|
||||
{
|
||||
#define MSG_SIZE 512 /* 512 bytes should be more than enough for a short message */
|
||||
opj_msg_callback msg_handler = NULL;
|
||||
|
||||
opj_event_mgr_t *event_mgr = cinfo->event_mgr;
|
||||
if (event_mgr != NULL) {
|
||||
switch (event_type) {
|
||||
case EVT_ERROR:
|
||||
msg_handler = event_mgr->error_handler;
|
||||
break;
|
||||
case EVT_WARNING:
|
||||
msg_handler = event_mgr->warning_handler;
|
||||
break;
|
||||
case EVT_INFO:
|
||||
msg_handler = event_mgr->info_handler;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if (msg_handler == NULL) {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
|
||||
if ((fmt != NULL) && (event_mgr != NULL)) {
|
||||
va_list arg;
|
||||
int str_length, i, j;
|
||||
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' */
|
||||
for (i = 0, j = 0; i < str_length; ++i) {
|
||||
if (fmt[i] == '%') {
|
||||
if (i + 1 < str_length) {
|
||||
switch (tolower(fmt[i + 1])) {
|
||||
case '%' :
|
||||
message[j++] = '%';
|
||||
break;
|
||||
case 'o' : { /* octal numbers */
|
||||
char tmp[16];
|
||||
_itoa(va_arg(arg, int), tmp, 8);
|
||||
strcat(message, tmp);
|
||||
j += strlen(tmp);
|
||||
++i;
|
||||
break;
|
||||
}
|
||||
case 'i' : /* decimal numbers */
|
||||
case 'd' : {
|
||||
char tmp[16];
|
||||
_itoa(va_arg(arg, int), tmp, 10);
|
||||
strcat(message, tmp);
|
||||
j += strlen(tmp);
|
||||
++i;
|
||||
break;
|
||||
}
|
||||
case 'x' : { /* hexadecimal numbers */
|
||||
char tmp[16];
|
||||
_itoa(va_arg(arg, int), tmp, 16);
|
||||
strcat(message, tmp);
|
||||
j += strlen(tmp);
|
||||
++i;
|
||||
break;
|
||||
}
|
||||
case 's' : { /* strings */
|
||||
char *tmp = va_arg(arg, char*);
|
||||
strcat(message, tmp);
|
||||
j += strlen(tmp);
|
||||
++i;
|
||||
break;
|
||||
}
|
||||
case 'f' : { /* floats */
|
||||
char tmp[16];
|
||||
double value = va_arg(arg, double);
|
||||
sprintf(tmp, "%f", value);
|
||||
strcat(message, tmp);
|
||||
j += strlen(tmp);
|
||||
++i;
|
||||
break;
|
||||
}
|
||||
};
|
||||
} else {
|
||||
message[j++] = fmt[i];
|
||||
}
|
||||
} else {
|
||||
message[j++] = fmt[i];
|
||||
};
|
||||
}
|
||||
/* deinitialize the optional parameter list */
|
||||
va_end(arg);
|
||||
|
||||
/* output the message to the user program */
|
||||
msg_handler(message, cinfo->client_data);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
|
@ -1,63 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 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 __EVENT_H
|
||||
#define __EVENT_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.
|
||||
*/
|
||||
|
||||
#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 Funciones generales (see also openjp3d.h) */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Write formatted data to a string and send the string to a user callback.
|
||||
@param cinfo Codec context info
|
||||
@param event_type Event type or callback to use to send the message
|
||||
@param fmt Format-control string (plus optional arguments)
|
||||
@return Returns true if successful, returns false otherwise
|
||||
*/
|
||||
bool opj_event_msg(opj_common_ptr cinfo, int event_type, const char *fmt, ...);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __EVENT_H */
|
|
@ -1,68 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#ifndef __FIX_H
|
||||
#define __FIX_H
|
||||
|
||||
#if defined(_MSC_VER) || defined(__BORLANDC__)
|
||||
#define int64 __int64
|
||||
#else
|
||||
#define int64 long long
|
||||
#endif
|
||||
|
||||
/**
|
||||
@file fix.h
|
||||
@brief Implementation of operations of specific multiplication (FIX)
|
||||
|
||||
The functions in FIX.H have for goal to realize specific multiplication.
|
||||
*/
|
||||
|
||||
/** @defgroup FIX FIX - Implementation of operations of specific multiplication */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Multiply two fixed-precision rational numbers.
|
||||
@param a
|
||||
@param b
|
||||
@return Returns a * b
|
||||
*/
|
||||
static int fix_mul(int a, int b)
|
||||
{
|
||||
int64 temp = (int64) a * (int64) b >> 12;
|
||||
return (int)((temp >> 1) + (temp & 1)) ;
|
||||
}
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __FIX_H */
|
|
@ -1,138 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#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.
|
||||
*/
|
||||
|
||||
/** @defgroup INT INT - Implementation of operations on integers */
|
||||
/*@{*/
|
||||
|
||||
/** @name Funciones generales (see also openjp3d.h) */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Get the minimum of two integers
|
||||
@return Returns a if a < b else b
|
||||
*/
|
||||
static int int_min(int a, int b)
|
||||
{
|
||||
return a < b ? a : b;
|
||||
}
|
||||
/**
|
||||
Get the maximum of two integers
|
||||
@return Returns a if a > b else b
|
||||
*/
|
||||
static int int_max(int a, int b)
|
||||
{
|
||||
return (a > b) ? a : b;
|
||||
}
|
||||
/**
|
||||
Clamp an integer inside an interval
|
||||
@return
|
||||
<ul>
|
||||
<li>Returns a if (min < a < max)
|
||||
<li>Returns max if (a > max)
|
||||
<li>Returns min if (a < min)
|
||||
</ul>
|
||||
*/
|
||||
static int int_clamp(int a, int min, int max)
|
||||
{
|
||||
if (a < min) {
|
||||
return min;
|
||||
}
|
||||
if (a > max) {
|
||||
return max;
|
||||
}
|
||||
return a;
|
||||
}
|
||||
/**
|
||||
@return Get absolute value of integer
|
||||
*/
|
||||
static int int_abs(int a)
|
||||
{
|
||||
return a < 0 ? -a : a;
|
||||
}
|
||||
|
||||
static double dbl_abs(double a)
|
||||
{
|
||||
return a < 0 ? -a : a;
|
||||
}
|
||||
/**
|
||||
Divide an integer and round upwards
|
||||
@return Returns a divided by b
|
||||
*/
|
||||
static int int_ceildiv(int a, int b)
|
||||
{
|
||||
return (a + b - 1) / b;
|
||||
}
|
||||
/**
|
||||
Divide an integer by a power of 2 and round upwards
|
||||
@return Returns a divided by 2^b
|
||||
*/
|
||||
static int int_ceildivpow2(int a, int 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 int int_floordivpow2(int a, int b)
|
||||
{
|
||||
return a >> b;
|
||||
}
|
||||
/**
|
||||
Get logarithm of an integer and round downwards
|
||||
@return Returns log2(a)
|
||||
*/
|
||||
static int int_floorlog2(int a)
|
||||
{
|
||||
int l;
|
||||
for (l = 0; a > 1; l++) {
|
||||
a >>= 1;
|
||||
}
|
||||
return l;
|
||||
}
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif
|
File diff suppressed because it is too large
Load Diff
|
@ -1,525 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* Copyright (c) 2006, Mónica Díez García, Image Processing Laboratory, University of Valladolid, Spain
|
||||
* 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 __J3D_H
|
||||
#define __J3D_H
|
||||
/**
|
||||
@file jp3d.h
|
||||
@brief The JPEG-2000 Codestream Reader/Writer (J3D)
|
||||
|
||||
The functions in J3D.C have for goal to read/write the several parts of the codestream: markers and data.
|
||||
*/
|
||||
|
||||
/** @defgroup J3D J3D - JPEG-2000 PART 10 codestream reader/writer */
|
||||
/*@{*/
|
||||
|
||||
#define J3D_CP_CSTY_PRT 0x01
|
||||
#define J3D_CP_CSTY_SOP 0x02
|
||||
#define J3D_CP_CSTY_EPH 0x04
|
||||
#define J3D_CCP_CSTY_PRT 0x01
|
||||
/** Table A-8 */
|
||||
#define J3D_CCP_CBLKSTY_LAZY 0x01 /* Selective arithmetic coding bypass */
|
||||
#define J3D_CCP_CBLKSTY_RESET 0x02 /* Reset context probabilities on coding pass boundaries */
|
||||
#define J3D_CCP_CBLKSTY_TERMALL 0x04 /* Termination on each coding pass */
|
||||
#define J3D_CCP_CBLKSTY_VSC 0x08 /* Vertically causal context, add also hook for switching off and on 3D context models */
|
||||
#define J3D_CCP_CBLKSTY_PTERM 0x10 /* Predictable termination */
|
||||
#define J3D_CCP_CBLKSTY_SEGSYM 0x20 /* Segmentation symbols are used */
|
||||
#define J3D_CCP_CBLKSTY_3DCTXT 0x40 /* 3D context models (3D-EBCOT) vs 2D context models */
|
||||
|
||||
#define J3D_CCP_QNTSTY_NOQNT 0 /* Quantization style : no quantization */
|
||||
#define J3D_CCP_QNTSTY_SIQNT 1 /* Quantization style : scalar derived (values signalled only in LLL subband) */
|
||||
#define J3D_CCP_QNTSTY_SEQNT 2 /* Quantization style : scalar expounded (values signalled for each subband) */
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
#define J3D_MS_SOC 0xff4f /**< SOC marker value */
|
||||
#define J3D_MS_SOT 0xff90 /**< SOT marker value */
|
||||
#define J3D_MS_SOD 0xff93 /**< SOD marker value */
|
||||
#define J3D_MS_EOC 0xffd9 /**< EOC marker value */
|
||||
#define J3D_MS_CAP 0xff50 /**< CAP marker value */
|
||||
#define J3D_MS_SIZ 0xff51 /**< SIZ marker value */
|
||||
#define J3D_MS_NSI 0xff54 /**< NSI marker value */
|
||||
#define J3D_MS_COD 0xff52 /**< COD marker value */
|
||||
#define J3D_MS_COC 0xff53 /**< COC marker value */
|
||||
#define J3D_MS_RGN 0xff5e /**< RGN marker value */
|
||||
#define J3D_MS_QCD 0xff5c /**< QCD marker value */
|
||||
#define J3D_MS_QCC 0xff5d /**< QCC marker value */
|
||||
#define J3D_MS_POC 0xff5f /**< POC marker value */
|
||||
#define J3D_MS_TLM 0xff55 /**< TLM marker value */
|
||||
#define J3D_MS_PLM 0xff57 /**< PLM marker value */
|
||||
#define J3D_MS_PLT 0xff58 /**< PLT marker value */
|
||||
#define J3D_MS_PPM 0xff60 /**< PPM marker value */
|
||||
#define J3D_MS_PPT 0xff61 /**< PPT marker value */
|
||||
#define J3D_MS_SOP 0xff91 /**< SOP marker value */
|
||||
#define J3D_MS_EPH 0xff92 /**< EPH marker value */
|
||||
#define J3D_MS_CRG 0xff63 /**< CRG marker value */
|
||||
#define J3D_MS_COM 0xff64 /**< COM marker value */
|
||||
/*15444-2*/
|
||||
#define J3D_MS_DCO 0xff70 /**< DCO marker value */
|
||||
#define J3D_MS_VMS 0xff71 /**< VMS marker value */
|
||||
#define J3D_MS_DFS 0xff72 /**< DFS marker value */
|
||||
#define J3D_MS_ADS 0xff73 /**< ADS marker value */
|
||||
#define J3D_MS_ATK 0xff79 /**< ATK marker value */
|
||||
#define J3D_MS_CBD 0xff78 /**< CBD marker value */
|
||||
#define J3D_MS_MCT 0xff74 /**< MCT marker value */
|
||||
#define J3D_MS_MCC 0xff75 /**< MCC marker value */
|
||||
#define J3D_MS_MCO 0xff77 /**< MCO marker value */
|
||||
#define J3D_MS_NLT 0xff76 /**< NLT marker value */
|
||||
#define J3D_MS_QPD 0xff5a /**< QPD marker value */
|
||||
#define J3D_MS_QPC 0xff5b /**< QPC marker value */
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/* Capability RSIZ parameter, extended */
|
||||
#define J3D_RSIZ_BASIC 0x0000
|
||||
|
||||
#define J3D_RSIZ_DCO 0x8001 /* Required */
|
||||
#define J3D_RSIZ_VSQNT 0x8002
|
||||
#define J3D_RSIZ_TCQNT 0x8004
|
||||
#define J3D_RSIZ_VMASK 0x8008
|
||||
#define J3D_RSIZ_SSOVL 0x8010
|
||||
#define J3D_RSIZ_ADECS 0x8020
|
||||
#define J3D_RSIZ_ATK 0x8040 /*Required*/
|
||||
#define J3D_RSIZ_SSYMK 0x8080
|
||||
#define J3D_RSIZ_MCT 0x8100 /*Not compatible with DCO*/
|
||||
#define J3D_RSIZ_NLT 0x8200 /*Required*/
|
||||
#define J3D_RSIZ_ASHAP 0x8400
|
||||
#define J3D_RSIZ_PRQNT 0x8800
|
||||
|
||||
#define J3D_CAP_10 0x00400000
|
||||
/* Arbitrary transformation kernel, 15444-2 */
|
||||
#define J3D_ATK_IRR 0
|
||||
#define J3D_ATK_REV 1
|
||||
#define J3D_ATK_ARB 0
|
||||
#define J3D_ATK_WS 1
|
||||
#define J3D_ATK_CON 0
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
Values that specify the status of the decoding process when decoding the main header.
|
||||
These values may be combined with a | operator.
|
||||
*/
|
||||
typedef enum J3D_STATUS {
|
||||
/**< a SOC marker is expected */
|
||||
J3D_STATE_MHSOC = 0x0001,
|
||||
/**< a SIZ marker is expected */
|
||||
J3D_STATE_MHSIZ = 0x0002,
|
||||
/**< the decoding process is in the main header */
|
||||
J3D_STATE_MH = 0x0004,
|
||||
/**< the decoding process is in a tile part header and expects a SOT marker */
|
||||
J3D_STATE_TPHSOT = 0x0008,
|
||||
/**< the decoding process is in a tile part header */
|
||||
J3D_STATE_TPH = 0x0010,
|
||||
/**< the EOC marker has just been read */
|
||||
J3D_STATE_MT = 0x0020,
|
||||
/**< the decoding process must not expect a EOC marker because the codestream is truncated */
|
||||
J3D_STATE_NEOC = 0x0040
|
||||
} J3D_STATUS;
|
||||
|
||||
|
||||
|
||||
/**
|
||||
Arbitrary transformation kernel
|
||||
*/
|
||||
typedef struct opj_atk {
|
||||
/** index of wavelet kernel */
|
||||
int index;
|
||||
/** Numerical type of scaling factor and lifting step parameters */
|
||||
int coeff_typ;
|
||||
/** Wavelet filter category */
|
||||
int filt_cat;
|
||||
/** Wavelet transformation type (REV/IRR) */
|
||||
int wt_typ;
|
||||
/** Initial odd/even subsequence */
|
||||
int minit;
|
||||
/** Boundary extension method (constant CON / whole-sample symmetric WS) */
|
||||
int exten;
|
||||
/** Scaling factor. Only for wt_typ=IRR */
|
||||
double Katk;
|
||||
/** Number of lifting steps */
|
||||
int Natk;
|
||||
/** Offset for lifting step s. Only for filt_cat=ARB */
|
||||
int Oatk[256];
|
||||
/** Base 2 scaling exponent for lifting step s. Only for wt_typ=REV */
|
||||
int Eatk[256];
|
||||
/** Additive residue for lifting step s. Only for wt_typ=REV */
|
||||
int Batk[256];
|
||||
/** Number of lifting coefficients signaled for lifting step s */
|
||||
int LCatk[256];
|
||||
/** Lifting coefficient k for lifting step s */
|
||||
double Aatk[256][256];
|
||||
} opj_atk_t;
|
||||
|
||||
|
||||
/**
|
||||
Quantization stepsize
|
||||
*/
|
||||
typedef struct opj_stepsize {
|
||||
/** exponent */
|
||||
int expn;
|
||||
/** mantissa */
|
||||
int mant;
|
||||
} opj_stepsize_t;
|
||||
|
||||
/**
|
||||
Tile-component coding parameters
|
||||
*/
|
||||
typedef struct opj_tccp {
|
||||
/** coding style */
|
||||
int csty;
|
||||
/** number of resolutions of x, y and z-axis */
|
||||
int numresolution[3];
|
||||
/** code-blocks width height & depth*/
|
||||
int cblk[3];
|
||||
/** code-block coding style */
|
||||
int cblksty;
|
||||
/** 0: no ATK (only 9-7 or 5-3) 1: ATK defined WT*/
|
||||
int atk_wt[3];
|
||||
/** Arbitrary transformation kernel (15444-2)*/
|
||||
opj_atk_t *atk;
|
||||
/** DWT identifier for x, y and z-axis (0:WT9-7 1:WT5-3 >1:WT-atk->index) */
|
||||
int dwtid[3];
|
||||
/** reversible/irreversible wavelet transfomation (0:irrev 1:reversible)*/
|
||||
int reversible;
|
||||
/** quantisation style */
|
||||
int qntsty;
|
||||
/** stepsizes used for quantization */
|
||||
opj_stepsize_t stepsizes[J3D_MAXBANDS];
|
||||
/** number of guard bits. Table A28 de 15444-1*/
|
||||
int numgbits;
|
||||
/** Region Of Interest shift */
|
||||
int roishift;
|
||||
/** precinct width height & depth*/
|
||||
int prctsiz[3][J3D_MAXRLVLS];
|
||||
} opj_tccp_t;
|
||||
|
||||
/**
|
||||
Tile coding parameters : coding/decoding parameters common to all tiles
|
||||
(information like COD, COC in main header)
|
||||
*/
|
||||
typedef struct opj_tcp {
|
||||
/** 1 : first part-tile of a tile */
|
||||
int first;
|
||||
/** coding style */
|
||||
int csty;
|
||||
/** progression order */
|
||||
OPJ_PROG_ORDER prg;
|
||||
/** number of layers */
|
||||
int numlayers;
|
||||
/** multi-component transform identifier */
|
||||
int mct;
|
||||
/** rates of layers */
|
||||
float rates[100];
|
||||
/** number of progression order changes */
|
||||
int numpocs;
|
||||
/** indicates if a POC marker has been used O:NO, 1:YES */
|
||||
int POC;
|
||||
/** progression order changes */
|
||||
opj_poc_t pocs[J3D_MAXRLVLS - 1];
|
||||
/** add fixed_quality */
|
||||
float distoratio[100];
|
||||
/** tile-component coding parameters */
|
||||
opj_tccp_t *tccps;
|
||||
/** packet header store there for futur use in t2_decode_packet */
|
||||
unsigned char *ppt_data;
|
||||
/** pointer remaining on the first byte of the first header if ppt is used */
|
||||
unsigned char *ppt_data_first;
|
||||
/** If ppt == 1 --> there was a PPT marker for the present tile */
|
||||
int ppt;
|
||||
/** used in case of multiple marker PPT (number of info already stored) */
|
||||
int ppt_store;
|
||||
int ppt_len;
|
||||
} opj_tcp_t;
|
||||
|
||||
/**
|
||||
Coding parameters
|
||||
*/
|
||||
typedef struct opj_cp {
|
||||
/** transform format 0: 2DWT, 1: 2D1P, 2: 3DWT, 3: 3RLS */
|
||||
OPJ_TRANSFORM transform_format;
|
||||
/** entropy coding format 0: 2EB, 1: 3EB, 2: 2GR, 3: 3GR, 4: GRI*/
|
||||
OPJ_ENTROPY_CODING encoding_format;
|
||||
/** allocation by rate/distortion */
|
||||
int disto_alloc;
|
||||
/** allocation by fixed layer */
|
||||
int fixed_alloc;
|
||||
/** add fixed_quality */
|
||||
int fixed_quality;
|
||||
/** Rsiz: capabilities */
|
||||
int rsiz;
|
||||
/** if != 0, then original dimension divided by 2^(reduce); if == 0 or not used, volume is decoded to the full resolution */
|
||||
int reduce[3];
|
||||
/** if != 0, then only the first "layer" layers are decoded; if == 0 or not used, all the quality layers are decoded */
|
||||
int layer;
|
||||
/** 0 = no index || 1 = index */
|
||||
int index_on;
|
||||
/** Big-Endian/Little-endian order */
|
||||
int bigendian;
|
||||
/** XTOsiz */
|
||||
int tx0;
|
||||
/** YTOsiz */
|
||||
int ty0;
|
||||
/** ZTOsiz */
|
||||
int tz0;
|
||||
/** XTsiz */
|
||||
int tdx;
|
||||
/** YTsiz */
|
||||
int tdy;
|
||||
/** ZTsiz */
|
||||
int tdz;
|
||||
/** comment for coding */
|
||||
char *comment;
|
||||
/** number of tiles in width, height and depth */
|
||||
int tw;
|
||||
int th;
|
||||
int tl;
|
||||
/** ID number of the tiles present in the codestream */
|
||||
int *tileno;
|
||||
/** size of the vector tileno */
|
||||
int tileno_size;
|
||||
/** tile coding parameters */
|
||||
opj_tcp_t *tcps;
|
||||
/** fixed layer */
|
||||
int *matrice;
|
||||
|
||||
/** packet header store there for futur use in t2_decode_packet */
|
||||
unsigned char *ppm_data;
|
||||
/** pointer remaining on the first byte of the first header if ppm is used */
|
||||
unsigned char *ppm_data_first;
|
||||
/** if ppm == 1 --> there was a PPM marker for the present tile */
|
||||
int ppm;
|
||||
/** use in case of multiple marker PPM (number of info already store) */
|
||||
int ppm_store;
|
||||
/** use in case of multiple marker PPM (case on non-finished previous info) */
|
||||
int ppm_previous;
|
||||
int ppm_len;
|
||||
} opj_cp_t;
|
||||
|
||||
/**
|
||||
Information concerning a packet inside tile
|
||||
*/
|
||||
typedef struct opj_packet_info {
|
||||
/** start position */
|
||||
int start_pos;
|
||||
/** end position */
|
||||
int end_pos;
|
||||
/** distorsion introduced */
|
||||
double disto;
|
||||
} opj_packet_info_t;
|
||||
|
||||
/**
|
||||
Index structure : information regarding tiles inside volume
|
||||
*/
|
||||
typedef struct opj_tile_info {
|
||||
/** value of thresh for each layer by tile cfr. Marcela */
|
||||
double *thresh;
|
||||
/** number of tile */
|
||||
int num_tile;
|
||||
/** 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, height and depth) */
|
||||
int prctno[3][J3D_MAXRLVLS];
|
||||
/** precinct size (in power of 2), in X for each resolution level */
|
||||
int prctsiz[3][J3D_MAXRLVLS];
|
||||
/** information concerning packets inside tile */
|
||||
opj_packet_info_t *packet;
|
||||
|
||||
/** add fixed_quality */
|
||||
int nbpix;
|
||||
/** add fixed_quality */
|
||||
double distotile;
|
||||
} opj_tile_info_t;
|
||||
|
||||
/**
|
||||
Index structure
|
||||
*/
|
||||
typedef struct opj_volume_info {
|
||||
|
||||
/** transform format 0: 2DWT, 1: 2D1P, 2: 3DWT, 3: 3RLS */
|
||||
OPJ_TRANSFORM transform_format;
|
||||
/** output file format 0: 2EB, 1: 3EB, 2: 2GR, 3: 3GR, 4: GRI*/
|
||||
OPJ_ENTROPY_CODING encoding_format; /** 0 = no index || 1 = index */
|
||||
int index_on;
|
||||
/** 0 = wt 9-7 || 1 = wt 5-3 || >=2 wt atk defined */
|
||||
int dwtid[3];
|
||||
/** maximum distortion reduction on the whole volume (add for Marcela) */
|
||||
double D_max;
|
||||
/** packet number */
|
||||
int num;
|
||||
/** writing the packet in the index with t2_encode_packets */
|
||||
int index_write;
|
||||
/** volume width, height and depth */
|
||||
int volume_w;
|
||||
int volume_h;
|
||||
int volume_l;
|
||||
/** progression order */
|
||||
OPJ_PROG_ORDER prog;
|
||||
/** tile size in x, y and z */
|
||||
int tile_x;
|
||||
int tile_y;
|
||||
int tile_z;
|
||||
/** tile origin in x, y and z */
|
||||
int tile_Ox;
|
||||
int tile_Oy;
|
||||
int tile_Oz;
|
||||
/** number of tiles in X, Y and Z */
|
||||
int tw;
|
||||
int th;
|
||||
int tl;
|
||||
/** component numbers */
|
||||
int comp;
|
||||
/** number of layer */
|
||||
int layer;
|
||||
/** number of decomposition in X, Y and Z*/
|
||||
int decomposition[3];
|
||||
/** DC offset (15444-2) */
|
||||
int dcoffset;
|
||||
/** main header position */
|
||||
int main_head_end;
|
||||
/** codestream's size */
|
||||
int codestream_size;
|
||||
/** information regarding tiles inside volume */
|
||||
opj_tile_info_t *tile;
|
||||
} opj_volume_info_t;
|
||||
|
||||
/**
|
||||
JPEG-2000 codestream reader/writer
|
||||
*/
|
||||
typedef struct opj_j3d {
|
||||
/** codec context */
|
||||
opj_common_ptr cinfo;
|
||||
/** locate in which part of the codestream the decoder is (main header, tile header, end) */
|
||||
int state;
|
||||
/** number of the tile currently concern by coding/decoding */
|
||||
int curtileno;
|
||||
/** locate the position of the end of the tile in the codestream, used to detect a truncated codestream (in j3d_read_sod) */
|
||||
unsigned char *eot;
|
||||
/** locate the start position of the SOT marker of the current coded tile: */
|
||||
int sot_start;
|
||||
/* after encoding the tile, a jump (in j3d_write_sod) is done to the SOT marker to store the value of its length. */
|
||||
int sod_start;
|
||||
/** as the J3D-file is written in several parts during encoding, it enables to make the right correction in position return by cio_tell */
|
||||
int pos_correction;
|
||||
/** array used to store the data of each tile */
|
||||
unsigned char **tile_data;
|
||||
/** array used to store the length of each tile */
|
||||
int *tile_len;
|
||||
|
||||
/** decompression only : store decoding parameters common to all tiles */
|
||||
opj_tcp_t *default_tcp;
|
||||
/** pointer to the encoded / decoded volume */
|
||||
opj_volume_t *volume;
|
||||
/** pointer to the coding parameters */
|
||||
opj_cp_t *cp;
|
||||
/** helper used to write the index file */
|
||||
opj_volume_info_t *volume_info;
|
||||
/** pointer to the byte i/o stream */
|
||||
opj_cio_t *cio;
|
||||
} opj_j3d_t;
|
||||
|
||||
/** @name Funciones generales */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Creates a J3D decompression structure
|
||||
@param cinfo Codec context info
|
||||
@return Returns a handle to a J3D decompressor if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_j3d_t* j3d_create_decompress(opj_common_ptr cinfo);
|
||||
/**
|
||||
Destroy a J3D decompressor handle
|
||||
@param j3d J3D decompressor handle to destroy
|
||||
*/
|
||||
void j3d_destroy_decompress(opj_j3d_t *j3d);
|
||||
/**
|
||||
Setup the decoder decoding parameters using user parameters.
|
||||
Decoding parameters are returned in j3d->cp.
|
||||
@param j3d J3D decompressor handle
|
||||
@param parameters decompression parameters
|
||||
*/
|
||||
void j3d_setup_decoder(opj_j3d_t *j3d, opj_dparameters_t *parameters);
|
||||
/**
|
||||
Decode an volume from a JPEG-2000 codestream
|
||||
@param j3d J3D decompressor handle
|
||||
@param cio Input buffer stream
|
||||
@return Returns a decoded volume if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_volume_t* j3d_decode(opj_j3d_t *j3d, opj_cio_t *cio);
|
||||
/**
|
||||
Decode an volume form a JPT-stream (JPEG 2000, JPIP)
|
||||
@param j3d J3D decompressor handle
|
||||
@param cio Input buffer stream
|
||||
@return Returns a decoded volume if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_volume_t* j3d_decode_jpt_stream(opj_j3d_t *j3d, opj_cio_t *cio);
|
||||
/**
|
||||
Creates a J3D compression structure
|
||||
@param cinfo Codec context info
|
||||
@return Returns a handle to a J3D compressor if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_j3d_t* j3d_create_compress(opj_common_ptr cinfo);
|
||||
/**
|
||||
Destroy a J3D compressor handle
|
||||
@param j3d J3D compressor handle to destroy
|
||||
*/
|
||||
void j3d_destroy_compress(opj_j3d_t *j3d);
|
||||
/**
|
||||
Setup the encoder parameters using the current volume and using user parameters.
|
||||
Coding parameters are returned in j3d->cp.
|
||||
@param j3d J3D compressor handle
|
||||
@param parameters compression parameters
|
||||
@param volume input filled volume
|
||||
*/
|
||||
void j3d_setup_encoder(opj_j3d_t *j3d, opj_cparameters_t *parameters,
|
||||
opj_volume_t *volume);
|
||||
/**
|
||||
Encode an volume into a JPEG-2000 codestream
|
||||
@param j3d J3D compressor handle
|
||||
@param cio Output buffer stream
|
||||
@param volume Volume to encode
|
||||
@param index Name of the index file if required, NULL otherwise
|
||||
@return Returns true if successful, returns false otherwise
|
||||
*/
|
||||
bool j3d_encode(opj_j3d_t *j3d, opj_cio_t *cio, opj_volume_t *volume,
|
||||
char *index);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __J3D_H */
|
|
@ -1,85 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 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.
|
||||
*/
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <sys/time.h>
|
||||
#include <sys/resource.h>
|
||||
#include <sys/times.h>
|
||||
#endif /* _WIN32 */
|
||||
#include "opj_includes.h"
|
||||
|
||||
double opj_clock()
|
||||
{
|
||||
#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 /* _WIN32 */
|
||||
}
|
||||
|
||||
void* opj_malloc(size_t size)
|
||||
{
|
||||
void *memblock = malloc(size);
|
||||
if (memblock) {
|
||||
memset(memblock, 0, size);
|
||||
}
|
||||
return memblock;
|
||||
}
|
||||
|
||||
void* opj_realloc(void *memblock, size_t size)
|
||||
{
|
||||
return realloc(memblock, size);
|
||||
}
|
||||
|
||||
void opj_free(void *memblock)
|
||||
{
|
||||
free(memblock);
|
||||
}
|
||||
|
||||
|
|
@ -1,80 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 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 __J3D_LIB_H
|
||||
#define __J3D_LIB_H
|
||||
/**
|
||||
@file jp3d_lib.h
|
||||
@brief Internal functions
|
||||
|
||||
The functions in JP3D_LIB.C are internal utilities mainly used for memory management.
|
||||
*/
|
||||
|
||||
/** @defgroup MISC MISC - Miscellaneous internal functions */
|
||||
/*@{*/
|
||||
|
||||
/** @name Funciones generales */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
Difference in successive opj_clock() calls tells you the elapsed time
|
||||
@return Returns time in seconds
|
||||
*/
|
||||
double opj_clock(void);
|
||||
|
||||
/**
|
||||
Allocate a memory block with elements initialized to 0
|
||||
@param size Bytes to allocate
|
||||
@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
|
||||
*/
|
||||
void* opj_malloc(size_t size);
|
||||
|
||||
/**
|
||||
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
|
||||
*/
|
||||
void* opj_realloc(void *memblock, size_t size);
|
||||
|
||||
/**
|
||||
Deallocates or frees a memory block.
|
||||
@param memblock Previously allocated memory block to be freed
|
||||
*/
|
||||
void opj_free(void *memblock);
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __J3D_LIB_H */
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
prefix=@CMAKE_INSTALL_PREFIX@
|
||||
bindir=${prefix}/@OPENJPEG_INSTALL_BIN_DIR@
|
||||
mandir=${prefix}/@OPENJPEG_INSTALL_MAN_DIR@
|
||||
docdir=${prefix}/@OPENJPEG_INSTALL_DOC_DIR@
|
||||
libdir=${prefix}/@OPENJPEG_INSTALL_LIB_DIR@
|
||||
includedir=${prefix}/@OPENJPEG_INSTALL_INCLUDE_DIR@
|
||||
|
||||
Name: openjp3d
|
||||
Description: JPEG2000 Extensions for three-dimensional data (Part 10)
|
||||
URL: http://www.openjpeg.org/
|
||||
Version: @OPENJPEG_VERSION@
|
||||
Libs: -L${libdir} -lopenjp3d
|
||||
Libs.private: -lm
|
||||
Cflags: -I${includedir}
|
|
@ -1,142 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/* <summary> */
|
||||
/* This table contains the norms of the basis function of the reversible MCT. */
|
||||
/* </summary> */
|
||||
static const double mct_norms[3] = { 1.732, .8292, .8292 };
|
||||
|
||||
/* <summary> */
|
||||
/* This table contains the norms of the basis function of the irreversible MCT. */
|
||||
/* </summary> */
|
||||
static const double mct_norms_real[3] = { 1.732, 1.805, 1.573 };
|
||||
|
||||
/* <summary> */
|
||||
/* Forward reversible MCT. */
|
||||
/* </summary> */
|
||||
void mct_encode(int *c0, int *c1, int *c2, int n)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < n; i++) {
|
||||
int r, g, b, y, u, v;
|
||||
r = c0[i];
|
||||
g = c1[i];
|
||||
b = c2[i];
|
||||
y = (r + (g << 1) + b) >> 2;
|
||||
u = b - g;
|
||||
v = r - g;
|
||||
c0[i] = y;
|
||||
c1[i] = u;
|
||||
c2[i] = v;
|
||||
}
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Inverse reversible MCT. */
|
||||
/* </summary> */
|
||||
void mct_decode(int *c0, int *c1, int *c2, int n)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < n; i++) {
|
||||
int y, u, v, r, g, b;
|
||||
y = c0[i];
|
||||
u = c1[i];
|
||||
v = c2[i];
|
||||
g = y - ((u + v) >> 2);
|
||||
r = v + g;
|
||||
b = u + g;
|
||||
c0[i] = r;
|
||||
c1[i] = g;
|
||||
c2[i] = b;
|
||||
}
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Get norm of basis function of reversible MCT. */
|
||||
/* </summary> */
|
||||
double mct_getnorm(int compno)
|
||||
{
|
||||
return mct_norms[compno];
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Forward irreversible MCT. */
|
||||
/* </summary> */
|
||||
void mct_encode_real(int *c0, int *c1, int *c2, int n)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < n; i++) {
|
||||
int r, g, b, y, u, v;
|
||||
r = c0[i];
|
||||
g = c1[i];
|
||||
b = c2[i];
|
||||
y = fix_mul(r, 2449) + fix_mul(g, 4809) + fix_mul(b, 934);
|
||||
u = -fix_mul(r, 1382) - fix_mul(g, 2714) + fix_mul(b, 4096);
|
||||
v = fix_mul(r, 4096) - fix_mul(g, 3430) - fix_mul(b, 666);
|
||||
c0[i] = y;
|
||||
c1[i] = u;
|
||||
c2[i] = v;
|
||||
}
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Inverse irreversible MCT. */
|
||||
/* </summary> */
|
||||
void mct_decode_real(int *c0, int *c1, int *c2, int n)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < n; i++) {
|
||||
int y, u, v, r, g, b;
|
||||
y = c0[i];
|
||||
u = c1[i];
|
||||
v = c2[i];
|
||||
r = y + fix_mul(v, 11485);
|
||||
g = y - fix_mul(u, 2819) - fix_mul(v, 5850);
|
||||
b = y + fix_mul(u, 14516);
|
||||
c0[i] = r;
|
||||
c1[i] = g;
|
||||
c2[i] = b;
|
||||
}
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Get norm of basis function of irreversible MCT. */
|
||||
/* </summary> */
|
||||
double mct_getnorm_real(int compno)
|
||||
{
|
||||
return mct_norms_real[compno];
|
||||
}
|
|
@ -1,102 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#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.
|
||||
*/
|
||||
|
||||
/** @defgroup MCT MCT - Implementation of a multi-component transform */
|
||||
/*@{*/
|
||||
|
||||
/** @name Funciones generales */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
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(int *c0, int *c1, int *c2, int 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(int *c0, int *c1, int *c2, int 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
|
||||
*/
|
||||
double mct_getnorm(int 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(int *c0, int *c1, int *c2, int 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(int *c0, int *c1, int *c2, int 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
|
||||
*/
|
||||
double mct_getnorm_real(int compno);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __MCT_H */
|
|
@ -1,585 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.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);
|
||||
/**
|
||||
Exchange MPS with LPS
|
||||
@param mqc MQC handle
|
||||
@return
|
||||
*/
|
||||
static int mqc_mpsexchange(opj_mqc_t *mqc);
|
||||
/**
|
||||
Exchange LPS with MPS
|
||||
@param mqc MQC handle
|
||||
@return
|
||||
*/
|
||||
static int 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)
|
||||
{
|
||||
unsigned int tempc = mqc->c + mqc->a;
|
||||
mqc->c |= 0xffff;
|
||||
if (mqc->c >= tempc) {
|
||||
mqc->c -= 0x8000;
|
||||
}
|
||||
}
|
||||
|
||||
static int mqc_mpsexchange(opj_mqc_t *mqc)
|
||||
{
|
||||
int 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 int mqc_lpsexchange(opj_mqc_t *mqc)
|
||||
{
|
||||
int 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) {
|
||||
unsigned int c;
|
||||
if (mqc->bp + 1 != mqc->end) {
|
||||
c = *(mqc->bp + 1);
|
||||
} else {
|
||||
c = 0xff;
|
||||
}
|
||||
if (*mqc->bp == 0xff) {
|
||||
if (c > 0x8f) {
|
||||
mqc->c += 0xff00;
|
||||
mqc->ct = 8;
|
||||
} else {
|
||||
mqc->bp++;
|
||||
mqc->c += c << 9;
|
||||
mqc->ct = 7;
|
||||
}
|
||||
} else {
|
||||
mqc->bp++;
|
||||
mqc->c += c << 8;
|
||||
mqc->ct = 8;
|
||||
}
|
||||
} else {
|
||||
mqc->c += 0xff00;
|
||||
mqc->ct = 8;
|
||||
}
|
||||
}
|
||||
|
||||
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()
|
||||
{
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
int mqc_numbytes(opj_mqc_t *mqc)
|
||||
{
|
||||
return mqc->bp - mqc->start;
|
||||
}
|
||||
|
||||
void mqc_init_enc(opj_mqc_t *mqc, unsigned char *bp)
|
||||
{
|
||||
mqc_setcurctx(mqc, 0);
|
||||
mqc->a = 0x8000;
|
||||
mqc->c = 0;
|
||||
mqc->bp = bp - 1;
|
||||
mqc->ct = 12;
|
||||
if (*mqc->bp == 0xff) {
|
||||
mqc->ct = 13;
|
||||
}
|
||||
mqc->start = bp;
|
||||
}
|
||||
|
||||
void mqc_setcurctx(opj_mqc_t *mqc, int ctxno)
|
||||
{
|
||||
mqc->curctx = &mqc->ctxs[ctxno];
|
||||
}
|
||||
|
||||
void mqc_encode(opj_mqc_t *mqc, int 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, int 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;
|
||||
}
|
||||
}
|
||||
|
||||
int mqc_bypass_flush_enc(opj_mqc_t *mqc)
|
||||
{
|
||||
unsigned char 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, 18, 0, 46);
|
||||
mqc_setstate(mqc, 0, 0, 3);
|
||||
mqc_setstate(mqc, 1, 0, 4);
|
||||
}
|
||||
|
||||
void mqc_reset_enc_3(opj_mqc_t *mqc)
|
||||
{
|
||||
mqc_resetstates(mqc);
|
||||
mqc_setstate(mqc, T1_3D_CTXNO_UNI, 0, 46);
|
||||
mqc_setstate(mqc, T1_3D_CTXNO_AGG, 0, 3);
|
||||
mqc_setstate(mqc, T1_3D_CTXNO_ZC, 0, 4);
|
||||
}
|
||||
|
||||
int mqc_restart_enc(opj_mqc_t *mqc)
|
||||
{
|
||||
int correction = 1;
|
||||
|
||||
/* <flush part> */
|
||||
int 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)
|
||||
{
|
||||
int 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)
|
||||
{
|
||||
int i;
|
||||
mqc_setcurctx(mqc, 18);
|
||||
|
||||
for (i = 1; i < 5; i++) {
|
||||
mqc_encode(mqc, i % 2);
|
||||
}
|
||||
}
|
||||
|
||||
void mqc_init_dec(opj_mqc_t *mqc, unsigned char *bp, int 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;
|
||||
}
|
||||
|
||||
int mqc_decode(opj_mqc_t *mqc)
|
||||
{
|
||||
int 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 d;
|
||||
}
|
||||
|
||||
void mqc_resetstates(opj_mqc_t *mqc)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < MQC_NUMCTXS; i++) {
|
||||
mqc->ctxs[i] = mqc_states;
|
||||
}
|
||||
}
|
||||
|
||||
void mqc_setstate(opj_mqc_t *mqc, int ctxno, int msb, int prob)
|
||||
{
|
||||
mqc->ctxs[ctxno] = &mqc_states[msb + (prob << 1)];
|
||||
}
|
||||
|
||||
|
|
@ -1,206 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#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.
|
||||
*/
|
||||
|
||||
/** @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) */
|
||||
unsigned int qeval;
|
||||
/** the Most Probable Symbol (0 or 1) */
|
||||
int 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 {
|
||||
unsigned int c;
|
||||
unsigned int a;
|
||||
unsigned int ct;
|
||||
unsigned char *bp;
|
||||
unsigned char *start;
|
||||
unsigned char *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
|
||||
*/
|
||||
int 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, int ctxno, int msb, int 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, unsigned char *bp);
|
||||
/**
|
||||
Set the current context used for coding/decoding
|
||||
@param mqc MQC handle
|
||||
@param ctxno Number that identifies the context
|
||||
*/
|
||||
void mqc_setcurctx(opj_mqc_t *mqc, int 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, int 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, int d);
|
||||
/**
|
||||
BYPASS mode switch, flush operation
|
||||
<h2>Not fully implemented and tested !!</h2>
|
||||
@param mqc MQC handle
|
||||
@return Returns 1 (always)
|
||||
*/
|
||||
int mqc_bypass_flush_enc(opj_mqc_t *mqc);
|
||||
/**
|
||||
RESET mode switch
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
void mqc_reset_enc(opj_mqc_t *mqc);
|
||||
/**
|
||||
RESET mode switch
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
void mqc_reset_enc_3(opj_mqc_t *mqc);
|
||||
/**
|
||||
RESTART mode switch (TERMALL)
|
||||
@param mqc MQC handle
|
||||
@return Returns 1 (always)
|
||||
*/
|
||||
int 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, unsigned char *bp, int len);
|
||||
/**
|
||||
Decode a symbol
|
||||
@param mqc MQC handle
|
||||
@return Returns the decoded symbol (0 or 1)
|
||||
*/
|
||||
int mqc_decode(opj_mqc_t *mqc);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __MQC_H */
|
|
@ -1,234 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2006, Mónica Díez García, Image Processing Laboratory, University of Valladolid, Spain
|
||||
* 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 "opj_includes.h"
|
||||
#include "openjp3d.h"
|
||||
#define JP3D_VERSION "1.3.0"
|
||||
/* ---------------------------------------------------------------------- */
|
||||
#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()
|
||||
{
|
||||
return JP3D_VERSION;
|
||||
}
|
||||
opj_dinfo_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT format)
|
||||
{
|
||||
opj_dinfo_t *dinfo = (opj_dinfo_t*)opj_malloc(sizeof(opj_dinfo_t));
|
||||
if (!dinfo) {
|
||||
return NULL;
|
||||
}
|
||||
dinfo->is_decompressor = true;
|
||||
switch (format) {
|
||||
case CODEC_J3D:
|
||||
case CODEC_J2K:
|
||||
/* get a J3D decoder handle */
|
||||
dinfo->j3d_handle = (void*)j3d_create_decompress((opj_common_ptr)dinfo);
|
||||
if (!dinfo->j3d_handle) {
|
||||
opj_free(dinfo);
|
||||
return NULL;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
opj_free(dinfo);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
dinfo->codec_format = format;
|
||||
|
||||
return dinfo;
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_destroy_decompress(opj_dinfo_t *dinfo)
|
||||
{
|
||||
if (dinfo) {
|
||||
/* destroy the codec */
|
||||
if (dinfo->codec_format != CODEC_UNKNOWN) {
|
||||
j3d_destroy_decompress((opj_j3d_t*)dinfo->j3d_handle);
|
||||
}
|
||||
/* destroy the decompressor */
|
||||
opj_free(dinfo);
|
||||
}
|
||||
}
|
||||
|
||||
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] = 0;
|
||||
parameters->cp_reduce[1] = 0;
|
||||
parameters->cp_reduce[2] = 0;
|
||||
parameters->bigendian = 0;
|
||||
|
||||
parameters->decod_format = -1;
|
||||
parameters->cod_format = -1;
|
||||
}
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_setup_decoder(opj_dinfo_t *dinfo,
|
||||
opj_dparameters_t *parameters)
|
||||
{
|
||||
if (dinfo && parameters) {
|
||||
if (dinfo->codec_format != CODEC_UNKNOWN) {
|
||||
j3d_setup_decoder((opj_j3d_t*)dinfo->j3d_handle, parameters);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
opj_volume_t* OPJ_CALLCONV opj_decode(opj_dinfo_t *dinfo, opj_cio_t *cio)
|
||||
{
|
||||
if (dinfo && cio) {
|
||||
if (dinfo->codec_format != CODEC_UNKNOWN) {
|
||||
return j3d_decode((opj_j3d_t*)dinfo->j3d_handle, cio);
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
opj_cinfo_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT format)
|
||||
{
|
||||
opj_cinfo_t *cinfo = (opj_cinfo_t*)opj_malloc(sizeof(opj_cinfo_t));
|
||||
if (!cinfo) {
|
||||
return NULL;
|
||||
}
|
||||
cinfo->is_decompressor = false;
|
||||
switch (format) {
|
||||
case CODEC_J3D:
|
||||
case CODEC_J2K:
|
||||
/* get a J3D coder handle */
|
||||
cinfo->j3d_handle = (void*)j3d_create_compress((opj_common_ptr)cinfo);
|
||||
if (!cinfo->j3d_handle) {
|
||||
opj_free(cinfo);
|
||||
return NULL;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
opj_free(cinfo);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
cinfo->codec_format = format;
|
||||
|
||||
return cinfo;
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_destroy_compress(opj_cinfo_t *cinfo)
|
||||
{
|
||||
if (cinfo) {
|
||||
/* destroy the codec */
|
||||
if (cinfo->codec_format != CODEC_UNKNOWN) {
|
||||
j3d_destroy_compress((opj_j3d_t*)cinfo->j3d_handle);
|
||||
}
|
||||
/* destroy the decompressor */
|
||||
opj_free(cinfo);
|
||||
}
|
||||
}
|
||||
|
||||
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->numresolution[0] = 3;
|
||||
parameters->numresolution[1] = 3;
|
||||
parameters->numresolution[2] = 1;
|
||||
parameters->cblock_init[0] = 64;
|
||||
parameters->cblock_init[1] = 64;
|
||||
parameters->cblock_init[2] = 64;
|
||||
parameters->prog_order = LRCP;
|
||||
parameters->roi_compno = -1; /* no ROI */
|
||||
parameters->atk_wt[0] = 1; /* 5-3 WT */
|
||||
parameters->atk_wt[1] = 1; /* 5-3 WT */
|
||||
parameters->atk_wt[2] = 1; /* 5-3 WT */
|
||||
parameters->irreversible = 0;
|
||||
parameters->subsampling_dx = 1;
|
||||
parameters->subsampling_dy = 1;
|
||||
parameters->subsampling_dz = 1;
|
||||
|
||||
parameters->decod_format = -1;
|
||||
parameters->cod_format = -1;
|
||||
parameters->encoding_format = ENCOD_2EB;
|
||||
parameters->transform_format = TRF_2D_DWT;
|
||||
}
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_setup_encoder(opj_cinfo_t *cinfo,
|
||||
opj_cparameters_t *parameters, opj_volume_t *volume)
|
||||
{
|
||||
if (cinfo && parameters && volume) {
|
||||
if (cinfo->codec_format != CODEC_UNKNOWN) {
|
||||
j3d_setup_encoder((opj_j3d_t*)cinfo->j3d_handle, parameters, volume);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool OPJ_CALLCONV opj_encode(opj_cinfo_t *cinfo, opj_cio_t *cio,
|
||||
opj_volume_t *volume, char *index)
|
||||
{
|
||||
if (cinfo && cio && volume) {
|
||||
if (cinfo->codec_format != CODEC_UNKNOWN) {
|
||||
return j3d_encode((opj_j3d_t*)cinfo->j3d_handle, cio, volume, index);
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -1,736 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* Copyright (c) 2006, Mónica Díez García, Image Processing Laboratory, University of Valladolid, Spain
|
||||
* 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
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
Compiler directives
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
#if defined(OPJ_STATIC) || !defined(_WIN32)
|
||||
/* http://gcc.gnu.org/wiki/Visibility */
|
||||
#if __GNUC__ >= 4
|
||||
#define OPJ_API __attribute__ ((visibility ("default")))
|
||||
#define OPJ_LOCAL __attribute__ ((visibility ("hidden")))
|
||||
#else
|
||||
#define OPJ_API
|
||||
#define OPJ_LOCAL
|
||||
#endif
|
||||
#define OPJ_CALLCONV
|
||||
#else
|
||||
#define OPJ_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 OPJ_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
|
||||
OPJ_API functions as being imported from a DLL, whereas this DLL sees symbols
|
||||
defined with this macro as being exported.
|
||||
*/
|
||||
#if defined(OPJ_EXPORTS) || defined(DLL_EXPORT)
|
||||
#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)
|
||||
/*
|
||||
The C language implementation does correctly provide the standard header
|
||||
file "stdbool.h".
|
||||
*/
|
||||
#include <stdbool.h>
|
||||
#else
|
||||
/*
|
||||
The C language implementation does not provide the standard header file
|
||||
"stdbool.h" as required by ISO/IEC 9899:1999. Try to compensate for this
|
||||
braindamage below.
|
||||
*/
|
||||
#if !defined(bool)
|
||||
#define bool int
|
||||
#endif
|
||||
#if !defined(true)
|
||||
#define true 1
|
||||
#endif
|
||||
#if !defined(false)
|
||||
#define false 0
|
||||
#endif
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
Useful constant definitions
|
||||
==========================================================
|
||||
*/
|
||||
#ifndef MAX_SLICES
|
||||
#define MAX_SLICES 300 /**< Maximum allowed size for slices */
|
||||
#endif /* MAX_PATH */
|
||||
|
||||
#ifndef MAX_PATH
|
||||
#define MAX_PATH 260 /**< Maximum allowed size for filenames */
|
||||
#endif /* MAX_PATH */
|
||||
|
||||
#define J3D_MAXRLVLS 32 /**< Number of maximum resolution level authorized */
|
||||
#define J3D_MAXBANDS (7*J3D_MAXRLVLS + 1) /**< Number of maximum sub-band linked to number of resolution level */
|
||||
|
||||
#define TINY 1.0E-20
|
||||
/*
|
||||
==========================================================
|
||||
enum definitions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
#define J2K_CFMT 0
|
||||
#define J3D_CFMT 1
|
||||
#define LSE_CFMT 2
|
||||
|
||||
#define BIN_DFMT 0
|
||||
#define PGX_DFMT 1
|
||||
#define IMG_DFMT 2
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/** Progression order */
|
||||
typedef enum PROG_ORDER {
|
||||
/**< place-holder */
|
||||
PROG_UNKNOWN = -1,
|
||||
/**< layer-resolution-component-precinct order */
|
||||
LRCP = 0,
|
||||
/**< resolution-layer-component-precinct order */
|
||||
RLCP = 1,
|
||||
/**< resolution-precinct-component-layer order */
|
||||
RPCL = 2,
|
||||
/**< precinct-component-resolution-layer order */
|
||||
PCRL = 3,
|
||||
/**< component-precinct-resolution-layer order */
|
||||
CPRL = 4
|
||||
} OPJ_PROG_ORDER;
|
||||
|
||||
/**
|
||||
Supported volume color spaces
|
||||
*/
|
||||
typedef enum COLOR_SPACE {
|
||||
/**< place-holder */
|
||||
CLRSPC_UNKNOWN = -1,
|
||||
/**< sRGB */
|
||||
CLRSPC_SRGB = 1,
|
||||
/**< grayscale */
|
||||
CLRSPC_GRAY = 2,
|
||||
/**< YUV */
|
||||
CLRSPC_SYCC = 3
|
||||
} OPJ_COLOR_SPACE;
|
||||
|
||||
/**
|
||||
Supported codec
|
||||
*/
|
||||
typedef enum CODEC_FORMAT {
|
||||
/**< place-holder */
|
||||
CODEC_UNKNOWN = -1,
|
||||
/**< JPEG-2000 codestream : read/write */
|
||||
CODEC_J2K = 0,
|
||||
/**< JPEG-2000 Part 10 file format : read/write */
|
||||
CODEC_J3D = 1
|
||||
} OPJ_CODEC_FORMAT;
|
||||
|
||||
/**
|
||||
Supported entropy coding algorithms
|
||||
*/
|
||||
typedef enum ENTROPY_CODING {
|
||||
/**< place-holder */
|
||||
ENCOD_UNKNOWN = -1,
|
||||
/**< 2D EBCOT encoding */
|
||||
ENCOD_2EB = 0,
|
||||
/**< 3D EBCOT encoding */
|
||||
ENCOD_3EB = 1,
|
||||
/**< Golomb-Rice coding with 2D context */
|
||||
ENCOD_2GR = 2,
|
||||
/**< Golomb-Rice coding with 3D context */
|
||||
ENCOD_3GR = 3
|
||||
} OPJ_ENTROPY_CODING;
|
||||
|
||||
/**
|
||||
Supported transforms
|
||||
*/
|
||||
typedef enum TRANSFORM {
|
||||
/**< place-holder */
|
||||
TRF_UNKNOWN = -1,
|
||||
/**< 2D DWT, no transform in axial dim */
|
||||
TRF_2D_DWT = 0,
|
||||
/**< 3D DWT */
|
||||
TRF_3D_DWT = 1,
|
||||
/**< 3D prediction*/
|
||||
TRF_3D_RLS = 2,
|
||||
TRF_3D_LSE = 3
|
||||
} OPJ_TRANSFORM;
|
||||
/*
|
||||
==========================================================
|
||||
event manager typedef definitions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
/**
|
||||
Callback function prototype for events
|
||||
@param msg Event message
|
||||
@param client_data
|
||||
*/
|
||||
typedef void (*opj_msg_callback)(const char *msg, void *client_data);
|
||||
|
||||
/**
|
||||
Message handler object
|
||||
used for
|
||||
<ul>
|
||||
<li>Error messages
|
||||
<li>Warning messages
|
||||
<li>Debugging messages
|
||||
</ul>
|
||||
*/
|
||||
typedef struct opj_event_mgr {
|
||||
/** 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;
|
||||
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
codec typedef definitions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
/**
|
||||
Progression order changes
|
||||
*/
|
||||
typedef struct opj_poc {
|
||||
int resno0, compno0;
|
||||
int layno1, resno1, compno1;
|
||||
OPJ_PROG_ORDER prg;
|
||||
int tile;
|
||||
char progorder[4];
|
||||
} 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;
|
||||
/** ZTOsiz */
|
||||
int cp_tz0;
|
||||
|
||||
/** XTsiz */
|
||||
int cp_tdx;
|
||||
/** YTsiz */
|
||||
int cp_tdy;
|
||||
/** ZTsiz */
|
||||
int cp_tdz;
|
||||
|
||||
/** 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;
|
||||
/** number of layers */
|
||||
int tcp_numlayers;
|
||||
/** rates for successive layers */
|
||||
float tcp_rates[100];
|
||||
/** psnr's for successive layers */
|
||||
float tcp_distoratio[100];
|
||||
/** comment for coding */
|
||||
char *cp_comment;
|
||||
/** csty : coding style */
|
||||
int csty;
|
||||
/** DC offset (DCO) */
|
||||
int dcoffset;
|
||||
/** progression order (default LRCP) */
|
||||
OPJ_PROG_ORDER prog_order;
|
||||
/** progression order changes */
|
||||
opj_poc_t POC[J3D_MAXRLVLS - 1];
|
||||
/** number of progression order changes (POC), default to 0 */
|
||||
int numpocs;
|
||||
|
||||
/** number of resolutions */
|
||||
int numresolution[3];
|
||||
/** initial code block width, height and depth, default to 64 */
|
||||
int cblock_init[3];
|
||||
/** mode switch (1=BYPASS(LAZY) 2=RESET 4=RESTART(TERMALL) 8=VSC 16=ERTERM(SEGTERM) 32=SEGMARK(SEGSYM)) */
|
||||
int mode;
|
||||
|
||||
/** 1 : use the irreversible DWT 9-7, 0 : use lossless compression (default) */
|
||||
int irreversible;
|
||||
/** WT from ATK, default to 0 (false), no of atk used */
|
||||
int atk_wt[3];
|
||||
/** 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 prct_init[3][J3D_MAXRLVLS];
|
||||
|
||||
/** transform format 0: 0: 2DWT, 1: 2D1P, 2: 3DWT, 3: 3RLS */
|
||||
OPJ_TRANSFORM transform_format;
|
||||
/** output file format 0: 2EB, 1: 3EB, 2: 2GR, 3: 3GR, 4: GRI */
|
||||
OPJ_ENTROPY_CODING encoding_format;
|
||||
|
||||
/**@name command line encoder parameters (not used inside the library) */
|
||||
/*@{*/
|
||||
char infile[MAX_PATH]; /** input file name */
|
||||
char outfile[MAX_PATH]; /** output file name */
|
||||
char imgfile[MAX_PATH]; /** IMG file name for BIN volumes*/
|
||||
int index_on; /** creation of an index file, default to 0 (false) */
|
||||
char index[MAX_PATH]; /** index file name */
|
||||
|
||||
int volume_offset_x0; /** subvolume encoding: origin volume offset in x, y and z direction */
|
||||
int volume_offset_y0;
|
||||
int volume_offset_z0;
|
||||
|
||||
int subsampling_dx; /** subsampling value for dx */
|
||||
int subsampling_dy;
|
||||
int subsampling_dz;
|
||||
|
||||
int decod_format; /** input file format 0: BIN, 1: PGX */
|
||||
int cod_format; /** output file format 0: JP3D */
|
||||
/*@}*/
|
||||
} opj_cparameters_t;
|
||||
|
||||
/**
|
||||
Decompression parameters
|
||||
*/
|
||||
typedef struct opj_dparameters {
|
||||
/** Set the number of highest resolution levels to be discarded. if != 0, then original dimension divided by 2^(reduce); if == 0 or not used, volume is decoded to the full resolution */
|
||||
int cp_reduce[3];
|
||||
/** Set the maximum number of quality layers to decode. if != 0, then only the first "layer" layers are decoded; if == 0 or not used, all the quality layers are decoded */
|
||||
int cp_layer;
|
||||
int bigendian;
|
||||
|
||||
/**@name command line encoder parameters (not used inside the library) */
|
||||
/*@{*/
|
||||
/** input file name */
|
||||
char infile[MAX_PATH];
|
||||
/** output file name */
|
||||
char outfile[MAX_PATH];
|
||||
/** IMG file name for BIN volumes*/
|
||||
char imgfile[MAX_PATH];
|
||||
/** Original file name for PSNR measures*/
|
||||
char original[MAX_PATH];
|
||||
/** input file format 0: J2K, 1: JP3D */
|
||||
int decod_format;
|
||||
/** input file format 0: BIN, 1: PGM */
|
||||
int cod_format;
|
||||
/** original file format 0: BIN, 1: PGM */
|
||||
int orig_format;
|
||||
/*@}*/
|
||||
} opj_dparameters_t;
|
||||
|
||||
/** Common fields between JPEG-2000 compression and decompression master structs. */
|
||||
#define opj_common_fields \
|
||||
opj_event_mgr_t *event_mgr; /**< pointer to the event manager */\
|
||||
void * client_data; /**< Available for use by application */\
|
||||
bool is_decompressor; /**< So common code can tell which is which */\
|
||||
OPJ_CODEC_FORMAT codec_format; /**< selected codec */\
|
||||
OPJ_ENTROPY_CODING encoding_format; /**< selected entropy coding */\
|
||||
OPJ_TRANSFORM transform_format; /**< selected transform */\
|
||||
void *j3d_handle /**< pointer to the J3D codec */
|
||||
|
||||
/* Routines that are to be used by both halves of the library are declared
|
||||
* to receive a pointer to this structure. There are no actual instances of
|
||||
* opj_common_struct_t, only of opj_cinfo_t and opj_dinfo_t.
|
||||
*/
|
||||
typedef struct opj_common_struct {
|
||||
opj_common_fields; /* Fields common to both master struct types */
|
||||
/* Additional fields follow in an actual opj_cinfo_t or
|
||||
* opj_dinfo_t. All three structs must agree on these
|
||||
* initial fields! (This would be a lot cleaner in C++.)
|
||||
*/
|
||||
} opj_common_struct_t;
|
||||
|
||||
typedef opj_common_struct_t * opj_common_ptr;
|
||||
|
||||
/**
|
||||
Compression context info
|
||||
*/
|
||||
typedef struct opj_cinfo {
|
||||
/** Fields shared with opj_dinfo_t */
|
||||
opj_common_fields;
|
||||
/* other specific fields go here */
|
||||
} opj_cinfo_t;
|
||||
|
||||
/**
|
||||
Decompression context info
|
||||
*/
|
||||
typedef struct opj_dinfo {
|
||||
/** Fields shared with opj_cinfo_t */
|
||||
opj_common_fields;
|
||||
/* other specific fields go here */
|
||||
} opj_dinfo_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
|
||||
|
||||
/**
|
||||
Byte input-output stream (CIO)
|
||||
*/
|
||||
typedef struct opj_cio {
|
||||
/** codec context */
|
||||
opj_common_ptr cinfo;
|
||||
/** open mode (read/write) either OPJ_STREAM_READ or OPJ_STREAM_WRITE */
|
||||
int openmode;
|
||||
/** pointer to the start of the buffer */
|
||||
unsigned char *buffer;
|
||||
/** buffer size in bytes */
|
||||
int length;
|
||||
/** pointer to the start of the stream */
|
||||
unsigned char *start;
|
||||
/** pointer to the end of the stream */
|
||||
unsigned char *end;
|
||||
/** pointer to the current position */
|
||||
unsigned char *bp;
|
||||
} opj_cio_t;
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
volume typedef definitions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
/**
|
||||
Defines a single volume component
|
||||
*/
|
||||
typedef struct opj_volume_comp {
|
||||
/** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
|
||||
int dx;
|
||||
/** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
|
||||
int dy;
|
||||
/** ZRsiz: vertical separation of a sample of ith component with respect to the reference grid */
|
||||
int dz;
|
||||
/** data width */
|
||||
int w;
|
||||
/** data height */
|
||||
int h;
|
||||
/** data length : no of slices */
|
||||
int l;
|
||||
/** x component offset compared to the whole volume */
|
||||
int x0;
|
||||
/** y component offset compared to the whole volume */
|
||||
int y0;
|
||||
/** z component offset compared to the whole volume */
|
||||
int z0;
|
||||
/** precision */
|
||||
int prec;
|
||||
/** volume depth in bits */
|
||||
int bpp;
|
||||
/** DC offset (15444-2) */
|
||||
int dcoffset;
|
||||
/** signed (1) / unsigned (0) */
|
||||
int sgnd;
|
||||
/** BE byte order (1) / LE byte order (0) */
|
||||
int bigendian;
|
||||
/** number of decoded resolution */
|
||||
int resno_decoded[3];
|
||||
/** number of division by 2 of the out volume compared to the original size of volume */
|
||||
int factor[3];
|
||||
/** volume component data */
|
||||
int *data;
|
||||
} opj_volume_comp_t;
|
||||
|
||||
/**
|
||||
Defines volume data and characteristics
|
||||
*/
|
||||
typedef struct opj_volume {
|
||||
/** XOsiz: horizontal offset from the origin of the reference grid to the left side of the volume area */
|
||||
int x0;
|
||||
/** YOsiz: vertical offset from the origin of the reference grid to the top side of the volume area */
|
||||
int y0;
|
||||
/** ZOsiz: vertical offset from the origin of the reference grid to the top side of the volume area */
|
||||
int z0;
|
||||
/** Xsiz: width of the reference grid */
|
||||
int x1;
|
||||
/** Ysiz: height of the reference grid */
|
||||
int y1;
|
||||
/** Zsiz: length of the reference grid */
|
||||
int z1;
|
||||
/** number of components in the volume */
|
||||
int numcomps;
|
||||
/** number of slices in the volume */
|
||||
int numslices;
|
||||
/** color space: sRGB, Greyscale or YUV */
|
||||
OPJ_COLOR_SPACE color_space;
|
||||
/** volume components */
|
||||
opj_volume_comp_t *comps;
|
||||
} opj_volume_t;
|
||||
|
||||
/**
|
||||
Component parameters structure used by the opj_volume_create function
|
||||
*/
|
||||
typedef struct opj_volume_comptparm {
|
||||
/** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
|
||||
int dx;
|
||||
/** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
|
||||
int dy;
|
||||
/** ZRsiz: axial separation of a sample of ith component with respect to the reference grid */
|
||||
int dz;
|
||||
/** data width */
|
||||
int w;
|
||||
/** data height */
|
||||
int h;
|
||||
/** data length */
|
||||
int l;
|
||||
/** x component offset compared to the whole volume */
|
||||
int x0;
|
||||
/** y component offset compared to the whole volume */
|
||||
int y0;
|
||||
/** z component offset compared to the whole volume */
|
||||
int z0;
|
||||
/** precision */
|
||||
int prec;
|
||||
/** volume depth in bits */
|
||||
int bpp;
|
||||
/** signed (1) / unsigned (0) */
|
||||
int sgnd;
|
||||
/** DC offset*/
|
||||
int dcoffset;
|
||||
/** BE byte order (1) / LE byte order (0) */
|
||||
int bigendian;
|
||||
} opj_volume_cmptparm_t;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
openjpeg version
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
OPJ_API const char * OPJ_CALLCONV opj_version(void);
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
volume functions definitions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
/**
|
||||
Create an volume
|
||||
@param numcmpts number of components
|
||||
@param cmptparms components parameters
|
||||
@param clrspc volume color space
|
||||
@return returns a new volume structure if successful, returns NULL otherwise
|
||||
*/
|
||||
OPJ_API opj_volume_t* OPJ_CALLCONV opj_volume_create(int numcmpts,
|
||||
opj_volume_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc);
|
||||
|
||||
/**
|
||||
Deallocate any resources associated with an volume
|
||||
@param volume volume to be destroyed
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_volume_destroy(opj_volume_t *volume);
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
stream functions definitions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
/**
|
||||
Open and allocate a memory stream for read / write.
|
||||
On reading, the user must provide a buffer containing encoded data. The buffer will be
|
||||
wrapped by the returned CIO handle.
|
||||
On writing, buffer parameters must be set to 0: a buffer will be allocated by the library
|
||||
to contain encoded data.
|
||||
@param cinfo Codec context info
|
||||
@param buffer Reading: buffer address. Writing: NULL
|
||||
@param length Reading: buffer length. Writing: 0
|
||||
@return Returns a CIO handle if successful, returns NULL otherwise
|
||||
*/
|
||||
OPJ_API opj_cio_t* OPJ_CALLCONV opj_cio_open(opj_common_ptr cinfo,
|
||||
unsigned char *buffer, int length);
|
||||
|
||||
/**
|
||||
Close and free a CIO handle
|
||||
@param cio CIO handle to free
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_cio_close(opj_cio_t *cio);
|
||||
|
||||
/**
|
||||
Get position in byte stream
|
||||
@param cio CIO handle
|
||||
@return Returns the position in bytes
|
||||
*/
|
||||
OPJ_API int OPJ_CALLCONV cio_tell(opj_cio_t *cio);
|
||||
/**
|
||||
Set position in byte stream
|
||||
@param cio CIO handle
|
||||
@param pos Position, in number of bytes, from the beginning of the stream
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV cio_seek(opj_cio_t *cio, int pos);
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
event manager functions definitions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
OPJ_API opj_event_mgr_t* OPJ_CALLCONV opj_set_event_mgr(opj_common_ptr cinfo,
|
||||
opj_event_mgr_t *event_mgr, void *context);
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
codec functions definitions
|
||||
==========================================================
|
||||
*/
|
||||
/**
|
||||
Creates a J3D decompression structure
|
||||
@param format Decoder to select
|
||||
@return Returns a handle to a decompressor if successful, returns NULL otherwise
|
||||
*/
|
||||
OPJ_API opj_dinfo_t* OPJ_CALLCONV opj_create_decompress(
|
||||
OPJ_CODEC_FORMAT format);
|
||||
/**
|
||||
Destroy a decompressor handle
|
||||
@param dinfo decompressor handle to destroy
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_destroy_decompress(opj_dinfo_t *dinfo);
|
||||
/**
|
||||
Set decoding parameters to default values
|
||||
@param parameters Decompression parameters
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_set_default_decoder_parameters(
|
||||
opj_dparameters_t *parameters);
|
||||
/**
|
||||
Setup the decoder decoding parameters using user parameters.
|
||||
Decoding parameters are returned in j3d->cp.
|
||||
@param dinfo decompressor handle
|
||||
@param parameters decompression parameters
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_setup_decoder(opj_dinfo_t *dinfo,
|
||||
opj_dparameters_t *parameters);
|
||||
/**
|
||||
Decode an volume from a JPEG-2000 codestream
|
||||
@param dinfo decompressor handle
|
||||
@param cio Input buffer stream
|
||||
@return Returns a decoded volume if successful, returns NULL otherwise
|
||||
*/
|
||||
OPJ_API opj_volume_t* OPJ_CALLCONV opj_decode(opj_dinfo_t *dinfo,
|
||||
opj_cio_t *cio);
|
||||
/**
|
||||
Creates a J3D/JP2 compression structure
|
||||
@param format Coder to select
|
||||
@return Returns a handle to a compressor if successful, returns NULL otherwise
|
||||
*/
|
||||
OPJ_API opj_cinfo_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT format);
|
||||
/**
|
||||
Destroy a compressor handle
|
||||
@param cinfo compressor handle to destroy
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_destroy_compress(opj_cinfo_t *cinfo);
|
||||
/**
|
||||
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 volume
|
||||
<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);
|
||||
/**
|
||||
Setup the encoder parameters using the current volume and using user parameters.
|
||||
@param cinfo compressor handle
|
||||
@param parameters compression parameters
|
||||
@param volume input filled volume
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_setup_encoder(opj_cinfo_t *cinfo,
|
||||
opj_cparameters_t *parameters, opj_volume_t *volume);
|
||||
/**
|
||||
Encode an volume into a JPEG-2000 codestream
|
||||
@param cinfo compressor handle
|
||||
@param cio Output buffer stream
|
||||
@param volume Volume to encode
|
||||
@param index Name of the index file if required, NULL otherwise
|
||||
@return Returns true if successful, returns false otherwise
|
||||
*/
|
||||
OPJ_API bool OPJ_CALLCONV opj_encode(opj_cinfo_t *cinfo, opj_cio_t *cio,
|
||||
opj_volume_t *volume, char *index);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* OPENJPEG_H */
|
|
@ -1,83 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 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 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
|
||||
==========================================================
|
||||
*/
|
||||
#include "openjp3d.h"
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
OpenJPEG modules
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
#include "jp3d_lib.h"
|
||||
#include "event.h"
|
||||
#include "cio.h"
|
||||
|
||||
#include "volume.h"
|
||||
#include "jp3d.h"
|
||||
|
||||
#include "mqc.h"
|
||||
#include "raw.h"
|
||||
#include "bio.h"
|
||||
#include "tgt.h"
|
||||
#include "tcd.h"
|
||||
#include "t1.h"
|
||||
#include "t1_3d.h"
|
||||
#include "dwt.h"
|
||||
#include "pi.h"
|
||||
#include "t2.h"
|
||||
#include "mct.h"
|
||||
#include "int.h"
|
||||
#include "fix.h"
|
||||
|
||||
#endif /* OPJ_INCLUDES_H */
|
|
@ -1,709 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* Copyright (c) 2006, Mónica Díez, LPI-UVA, Spain
|
||||
* 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"
|
||||
|
||||
/** @defgroup PI PI - Implementation of a packet iterator */
|
||||
/*@{*/
|
||||
|
||||
/** @name Funciones locales */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
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);
|
||||
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
local functions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
static bool pi_next_lrcp(opj_pi_iterator_t * pi)
|
||||
{
|
||||
opj_pi_comp_t *comp = NULL;
|
||||
opj_pi_resolution_t *res = NULL;
|
||||
long 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 = 0; 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->numresolution[0]) {
|
||||
continue;
|
||||
}
|
||||
res = &comp->resolutions[pi->resno];
|
||||
/*for (pi->precno = 0; pi->precno < (res->prctno[0] * res->prctno[1]); pi->precno++) {*/
|
||||
for (pi->precno = 0;
|
||||
pi->precno < (res->prctno[0] * res->prctno[1] * res->prctno[2]); 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 = NULL;
|
||||
opj_pi_resolution_t *res = NULL;
|
||||
long 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 = 0; 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->numresolution[0]) {
|
||||
continue;
|
||||
}
|
||||
res = &comp->resolutions[pi->resno];
|
||||
/*for (pi->precno = 0; pi->precno < (res->prctno[0] * res->prctno[1]); pi->precno++) {*/
|
||||
for (pi->precno = 0;
|
||||
pi->precno < (res->prctno[0] * res->prctno[1] * res->prctno[2]); 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 = NULL;
|
||||
opj_pi_resolution_t *res = NULL;
|
||||
long index = 0;
|
||||
|
||||
if (!pi->first) {
|
||||
goto LABEL_SKIP;
|
||||
} else {
|
||||
int 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->numresolution[0]; resno++) {
|
||||
int dx, dy, dz;
|
||||
res = &comp->resolutions[resno];
|
||||
dx = comp->dx * (1 << (res->pdx + comp->numresolution[0] - 1 - resno));
|
||||
dy = comp->dy * (1 << (res->pdy + comp->numresolution[1] - 1 - resno));
|
||||
dz = comp->dz * (1 << (res->pdz + comp->numresolution[2] - 1 - resno));
|
||||
pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
|
||||
pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
|
||||
pi->dz = !pi->dz ? dz : int_min(pi->dz, dz);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {
|
||||
for (pi->z = pi->tz0; pi->z < pi->tz1; pi->z += pi->dz - (pi->z % pi->dz)) {
|
||||
for (pi->y = pi->ty0; pi->y < pi->ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
|
||||
for (pi->x = pi->tx0; pi->x < pi->tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
|
||||
for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
|
||||
int levelnox, levelnoy, levelnoz;
|
||||
int trx0, try0, trz0;
|
||||
int trx1, try1, trz1;
|
||||
int rpx, rpy, rpz;
|
||||
int prci, prcj, prck;
|
||||
comp = &pi->comps[pi->compno];
|
||||
if (pi->resno >= comp->numresolution[0]) {
|
||||
continue;
|
||||
}
|
||||
res = &comp->resolutions[pi->resno];
|
||||
levelnox = comp->numresolution[0] - 1 - pi->resno;
|
||||
levelnoy = comp->numresolution[1] - 1 - pi->resno;
|
||||
levelnoz = comp->numresolution[2] - 1 - pi->resno;
|
||||
trx0 = int_ceildiv(pi->tx0, comp->dx << levelnox);
|
||||
try0 = int_ceildiv(pi->ty0, comp->dy << levelnoy);
|
||||
trz0 = int_ceildiv(pi->tz0, comp->dz << levelnoz);
|
||||
trx1 = int_ceildiv(pi->tx1, comp->dx << levelnox);
|
||||
try1 = int_ceildiv(pi->ty1, comp->dy << levelnoy);
|
||||
trz1 = int_ceildiv(pi->tz1, comp->dz << levelnoz);
|
||||
rpx = res->pdx + levelnox;
|
||||
rpy = res->pdy + levelnoy;
|
||||
rpz = res->pdz + levelnoz;
|
||||
|
||||
/* To avoid divisions by zero / undefined behaviour on shift */
|
||||
if (rpx >= 31 || ((comp->dx << rpx) >> rpx) != comp->dx ||
|
||||
rpy >= 31 || ((comp->dy << rpy) >> rpy) != comp->dy ||
|
||||
rpz >= 31 || ((comp->dz << rpz) >> rpz) != comp->dz) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ((!(pi->x % (comp->dx << rpx) == 0) || (pi->x == pi->tx0 &&
|
||||
(trx0 << levelnox) % (1 << rpx)))) {
|
||||
continue;
|
||||
}
|
||||
if ((!(pi->y % (comp->dy << rpy) == 0) || (pi->y == pi->ty0 &&
|
||||
(try0 << levelnoy) % (1 << rpx)))) {
|
||||
continue;
|
||||
}
|
||||
if ((!(pi->z % (comp->dz << rpz) == 0) || (pi->z == pi->tz0 &&
|
||||
(trz0 << levelnoz) % (1 << rpx)))) {
|
||||
continue;
|
||||
}
|
||||
if ((res->prctno[0] == 0) || (res->prctno[1] == 0) || (res->prctno[2] == 0)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ((trx0 == trx1) || (try0 == try1) || (trz0 == trz1)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelnox), res->pdx)
|
||||
- int_floordivpow2(trx0, res->pdx);
|
||||
prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelnoy), res->pdy)
|
||||
- int_floordivpow2(try0, res->pdy);
|
||||
prck = int_floordivpow2(int_ceildiv(pi->z, comp->dz << levelnoz), res->pdz)
|
||||
- int_floordivpow2(trz0, res->pdz);
|
||||
pi->precno = prci + prcj * res->prctno[0] + prck * res->prctno[0] *
|
||||
res->prctno[1];
|
||||
for (pi->layno = 0; 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 = NULL;
|
||||
opj_pi_resolution_t *res = NULL;
|
||||
long index = 0;
|
||||
|
||||
if (!pi->first) {
|
||||
comp = &pi->comps[pi->compno];
|
||||
goto LABEL_SKIP;
|
||||
} else {
|
||||
int compno, resno;
|
||||
pi->first = 0;
|
||||
pi->dx = 0;
|
||||
pi->dy = 0;
|
||||
pi->dz = 0;
|
||||
for (compno = 0; compno < pi->numcomps; compno++) {
|
||||
comp = &pi->comps[compno];
|
||||
for (resno = 0; resno < comp->numresolution[0]; resno++) {
|
||||
int dx, dy, dz;
|
||||
res = &comp->resolutions[resno];
|
||||
dx = comp->dx * (1 << (res->pdx + comp->numresolution[0] - 1 - resno));
|
||||
dy = comp->dy * (1 << (res->pdy + comp->numresolution[1] - 1 - resno));
|
||||
dz = comp->dz * (1 << (res->pdy + comp->numresolution[2] - 1 - resno));
|
||||
pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
|
||||
pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
|
||||
pi->dz = !pi->dz ? dz : int_min(pi->dz, dz);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (pi->z = pi->tz0; pi->z < pi->tz1; pi->z += pi->dz - (pi->z % pi->dz)) {
|
||||
for (pi->y = pi->ty0; pi->y < pi->ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
|
||||
for (pi->x = pi->tx0; pi->x < pi->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];
|
||||
for (pi->resno = pi->poc.resno0;
|
||||
pi->resno < int_min(pi->poc.resno1, comp->numresolution[0]); pi->resno++) {
|
||||
int levelnox, levelnoy, levelnoz;
|
||||
int trx0, try0, trz0;
|
||||
int trx1, try1, trz1;
|
||||
int rpx, rpy, rpz;
|
||||
int prci, prcj, prck;
|
||||
comp = &pi->comps[pi->compno];
|
||||
if (pi->resno >= comp->numresolution[0]) {
|
||||
continue;
|
||||
}
|
||||
res = &comp->resolutions[pi->resno];
|
||||
levelnox = comp->numresolution[0] - 1 - pi->resno;
|
||||
levelnoy = comp->numresolution[1] - 1 - pi->resno;
|
||||
levelnoz = comp->numresolution[2] - 1 - pi->resno;
|
||||
trx0 = int_ceildiv(pi->tx0, comp->dx << levelnox);
|
||||
try0 = int_ceildiv(pi->ty0, comp->dy << levelnoy);
|
||||
trz0 = int_ceildiv(pi->tz0, comp->dz << levelnoz);
|
||||
trx1 = int_ceildiv(pi->tx1, comp->dx << levelnox);
|
||||
try1 = int_ceildiv(pi->ty1, comp->dy << levelnoy);
|
||||
trz1 = int_ceildiv(pi->tz1, comp->dz << levelnoz);
|
||||
rpx = res->pdx + levelnox;
|
||||
rpy = res->pdy + levelnoy;
|
||||
rpz = res->pdz + levelnoz;
|
||||
|
||||
/* To avoid divisions by zero / undefined behaviour on shift */
|
||||
if (rpx >= 31 || ((comp->dx << rpx) >> rpx) != comp->dx ||
|
||||
rpy >= 31 || ((comp->dy << rpy) >> rpy) != comp->dy ||
|
||||
rpz >= 31 || ((comp->dz << rpz) >> rpz) != comp->dz) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ((!(pi->x % (comp->dx << rpx) == 0) || (pi->x == pi->tx0 &&
|
||||
(trx0 << levelnox) % (1 << rpx)))) {
|
||||
continue;
|
||||
}
|
||||
if ((!(pi->y % (comp->dy << rpy) == 0) || (pi->y == pi->ty0 &&
|
||||
(try0 << levelnoy) % (1 << rpx)))) {
|
||||
continue;
|
||||
}
|
||||
if ((!(pi->z % (comp->dz << rpz) == 0) || (pi->z == pi->tz0 &&
|
||||
(trz0 << levelnoz) % (1 << rpx)))) {
|
||||
continue;
|
||||
}
|
||||
if ((res->prctno[0] == 0) || (res->prctno[1] == 0) || (res->prctno[2] == 0)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ((trx0 == trx1) || (try0 == try1) || (trz0 == trz1)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelnox), res->pdx)
|
||||
- int_floordivpow2(trx0, res->pdx);
|
||||
prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelnoy), res->pdy)
|
||||
- int_floordivpow2(try0, res->pdy);
|
||||
prck = int_floordivpow2(int_ceildiv(pi->z, comp->dz << levelnoz), res->pdz)
|
||||
- int_floordivpow2(trz0, res->pdz);
|
||||
pi->precno = prci + prcj * res->prctno[0] + prck * res->prctno[0] *
|
||||
res->prctno[1];
|
||||
for (pi->layno = 0; 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 = NULL;
|
||||
opj_pi_resolution_t *res = NULL;
|
||||
long 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++) {
|
||||
int resno;
|
||||
comp = &pi->comps[pi->compno];
|
||||
pi->dx = 0;
|
||||
pi->dy = 0;
|
||||
pi->dz = 0;
|
||||
for (resno = 0; resno < comp->numresolution[0]; resno++) {
|
||||
int dx, dy, dz;
|
||||
res = &comp->resolutions[resno];
|
||||
dx = comp->dx * (1 << (res->pdx + comp->numresolution[0] - 1 - resno));
|
||||
dy = comp->dy * (1 << (res->pdy + comp->numresolution[1] - 1 - resno));
|
||||
dz = comp->dz * (1 << (res->pdz + comp->numresolution[2] - 1 - resno));
|
||||
pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
|
||||
pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
|
||||
pi->dz = !pi->dz ? dz : int_min(pi->dz, dz);
|
||||
}
|
||||
for (pi->z = pi->tz0; pi->z < pi->tz1; pi->z += pi->dz - (pi->z % pi->dz)) {
|
||||
for (pi->y = pi->ty0; pi->y < pi->ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
|
||||
for (pi->x = pi->tx0; pi->x < pi->tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
|
||||
for (pi->resno = pi->poc.resno0;
|
||||
pi->resno < int_min(pi->poc.resno1, comp->numresolution[0]); pi->resno++) {
|
||||
int levelnox, levelnoy, levelnoz;
|
||||
int trx0, try0, trz0;
|
||||
int trx1, try1, trz1;
|
||||
int rpx, rpy, rpz;
|
||||
int prci, prcj, prck;
|
||||
comp = &pi->comps[pi->compno];
|
||||
if (pi->resno >= comp->numresolution[0]) {
|
||||
continue;
|
||||
}
|
||||
res = &comp->resolutions[pi->resno];
|
||||
levelnox = comp->numresolution[0] - 1 - pi->resno;
|
||||
levelnoy = comp->numresolution[1] - 1 - pi->resno;
|
||||
levelnoz = comp->numresolution[2] - 1 - pi->resno;
|
||||
trx0 = int_ceildiv(pi->tx0, comp->dx << levelnox);
|
||||
try0 = int_ceildiv(pi->ty0, comp->dy << levelnoy);
|
||||
trz0 = int_ceildiv(pi->tz0, comp->dz << levelnoz);
|
||||
trx1 = int_ceildiv(pi->tx1, comp->dx << levelnox);
|
||||
try1 = int_ceildiv(pi->ty1, comp->dy << levelnoy);
|
||||
trz1 = int_ceildiv(pi->tz1, comp->dz << levelnoz);
|
||||
rpx = res->pdx + levelnox;
|
||||
rpy = res->pdy + levelnoy;
|
||||
rpz = res->pdz + levelnoz;
|
||||
|
||||
/* To avoid divisions by zero / undefined behaviour on shift */
|
||||
if (rpx >= 31 || ((comp->dx << rpx) >> rpx) != comp->dx ||
|
||||
rpy >= 31 || ((comp->dy << rpy) >> rpy) != comp->dy ||
|
||||
rpz >= 31 || ((comp->dz << rpz) >> rpz) != comp->dz) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ((!(pi->x % (comp->dx << rpx) == 0) || (pi->x == pi->tx0 &&
|
||||
(trx0 << levelnox) % (1 << rpx)))) {
|
||||
continue;
|
||||
}
|
||||
if ((!(pi->y % (comp->dy << rpy) == 0) || (pi->y == pi->ty0 &&
|
||||
(try0 << levelnoy) % (1 << rpx)))) {
|
||||
continue;
|
||||
}
|
||||
if ((!(pi->z % (comp->dz << rpz) == 0) || (pi->z == pi->tz0 &&
|
||||
(trz0 << levelnoz) % (1 << rpx)))) {
|
||||
continue;
|
||||
}
|
||||
if ((res->prctno[0] == 0) || (res->prctno[1] == 0) || (res->prctno[2] == 0)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ((trx0 == trx1) || (try0 == try1) || (trz0 == trz1)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelnox), res->pdx)
|
||||
- int_floordivpow2(trx0, res->pdx);
|
||||
prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelnoy), res->pdy)
|
||||
- int_floordivpow2(try0, res->pdy);
|
||||
prck = int_floordivpow2(int_ceildiv(pi->z, comp->dz << levelnoz), res->pdz)
|
||||
- int_floordivpow2(trz0, res->pdz);
|
||||
pi->precno = prci + prcj * res->prctno[0] + prck * res->prctno[0] *
|
||||
res->prctno[1];
|
||||
for (pi->layno = 0; 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(opj_volume_t *volume, opj_cp_t *cp, int tileno)
|
||||
{
|
||||
int p, q, r;
|
||||
int compno, resno, pino;
|
||||
opj_pi_iterator_t *pi = NULL;
|
||||
opj_tcp_t *tcp = NULL;
|
||||
opj_tccp_t *tccp = NULL;
|
||||
size_t array_size;
|
||||
|
||||
tcp = &cp->tcps[tileno];
|
||||
|
||||
array_size = (tcp->numpocs + 1) * sizeof(opj_pi_iterator_t);
|
||||
pi = (opj_pi_iterator_t *) opj_malloc(array_size);
|
||||
if (!pi) {
|
||||
fprintf(stdout, "[ERROR] Malloc of opj_pi_iterator failed \n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (pino = 0; pino < tcp->numpocs + 1; pino++) { /* change */
|
||||
int maxres = 0;
|
||||
int maxprec = 0;
|
||||
p = tileno % cp->tw;
|
||||
q = tileno / cp->tw;
|
||||
r = tileno / (cp->tw * cp->th);
|
||||
|
||||
pi[pino].tx0 = int_max(cp->tx0 + p * cp->tdx, volume->x0);
|
||||
pi[pino].ty0 = int_max(cp->ty0 + q * cp->tdy, volume->y0);
|
||||
pi[pino].tz0 = int_max(cp->tz0 + r * cp->tdz, volume->z0);
|
||||
pi[pino].tx1 = int_min(cp->tx0 + (p + 1) * cp->tdx, volume->x1);
|
||||
pi[pino].ty1 = int_min(cp->ty0 + (q + 1) * cp->tdy, volume->y1);
|
||||
pi[pino].tz1 = int_min(cp->tz0 + (r + 1) * cp->tdz, volume->z1);
|
||||
pi[pino].numcomps = volume->numcomps;
|
||||
|
||||
array_size = volume->numcomps * sizeof(opj_pi_comp_t);
|
||||
pi[pino].comps = (opj_pi_comp_t *) opj_malloc(array_size);
|
||||
if (!pi[pino].comps) {
|
||||
fprintf(stdout, "[ERROR] Malloc of opj_pi_comp failed \n");
|
||||
pi_destroy(pi, cp, tileno);
|
||||
return NULL;
|
||||
}
|
||||
memset(pi[pino].comps, 0, array_size);
|
||||
|
||||
for (compno = 0; compno < pi->numcomps; compno++) {
|
||||
int tcx0, tcx1, tcy0, tcy1, tcz0, tcz1;
|
||||
int i;
|
||||
opj_pi_comp_t *comp = &pi[pino].comps[compno];
|
||||
tccp = &tcp->tccps[compno];
|
||||
|
||||
comp->dx = volume->comps[compno].dx;
|
||||
comp->dy = volume->comps[compno].dy;
|
||||
comp->dz = volume->comps[compno].dz;
|
||||
for (i = 0; i < 3; i++) {
|
||||
comp->numresolution[i] = tccp->numresolution[i];
|
||||
if (comp->numresolution[i] > maxres) {
|
||||
maxres = comp->numresolution[i];
|
||||
}
|
||||
}
|
||||
array_size = comp->numresolution[0] * sizeof(opj_pi_resolution_t);
|
||||
comp->resolutions = (opj_pi_resolution_t *) opj_malloc(array_size);
|
||||
if (!comp->resolutions) {
|
||||
fprintf(stdout, "[ERROR] Malloc of opj_pi_resolution failed \n");
|
||||
pi_destroy(pi, cp, tileno);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
tcx0 = int_ceildiv(pi->tx0, comp->dx);
|
||||
tcy0 = int_ceildiv(pi->ty0, comp->dy);
|
||||
tcz0 = int_ceildiv(pi->tz0, comp->dz);
|
||||
tcx1 = int_ceildiv(pi->tx1, comp->dx);
|
||||
tcy1 = int_ceildiv(pi->ty1, comp->dy);
|
||||
tcz1 = int_ceildiv(pi->tz1, comp->dz);
|
||||
|
||||
for (resno = 0; resno < comp->numresolution[0]; resno++) {
|
||||
int levelnox, levelnoy, levelnoz, diff;
|
||||
int rx0, ry0, rz0, rx1, ry1, rz1;
|
||||
int px0, py0, pz0, px1, py1, pz1;
|
||||
opj_pi_resolution_t *res = &comp->resolutions[resno];
|
||||
if (tccp->csty & J3D_CCP_CSTY_PRT) {
|
||||
res->pdx = tccp->prctsiz[0][resno];
|
||||
res->pdy = tccp->prctsiz[1][resno];
|
||||
res->pdz = tccp->prctsiz[2][resno];
|
||||
} else {
|
||||
res->pdx = 15;
|
||||
res->pdy = 15;
|
||||
res->pdz = 15;
|
||||
}
|
||||
levelnox = comp->numresolution[0] - 1 - resno;
|
||||
levelnoy = comp->numresolution[1] - 1 - resno;
|
||||
levelnoz = comp->numresolution[2] - 1 - resno;
|
||||
if (levelnoz < 0) {
|
||||
levelnoz = 0;
|
||||
}
|
||||
diff = comp->numresolution[0] - comp->numresolution[2];
|
||||
|
||||
rx0 = int_ceildivpow2(tcx0, levelnox);
|
||||
ry0 = int_ceildivpow2(tcy0, levelnoy);
|
||||
rz0 = int_ceildivpow2(tcz0, levelnoz);
|
||||
rx1 = int_ceildivpow2(tcx1, levelnox);
|
||||
ry1 = int_ceildivpow2(tcy1, levelnoy);
|
||||
rz1 = int_ceildivpow2(tcz1, levelnoz);
|
||||
px0 = int_floordivpow2(rx0, res->pdx) << res->pdx;
|
||||
py0 = int_floordivpow2(ry0, res->pdy) << res->pdy;
|
||||
pz0 = int_floordivpow2(rz0, res->pdz) << res->pdz;
|
||||
px1 = int_ceildivpow2(rx1, res->pdx) << res->pdx;
|
||||
py1 = int_ceildivpow2(ry1, res->pdy) << res->pdy;
|
||||
pz1 = int_ceildivpow2(rz1, res->pdz) << res->pdz;
|
||||
res->prctno[0] = (rx0 == rx1) ? 0 : ((px1 - px0) >> res->pdx);
|
||||
res->prctno[1] = (ry0 == ry1) ? 0 : ((py1 - py0) >> res->pdy);
|
||||
res->prctno[2] = (rz0 == rz1) ? 0 : ((pz1 - pz0) >> res->pdz);
|
||||
|
||||
if (res->prctno[0]*res->prctno[1]*res->prctno[2] > maxprec) {
|
||||
maxprec = res->prctno[0] * res->prctno[1] * res->prctno[2];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
tccp = &tcp->tccps[0];
|
||||
pi[pino].step_p = 1;
|
||||
pi[pino].step_c = maxprec * pi[pino].step_p;
|
||||
pi[pino].step_r = volume->numcomps * pi[pino].step_c;
|
||||
pi[pino].step_l = maxres * pi[pino].step_r;
|
||||
|
||||
if (pino == 0) {
|
||||
array_size = volume->numcomps * maxres * tcp->numlayers * maxprec * sizeof(
|
||||
short int);
|
||||
pi[pino].include = (short int *) opj_malloc(array_size);
|
||||
if (!pi[pino].include) {
|
||||
fprintf(stdout, "[ERROR] Malloc of pi[pino].include failed \n");
|
||||
pi_destroy(pi, cp, tileno);
|
||||
return NULL;
|
||||
}
|
||||
} else {
|
||||
pi[pino].include = pi[pino - 1].include;
|
||||
}
|
||||
|
||||
if (tcp->POC == 0) {
|
||||
pi[pino].first = 1;
|
||||
pi[pino].poc.resno0 = 0;
|
||||
pi[pino].poc.compno0 = 0;
|
||||
pi[pino].poc.layno1 = tcp->numlayers;
|
||||
pi[pino].poc.resno1 = maxres;
|
||||
pi[pino].poc.compno1 = volume->numcomps;
|
||||
pi[pino].poc.prg = tcp->prg;
|
||||
} else {
|
||||
pi[pino].first = 1;
|
||||
pi[pino].poc.resno0 = tcp->pocs[pino].resno0;
|
||||
pi[pino].poc.compno0 = tcp->pocs[pino].compno0;
|
||||
pi[pino].poc.layno1 = tcp->pocs[pino].layno1;
|
||||
pi[pino].poc.resno1 = tcp->pocs[pino].resno1;
|
||||
pi[pino].poc.compno1 = tcp->pocs[pino].compno1;
|
||||
pi[pino].poc.prg = tcp->pocs[pino].prg;
|
||||
}
|
||||
}
|
||||
|
||||
return pi;
|
||||
}
|
||||
|
||||
void pi_destroy(opj_pi_iterator_t *pi, opj_cp_t *cp, int tileno)
|
||||
{
|
||||
int compno, pino;
|
||||
opj_tcp_t *tcp = &cp->tcps[tileno];
|
||||
if (pi) {
|
||||
for (pino = 0; pino < tcp->numpocs + 1; pino++) {
|
||||
if (pi[pino].comps) {
|
||||
for (compno = 0; compno < pi->numcomps; compno++) {
|
||||
opj_pi_comp_t *comp = &pi[pino].comps[compno];
|
||||
if (comp->resolutions) {
|
||||
opj_free(comp->resolutions);
|
||||
}
|
||||
}
|
||||
opj_free(pi[pino].comps);
|
||||
}
|
||||
}
|
||||
if (pi->include) {
|
||||
opj_free(pi->include);
|
||||
}
|
||||
opj_free(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);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
|
@ -1,150 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* Copyright (c) 2006, Mónica Díez García, Image Processing Laboratory, University of Valladolid, Spain
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/** @defgroup PI PI - Implementation of a packet iterator */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Packet iterator : resolution level information
|
||||
*/
|
||||
typedef struct opj_pi_resolution {
|
||||
/** Size of precints in horizontal axis */
|
||||
int pdx;
|
||||
/** Size of precints in vertical axis */
|
||||
int pdy;
|
||||
/** Size of precints in axial axis */
|
||||
int pdz;
|
||||
/** Number of precints in each axis */
|
||||
int prctno[3];
|
||||
} opj_pi_resolution_t;
|
||||
|
||||
/**
|
||||
Packet iterator : component information
|
||||
*/
|
||||
typedef struct opj_pi_comp {
|
||||
/** Size in horizontal axis */
|
||||
int dx;
|
||||
/** Size in vertical axis */
|
||||
int dy;
|
||||
/** Size in axial axis */
|
||||
int dz;
|
||||
/** Number of resolution levels */
|
||||
int numresolution[3];
|
||||
/** Packet iterator : resolution level information */
|
||||
opj_pi_resolution_t *resolutions;
|
||||
} opj_pi_comp_t;
|
||||
|
||||
/**
|
||||
Packet iterator
|
||||
*/
|
||||
typedef struct opj_pi_iterator {
|
||||
/** precise if the packet has been already used (useful for progression order change) */
|
||||
short int *include;
|
||||
/** layer step used to localize the packet in the include vector */
|
||||
int step_l;
|
||||
/** resolution step used to localize the packet in the include vector */
|
||||
int step_r;
|
||||
/** component step used to localize the packet in the include vector */
|
||||
int step_c;
|
||||
/** precinct step used to localize the packet in the include vector */
|
||||
int step_p;
|
||||
/** component that identify the packet */
|
||||
int compno;
|
||||
/** resolution that identify the packet */
|
||||
int resno;
|
||||
/** precinct that identify the packet */
|
||||
int precno;
|
||||
/** layer that identify the packet */
|
||||
int layno;
|
||||
/** 0 if the first packet */
|
||||
int first;
|
||||
/** progression order change information */
|
||||
opj_poc_t poc;
|
||||
/** Packet iterator : component information */
|
||||
opj_pi_comp_t *comps;
|
||||
|
||||
int numcomps;
|
||||
int tx0, ty0, tz0;
|
||||
int tx1, ty1, tz1;
|
||||
int x, y, z;
|
||||
int dx, dy, dz;
|
||||
} opj_pi_iterator_t;
|
||||
|
||||
/** @name Funciones generales */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Create a packet iterator
|
||||
@param volume Raw volume 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(opj_volume_t * volume, opj_cp_t * cp, int tileno);
|
||||
|
||||
/**
|
||||
Destroy a packet iterator
|
||||
@param pi Previously created packet iterator
|
||||
@param cp Coding parameters
|
||||
@param tileno Number that identifies the tile for which the packets were listed
|
||||
@see pi_create
|
||||
*/
|
||||
void pi_destroy(opj_pi_iterator_t *pi, opj_cp_t *cp, int tileno);
|
||||
|
||||
/**
|
||||
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 */
|
|
@ -1,96 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
local functions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
RAW encoding interface
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
opj_raw_t* raw_create()
|
||||
{
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
int raw_numbytes(opj_raw_t *raw)
|
||||
{
|
||||
return raw->bp - raw->start;
|
||||
}
|
||||
|
||||
void raw_init_dec(opj_raw_t *raw, unsigned char *bp, int len)
|
||||
{
|
||||
raw->start = bp;
|
||||
raw->lenmax = len;
|
||||
raw->len = 0;
|
||||
raw->c = 0;
|
||||
raw->ct = 0;
|
||||
}
|
||||
|
||||
int raw_decode(opj_raw_t *raw)
|
||||
{
|
||||
int d;
|
||||
if (raw->ct == 0) {
|
||||
raw->ct = 8;
|
||||
if (raw->len == raw->lenmax) {
|
||||
raw->c = 0xff;
|
||||
} else {
|
||||
if (raw->c == 0xff) {
|
||||
raw->ct = 7;
|
||||
}
|
||||
raw->c = *(raw->start + raw->len);
|
||||
raw->len++;
|
||||
}
|
||||
}
|
||||
raw->ct--;
|
||||
d = (raw->c >> raw->ct) & 0x01;
|
||||
|
||||
return d;
|
||||
}
|
||||
|
|
@ -1,104 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#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.
|
||||
*/
|
||||
|
||||
/** @defgroup RAW RAW - Implementation of operations for raw encoding */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
RAW encoding operations
|
||||
*/
|
||||
typedef struct opj_raw {
|
||||
/** Temporary buffer where bits are coded or decoded */
|
||||
unsigned char c;
|
||||
/** Number of bits already read or free to write */
|
||||
unsigned int ct;
|
||||
/** Maximum length to decode */
|
||||
unsigned int lenmax;
|
||||
/** Length decoded */
|
||||
unsigned int len;
|
||||
/** Pointer to the current position in the buffer */
|
||||
unsigned char *bp;
|
||||
/** Pointer to the start of the buffer */
|
||||
unsigned char *start;
|
||||
/** Pointer to the end of the buffer */
|
||||
unsigned char *end;
|
||||
} opj_raw_t;
|
||||
|
||||
/** @name Funciones generales */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
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
|
||||
*/
|
||||
int 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, unsigned char *bp, int len);
|
||||
/**
|
||||
Decode a symbol using raw-decoder. Cfr p.506 TAUBMAN
|
||||
@param raw RAW handle
|
||||
@return Returns the decoded symbol (0 or 1)
|
||||
*/
|
||||
int raw_decode(opj_raw_t *raw);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __RAW_H */
|
File diff suppressed because it is too large
Load Diff
|
@ -1,179 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#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.
|
||||
*/
|
||||
|
||||
/** @defgroup T1 T1 - Implementation of the tier-1 coding */
|
||||
/*@{*/
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
#define T1_NMSEDEC_BITS 7
|
||||
|
||||
#define T1_MAXCBLKW 256 /*< Maximum size of code-block (width) */
|
||||
#define T1_MAXCBLKH 256 /*< Maximum size of code-block (height) */
|
||||
#define T1_MAXCBLKD 256 /*< Maximum size of code-block (depth) */
|
||||
#define T1_MINCBLKW 4 /*< Minimum size of code-block (width) */
|
||||
#define T1_MINCBLKH 4 /*< Minimum size of code-block (height) */
|
||||
#define T1_MINCBLKD 4 /*< Minimum size of code-block (depth) */
|
||||
#define T1_MAXWHD 18
|
||||
#define T1_CBLKW 256
|
||||
#define T1_CBLKH 256
|
||||
#define T1_CBLKD 256
|
||||
|
||||
#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_AGG 1
|
||||
#define T1_NUMCTXS_ZC 9
|
||||
#define T1_NUMCTXS_MAG 3
|
||||
#define T1_NUMCTXS_SC 5
|
||||
#define T1_NUMCTXS_UNI 1
|
||||
|
||||
#define T1_CTXNO_AGG 0
|
||||
#define T1_CTXNO_ZC (T1_CTXNO_AGG+T1_NUMCTXS_AGG)
|
||||
#define T1_CTXNO_MAG (T1_CTXNO_ZC+T1_NUMCTXS_ZC)
|
||||
#define T1_CTXNO_SC (T1_CTXNO_MAG+T1_NUMCTXS_MAG)
|
||||
#define T1_CTXNO_UNI (T1_CTXNO_SC+T1_NUMCTXS_SC)
|
||||
#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)*/
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
Tier-1 coding (coding of code-block coefficients)
|
||||
*/
|
||||
typedef struct opj_t1 {
|
||||
/** codec context */
|
||||
opj_common_ptr cinfo;
|
||||
|
||||
/** MQC component */
|
||||
opj_mqc_t *mqc;
|
||||
/** RAW component */
|
||||
opj_raw_t *raw;
|
||||
/** LUTs for context-based coding */
|
||||
int lut_ctxno_zc[1024];
|
||||
int lut_ctxno_sc[256];
|
||||
int lut_ctxno_mag[4096];
|
||||
int lut_spb[256];
|
||||
/** LUTs for decoding normalised MSE */
|
||||
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];
|
||||
/** Codeblock data */
|
||||
int data[T1_CBLKD][T1_CBLKH][T1_CBLKW];/*int ***data;*/
|
||||
/** Context information for each voxel in codeblock */
|
||||
int flags[T1_CBLKD + 2][T1_CBLKH + 2][T1_CBLKH + 2];/*int ***flags;*/
|
||||
} opj_t1_t;
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Create a new T1 handle
|
||||
and initialize the look-up tables of the Tier-1 coder/decoder
|
||||
@return Returns a new T1 handle if successful, returns NULL otherwise
|
||||
@see t1_init_luts
|
||||
*/
|
||||
opj_t1_t* t1_create(opj_common_ptr cinfo);
|
||||
/**
|
||||
Destroy a previously created T1 handle
|
||||
@param t1 T1 handle to destroy
|
||||
*/
|
||||
void t1_destroy(opj_t1_t *t1);
|
||||
/**
|
||||
Encode the code-blocks of a tile
|
||||
@param t1 T1 handle
|
||||
@param tile The tile to encode
|
||||
@param tcp Tile coding parameters
|
||||
*/
|
||||
void t1_encode_cblks(opj_t1_t *t1, opj_tcd_tile_t *tile, opj_tcp_t *tcp);
|
||||
/**
|
||||
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, opj_tcd_tile_t *tile, opj_tcp_t *tcp);
|
||||
/**
|
||||
Get weigths of MSE decoding
|
||||
@param nmsedec The normalized MSE reduction
|
||||
@param compno
|
||||
@param level
|
||||
@param orient
|
||||
@param bpno
|
||||
@param stepsize
|
||||
@param numcomps
|
||||
@param dwtid
|
||||
returns MSE associated to decoding pass
|
||||
*/
|
||||
double t1_getwmsedec(int nmsedec, int compno, int level[3], int orient,
|
||||
int bpno, double stepsize, int numcomps, int dwtid[3]);
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __T1_H */
|
File diff suppressed because it is too large
Load Diff
|
@ -1,173 +0,0 @@
|
|||
/*
|
||||
* Copyrigth (c) 2006, Mónica Díez, LPI-UVA, Spain
|
||||
* 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_3D_H
|
||||
#define __T1_3D_H
|
||||
/**
|
||||
@file t1_3d.h
|
||||
@brief Implementation of the tier-1 coding (coding of code-block coefficients) (T1)
|
||||
|
||||
The functions in T1_3D.C have for goal to realize the tier-1 coding operation of 3D-EBCOT.
|
||||
The functions in T1_3D.C are used by some function in TCD.C.
|
||||
*/
|
||||
|
||||
/** @defgroup T1_3D T1_3D - Implementation of the tier-1 coding */
|
||||
/*@{*/
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/* Neighbourhood of 3D EBCOT (Significance context)*/
|
||||
#define T1_3D_SIG_NE 0x00000001 /*< Context orientation : North-East direction */
|
||||
#define T1_3D_SIG_SE 0x00000002 /*< Context orientation : South-East direction */
|
||||
#define T1_3D_SIG_SW 0x00000004 /*< Context orientation : South-West direction */
|
||||
#define T1_3D_SIG_NW 0x00000008 /* Context orientation : North-West direction */
|
||||
#define T1_3D_SIG_N 0x00000010 /*< Context orientation : North direction */
|
||||
#define T1_3D_SIG_E 0x00000020 /*< Context orientation : East direction */
|
||||
#define T1_3D_SIG_S 0x00000040 /*< Context orientation : South direction */
|
||||
#define T1_3D_SIG_W 0x00000080 /*< Context orientation : West direction */
|
||||
#define T1_3D_SIG_FC 0x00000100 /*< Context orientation : Forward Central direction */
|
||||
#define T1_3D_SIG_BC 0x00000200 /*< Context orientation : Backward Central direction */
|
||||
#define T1_3D_SIG_FNE 0x00000400 /*< Context orientation : Forward North-East direction */
|
||||
#define T1_3D_SIG_FSE 0x00000800 /*< Context orientation : Forward South-East direction */
|
||||
#define T1_3D_SIG_FSW 0x00001000 /*< Context orientation : Forward South-West direction */
|
||||
#define T1_3D_SIG_FNW 0x00002000 /*< Context orientation : Forward North-West direction */
|
||||
#define T1_3D_SIG_FN 0x00004000 /*< Context orientation : Forward North direction */
|
||||
#define T1_3D_SIG_FE 0x00008000 /*< Context orientation : Forward East direction */
|
||||
#define T1_3D_SIG_FS 0x00010000 /*< Context orientation : Forward South direction */
|
||||
#define T1_3D_SIG_FW 0x00020000 /*< Context orientation : Forward West direction */
|
||||
#define T1_3D_SIG_BNE 0x00040000 /*< Context orientation : Backward North-East direction */
|
||||
#define T1_3D_SIG_BSE 0x00080000 /*< Context orientation : Backward South-East direction */
|
||||
#define T1_3D_SIG_BSW 0x00100000 /*< Context orientation : Backward South-West direction */
|
||||
#define T1_3D_SIG_BNW 0x00200000 /*< Context orientation : Backward North-West direction */
|
||||
#define T1_3D_SIG_BN 0x00400000 /*< Context orientation : Backward North direction */
|
||||
#define T1_3D_SIG_BE 0x00800000 /*< Context orientation : Backward East direction */
|
||||
#define T1_3D_SIG_BS 0x01000000 /*< Context orientation : Backward South direction */
|
||||
#define T1_3D_SIG_BW 0x02000000 /*< Context orientation : Backward West direction */
|
||||
#define T1_3D_SIG_COTH (T1_3D_SIG_N|T1_3D_SIG_NE|T1_3D_SIG_E|T1_3D_SIG_SE|T1_3D_SIG_S|T1_3D_SIG_SW|T1_3D_SIG_W|T1_3D_SIG_NW)
|
||||
#define T1_3D_SIG_BOTH (T1_3D_SIG_BN|T1_3D_SIG_BNE|T1_3D_SIG_BE|T1_3D_SIG_BSE|T1_3D_SIG_BS|T1_3D_SIG_BSW|T1_3D_SIG_BW|T1_3D_SIG_BNW|T1_3D_SIG_BC)
|
||||
#define T1_3D_SIG_FOTH (T1_3D_SIG_FN|T1_3D_SIG_FNE|T1_3D_SIG_FE|T1_3D_SIG_FSE|T1_3D_SIG_FS|T1_3D_SIG_FSW|T1_3D_SIG_FW|T1_3D_SIG_FNW|T1_3D_SIG_FC)
|
||||
#define T1_3D_SIG_OTH (T1_3D_SIG_FOTH|T1_3D_SIG_BOTH|T1_3D_SIG_COTH)
|
||||
#define T1_3D_SIG_PRIM (T1_3D_SIG_N|T1_3D_SIG_E|T1_3D_SIG_S|T1_3D_SIG_W|T1_3D_SIG_FC|T1_3D_SIG_BC)
|
||||
|
||||
#define T1_3D_SGN_N 0x0400
|
||||
#define T1_3D_SGN_E 0x0800
|
||||
#define T1_3D_SGN_S 0x1000
|
||||
#define T1_3D_SGN_W 0x2000
|
||||
#define T1_3D_SGN_F 0x4000
|
||||
#define T1_3D_SGN_B 0x8000
|
||||
#define T1_3D_SGN (T1_3D_SGN_N|T1_3D_SGN_E|T1_3D_SGN_S|T1_3D_SGN_W|T1_3D_SGN_F|T1_3D_SGN_B)
|
||||
|
||||
#define T1_3D_SIG 0x0001 /*Significance state*/
|
||||
#define T1_3D_REFINE 0x0002 /*Delayed significance*/
|
||||
#define T1_3D_VISIT 0x0004 /*First-pass membership*/
|
||||
|
||||
#define T1_3D_NUMCTXS_AGG 1
|
||||
#define T1_3D_NUMCTXS_ZC 16
|
||||
#define T1_3D_NUMCTXS_MAG 3
|
||||
#define T1_3D_NUMCTXS_SC 6
|
||||
#define T1_3D_NUMCTXS_UNI 1
|
||||
|
||||
#define T1_3D_CTXNO_AGG 0
|
||||
#define T1_3D_CTXNO_ZC (T1_3D_CTXNO_AGG+T1_3D_NUMCTXS_AGG) /*1*/
|
||||
#define T1_3D_CTXNO_MAG (T1_3D_CTXNO_ZC+T1_3D_NUMCTXS_ZC) /*17*/
|
||||
#define T1_3D_CTXNO_SC (T1_3D_CTXNO_MAG+T1_3D_NUMCTXS_MAG) /*20*/
|
||||
#define T1_3D_CTXNO_UNI (T1_3D_CTXNO_SC+T1_3D_NUMCTXS_SC) /*26*/
|
||||
#define T1_3D_NUMCTXS (T1_3D_CTXNO_UNI+T1_3D_NUMCTXS_UNI) /*27*/
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
Tier-1 coding (coding of code-block coefficients)
|
||||
*/
|
||||
typedef struct opj_t1_3d {
|
||||
/** Codec context */
|
||||
opj_common_ptr cinfo;
|
||||
/** MQC component */
|
||||
opj_mqc_t *mqc;
|
||||
/** RAW component */
|
||||
opj_raw_t *raw;
|
||||
/** LUTs for decoding normalised MSE */
|
||||
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];
|
||||
/** Codeblock data */
|
||||
int data[T1_CBLKD][T1_CBLKH][T1_CBLKW];
|
||||
/** Context information for each voxel in codeblock */
|
||||
unsigned int flags[T1_CBLKD + 2][T1_CBLKH + 2][T1_CBLKH + 2];
|
||||
/** Voxel information (significance/visited/refined) */
|
||||
int flagSVR[T1_CBLKD + 2][T1_CBLKH + 2][T1_CBLKH + 2];
|
||||
} opj_t1_3d_t;
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Create a new T1_3D handle
|
||||
and initialize the look-up tables of the Tier-1 coder/decoder
|
||||
@return Returns a new T1 handle if successful, returns NULL otherwise
|
||||
@see t1_init_luts
|
||||
*/
|
||||
opj_t1_3d_t* t1_3d_create(opj_common_ptr cinfo);
|
||||
/**
|
||||
Destroy a previously created T1_3D handle
|
||||
@param t1 T1_3D handle to destroy
|
||||
*/
|
||||
void t1_3d_destroy(opj_t1_3d_t *t1);
|
||||
/**
|
||||
Encode the code-blocks of a tile
|
||||
@param t1 T1_3D handle
|
||||
@param tile The tile to encode
|
||||
@param tcp Tile coding parameters
|
||||
*/
|
||||
void t1_3d_encode_cblks(opj_t1_3d_t *t1, opj_tcd_tile_t *tile, opj_tcp_t *tcp);
|
||||
/**
|
||||
Decode the code-blocks of a tile
|
||||
@param t1 T1_3D handle
|
||||
@param tile The tile to decode
|
||||
@param tcp Tile coding parameters
|
||||
*/
|
||||
void t1_3d_decode_cblks(opj_t1_3d_t *t1, opj_tcd_tile_t *tile, opj_tcp_t *tcp);
|
||||
/**
|
||||
Get weigths of MSE decoding
|
||||
@param nmsedec The normalized MSE reduction
|
||||
@param compno
|
||||
@param level
|
||||
@param orient
|
||||
@param bpno
|
||||
@param reversible
|
||||
@param stepsize
|
||||
@param numcomps
|
||||
@param dwtid
|
||||
returns MSE associated to decoding pass
|
||||
double t1_3d_getwmsedec(int nmsedec, int compno, int levelxy, int levelz, int orient, int bpno, int reversible, double stepsize, int numcomps, int dwtid);
|
||||
*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __T1_H */
|
|
@ -1,731 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/** @defgroup T2 T2 - Implementation of a tier-2 coding */
|
||||
/*@{*/
|
||||
|
||||
/** @name Local static functions */
|
||||
/*@{*/
|
||||
|
||||
static void t2_putcommacode(opj_bio_t *bio, int n);
|
||||
static int 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, int n);
|
||||
static int 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 volume_info Structure to create an index file
|
||||
@param tileno Number of the tile encoded
|
||||
@param cp Coding parameters
|
||||
@return Number of bytes encoded from the packet
|
||||
*/
|
||||
static int t2_encode_packet(opj_tcd_tile_t *tile, opj_tcp_t *tcp,
|
||||
opj_pi_iterator_t *pi, unsigned char *dest, int len,
|
||||
opj_volume_info_t *volume_info, int tileno, opj_cp_t *cp);
|
||||
/**
|
||||
Initialize the segment decoder
|
||||
@param seg Segment instance
|
||||
@param cblksty Codeblock style
|
||||
@param first Is first segment
|
||||
*/
|
||||
static void t2_init_seg(opj_tcd_seg_t *seg, int cblksty, int 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 Number of bytes decoded from the packet
|
||||
*/
|
||||
int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len,
|
||||
opj_tcd_tile_t *tile, opj_tcp_t *tcp, opj_pi_iterator_t *pi);
|
||||
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/* #define RESTART 0x04 */
|
||||
static void t2_putcommacode(opj_bio_t *bio, int n)
|
||||
{
|
||||
while (--n >= 0) {
|
||||
bio_write(bio, 1, 1);
|
||||
}
|
||||
bio_write(bio, 0, 1);
|
||||
}
|
||||
|
||||
static int t2_getcommacode(opj_bio_t *bio)
|
||||
{
|
||||
int n;
|
||||
for (n = 0; bio_read(bio, 1); n++) {
|
||||
;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
static void t2_putnumpasses(opj_bio_t *bio, int 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 int t2_getnumpasses(opj_bio_t *bio)
|
||||
{
|
||||
int 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 int t2_encode_packet(opj_tcd_tile_t * tile, opj_tcp_t * tcp,
|
||||
opj_pi_iterator_t *pi, unsigned char *dest, int len,
|
||||
opj_volume_info_t * volume_info, int tileno, opj_cp_t *cp)
|
||||
{
|
||||
int bandno, cblkno;
|
||||
unsigned char *sop = 0, *eph = 0;
|
||||
unsigned char *c = dest;
|
||||
|
||||
int compno = pi->compno; /* component value */
|
||||
int resno = pi->resno; /* resolution level value */
|
||||
int precno = pi->precno; /* precinct value */
|
||||
int layno = pi->layno; /* quality layer value */
|
||||
|
||||
opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
|
||||
opj_tcd_resolution_t *res = &tilec->resolutions[resno];
|
||||
|
||||
opj_bio_t *bio = NULL; /* BIO component */
|
||||
|
||||
/* <SOP 0xff91> */
|
||||
if ((tcp->csty & J3D_CP_CSTY_SOP)) {
|
||||
sop = (unsigned char *) opj_malloc(6 * sizeof(unsigned char));
|
||||
sop[0] = 255;
|
||||
sop[1] = 145;
|
||||
sop[2] = 0;
|
||||
sop[3] = 4;
|
||||
sop[4] = (volume_info) ? (volume_info->num % 65536) / 256 : (0 % 65536) / 256 ;
|
||||
sop[5] = (volume_info) ? (volume_info->num % 65536) % 256 : (0 % 65536) % 256 ;
|
||||
memcpy(c, sop, 6);
|
||||
opj_free(sop);
|
||||
c += 6;
|
||||
}
|
||||
/* </SOP> */
|
||||
|
||||
if (!layno) {
|
||||
for (bandno = 0; bandno < res->numbands; bandno++) {
|
||||
opj_tcd_band_t *band = &res->bands[bandno];
|
||||
opj_tcd_precinct_t *prc = &band->precincts[precno];
|
||||
tgt_reset(prc->incltree);
|
||||
tgt_reset(prc->imsbtree);
|
||||
for (cblkno = 0; cblkno < prc->cblkno[0] * prc->cblkno[1] * prc->cblkno[2];
|
||||
cblkno++) {
|
||||
opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
|
||||
cblk->numpasses = 0;
|
||||
tgt_setvalue(prc->imsbtree, cblkno, band->numbps - cblk->numbps);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bio = bio_create();
|
||||
bio_init_enc(bio, c, len);
|
||||
bio_write(bio, 1, 1); /* Empty header bit */
|
||||
|
||||
/* Writing Packet header */
|
||||
for (bandno = 0; bandno < res->numbands; bandno++) {
|
||||
opj_tcd_band_t *band = &res->bands[bandno];
|
||||
opj_tcd_precinct_t *prc = &band->precincts[precno];
|
||||
for (cblkno = 0; cblkno < prc->cblkno[0] * prc->cblkno[1] * prc->cblkno[2];
|
||||
cblkno++) {
|
||||
opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
|
||||
opj_tcd_layer_t *layer = &cblk->layers[layno];
|
||||
if (!cblk->numpasses && layer->numpasses) {
|
||||
tgt_setvalue(prc->incltree, cblkno, layno);
|
||||
}
|
||||
}
|
||||
|
||||
for (cblkno = 0; cblkno < prc->cblkno[0] * prc->cblkno[1] * prc->cblkno[2];
|
||||
cblkno++) {
|
||||
opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
|
||||
opj_tcd_layer_t *layer = &cblk->layers[layno];
|
||||
int increment = 0;
|
||||
int nump = 0;
|
||||
int len = 0, passno;
|
||||
/* 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) {
|
||||
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);
|
||||
|
||||
/* computation of the increase of the length indicator and insertion in the header */
|
||||
for (passno = cblk->numpasses; passno < cblk->numpasses + layer->numpasses;
|
||||
passno++) {
|
||||
opj_tcd_pass_t *pass = &cblk->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;
|
||||
}
|
||||
}
|
||||
t2_putcommacode(bio, increment);
|
||||
|
||||
/* computation of the new Length indicator */
|
||||
cblk->numlenbits += increment;
|
||||
|
||||
/* insertion of the codeword segment length */
|
||||
for (passno = cblk->numpasses; passno < cblk->numpasses + layer->numpasses;
|
||||
passno++) {
|
||||
opj_tcd_pass_t *pass = &cblk->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;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (bio_flush(bio)) {
|
||||
bio_destroy(bio);
|
||||
return -999; /* modified to eliminate longjmp !! */
|
||||
}
|
||||
|
||||
c += bio_numbytes(bio);
|
||||
|
||||
bio_destroy(bio);
|
||||
|
||||
/* <EPH 0xff92> */
|
||||
if (tcp->csty & J3D_CP_CSTY_EPH) {
|
||||
eph = (unsigned char *) opj_malloc(2 * sizeof(unsigned char));
|
||||
eph[0] = 255;
|
||||
eph[1] = 146;
|
||||
memcpy(c, eph, 2);
|
||||
opj_free(eph);
|
||||
c += 2;
|
||||
}
|
||||
/* </EPH> */
|
||||
|
||||
/* Writing the packet body */
|
||||
|
||||
for (bandno = 0; bandno < res->numbands; bandno++) {
|
||||
opj_tcd_band_t *band = &res->bands[bandno];
|
||||
opj_tcd_precinct_t *prc = &band->precincts[precno];
|
||||
for (cblkno = 0; cblkno < prc->cblkno[0] * prc->cblkno[1] * prc->cblkno[2];
|
||||
cblkno++) {
|
||||
opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
|
||||
opj_tcd_layer_t *layer = &cblk->layers[layno];
|
||||
if (!layer->numpasses) {
|
||||
continue;
|
||||
}
|
||||
if (c + layer->len > dest + len) {
|
||||
return -999;
|
||||
}
|
||||
|
||||
memcpy(c, layer->data, layer->len);
|
||||
cblk->numpasses += layer->numpasses;
|
||||
c += layer->len;
|
||||
/* ADD for index Cfr. Marcela --> delta disto by packet */
|
||||
if (volume_info && volume_info->index_write && volume_info->index_on) {
|
||||
opj_tile_info_t *info_TL = &volume_info->tile[tileno];
|
||||
opj_packet_info_t *info_PK = &info_TL->packet[volume_info->num];
|
||||
info_PK->disto += layer->disto;
|
||||
if (volume_info->D_max < info_PK->disto) {
|
||||
volume_info->D_max = info_PK->disto;
|
||||
}
|
||||
}
|
||||
/* </ADD> */
|
||||
}
|
||||
}
|
||||
|
||||
return (c - dest);
|
||||
}
|
||||
|
||||
static void t2_init_seg(opj_tcd_seg_t * seg, int cblksty, int first)
|
||||
{
|
||||
seg->numpasses = 0;
|
||||
seg->len = 0;
|
||||
if (cblksty & J3D_CCP_CBLKSTY_TERMALL) {
|
||||
seg->maxpasses = 1;
|
||||
} else if (cblksty & J3D_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;
|
||||
}
|
||||
}
|
||||
|
||||
int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len,
|
||||
opj_tcd_tile_t *tile, opj_tcp_t *tcp, opj_pi_iterator_t *pi)
|
||||
{
|
||||
int bandno, cblkno;
|
||||
unsigned char *c = src;
|
||||
|
||||
opj_cp_t *cp = t2->cp;
|
||||
|
||||
int compno = pi->compno; /* component value */
|
||||
int resno = pi->resno; /* resolution level value */
|
||||
int precno = pi->precno; /* precinct value */
|
||||
int layno = pi->layno; /* quality layer value */
|
||||
|
||||
opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
|
||||
opj_tcd_resolution_t *res = &tilec->resolutions[resno];
|
||||
|
||||
unsigned char *hd = NULL;
|
||||
int present;
|
||||
|
||||
opj_bio_t *bio = NULL; /* BIO component */
|
||||
|
||||
if (layno == 0) {
|
||||
for (bandno = 0; bandno < res->numbands; bandno++) {
|
||||
opj_tcd_band_t *band = &res->bands[bandno];
|
||||
opj_tcd_precinct_t *prc = &band->precincts[precno];
|
||||
|
||||
if ((band->x1 - band->x0 == 0) || (band->y1 - band->y0 == 0) ||
|
||||
(band->z1 - band->z0 == 0)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
tgt_reset(prc->incltree);
|
||||
tgt_reset(prc->imsbtree);
|
||||
for (cblkno = 0; cblkno < prc->cblkno[0] * prc->cblkno[1] * prc->cblkno[2];
|
||||
cblkno++) {
|
||||
opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
|
||||
cblk->numsegs = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* SOP markers */
|
||||
|
||||
if (tcp->csty & J3D_CP_CSTY_SOP) {
|
||||
if ((*c) != 0xff || (*(c + 1) != 0x91)) {
|
||||
opj_event_msg(t2->cinfo, EVT_WARNING, "Expected SOP marker\n");
|
||||
} else {
|
||||
c += 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
|
||||
*/
|
||||
|
||||
bio = bio_create();
|
||||
|
||||
if (cp->ppm == 1) { /* PPM */
|
||||
hd = cp->ppm_data;
|
||||
bio_init_dec(bio, hd, cp->ppm_len);
|
||||
} else if (tcp->ppt == 1) { /* PPT */
|
||||
hd = tcp->ppt_data;
|
||||
bio_init_dec(bio, hd, tcp->ppt_len);
|
||||
} else { /* Normal Case */
|
||||
hd = c;
|
||||
bio_init_dec(bio, hd, src + len - hd);
|
||||
}
|
||||
|
||||
present = bio_read(bio, 1);
|
||||
|
||||
if (!present) {
|
||||
bio_inalign(bio);
|
||||
hd += bio_numbytes(bio);
|
||||
bio_destroy(bio);
|
||||
|
||||
/* EPH markers */
|
||||
|
||||
if (tcp->csty & J3D_CP_CSTY_EPH) {
|
||||
if ((*hd) != 0xff || (*(hd + 1) != 0x92)) {
|
||||
printf("Error : expected EPH marker\n");
|
||||
} else {
|
||||
hd += 2;
|
||||
}
|
||||
}
|
||||
|
||||
if (cp->ppm == 1) { /* PPM case */
|
||||
cp->ppm_len += cp->ppm_data - hd;
|
||||
cp->ppm_data = hd;
|
||||
return (c - src);
|
||||
}
|
||||
if (tcp->ppt == 1) { /* PPT case */
|
||||
tcp->ppt_len += tcp->ppt_data - hd;
|
||||
tcp->ppt_data = hd;
|
||||
return (c - src);
|
||||
}
|
||||
|
||||
return (hd - src);
|
||||
}
|
||||
|
||||
for (bandno = 0; bandno < res->numbands; bandno++) {
|
||||
opj_tcd_band_t *band = &res->bands[bandno];
|
||||
opj_tcd_precinct_t *prc = &band->precincts[precno];
|
||||
|
||||
if ((band->x1 - band->x0 == 0) || (band->y1 - band->y0 == 0) ||
|
||||
(band->z1 - band->z0 == 0)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
for (cblkno = 0; cblkno < prc->cblkno[0] * prc->cblkno[1] * prc->cblkno[2];
|
||||
cblkno++) {
|
||||
int included, increment, n;
|
||||
opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
|
||||
opj_tcd_seg_t *seg = NULL;
|
||||
/* if cblk not yet included before --> inclusion tagtree */
|
||||
if (!cblk->numsegs) {
|
||||
included = tgt_decode(bio, prc->incltree, cblkno, layno + 1);
|
||||
/* else one bit */
|
||||
} else {
|
||||
included = bio_read(bio, 1);
|
||||
}
|
||||
/* if cblk not included */
|
||||
if (!included) {
|
||||
cblk->numnewpasses = 0;
|
||||
continue;
|
||||
}
|
||||
/* if cblk not yet included --> zero-bitplane tagtree */
|
||||
if (!cblk->numsegs) {
|
||||
int i, numimsbs;
|
||||
for (i = 0; !tgt_decode(bio, prc->imsbtree, cblkno, i); i++);
|
||||
numimsbs = i - 1;
|
||||
cblk->numbps = band->numbps - numimsbs;
|
||||
cblk->numlenbits = 3;
|
||||
}
|
||||
/* number of coding passes */
|
||||
cblk->numnewpasses = t2_getnumpasses(bio);
|
||||
increment = t2_getcommacode(bio);
|
||||
/* length indicator increment */
|
||||
cblk->numlenbits += increment;
|
||||
if (!cblk->numsegs) {
|
||||
seg = &cblk->segs[0];
|
||||
t2_init_seg(seg, tcp->tccps[compno].cblksty, 1);
|
||||
} else {
|
||||
seg = &cblk->segs[cblk->numsegs - 1];
|
||||
if (seg->numpasses == seg->maxpasses) {
|
||||
t2_init_seg(++seg, tcp->tccps[compno].cblksty, 0);
|
||||
}
|
||||
}
|
||||
n = cblk->numnewpasses;
|
||||
|
||||
do {
|
||||
seg->numnewpasses = int_min(seg->maxpasses - seg->numpasses, n);
|
||||
seg->newlen = bio_read(bio,
|
||||
cblk->numlenbits + int_floorlog2(seg->numnewpasses));
|
||||
n -= seg->numnewpasses;
|
||||
if (n > 0) {
|
||||
t2_init_seg(++seg, tcp->tccps[compno].cblksty, 0);
|
||||
}
|
||||
} while (n > 0);
|
||||
}
|
||||
}
|
||||
|
||||
if (bio_inalign(bio)) {
|
||||
bio_destroy(bio);
|
||||
return -999;
|
||||
}
|
||||
|
||||
hd += bio_numbytes(bio);
|
||||
bio_destroy(bio);
|
||||
|
||||
/* EPH markers */
|
||||
if (tcp->csty & J3D_CP_CSTY_EPH) {
|
||||
if ((*hd) != 0xff || (*(hd + 1) != 0x92)) {
|
||||
opj_event_msg(t2->cinfo, EVT_ERROR, "Expected EPH marker\n");
|
||||
return -999;
|
||||
} else {
|
||||
hd += 2;
|
||||
}
|
||||
}
|
||||
|
||||
if (cp->ppm == 1) {
|
||||
cp->ppm_len += cp->ppm_data - hd;
|
||||
cp->ppm_data = hd;
|
||||
} else if (tcp->ppt == 1) {
|
||||
tcp->ppt_len += tcp->ppt_data - hd;
|
||||
tcp->ppt_data = hd;
|
||||
} else {
|
||||
c = hd;
|
||||
}
|
||||
|
||||
for (bandno = 0; bandno < res->numbands; bandno++) {
|
||||
opj_tcd_band_t *band = &res->bands[bandno];
|
||||
opj_tcd_precinct_t *prc = &band->precincts[precno];
|
||||
|
||||
if ((band->x1 - band->x0 == 0) || (band->y1 - band->y0 == 0) ||
|
||||
(band->z1 - band->z0 == 0)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
for (cblkno = 0; cblkno < prc->cblkno[0] * prc->cblkno[1] * prc->cblkno[2];
|
||||
cblkno++) {
|
||||
opj_tcd_cblk_t *cblk = &prc->cblks[cblkno];
|
||||
opj_tcd_seg_t *seg = NULL;
|
||||
if (!cblk->numnewpasses) {
|
||||
continue;
|
||||
}
|
||||
if (!cblk->numsegs) {
|
||||
seg = &cblk->segs[0];
|
||||
cblk->numsegs++;
|
||||
cblk->len = 0;
|
||||
} else {
|
||||
seg = &cblk->segs[cblk->numsegs - 1];
|
||||
if (seg->numpasses == seg->maxpasses) {
|
||||
seg++;
|
||||
cblk->numsegs++;
|
||||
}
|
||||
}
|
||||
|
||||
do {
|
||||
if (c + seg->newlen > src + len) {
|
||||
return -999;
|
||||
}
|
||||
|
||||
memcpy(cblk->data + cblk->len, c, seg->newlen);
|
||||
if (seg->numpasses == 0) {
|
||||
seg->data = cblk->data + cblk->len;
|
||||
}
|
||||
c += seg->newlen;
|
||||
cblk->len += seg->newlen;
|
||||
seg->len += seg->newlen;
|
||||
seg->numpasses += seg->numnewpasses;
|
||||
cblk->numnewpasses -= seg->numnewpasses;
|
||||
if (cblk->numnewpasses > 0) {
|
||||
seg++;
|
||||
cblk->numsegs++;
|
||||
}
|
||||
} while (cblk->numnewpasses > 0);
|
||||
}
|
||||
}
|
||||
|
||||
return (c - src);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
int t2_encode_packets(opj_t2_t* t2, int tileno, opj_tcd_tile_t *tile,
|
||||
int maxlayers, unsigned char *dest, int len, opj_volume_info_t *volume_info)
|
||||
{
|
||||
unsigned char *c = dest;
|
||||
int e = 0;
|
||||
opj_pi_iterator_t *pi = NULL;
|
||||
int pino;
|
||||
|
||||
opj_volume_t *volume = t2->volume;
|
||||
opj_cp_t *cp = t2->cp;
|
||||
|
||||
/* create a packet iterator */
|
||||
pi = pi_create(volume, cp, tileno);
|
||||
if (!pi) {
|
||||
fprintf(stdout, "[ERROR] Failed to create a pi structure\n");
|
||||
return -999;
|
||||
}
|
||||
|
||||
if (volume_info) {
|
||||
volume_info->num = 0;
|
||||
}
|
||||
|
||||
for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++) {
|
||||
while (pi_next(&pi[pino])) {
|
||||
if (pi[pino].layno < maxlayers) {
|
||||
e = t2_encode_packet(tile, &cp->tcps[tileno], &pi[pino], c, dest + len - c,
|
||||
volume_info, tileno, cp);
|
||||
/*opj_event_msg(t2->cinfo, EVT_INFO, " t2_encode_packet: %d bytes coded\n",e);*/
|
||||
if (e == -999) {
|
||||
break;
|
||||
} else {
|
||||
c += e;
|
||||
}
|
||||
|
||||
/* INDEX >> */
|
||||
if (volume_info && volume_info->index_on) {
|
||||
if (volume_info->index_write) {
|
||||
opj_tile_info_t *info_TL = &volume_info->tile[tileno];
|
||||
opj_packet_info_t *info_PK = &info_TL->packet[volume_info->num];
|
||||
if (!volume_info->num) {
|
||||
info_PK->start_pos = info_TL->end_header + 1;
|
||||
} else {
|
||||
info_PK->start_pos = info_TL->packet[volume_info->num - 1].end_pos + 1;
|
||||
}
|
||||
info_PK->end_pos = info_PK->start_pos + e - 1;
|
||||
}
|
||||
|
||||
volume_info->num++;
|
||||
}
|
||||
/* << INDEX */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* don't forget to release pi */
|
||||
pi_destroy(pi, cp, tileno);
|
||||
|
||||
if (e == -999) {
|
||||
return e;
|
||||
}
|
||||
|
||||
return (c - dest);
|
||||
}
|
||||
|
||||
int t2_decode_packets(opj_t2_t *t2, unsigned char *src, int len, int tileno,
|
||||
opj_tcd_tile_t *tile)
|
||||
{
|
||||
unsigned char *c = src;
|
||||
opj_pi_iterator_t *pi;
|
||||
int pino, e = 0;
|
||||
int n = 0, i;
|
||||
|
||||
opj_volume_t *volume = t2->volume;
|
||||
opj_cp_t *cp = t2->cp;
|
||||
|
||||
/* create a packet iterator */
|
||||
pi = pi_create(volume, cp, tileno);
|
||||
if (!pi) {
|
||||
/* TODO: throw an error */
|
||||
return -999;
|
||||
}
|
||||
|
||||
for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++) {
|
||||
while (pi_next(&pi[pino])) {
|
||||
if ((cp->layer == 0) || (cp->layer >= ((pi[pino].layno) + 1))) {
|
||||
e = t2_decode_packet(t2, c, src + len - c, tile, &cp->tcps[tileno], &pi[pino]);
|
||||
} else {
|
||||
e = 0;
|
||||
}
|
||||
|
||||
/* progression in resolution */
|
||||
for (i = 0; i < 3; i++) {
|
||||
volume->comps[pi[pino].compno].resno_decoded[i] = (e > 0) ? int_max(
|
||||
pi[pino].resno, volume->comps[pi[pino].compno].resno_decoded[i]) :
|
||||
volume->comps[pi[pino].compno].resno_decoded[i];
|
||||
}
|
||||
n++;
|
||||
|
||||
if (e == -999) { /* ADD */
|
||||
break;
|
||||
} else {
|
||||
opj_event_msg(t2->cinfo, EVT_INFO, " t2_decode_packet: %d bytes decoded\n", e);
|
||||
c += e;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* don't forget to release pi */
|
||||
pi_destroy(pi, cp, tileno);
|
||||
|
||||
if (e == -999) {
|
||||
return e;
|
||||
}
|
||||
|
||||
return (c - src);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
opj_t2_t* t2_create(opj_common_ptr cinfo, opj_volume_t *volume, opj_cp_t *cp)
|
||||
{
|
||||
/* create the tcd structure */
|
||||
opj_t2_t *t2 = (opj_t2_t*)opj_malloc(sizeof(opj_t2_t));
|
||||
if (!t2) {
|
||||
return NULL;
|
||||
}
|
||||
t2->cinfo = cinfo;
|
||||
t2->volume = volume;
|
||||
t2->cp = cp;
|
||||
|
||||
return t2;
|
||||
}
|
||||
|
||||
void t2_destroy(opj_t2_t *t2)
|
||||
{
|
||||
if (t2) {
|
||||
opj_free(t2);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,108 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* Copyright (c) 2006, Mónica Díez García, Image Processing Laboratory, University of Valladolid, Spain
|
||||
* 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)
|
||||
|
||||
*/
|
||||
|
||||
/** @defgroup T2 T2 - Implementation of a tier-2 coding */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Tier-2 coding
|
||||
*/
|
||||
typedef struct opj_t2 {
|
||||
/** Codec context */
|
||||
opj_common_ptr cinfo;
|
||||
/** Encoding: pointer to the src volume. Decoding: pointer to the dst volume. */
|
||||
opj_volume_t *volume;
|
||||
/** Pointer to the volume coding parameters */
|
||||
opj_cp_t *cp;
|
||||
} opj_t2_t;
|
||||
|
||||
/** @name Funciones generales */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
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 volume_info structure to create an index file
|
||||
@return Number of bytes written from packets
|
||||
*/
|
||||
int t2_encode_packets(opj_t2_t* t2, int tileno, opj_tcd_tile_t *tile,
|
||||
int maxlayers, unsigned char *dest, int len, opj_volume_info_t *volume_info);
|
||||
|
||||
/**
|
||||
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
|
||||
@return Number of bytes read from packets
|
||||
*/
|
||||
int t2_decode_packets(opj_t2_t *t2, unsigned char *src, int len, int tileno,
|
||||
opj_tcd_tile_t *tile);
|
||||
|
||||
/**
|
||||
Create a T2 handle
|
||||
@param cinfo Codec context info
|
||||
@param volume Source or destination volume
|
||||
@param cp Volume coding parameters
|
||||
@return Returns a new T2 handle if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_t2_t* t2_create(opj_common_ptr cinfo, opj_volume_t *volume, opj_cp_t *cp);
|
||||
/**
|
||||
Destroy a T2 handle
|
||||
@param t2 T2 handle to destroy
|
||||
*/
|
||||
void t2_destroy(opj_t2_t *t2);
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __T2_H */
|
File diff suppressed because it is too large
Load Diff
|
@ -1,343 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* Copyright (c) 2006, Mónica Díez García, Image Processing Laboratory, University of Valladolid, Spain
|
||||
* 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 JP3D.C.
|
||||
*/
|
||||
|
||||
/** @defgroup TCD TCD - Implementation of a tile coder/decoder */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Tile coder/decoder: segment instance
|
||||
*/
|
||||
typedef struct opj_tcd_seg {
|
||||
/** Number of passes in the segment */
|
||||
int numpasses;
|
||||
/** Length of information */
|
||||
int len;
|
||||
/** Data */
|
||||
unsigned char *data;
|
||||
/** Number of passes possible for the segment */
|
||||
int maxpasses;
|
||||
/** Number of passes added to the segment */
|
||||
int numnewpasses;
|
||||
/** New length after inclusion of segments */
|
||||
int newlen;
|
||||
} opj_tcd_seg_t;
|
||||
|
||||
/**
|
||||
Tile coder/decoder: pass instance
|
||||
*/
|
||||
typedef struct opj_tcd_pass {
|
||||
/** Rate obtained in the pass*/
|
||||
int rate;
|
||||
/** Distorsion obtained in the pass*/
|
||||
double distortiondec;
|
||||
int term;
|
||||
/** Length of information */
|
||||
int len;
|
||||
} opj_tcd_pass_t;
|
||||
|
||||
/**
|
||||
Tile coder/decoder: layer instance
|
||||
*/
|
||||
typedef struct opj_tcd_layer {
|
||||
/** Number of passes in the layer */
|
||||
int numpasses;
|
||||
/** Length of information */
|
||||
int len;
|
||||
/** Distortion within layer */
|
||||
double disto; /* add for index (Cfr. Marcela) */
|
||||
unsigned char *data; /* data */
|
||||
} opj_tcd_layer_t;
|
||||
|
||||
/**
|
||||
Tile coder/decoder: codeblock instance
|
||||
*/
|
||||
typedef struct opj_tcd_cblk {
|
||||
/** Dimension of the code-blocks : left upper corner (x0, y0, z0) */
|
||||
int x0, y0, z0;
|
||||
/** Dimension of the code-blocks : right low corner (x1,y1,z1) */
|
||||
int x1, y1, z1;
|
||||
/** Number of bits per simbol in codeblock */
|
||||
int numbps;
|
||||
int numlenbits;
|
||||
int len; /* length */
|
||||
/** Number of pass already done for the code-blocks */
|
||||
int numpasses;
|
||||
/** number of pass added to the code-blocks */
|
||||
int numnewpasses;
|
||||
/** Number of segments */
|
||||
int numsegs;
|
||||
/** Segments information */
|
||||
opj_tcd_seg_t segs[100];
|
||||
/** Number of passes in the layer */
|
||||
int numpassesinlayers;
|
||||
/** Layer information */
|
||||
opj_tcd_layer_t layers[100];
|
||||
/** Total number of passes */
|
||||
int totalpasses;
|
||||
/** Information about the passes */
|
||||
opj_tcd_pass_t passes[100];
|
||||
/* Data */
|
||||
unsigned char data[524288];
|
||||
/*unsigned char *data;*/
|
||||
} opj_tcd_cblk_t;
|
||||
|
||||
/**
|
||||
Tile coder/decoder: precint instance
|
||||
*/
|
||||
typedef struct opj_tcd_precinct {
|
||||
/** Dimension of the precint : left upper corner (x0, y0, z0) */
|
||||
int x0, y0, z0;
|
||||
/** Dimension of the precint : right low corner (x1,y1,z1) */
|
||||
int x1, y1, z1;
|
||||
/** Number of codeblocks in precinct in width and height and length*/
|
||||
int cblkno[3];
|
||||
/** Information about the codeblocks */
|
||||
opj_tcd_cblk_t *cblks;
|
||||
/** Inclusion tree */
|
||||
opj_tgt_tree_t *incltree;
|
||||
/** Missing MSBs tree */
|
||||
opj_tgt_tree_t *imsbtree;
|
||||
} opj_tcd_precinct_t;
|
||||
|
||||
/**
|
||||
Tile coder/decoder: subband instance
|
||||
*/
|
||||
typedef struct opj_tcd_band {
|
||||
/** Dimension of the subband : left upper corner (x0, y0, z0) */
|
||||
int x0, y0, z0;
|
||||
/** Dimension of the subband : right low corner (x1,y1,z1) */
|
||||
int x1, y1, z1;
|
||||
/** Information about the precints */
|
||||
opj_tcd_precinct_t *precincts; /* precinct information */
|
||||
/** Number of bits per symbol in band */
|
||||
int numbps;
|
||||
/** Quantization stepsize associated */
|
||||
float stepsize;
|
||||
/** Band orientation (O->LLL,...,7->HHH) */
|
||||
int bandno;
|
||||
} opj_tcd_band_t;
|
||||
|
||||
/**
|
||||
Tile coder/decoder: resolution instance
|
||||
*/
|
||||
typedef struct opj_tcd_resolution {
|
||||
/** Dimension of the resolution level : left upper corner (x0, y0, z0) */
|
||||
int x0, y0, z0;
|
||||
/** Dimension of the resolution level : right low corner (x1,y1,z1) */
|
||||
int x1, y1, z1;
|
||||
/** Number of precints in each dimension for the resolution level */
|
||||
int prctno[3];
|
||||
/** Number of subbands for the resolution level */
|
||||
int numbands;
|
||||
/** Subband information */
|
||||
opj_tcd_band_t *bands;
|
||||
} opj_tcd_resolution_t;
|
||||
|
||||
/**
|
||||
Tile coder/decoder: component instance
|
||||
*/
|
||||
typedef struct opj_tcd_tilecomp {
|
||||
/** Dimension of the component : left upper corner (x0, y0, z0) */
|
||||
int x0, y0, z0;
|
||||
/** Dimension of the component : right low corner (x1,y1,z1) */
|
||||
int x1, y1, z1;
|
||||
/** Number of resolutions level if DWT transform*/
|
||||
int numresolution[3];
|
||||
/** Resolution information */
|
||||
opj_tcd_resolution_t *resolutions;
|
||||
/** Data of the component */
|
||||
int *data;
|
||||
/** Fixed_quality related */
|
||||
int nbpix;
|
||||
/** Number of bits per voxel in component */
|
||||
int bpp;
|
||||
} opj_tcd_tilecomp_t;
|
||||
|
||||
/**
|
||||
Tile coder/decoder: tile instance
|
||||
*/
|
||||
typedef struct opj_tcd_tile {
|
||||
/** Dimension of the tile : left upper corner (x0, y0, z0) */
|
||||
int x0, y0, z0;
|
||||
/** Dimension of the tile : right low corner (x1,y1,z1) */
|
||||
int x1, y1, z1;
|
||||
/** Number of components in tile */
|
||||
int numcomps;
|
||||
/** Components information */
|
||||
opj_tcd_tilecomp_t *comps;
|
||||
/** Fixed_quality related : no of bytes of data*/
|
||||
int nbpix;
|
||||
/** Fixed_quality related : distortion achieved in tile */
|
||||
double distotile;
|
||||
/** Fixed_quality related : distortion achieved in each layer */
|
||||
double distolayer[100];
|
||||
} opj_tcd_tile_t;
|
||||
|
||||
/**
|
||||
Tile coder/decoder: volume instance
|
||||
*/
|
||||
typedef struct opj_tcd_volume {
|
||||
/** Number of tiles in width and height and length */
|
||||
int tw, th, tl;
|
||||
/** Tiles information */
|
||||
opj_tcd_tile_t *tiles;
|
||||
} opj_tcd_volume_t;
|
||||
|
||||
/**
|
||||
Tile coder/decoder
|
||||
*/
|
||||
typedef struct opj_tcd {
|
||||
/** Codec context */
|
||||
opj_common_ptr cinfo;
|
||||
/** Volume information */
|
||||
opj_volume_t *volume;
|
||||
/** Coding parameters */
|
||||
opj_cp_t *cp;
|
||||
/** Coding/decoding parameters common to all tiles */
|
||||
opj_tcp_t *tcp;
|
||||
/** Info on each volume tile */
|
||||
opj_tcd_volume_t *tcd_volume;
|
||||
/** Pointer to the current encoded/decoded tile */
|
||||
opj_tcd_tile_t *tcd_tile;
|
||||
/** Current encoded/decoded tile */
|
||||
int tcd_tileno;
|
||||
|
||||
/**@name working variables */
|
||||
/*@{*/
|
||||
opj_tcd_tile_t *tile;
|
||||
opj_tcd_tilecomp_t *tilec;
|
||||
opj_tcd_resolution_t *res;
|
||||
opj_tcd_band_t *band;
|
||||
opj_tcd_precinct_t *prc;
|
||||
opj_tcd_cblk_t *cblk;
|
||||
/*@}*/
|
||||
} opj_tcd_t;
|
||||
|
||||
/** @name Funciones generales */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
Dump the content of a tcd structure
|
||||
*/
|
||||
void tcd_dump(FILE *fd, opj_tcd_t *tcd, opj_tcd_volume_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(opj_common_ptr cinfo);
|
||||
/**
|
||||
Destroy a previously created TCD handle
|
||||
@param tcd TCD handle to destroy
|
||||
*/
|
||||
void tcd_destroy(opj_tcd_t *tcd);
|
||||
/**
|
||||
Initialize the tile coder (allocate the memory)
|
||||
@param tcd TCD handle
|
||||
@param volume Raw volume
|
||||
@param cp Coding parameters
|
||||
@param curtileno Number that identifies the tile that will be encoded
|
||||
*/
|
||||
void tcd_malloc_encode(opj_tcd_t *tcd, opj_volume_t * volume, opj_cp_t * cp,
|
||||
int curtileno);
|
||||
/**
|
||||
Initialize the tile coder (reuses the memory allocated by tcd_malloc_encode)(for 3D-DWT)
|
||||
@param tcd TCD handle
|
||||
@param volume Raw volume
|
||||
@param cp Coding parameters
|
||||
@param curtileno Number that identifies the tile that will be encoded
|
||||
*/
|
||||
void tcd_init_encode(opj_tcd_t *tcd, opj_volume_t * volume, opj_cp_t * cp,
|
||||
int curtileno);
|
||||
/**
|
||||
Free the memory allocated for encoding
|
||||
@param tcd TCD handle
|
||||
*/
|
||||
void tcd_free_encode(opj_tcd_t *tcd);
|
||||
/**
|
||||
Initialize the tile decoder
|
||||
@param tcd TCD handle
|
||||
@param volume Raw volume
|
||||
@param cp Coding parameters
|
||||
*/
|
||||
void tcd_malloc_decode(opj_tcd_t *tcd, opj_volume_t * volume, opj_cp_t * cp);
|
||||
|
||||
void tcd_makelayer_fixed(opj_tcd_t *tcd, int layno, int final);
|
||||
void tcd_rateallocate_fixed(opj_tcd_t *tcd);
|
||||
void tcd_makelayer(opj_tcd_t *tcd, int layno, double thresh, int final);
|
||||
bool tcd_rateallocate(opj_tcd_t *tcd, unsigned char *dest, int len,
|
||||
opj_volume_info_t * volume_info);
|
||||
/**
|
||||
Encode a tile from the raw volume into a buffer
|
||||
@param tcd TCD handle
|
||||
@param tileno Number that identifies one of the tiles to be encoded
|
||||
@param dest Destination buffer
|
||||
@param len Length of destination buffer
|
||||
@param volume_info Creation of index file
|
||||
@return
|
||||
*/
|
||||
int tcd_encode_tile(opj_tcd_t *tcd, int tileno, unsigned char *dest, int len,
|
||||
opj_volume_info_t * volume_info);
|
||||
/**
|
||||
Decode a tile from a buffer into a raw volume
|
||||
@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, unsigned char *src, int len, int tileno);
|
||||
/**
|
||||
Free the memory allocated for decoding
|
||||
@param tcd TCD handle
|
||||
*/
|
||||
void tcd_free_decode(opj_tcd_t *tcd);
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __TCD_H */
|
|
@ -1,271 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
Tag-tree coder interface
|
||||
==========================================================
|
||||
*/
|
||||
void tgt_tree_dump(FILE *fd, opj_tgt_tree_t * tree)
|
||||
{
|
||||
int nodesno;
|
||||
|
||||
fprintf(fd, "TGT_TREE {\n");
|
||||
fprintf(fd, " numnodes: %d \n", tree->numnodes);
|
||||
fprintf(fd, " numleafsh: %d, numleafsv: %d, numleafsz: %d,\n", tree->numleafsh,
|
||||
tree->numleafsv, tree->numleafsz);
|
||||
|
||||
for (nodesno = 0; nodesno < tree->numnodes; nodesno++) {
|
||||
fprintf(fd, "tgt_node %d {\n", nodesno);
|
||||
fprintf(fd, " value: %d \n", tree->nodes[nodesno].value);
|
||||
fprintf(fd, " low: %d \n", tree->nodes[nodesno].low);
|
||||
fprintf(fd, " known: %d \n", tree->nodes[nodesno].known);
|
||||
if (tree->nodes[nodesno].parent) {
|
||||
fprintf(fd, " parent.value: %d \n", tree->nodes[nodesno].parent->value);
|
||||
fprintf(fd, " parent.low: %d \n", tree->nodes[nodesno].parent->low);
|
||||
fprintf(fd, " parent.known: %d \n", tree->nodes[nodesno].parent->known);
|
||||
}
|
||||
fprintf(fd, "}\n");
|
||||
|
||||
}
|
||||
fprintf(fd, "}\n");
|
||||
|
||||
}
|
||||
|
||||
|
||||
opj_tgt_tree_t *tgt_create(int numleafsh, int numleafsv, int numleafsz)
|
||||
{
|
||||
|
||||
int nplh[32];
|
||||
int nplv[32];
|
||||
int nplz[32];
|
||||
opj_tgt_node_t *node = NULL;
|
||||
opj_tgt_node_t *parentnode = NULL;
|
||||
opj_tgt_node_t *parentnode0 = NULL;
|
||||
opj_tgt_node_t *parentnode1 = NULL;
|
||||
opj_tgt_tree_t *tree = NULL;
|
||||
int i, j, k, p, p0;
|
||||
int numlvls;
|
||||
int n, z = 0;
|
||||
|
||||
tree = (opj_tgt_tree_t *) opj_malloc(sizeof(opj_tgt_tree_t));
|
||||
if (!tree) {
|
||||
return NULL;
|
||||
}
|
||||
tree->numleafsh = numleafsh;
|
||||
tree->numleafsv = numleafsv;
|
||||
tree->numleafsz = numleafsz;
|
||||
|
||||
numlvls = 0;
|
||||
nplh[0] = numleafsh;
|
||||
nplv[0] = numleafsv;
|
||||
nplz[0] = numleafsz;
|
||||
tree->numnodes = 0;
|
||||
do {
|
||||
n = nplh[numlvls] * nplv[numlvls] * nplz[numlvls];
|
||||
nplh[numlvls + 1] = (nplh[numlvls] + 1) / 2;
|
||||
nplv[numlvls + 1] = (nplv[numlvls] + 1) / 2;
|
||||
nplz[numlvls + 1] = (nplz[numlvls] + 1) / 2;
|
||||
tree->numnodes += n;
|
||||
++numlvls;
|
||||
} while (n > 1);
|
||||
|
||||
if (tree->numnodes == 0) {
|
||||
opj_free(tree);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
tree->nodes = (opj_tgt_node_t *) opj_malloc(tree->numnodes * sizeof(
|
||||
opj_tgt_node_t));
|
||||
if (!tree->nodes) {
|
||||
opj_free(tree);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
node = tree->nodes;
|
||||
parentnode = &tree->nodes[tree->numleafsh * tree->numleafsv * tree->numleafsz];
|
||||
parentnode0 = parentnode;
|
||||
parentnode1 = parentnode;
|
||||
/*fprintf(stdout,"\nH %d V %d Z %d numlvls %d nodes %d\n",tree->numleafsh,tree->numleafsv,tree->numleafsz,numlvls,tree->numnodes);*/
|
||||
for (i = 0; i < numlvls - 1; ++i) {
|
||||
for (z = 0; z < nplz[i]; ++z) {
|
||||
for (j = 0; j < nplv[i]; ++j) {
|
||||
k = nplh[i];
|
||||
while (--k >= 0) {
|
||||
node->parent =
|
||||
parentnode; /*fprintf(stdout,"node[%d].parent = node[%d]\n",n,p);*/
|
||||
++node;
|
||||
if (--k >= 0) {
|
||||
node->parent =
|
||||
parentnode; /*fprintf(stdout,"node[%d].parent = node[%d]\n",n,p);*/
|
||||
++node;
|
||||
}
|
||||
++parentnode;
|
||||
}
|
||||
if ((j & 1) || j == nplv[i] - 1) {
|
||||
parentnode0 = parentnode;
|
||||
} else {
|
||||
parentnode = parentnode0;
|
||||
}
|
||||
}
|
||||
if ((z & 1) || z == nplz[i] - 1) {
|
||||
parentnode1 = parentnode;
|
||||
} else {
|
||||
parentnode0 = parentnode1;
|
||||
parentnode = parentnode1;
|
||||
}
|
||||
}
|
||||
}
|
||||
node->parent = 0;
|
||||
|
||||
|
||||
tgt_reset(tree);
|
||||
|
||||
return tree;
|
||||
}
|
||||
|
||||
void tgt_destroy(opj_tgt_tree_t *tree)
|
||||
{
|
||||
opj_free(tree->nodes);
|
||||
opj_free(tree);
|
||||
}
|
||||
|
||||
void tgt_reset(opj_tgt_tree_t *tree)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (NULL == tree) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < tree->numnodes; i++) {
|
||||
tree->nodes[i].value = 999;
|
||||
tree->nodes[i].low = 0;
|
||||
tree->nodes[i].known = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void tgt_setvalue(opj_tgt_tree_t *tree, int leafno, int 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, int leafno,
|
||||
int threshold)
|
||||
{
|
||||
opj_tgt_node_t *stk[31];
|
||||
opj_tgt_node_t **stkptr;
|
||||
opj_tgt_node_t *node;
|
||||
int 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;
|
||||
}
|
||||
}
|
||||
|
||||
int tgt_decode(opj_bio_t *bio, opj_tgt_tree_t *tree, int leafno, int threshold)
|
||||
{
|
||||
opj_tgt_node_t *stk[31];
|
||||
opj_tgt_node_t **stkptr;
|
||||
opj_tgt_node_t *node;
|
||||
int 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;
|
||||
}
|
|
@ -1,131 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#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.
|
||||
*/
|
||||
|
||||
/** @defgroup TGT TGT - Implementation of a tag-tree coder */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Tag node
|
||||
*/
|
||||
typedef struct opj_tgt_node {
|
||||
/** Node parent reference */
|
||||
struct opj_tgt_node *parent;
|
||||
/** */
|
||||
int value;
|
||||
/** */
|
||||
int low;
|
||||
/** */
|
||||
int known;
|
||||
} opj_tgt_node_t;
|
||||
|
||||
/**
|
||||
Tag tree
|
||||
*/
|
||||
typedef struct opj_tgt_tree {
|
||||
/** Number of leaves from horizontal axis */
|
||||
int numleafsh;
|
||||
/** Number of leaves from vertical axis */
|
||||
int numleafsv;
|
||||
/** Number of leaves from axial axis */
|
||||
int numleafsz;
|
||||
/** Number of nodes */
|
||||
int numnodes;
|
||||
/** Reference to each node instance */
|
||||
opj_tgt_node_t *nodes;
|
||||
} opj_tgt_tree_t;
|
||||
|
||||
/** @name Funciones generales */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
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
|
||||
@param numleafsz Depth 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(int numleafsh, int numleafsv, int numleafsz);
|
||||
/**
|
||||
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, int leafno, int 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(opj_bio_t *bio, opj_tgt_tree_t *tree, int leafno,
|
||||
int 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
|
||||
*/
|
||||
int tgt_decode(opj_bio_t *bio, opj_tgt_tree_t *tree, int leafno, int threshold);
|
||||
|
||||
/*@}*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
void tgt_tree_dump(FILE *fd, opj_tgt_tree_t * tree);
|
||||
/*@}*/
|
||||
|
||||
#endif /* __TGT_H */
|
|
@ -1,101 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 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.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
#include "volume.h"
|
||||
#include "openjp3d.h"
|
||||
|
||||
opj_volume_t* OPJ_CALLCONV opj_volume_create(int numcmpts,
|
||||
opj_volume_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc)
|
||||
{
|
||||
int compno;
|
||||
opj_volume_t *volume = NULL;
|
||||
|
||||
volume = (opj_volume_t*)opj_malloc(sizeof(opj_volume_t));
|
||||
if (volume) {
|
||||
volume->color_space = clrspc;
|
||||
volume->numcomps = numcmpts;
|
||||
/* allocate memory for the per-component information */
|
||||
volume->comps = (opj_volume_comp_t*)opj_malloc(volume->numcomps * sizeof(
|
||||
opj_volume_comp_t));
|
||||
if (!volume->comps) {
|
||||
opj_volume_destroy(volume);
|
||||
return NULL;
|
||||
}
|
||||
/* create the individual volume components */
|
||||
for (compno = 0; compno < numcmpts; compno++) {
|
||||
opj_volume_comp_t *comp = &volume->comps[compno];
|
||||
comp->dx = cmptparms[compno].dx;
|
||||
comp->dy = cmptparms[compno].dy;
|
||||
comp->dz = cmptparms[compno].dz;
|
||||
comp->w = cmptparms[compno].w;
|
||||
comp->h = cmptparms[compno].h;
|
||||
comp->l = cmptparms[compno].l;
|
||||
comp->x0 = cmptparms[compno].x0;
|
||||
comp->y0 = cmptparms[compno].y0;
|
||||
comp->z0 = cmptparms[compno].z0;
|
||||
comp->prec = cmptparms[compno].prec;
|
||||
comp->bpp = cmptparms[compno].bpp;
|
||||
comp->sgnd = cmptparms[compno].sgnd;
|
||||
comp->bigendian = cmptparms[compno].bigendian;
|
||||
comp->dcoffset = cmptparms[compno].dcoffset;
|
||||
comp->data = (int*)opj_malloc(comp->w * comp->h * comp->l * sizeof(int));
|
||||
if (!comp->data) {
|
||||
fprintf(stdout, "Unable to malloc comp->data (%d x %d x %d x bytes)", comp->w,
|
||||
comp->h, comp->l);
|
||||
opj_volume_destroy(volume);
|
||||
return NULL;
|
||||
}
|
||||
/*fprintf(stdout,"%d %d %d %d %d %d %d %d %d", comp->w,comp->h, comp->l, comp->dx, comp->dy, comp->dz, comp->prec, comp->bpp, comp->sgnd);*/
|
||||
}
|
||||
}
|
||||
|
||||
return volume;
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_volume_destroy(opj_volume_t *volume)
|
||||
{
|
||||
int i;
|
||||
if (volume) {
|
||||
if (volume->comps) {
|
||||
/* volume components */
|
||||
for (i = 0; i < volume->numcomps; i++) {
|
||||
opj_volume_comp_t *volume_comp = &volume->comps[i];
|
||||
if (volume_comp->data) {
|
||||
opj_free(volume_comp->data);
|
||||
}
|
||||
}
|
||||
opj_free(volume->comps);
|
||||
}
|
||||
opj_free(volume);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2006, Mónica Díez García, Image Processing Laboratory, University of Valladolid, Spain
|
||||
* 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 __VOLUME_H
|
||||
#define __VOLUME_H
|
||||
/**
|
||||
@file volume.h
|
||||
@brief Implementation of operations on volumes (VOLUME)
|
||||
|
||||
The functions in VOLUME.C have for goal to realize operations on volumes.
|
||||
*/
|
||||
|
||||
/** @defgroup VOLUME VOLUME - Implementation of operations on volumes */
|
||||
/*@{*/
|
||||
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __VOLUME_H */
|
||||
|
|
@ -1,64 +0,0 @@
|
|||
# Makefile for the main JPWL OpenJPEG codecs: JPWL_ j2k_to_image and JPWL_image_to_j2k
|
||||
|
||||
add_definitions(-DUSE_JPWL)
|
||||
|
||||
set(OPENJPEG_SRCS
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/bio.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/cio.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/dwt.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/event.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/image.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/j2k.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/jp2.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/jpt.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/mct.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/mqc.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/openjpeg.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/j2k_lib.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/pi.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/raw.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/t1.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/t2.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/tcd.c
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2/tgt.c
|
||||
)
|
||||
|
||||
set(JPWL_SRCS crc.c jpwl.c jpwl_lib.c rs.c)
|
||||
if(APPLE)
|
||||
set_source_files_properties(
|
||||
rs.c
|
||||
PROPERTIES
|
||||
COMPILE_FLAGS -fno-common)
|
||||
endif()
|
||||
|
||||
include_directories(
|
||||
${OPENJPEG_BINARY_DIR}/src/lib/openjp2 # opj_config.h
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openmj2
|
||||
${OPENJPEG_SOURCE_DIR}/src/lib/openjpwl
|
||||
)
|
||||
|
||||
# Build the library
|
||||
if(WIN32)
|
||||
if(BUILD_SHARED_LIBS)
|
||||
add_definitions(-DOPJ_EXPORTS)
|
||||
else()
|
||||
add_definitions(-DOPJ_STATIC)
|
||||
endif()
|
||||
endif()
|
||||
add_library(openjpwl ${JPWL_SRCS} ${OPENJPEG_SRCS})
|
||||
if(UNIX)
|
||||
target_link_libraries(openjpwl m)
|
||||
endif()
|
||||
set_target_properties(openjpwl
|
||||
PROPERTIES ${OPENJPEG_LIBRARY_PROPERTIES})
|
||||
if(NOT ${CMAKE_VERSION} VERSION_LESS "2.8.12")
|
||||
target_compile_options(openjpwl PRIVATE ${OPENJPEG_LIBRARY_COMPILE_OPTIONS})
|
||||
endif()
|
||||
|
||||
# Install library
|
||||
install(TARGETS openjpwl
|
||||
EXPORT OpenJPEGTargets
|
||||
RUNTIME DESTINATION ${OPENJPEG_INSTALL_BIN_DIR} COMPONENT Applications
|
||||
LIBRARY DESTINATION ${OPENJPEG_INSTALL_LIB_DIR} COMPONENT Libraries
|
||||
ARCHIVE DESTINATION ${OPENJPEG_INSTALL_LIB_DIR} COMPONENT Libraries
|
||||
)
|
|
@ -1,136 +0,0 @@
|
|||
===============================================================================
|
||||
JPEG2000 Part 11 (ISO/IEC 15444-11 JPWL) Software
|
||||
|
||||
|
||||
|
||||
Version 20061213
|
||||
===============================================================================
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
1. Scope
|
||||
=============
|
||||
|
||||
This document describes the installation and use of the JPWL module in the framework of OpenJPEG library.
|
||||
|
||||
This implementation has been developed from OpenJPEG implementation of JPEG2000 standard, and for this reason it is written in C language.
|
||||
|
||||
If you find some bugs or if you have problems using the encoder/decoder, please send an e-mail to jpwl@diei.unipg.it
|
||||
|
||||
|
||||
2. Installing the code
|
||||
==========================
|
||||
|
||||
The JPWL code is integrated with the standard OpenJPEG library and codecs: it is activated by setting the macro USE_JPWL to defined in the preprocessor configuration options of your preferred C compiler.
|
||||
|
||||
2.1. Compiling the source code in Windows
|
||||
-------------------------------------------
|
||||
|
||||
The "jpwl" directory is already populated with a couple of Visual C++ 6.0 workspaces
|
||||
|
||||
* JPWL_image_to_j2k.dsw - Creates the encoder with JPWL functionalities
|
||||
* JPWL_j2k_to_image.dsw - Creates the decoder with JPWL functionalities
|
||||
|
||||
2.2. Compiling the source code in Unix-like systems
|
||||
-----------------------------------------------------
|
||||
|
||||
Under linux, enter the jpwl directory and type "make clean" and "make".
|
||||
|
||||
|
||||
3. Running the JPWL software
|
||||
=========================
|
||||
|
||||
The options available at the command line are exactly the same of the base OpenJPEG codecs. In addition, there is a "-W" switch that activates JPWL functionalities.
|
||||
|
||||
3.1. JPWL Encoder
|
||||
-------------------
|
||||
|
||||
-W : adoption of JPWL (Part 11) capabilities (-W params)
|
||||
The parameters can be written and repeated in any order:
|
||||
[h<tile><=type>,s<tile><=method>,a=<addr>,z=<size>,g=<range>,...
|
||||
...,p<tile:pack><=type>]
|
||||
|
||||
h selects the header error protection (EPB): 'type' can be
|
||||
[0=none 1,absent=predefined 16=CRC-16 32=CRC-32 37-128=RS]
|
||||
if 'tile' is absent, it applies to main and tile headers
|
||||
if 'tile' is present, it applies from that tile
|
||||
onwards, up to the next h<tile> spec, or to the last tile
|
||||
in the codestream (max. 16 specs)
|
||||
|
||||
p selects the packet error protection (EEP/UEP with EPBs)
|
||||
to be applied to raw data: 'type' can be
|
||||
[0=none 1,absent=predefined 16=CRC-16 32=CRC-32 37-128=RS]
|
||||
if 'tile:pack' is absent, it starts from tile 0, packet 0
|
||||
if 'tile:pack' is present, it applies from that tile
|
||||
and that packet onwards, up to the next packet spec
|
||||
or to the last packet in the last tile in the codestream
|
||||
(max. 16 specs)
|
||||
|
||||
s enables sensitivity data insertion (ESD): 'method' can be
|
||||
[-1=NO ESD 0=RELATIVE ERROR 1=MSE 2=MSE REDUCTION 3=PSNR
|
||||
4=PSNR INCREMENT 5=MAXERR 6=TSE 7=RESERVED]
|
||||
if 'tile' is absent, it applies to main header only
|
||||
if 'tile' is present, it applies from that tile
|
||||
onwards, up to the next s<tile> spec, or to the last tile
|
||||
in the codestream (max. 16 specs)
|
||||
|
||||
g determines the addressing mode: <range> can be
|
||||
[0=PACKET 1=BYTE RANGE 2=PACKET RANGE]
|
||||
|
||||
a determines the size of data addressing: <addr> can be
|
||||
2/4 bytes (small/large codestreams). If not set, auto-mode
|
||||
|
||||
z determines the size of sensitivity values: <size> can be
|
||||
1/2 bytes, for the transformed pseudo-floating point value
|
||||
|
||||
ex.:
|
||||
h,h0=64,h3=16,h5=32,p0=78,p0:24=56,p1,p3:0=0,p3:20=32,s=0,s0=6,s3=-1,a=0,g=1,z=1
|
||||
means
|
||||
predefined EPB in MH, rs(64,32) from TPH 0 to TPH 2,
|
||||
CRC-16 in TPH 3 and TPH 4, CRC-32 in remaining TPHs,
|
||||
UEP rs(78,32) for packets 0 to 23 of tile 0,
|
||||
UEP rs(56,32) for packets 24 to the last of tile 0,
|
||||
UEP rs default for packets of tile 1,
|
||||
no UEP for packets 0 to 19 of tile 3,
|
||||
UEP CRC-32 for packets 20 of tile 3 to last tile,
|
||||
relative sensitivity ESD for MH,
|
||||
TSE ESD from TPH 0 to TPH 2, byte range with automatic
|
||||
size of addresses and 1 byte for each sensitivity value
|
||||
|
||||
ex.:
|
||||
h,s,p
|
||||
means
|
||||
default protection to headers (MH and TPHs) as well as
|
||||
data packets, one ESD in MH
|
||||
|
||||
N.B.: use the following recommendations when specifying
|
||||
the JPWL parameters list
|
||||
- when you use UEP, always pair the 'p' option with 'h'
|
||||
|
||||
3.2. JPWL Decoder
|
||||
-------------------
|
||||
|
||||
-W <options>
|
||||
Activates the JPWL correction capability, if the codestream complies.
|
||||
Options can be a comma separated list of <param=val> tokens:
|
||||
c, c=numcomps
|
||||
numcomps is the number of expected components in the codestream
|
||||
(search of first EPB rely upon this, default is 3)
|
||||
|
||||
|
||||
4. Known bugs and limitations
|
||||
===============================
|
||||
|
||||
4.1. Bugs
|
||||
-----------
|
||||
|
||||
* It is not possible to save a JPWL encoded codestream using the wrapped file format (i.e. JP2): only raw file format (i.e. J2K) is working
|
||||
|
||||
4.2. Limitations
|
||||
------------------
|
||||
|
||||
* When specifying an UEP protection, you need to activate even TPH protection for those tiles where there is a protection of the packets
|
||||
* RED insertion is not currently implemented at the decoder
|
||||
* JPWL at entropy coding level is not implemented
|
|
@ -1,167 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* Copyright (c) 2005-2006, Dept. of Electronic and Information Engineering, Universita' degli Studi di Perugia, Italy
|
||||
* 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 USE_JPWL
|
||||
|
||||
#include "crc.h"
|
||||
|
||||
/**
|
||||
@file crc.c
|
||||
@brief Functions used to compute the 16- and 32-bit CRC of byte arrays
|
||||
|
||||
*/
|
||||
|
||||
/** file: CRC16.CPP
|
||||
*
|
||||
* CRC - Cyclic Redundancy Check (16-bit)
|
||||
*
|
||||
* A CRC-checksum is used to be sure, the data hasn't changed or is false.
|
||||
* To create a CRC-checksum, initialise a check-variable (unsigned short),
|
||||
* and set this to zero. Than call for every byte in the file (e.g.) the
|
||||
* procedure updateCRC16 with this check-variable as the first parameter,
|
||||
* and the byte as the second. At the end, the check-variable contains the
|
||||
* CRC-checksum.
|
||||
*
|
||||
* implemented by Michael Neumann, 14.06.1998
|
||||
*
|
||||
*/
|
||||
const unsigned short CRC16_table[256] = {
|
||||
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
|
||||
0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
|
||||
0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
|
||||
0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
|
||||
0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
|
||||
0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
|
||||
0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
|
||||
0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
|
||||
0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
|
||||
0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
|
||||
0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
|
||||
0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
|
||||
0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
|
||||
0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
|
||||
0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
|
||||
0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
|
||||
0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
|
||||
0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
|
||||
0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
|
||||
0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
|
||||
0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
|
||||
0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
|
||||
0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
|
||||
0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
|
||||
0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
|
||||
0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
|
||||
0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
|
||||
0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
|
||||
0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
|
||||
0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
|
||||
0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
|
||||
0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
|
||||
};
|
||||
|
||||
void updateCRC16(unsigned short *crc, unsigned char data)
|
||||
{
|
||||
*crc = CRC16_table[(*crc >> 8) & 0xFF] ^ (*crc << 8) ^ data;
|
||||
}
|
||||
|
||||
|
||||
/** file: CRC32.CPP
|
||||
*
|
||||
* CRC - Cyclic Redundancy Check (32-bit)
|
||||
*
|
||||
* A CRC-checksum is used to be sure, the data hasn't changed or is false.
|
||||
* To create a CRC-checksum, initialise a check-variable (unsigned long),
|
||||
* and set this to zero. Than call for every byte in the file (e.g.) the
|
||||
* procedure updateCRC32 with this check-variable as the first parameter,
|
||||
* and the byte as the second. At the end, the check-variable contains the
|
||||
* CRC-checksum.
|
||||
*
|
||||
* implemented by Michael Neumann, 14.06.1998
|
||||
*
|
||||
*/
|
||||
const unsigned long CRC32_table[256] = {
|
||||
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
|
||||
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
|
||||
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
|
||||
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
|
||||
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
|
||||
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
|
||||
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
|
||||
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
|
||||
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
|
||||
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
|
||||
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
|
||||
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
|
||||
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
|
||||
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
|
||||
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
|
||||
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
|
||||
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
|
||||
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
|
||||
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
|
||||
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
|
||||
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
|
||||
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
|
||||
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
|
||||
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
|
||||
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
|
||||
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
|
||||
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
|
||||
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
|
||||
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
|
||||
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
|
||||
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
|
||||
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
|
||||
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
|
||||
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
|
||||
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
|
||||
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
|
||||
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
|
||||
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
|
||||
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
|
||||
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
|
||||
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
|
||||
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
|
||||
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
|
||||
};
|
||||
|
||||
void updateCRC32(unsigned long *crc, unsigned char data)
|
||||
{
|
||||
*crc = CRC32_table[(unsigned char) * crc ^ data] ^ ((*crc >> 8) & 0x00FFFFFF);
|
||||
}
|
||||
|
||||
#endif /* USE_JPWL */
|
|
@ -1,89 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* Copyright (c) 2005-2006, Dept. of Electronic and Information Engineering, Universita' degli Studi di Perugia, Italy
|
||||
* 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 USE_JPWL
|
||||
|
||||
/**
|
||||
@file crc.h
|
||||
@brief Functions used to compute the 16- and 32-bit CRC of byte arrays
|
||||
|
||||
*/
|
||||
|
||||
#ifndef __CRC16_HEADER__
|
||||
#define __CRC16_HEADER__
|
||||
|
||||
/** file: CRC16.HPP
|
||||
*
|
||||
* CRC - Cyclic Redundancy Check (16-bit)
|
||||
*
|
||||
* A CRC-checksum is used to be sure, the data hasn't changed or is false.
|
||||
* To create a CRC-checksum, initialise a check-variable (unsigned short),
|
||||
* and set this to zero. Than call for every byte in the file (e.g.) the
|
||||
* procedure updateCRC16 with this check-variable as the first parameter,
|
||||
* and the byte as the second. At the end, the check-variable contains the
|
||||
* CRC-checksum.
|
||||
*
|
||||
* implemented by Michael Neumann, 14.06.1998
|
||||
*
|
||||
*/
|
||||
void updateCRC16(unsigned short *, unsigned char);
|
||||
|
||||
#endif /* __CRC16_HEADER__ */
|
||||
|
||||
|
||||
#ifndef __CRC32_HEADER__
|
||||
#define __CRC32_HEADER__
|
||||
|
||||
/** file: CRC32.HPP
|
||||
*
|
||||
* CRC - Cyclic Redundancy Check (32-bit)
|
||||
*
|
||||
* A CRC-checksum is used to be sure, the data hasn't changed or is false.
|
||||
* To create a CRC-checksum, initialise a check-variable (unsigned short),
|
||||
* and set this to zero. Than call for every byte in the file (e.g.) the
|
||||
* procedure updateCRC32 with this check-variable as the first parameter,
|
||||
* and the byte as the second. At the end, the check-variable contains the
|
||||
* CRC-checksum.
|
||||
*
|
||||
* implemented by Michael Neumann, 14.06.1998
|
||||
*
|
||||
*/
|
||||
void updateCRC32(unsigned long *, unsigned char);
|
||||
|
||||
#endif /* __CRC32_HEADER__ */
|
||||
|
||||
|
||||
#endif /* USE_JPWL */
|
File diff suppressed because it is too large
Load Diff
|
@ -1,438 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* Copyright (c) 2005-2006, Dept. of Electronic and Information Engineering, Universita' degli Studi di Perugia, Italy
|
||||
* 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 __JPWL_H
|
||||
#define __JPWL_H
|
||||
|
||||
#ifdef USE_JPWL
|
||||
|
||||
#include "crc.h"
|
||||
#include "rs.h"
|
||||
|
||||
/**
|
||||
@file jpwl.h
|
||||
@brief The JPEG-2000 Part11 (JPWL) marker segments manager
|
||||
|
||||
The functions in JPWL.C have for goal to read/write the markers added by JPWL.
|
||||
*/
|
||||
|
||||
/** @defgroup JPWL JPWL - JPEG-2000 Part11 (JPWL) codestream manager */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Assume a basic codestream structure, so you can resort better from uncorrected errors
|
||||
*/
|
||||
#define JPWL_ASSUME OPJ_TRUE
|
||||
|
||||
/**
|
||||
EPB (Error Protection Block) Marker segment
|
||||
*/
|
||||
typedef struct jpwl_epb_ms {
|
||||
/**@name Private fields set by epb_create */
|
||||
/*@{*/
|
||||
/** is the latest in header? */
|
||||
opj_bool latest;
|
||||
/** is it in packed mode? */
|
||||
opj_bool packed;
|
||||
/** TH where this marker has been placed (-1 means MH) */
|
||||
int tileno;
|
||||
/** index in current header (0-63) */
|
||||
unsigned char index;
|
||||
/** error protection method [-1=absent 0=none 1=predefined 16=CRC-16 32=CRC-32 37-128=RS] */
|
||||
int hprot;
|
||||
/** message word length of pre-data */
|
||||
int k_pre;
|
||||
/** code word length of pre-data */
|
||||
int n_pre;
|
||||
/** length of pre-data */
|
||||
int pre_len;
|
||||
/** message word length of post-data */
|
||||
int k_post;
|
||||
/** code word length of post-data */
|
||||
int n_post;
|
||||
/** length of post-data */
|
||||
int post_len;
|
||||
/*@}*/
|
||||
/**@name Marker segment fields */
|
||||
/*@{*/
|
||||
/** two bytes for the length of EPB MS, exluding the marker itself (11 to 65535 bytes) */
|
||||
unsigned short int Lepb;
|
||||
/** single byte for the style */
|
||||
unsigned char Depb;
|
||||
/** four bytes, from 0 to 2^31-1 */
|
||||
unsigned long int LDPepb;
|
||||
/** four bytes, next error management method */
|
||||
unsigned long int Pepb;
|
||||
/** EPB data, variable size */
|
||||
unsigned char *data;
|
||||
/*@}*/
|
||||
} jpwl_epb_ms_t;
|
||||
|
||||
/**
|
||||
EPC (Error Protection Capability) Marker segment
|
||||
*/
|
||||
typedef struct jpwl_epc_ms {
|
||||
/** is ESD active? */
|
||||
opj_bool esd_on;
|
||||
/** is RED active? */
|
||||
opj_bool red_on;
|
||||
/** is EPB active? */
|
||||
opj_bool epb_on;
|
||||
/** are informative techniques active? */
|
||||
opj_bool info_on;
|
||||
/**@name Marker segment fields */
|
||||
/*@{*/
|
||||
/** two bytes for the length of EPC MS, exluding the marker itself (9 to 65535 bytes) */
|
||||
unsigned short int Lepc;
|
||||
/** two bytes, CRC for the EPC, excluding Pcrc itself */
|
||||
unsigned short int Pcrc;
|
||||
/** four bytes, the codestream length from SOC to EOC */
|
||||
unsigned long int DL;
|
||||
/** one byte, signals JPWL techniques adoption */
|
||||
unsigned char Pepc;
|
||||
/** EPC data, variable length */
|
||||
unsigned char *data;
|
||||
/*@}*/
|
||||
} jpwl_epc_ms_t;
|
||||
|
||||
/**
|
||||
ESD (Error Sensitivity Descriptor) Marker segment
|
||||
*/
|
||||
typedef struct jpwl_esd_ms {
|
||||
/** codestream addressing mode [0=packet, 1=byte range, 2=packet range, 3=reserved] */
|
||||
unsigned char addrm;
|
||||
/** size of codestream addresses [2/4 bytes] */
|
||||
unsigned char ad_size;
|
||||
/** type of sensitivity
|
||||
[0=relative error, 1=MSE, 2=MSE reduction, 3=PSNR, 4=PSNR increment,
|
||||
5=MAXERR (absolute peak error), 6=TSE (total squared error), 7=reserved */
|
||||
unsigned char senst;
|
||||
/** size of sensitivity data (1/2 bytes) */
|
||||
unsigned char se_size;
|
||||
/**@name Marker segment fields */
|
||||
/*@{*/
|
||||
/** two bytes for the length of ESD MS, exluding the marker itself (4 to 65535 bytes) */
|
||||
unsigned short int Lesd;
|
||||
/** two bytes, component of error sensitivity */
|
||||
unsigned short int Cesd;
|
||||
/** one byte, signals JPWL techniques adoption */
|
||||
unsigned char Pesd;
|
||||
/** ESD data, variable length */
|
||||
unsigned char *data;
|
||||
/*@}*/
|
||||
/**@name Fields set by esd_create (only internal use) */
|
||||
/*@{*/
|
||||
/** number of components in the image */
|
||||
int numcomps;
|
||||
/** tile where this marker has been placed (-1 means MH) */
|
||||
int tileno;
|
||||
/** number of sensitivity values */
|
||||
unsigned long int svalnum;
|
||||
/** size of a single sensitivity pair (address+value) */
|
||||
size_t sensval_size;
|
||||
/*@}*/
|
||||
} jpwl_esd_ms_t;
|
||||
|
||||
/**
|
||||
RED (Residual Error Descriptor) Marker segment
|
||||
*/
|
||||
typedef struct jpwl_red_ms {
|
||||
/** two bytes for the length of RED MS, exluding the marker itself (3 to 65535 bytes) */
|
||||
unsigned short int Lred;
|
||||
/** one byte, signals JPWL techniques adoption */
|
||||
unsigned char Pred;
|
||||
/** RED data, variable length */
|
||||
unsigned char *data;
|
||||
} jpwl_red_ms_t;
|
||||
|
||||
/**
|
||||
Structure used to store JPWL markers temporary position and readyness
|
||||
*/
|
||||
typedef struct jpwl_marker {
|
||||
/** marker value (J2K_MS_EPC, etc.) */
|
||||
int id;
|
||||
/** union keeping the pointer to the real marker struct */
|
||||
union jpwl_marks {
|
||||
/** pointer to EPB marker */
|
||||
jpwl_epb_ms_t *epbmark;
|
||||
/** pointer to EPC marker */
|
||||
jpwl_epc_ms_t *epcmark;
|
||||
/** pointer to ESD marker */
|
||||
jpwl_esd_ms_t *esdmark;
|
||||
/** pointer to RED marker */
|
||||
jpwl_red_ms_t *redmark;
|
||||
} m;
|
||||
/** position where the marker should go, in the pre-JPWL codestream */
|
||||
unsigned long int pos;
|
||||
/** same as before, only written as a double, so we can sort it better */
|
||||
double dpos;
|
||||
/** length of the marker segment (marker excluded) */
|
||||
unsigned short int len;
|
||||
/** the marker length is ready or not? */
|
||||
opj_bool len_ready;
|
||||
/** the marker position is ready or not? */
|
||||
opj_bool pos_ready;
|
||||
/** the marker parameters are ready or not? */
|
||||
opj_bool parms_ready;
|
||||
/** are the written data ready or not */
|
||||
opj_bool data_ready;
|
||||
} jpwl_marker_t;
|
||||
|
||||
/**
|
||||
Encode according to JPWL specs
|
||||
@param j2k J2K handle
|
||||
@param cio codestream handle
|
||||
@param image image handle
|
||||
*/
|
||||
void jpwl_encode(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image);
|
||||
|
||||
/**
|
||||
Prepare the list of JPWL markers, after the Part 1 codestream
|
||||
has been finalized (index struct is full)
|
||||
@param j2k J2K handle
|
||||
@param cio codestream handle
|
||||
@param image image handle
|
||||
*/
|
||||
void jpwl_prepare_marks(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image);
|
||||
|
||||
/**
|
||||
Dump the list of JPWL markers, after it has been prepared
|
||||
@param j2k J2K handle
|
||||
@param cio codestream handle
|
||||
@param image image handle
|
||||
*/
|
||||
void jpwl_dump_marks(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image);
|
||||
|
||||
/**
|
||||
Read the EPC marker (Error Protection Capability)
|
||||
@param j2k J2K handle
|
||||
*/
|
||||
void j2k_read_epc(opj_j2k_t *j2k);
|
||||
|
||||
/**
|
||||
Write the EPC marker (Error Protection Capability), BUT the DL field is always set to 0
|
||||
(this simplifies the management of EPBs and it is openly stated in the standard
|
||||
as a possible value, mening that the information is not available) and the informative techniques
|
||||
are not yet implemented
|
||||
@param j2k J2K handle
|
||||
*/
|
||||
#if 0
|
||||
void j2k_write_epc(opj_j2k_t *j2k);
|
||||
#endif
|
||||
|
||||
/**
|
||||
Read the EPB marker (Error Protection Block)
|
||||
@param j2k J2K handle
|
||||
*/
|
||||
void j2k_read_epb(opj_j2k_t *j2k);
|
||||
|
||||
/**
|
||||
Write the EPB marker (Error Protection Block)
|
||||
@param j2k J2K handle
|
||||
*/
|
||||
void j2k_write_epb(opj_j2k_t *j2k);
|
||||
|
||||
/**
|
||||
Read the ESD marker (Error Sensitivity Descriptor)
|
||||
@param j2k J2K handle
|
||||
*/
|
||||
void j2k_read_esd(opj_j2k_t *j2k);
|
||||
|
||||
/**
|
||||
Read the RED marker (Residual Error Descriptor)
|
||||
@param j2k J2K handle
|
||||
*/
|
||||
void j2k_read_red(opj_j2k_t *j2k);
|
||||
|
||||
/** create an EPB marker segment
|
||||
@param j2k J2K compressor handle
|
||||
@param latest it is the latest EPB in the header
|
||||
@param packed EPB is in packed style
|
||||
@param tileno tile number where the marker has been placed (-1 means MH)
|
||||
@param idx current EPB running index
|
||||
@param hprot applied protection type (-1/0,1,16,32,37-128)
|
||||
@param pre_len length of pre-protected data
|
||||
@param post_len length of post-protected data
|
||||
@return returns the freshly created EPB
|
||||
*/
|
||||
jpwl_epb_ms_t *jpwl_epb_create(opj_j2k_t *j2k, opj_bool latest, opj_bool packed,
|
||||
int tileno, int idx, int hprot,
|
||||
unsigned long int pre_len, unsigned long int post_len);
|
||||
|
||||
/** add a number of EPB marker segments
|
||||
@param j2k J2K compressor handle
|
||||
@param jwmarker pointer to the JPWL markers list
|
||||
@param jwmarker_num pointer to the number of JPWL markers (gets updated)
|
||||
@param latest it is the latest group of EPBs in the header
|
||||
@param packed EPBs are in packed style
|
||||
@param insideMH it is in the MH
|
||||
@param idx pointer to the starting EPB running index (gets updated)
|
||||
@param hprot applied protection type (-1/0,1,16,32,37-128)
|
||||
@param place_pos place in original codestream where EPBs should go
|
||||
@param tileno tile number of these EPBs
|
||||
@param pre_len length of pre-protected data
|
||||
@param post_len length of post-protected data
|
||||
@return returns the length of all added markers
|
||||
*/
|
||||
int jpwl_epbs_add(opj_j2k_t *j2k, jpwl_marker_t *jwmarker, int *jwmarker_num,
|
||||
opj_bool latest, opj_bool packed, opj_bool insideMH, int *idx, int hprot,
|
||||
double place_pos, int tileno,
|
||||
unsigned long int pre_len, unsigned long int post_len);
|
||||
|
||||
/** add a number of ESD marker segments
|
||||
@param j2k J2K compressor handle
|
||||
@param jwmarker pointer to the JPWL markers list
|
||||
@param jwmarker_num pointer to the number of JPWL markers (gets updated)
|
||||
@param comps considered component (-1=average, 0/1/2/...=component no.)
|
||||
@param addrm addressing mode (0=packet, 1=byte range, 2=packet range, 3=reserved)
|
||||
@param ad_size size of addresses (2/4 bytes)
|
||||
@param senst sensitivity type
|
||||
@param se_size sensitivity values size (1/2 bytes)
|
||||
@param place_pos place in original codestream where EPBs should go
|
||||
@param tileno tile number of these EPBs
|
||||
@return returns the length of all added markers
|
||||
*/
|
||||
int jpwl_esds_add(opj_j2k_t *j2k, jpwl_marker_t *jwmarker, int *jwmarker_num,
|
||||
int comps, unsigned char addrm, unsigned char ad_size,
|
||||
unsigned char senst, unsigned char se_size,
|
||||
double place_pos, int tileno);
|
||||
|
||||
/** updates the information structure by modifying the positions and lengths
|
||||
@param j2k J2K compressor handle
|
||||
@param jwmarker pointer to JPWL markers list
|
||||
@param jwmarker_num number of JPWL markers
|
||||
@return returns true in case of success
|
||||
*/
|
||||
opj_bool jpwl_update_info(opj_j2k_t *j2k, jpwl_marker_t *jwmarker,
|
||||
int jwmarker_num);
|
||||
|
||||
|
||||
opj_bool jpwl_esd_fill(opj_j2k_t *j2k, jpwl_esd_ms_t *esdmark,
|
||||
unsigned char *buf);
|
||||
|
||||
opj_bool jpwl_epb_fill(opj_j2k_t *j2k, jpwl_epb_ms_t *epbmark,
|
||||
unsigned char *buf, unsigned char *post_buf);
|
||||
|
||||
opj_bool j2k_add_marker(opj_codestream_info_t *cstr_info,
|
||||
unsigned short int type, int pos, int len);
|
||||
|
||||
/** corrects the data in the JPWL codestream
|
||||
@param j2k J2K compressor handle
|
||||
@return true if correction is performed correctly
|
||||
*/
|
||||
opj_bool jpwl_correct(opj_j2k_t *j2k);
|
||||
|
||||
/** corrects the data protected by an EPB
|
||||
@param j2k J2K compressor handle
|
||||
@param buffer pointer to the EPB position
|
||||
@param type type of EPB: 0=MH, 1=TPH, 2=other, 3=auto
|
||||
@param pre_len length of pre-data
|
||||
@param post_len length of post_data
|
||||
@param conn is a pointer to the length of all connected (packed) EPBs
|
||||
@param L4_bufp is a pointer to the buffer pointer of redundancy data
|
||||
@return returns true if correction could be successfully performed
|
||||
*/
|
||||
opj_bool jpwl_epb_correct(opj_j2k_t *j2k, unsigned char *buffer, int type,
|
||||
int pre_len, int post_len, int *conn,
|
||||
unsigned char **L4_bufp);
|
||||
|
||||
/** check that a tile and its children have valid data
|
||||
@param j2k J2K decompressor handle
|
||||
@param tcd Tile decompressor handle
|
||||
@param tileno number of the tile to check
|
||||
*/
|
||||
opj_bool jpwl_check_tile(opj_j2k_t *j2k, opj_tcd_t *tcd, int tileno);
|
||||
|
||||
/** Macro functions for CRC computation */
|
||||
|
||||
/**
|
||||
Computes the CRC-16, as stated in JPWL specs
|
||||
@param CRC two bytes containing the CRC value (must be initialized with 0x0000)
|
||||
@param DATA byte for which the CRC is computed; call this on every byte of the sequence
|
||||
and get the CRC at the end
|
||||
*/
|
||||
#define jpwl_updateCRC16(CRC, DATA) updateCRC16(CRC, DATA)
|
||||
|
||||
/**
|
||||
Computes the CRC-32, as stated in JPWL specs
|
||||
@param CRC four bytes containing the CRC value (must be initialized with 0x00000000)
|
||||
@param DATA byte for which the CRC is computed; call this on every byte of the sequence
|
||||
and get the CRC at the end
|
||||
*/
|
||||
#define jpwl_updateCRC32(CRC, DATA) updateCRC32(CRC, DATA)
|
||||
|
||||
/**
|
||||
Computes the minimum between two integers
|
||||
@param a first integer to compare
|
||||
@param b second integer to compare
|
||||
@return returns the minimum integer between a and b
|
||||
*/
|
||||
#ifndef min
|
||||
#define min(a,b) (((a) < (b)) ? (a) : (b))
|
||||
#endif /* min */
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* USE_JPWL */
|
||||
|
||||
#ifdef USE_JPSEC
|
||||
|
||||
/** @defgroup JPSEC JPSEC - JPEG-2000 Part 8 (JPSEC) codestream manager */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Read the SEC marker (SEcured Codestream)
|
||||
@param j2k J2K handle
|
||||
*/
|
||||
void j2k_read_sec(opj_j2k_t *j2k);
|
||||
|
||||
/**
|
||||
Write the SEC marker (SEcured Codestream)
|
||||
@param j2k J2K handle
|
||||
*/
|
||||
void j2k_write_sec(opj_j2k_t *j2k);
|
||||
|
||||
/**
|
||||
Read the INSEC marker (SEcured Codestream)
|
||||
@param j2k J2K handle
|
||||
*/
|
||||
void j2k_read_insec(opj_j2k_t *j2k);
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* USE_JPSEC */
|
||||
|
||||
#endif /* __JPWL_H */
|
||||
|
File diff suppressed because it is too large
Load Diff
|
@ -1,15 +0,0 @@
|
|||
prefix=@CMAKE_INSTALL_PREFIX@
|
||||
bindir=${prefix}/@OPENJPEG_INSTALL_BIN_DIR@
|
||||
mandir=${prefix}/@OPENJPEG_INSTALL_MAN_DIR@
|
||||
docdir=${prefix}/@OPENJPEG_INSTALL_DOC_DIR@
|
||||
libdir=${prefix}/@OPENJPEG_INSTALL_LIB_DIR@
|
||||
includedir=${prefix}/@OPENJPEG_INSTALL_INCLUDE_DIR@
|
||||
|
||||
Name: openjpwl
|
||||
Description: JPEG2000 Wireless library (Part 11)
|
||||
URL: http://www.openjpeg.org/
|
||||
Version: @OPENJPEG_VERSION@
|
||||
Requires: libopenjp2
|
||||
Libs: -L${libdir} -lopenjpwl
|
||||
Libs.private: -lm
|
||||
Cflags: -I${includedir}
|
|
@ -1,625 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* Copyright (c) 2005-2006, Dept. of Electronic and Information Engineering, Universita' degli Studi di Perugia, Italy
|
||||
* 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 USE_JPWL
|
||||
|
||||
/**
|
||||
@file rs.c
|
||||
@brief Functions used to compute the Reed-Solomon parity and check of byte arrays
|
||||
|
||||
*/
|
||||
|
||||
/**
|
||||
* Reed-Solomon coding and decoding
|
||||
* Phil Karn (karn@ka9q.ampr.org) September 1996
|
||||
*
|
||||
* This file is derived from the program "new_rs_erasures.c" by Robert
|
||||
* Morelos-Zaragoza (robert@spectra.eng.hawaii.edu) and Hari Thirumoorthy
|
||||
* (harit@spectra.eng.hawaii.edu), Aug 1995
|
||||
*
|
||||
* I've made changes to improve performance, clean up the code and make it
|
||||
* easier to follow. Data is now passed to the encoding and decoding functions
|
||||
* through arguments rather than in global arrays. The decode function returns
|
||||
* the number of corrected symbols, or -1 if the word is uncorrectable.
|
||||
*
|
||||
* This code supports a symbol size from 2 bits up to 16 bits,
|
||||
* implying a block size of 3 2-bit symbols (6 bits) up to 65535
|
||||
* 16-bit symbols (1,048,560 bits). The code parameters are set in rs.h.
|
||||
*
|
||||
* Note that if symbols larger than 8 bits are used, the type of each
|
||||
* data array element switches from unsigned char to unsigned int. The
|
||||
* caller must ensure that elements larger than the symbol range are
|
||||
* not passed to the encoder or decoder.
|
||||
*
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include "rs.h"
|
||||
|
||||
/* This defines the type used to store an element of the Galois Field
|
||||
* used by the code. Make sure this is something larger than a char if
|
||||
* if anything larger than GF(256) is used.
|
||||
*
|
||||
* Note: unsigned char will work up to GF(256) but int seems to run
|
||||
* faster on the Pentium.
|
||||
*/
|
||||
typedef int gf;
|
||||
|
||||
/* KK = number of information symbols */
|
||||
static int KK;
|
||||
|
||||
/* Primitive polynomials - see Lin & Costello, Appendix A,
|
||||
* and Lee & Messerschmitt, p. 453.
|
||||
*/
|
||||
#if(MM == 2)/* Admittedly silly */
|
||||
int Pp[MM + 1] = { 1, 1, 1 };
|
||||
|
||||
#elif(MM == 3)
|
||||
/* 1 + x + x^3 */
|
||||
int Pp[MM + 1] = { 1, 1, 0, 1 };
|
||||
|
||||
#elif(MM == 4)
|
||||
/* 1 + x + x^4 */
|
||||
int Pp[MM + 1] = { 1, 1, 0, 0, 1 };
|
||||
|
||||
#elif(MM == 5)
|
||||
/* 1 + x^2 + x^5 */
|
||||
int Pp[MM + 1] = { 1, 0, 1, 0, 0, 1 };
|
||||
|
||||
#elif(MM == 6)
|
||||
/* 1 + x + x^6 */
|
||||
int Pp[MM + 1] = { 1, 1, 0, 0, 0, 0, 1 };
|
||||
|
||||
#elif(MM == 7)
|
||||
/* 1 + x^3 + x^7 */
|
||||
int Pp[MM + 1] = { 1, 0, 0, 1, 0, 0, 0, 1 };
|
||||
|
||||
#elif(MM == 8)
|
||||
/* 1+x^2+x^3+x^4+x^8 */
|
||||
int Pp[MM + 1] = { 1, 0, 1, 1, 1, 0, 0, 0, 1 };
|
||||
|
||||
#elif(MM == 9)
|
||||
/* 1+x^4+x^9 */
|
||||
int Pp[MM + 1] = { 1, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
|
||||
|
||||
#elif(MM == 10)
|
||||
/* 1+x^3+x^10 */
|
||||
int Pp[MM + 1] = { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1 };
|
||||
|
||||
#elif(MM == 11)
|
||||
/* 1+x^2+x^11 */
|
||||
int Pp[MM + 1] = { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
|
||||
|
||||
#elif(MM == 12)
|
||||
/* 1+x+x^4+x^6+x^12 */
|
||||
int Pp[MM + 1] = { 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1 };
|
||||
|
||||
#elif(MM == 13)
|
||||
/* 1+x+x^3+x^4+x^13 */
|
||||
int Pp[MM + 1] = { 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
|
||||
|
||||
#elif(MM == 14)
|
||||
/* 1+x+x^6+x^10+x^14 */
|
||||
int Pp[MM + 1] = { 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1 };
|
||||
|
||||
#elif(MM == 15)
|
||||
/* 1+x+x^15 */
|
||||
int Pp[MM + 1] = { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
|
||||
|
||||
#elif(MM == 16)
|
||||
/* 1+x+x^3+x^12+x^16 */
|
||||
int Pp[MM + 1] = { 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1 };
|
||||
|
||||
#else
|
||||
#error "MM must be in range 2-16"
|
||||
#endif
|
||||
|
||||
/* Alpha exponent for the first root of the generator polynomial */
|
||||
#define B0 0 /* Different from the default 1 */
|
||||
|
||||
/* index->polynomial form conversion table */
|
||||
gf Alpha_to[NN + 1];
|
||||
|
||||
/* Polynomial->index form conversion table */
|
||||
gf Index_of[NN + 1];
|
||||
|
||||
/* No legal value in index form represents zero, so
|
||||
* we need a special value for this purpose
|
||||
*/
|
||||
#define A0 (NN)
|
||||
|
||||
/* Generator polynomial g(x)
|
||||
* Degree of g(x) = 2*TT
|
||||
* has roots @**B0, @**(B0+1), ... ,@^(B0+2*TT-1)
|
||||
*/
|
||||
/*gf Gg[NN - KK + 1];*/
|
||||
gf Gg[NN - 1];
|
||||
|
||||
/* Compute x % NN, where NN is 2**MM - 1,
|
||||
* without a slow divide
|
||||
*/
|
||||
static /*inline*/ gf
|
||||
modnn(int x)
|
||||
{
|
||||
while (x >= NN) {
|
||||
x -= NN;
|
||||
x = (x >> MM) + (x & NN);
|
||||
}
|
||||
return x;
|
||||
}
|
||||
|
||||
/*#define min(a,b) ((a) < (b) ? (a) : (b))*/
|
||||
|
||||
#define CLEAR(a,n) {\
|
||||
int ci;\
|
||||
for(ci=(n)-1;ci >=0;ci--)\
|
||||
(a)[ci] = 0;\
|
||||
}
|
||||
|
||||
#define COPY(a,b,n) {\
|
||||
int ci;\
|
||||
for(ci=(n)-1;ci >=0;ci--)\
|
||||
(a)[ci] = (b)[ci];\
|
||||
}
|
||||
#define COPYDOWN(a,b,n) {\
|
||||
int ci;\
|
||||
for(ci=(n)-1;ci >=0;ci--)\
|
||||
(a)[ci] = (b)[ci];\
|
||||
}
|
||||
|
||||
void init_rs(int k)
|
||||
{
|
||||
KK = k;
|
||||
if (KK >= NN) {
|
||||
printf("KK must be less than 2**MM - 1\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
generate_gf();
|
||||
gen_poly();
|
||||
}
|
||||
|
||||
/* generate GF(2**m) from the irreducible polynomial p(X) in p[0]..p[m]
|
||||
lookup tables: index->polynomial form alpha_to[] contains j=alpha**i;
|
||||
polynomial form -> index form index_of[j=alpha**i] = i
|
||||
alpha=2 is the primitive element of GF(2**m)
|
||||
HARI's COMMENT: (4/13/94) alpha_to[] can be used as follows:
|
||||
Let @ represent the primitive element commonly called "alpha" that
|
||||
is the root of the primitive polynomial p(x). Then in GF(2^m), for any
|
||||
0 <= i <= 2^m-2,
|
||||
@^i = a(0) + a(1) @ + a(2) @^2 + ... + a(m-1) @^(m-1)
|
||||
where the binary vector (a(0),a(1),a(2),...,a(m-1)) is the representation
|
||||
of the integer "alpha_to[i]" with a(0) being the LSB and a(m-1) the MSB. Thus for
|
||||
example the polynomial representation of @^5 would be given by the binary
|
||||
representation of the integer "alpha_to[5]".
|
||||
Similarly, index_of[] can be used as follows:
|
||||
As above, let @ represent the primitive element of GF(2^m) that is
|
||||
the root of the primitive polynomial p(x). In order to find the power
|
||||
of @ (alpha) that has the polynomial representation
|
||||
a(0) + a(1) @ + a(2) @^2 + ... + a(m-1) @^(m-1)
|
||||
we consider the integer "i" whose binary representation with a(0) being LSB
|
||||
and a(m-1) MSB is (a(0),a(1),...,a(m-1)) and locate the entry
|
||||
"index_of[i]". Now, @^index_of[i] is that element whose polynomial
|
||||
representation is (a(0),a(1),a(2),...,a(m-1)).
|
||||
NOTE:
|
||||
The element alpha_to[2^m-1] = 0 always signifying that the
|
||||
representation of "@^infinity" = 0 is (0,0,0,...,0).
|
||||
Similarly, the element index_of[0] = A0 always signifying
|
||||
that the power of alpha which has the polynomial representation
|
||||
(0,0,...,0) is "infinity".
|
||||
|
||||
*/
|
||||
|
||||
void
|
||||
generate_gf(void)
|
||||
{
|
||||
register int i, mask;
|
||||
|
||||
mask = 1;
|
||||
Alpha_to[MM] = 0;
|
||||
for (i = 0; i < MM; i++) {
|
||||
Alpha_to[i] = mask;
|
||||
Index_of[Alpha_to[i]] = i;
|
||||
/* If Pp[i] == 1 then, term @^i occurs in poly-repr of @^MM */
|
||||
if (Pp[i] != 0) {
|
||||
Alpha_to[MM] ^= mask; /* Bit-wise EXOR operation */
|
||||
}
|
||||
mask <<= 1; /* single left-shift */
|
||||
}
|
||||
Index_of[Alpha_to[MM]] = MM;
|
||||
/*
|
||||
* Have obtained poly-repr of @^MM. Poly-repr of @^(i+1) is given by
|
||||
* poly-repr of @^i shifted left one-bit and accounting for any @^MM
|
||||
* term that may occur when poly-repr of @^i is shifted.
|
||||
*/
|
||||
mask >>= 1;
|
||||
for (i = MM + 1; i < NN; i++) {
|
||||
if (Alpha_to[i - 1] >= mask) {
|
||||
Alpha_to[i] = Alpha_to[MM] ^ ((Alpha_to[i - 1] ^ mask) << 1);
|
||||
} else {
|
||||
Alpha_to[i] = Alpha_to[i - 1] << 1;
|
||||
}
|
||||
Index_of[Alpha_to[i]] = i;
|
||||
}
|
||||
Index_of[0] = A0;
|
||||
Alpha_to[NN] = 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Obtain the generator polynomial of the TT-error correcting, length
|
||||
* NN=(2**MM -1) Reed Solomon code from the product of (X+@**(B0+i)), i = 0,
|
||||
* ... ,(2*TT-1)
|
||||
*
|
||||
* Examples:
|
||||
*
|
||||
* If B0 = 1, TT = 1. deg(g(x)) = 2*TT = 2.
|
||||
* g(x) = (x+@) (x+@**2)
|
||||
*
|
||||
* If B0 = 0, TT = 2. deg(g(x)) = 2*TT = 4.
|
||||
* g(x) = (x+1) (x+@) (x+@**2) (x+@**3)
|
||||
*/
|
||||
void
|
||||
gen_poly(void)
|
||||
{
|
||||
register int i, j;
|
||||
|
||||
Gg[0] = Alpha_to[B0];
|
||||
Gg[1] = 1; /* g(x) = (X+@**B0) initially */
|
||||
for (i = 2; i <= NN - KK; i++) {
|
||||
Gg[i] = 1;
|
||||
/*
|
||||
* Below multiply (Gg[0]+Gg[1]*x + ... +Gg[i]x^i) by
|
||||
* (@**(B0+i-1) + x)
|
||||
*/
|
||||
for (j = i - 1; j > 0; j--)
|
||||
if (Gg[j] != 0) {
|
||||
Gg[j] = Gg[j - 1] ^ Alpha_to[modnn((Index_of[Gg[j]]) + B0 + i - 1)];
|
||||
} else {
|
||||
Gg[j] = Gg[j - 1];
|
||||
}
|
||||
/* Gg[0] can never be zero */
|
||||
Gg[0] = Alpha_to[modnn((Index_of[Gg[0]]) + B0 + i - 1)];
|
||||
}
|
||||
/* convert Gg[] to index form for quicker encoding */
|
||||
for (i = 0; i <= NN - KK; i++) {
|
||||
Gg[i] = Index_of[Gg[i]];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* take the string of symbols in data[i], i=0..(k-1) and encode
|
||||
* systematically to produce NN-KK parity symbols in bb[0]..bb[NN-KK-1] data[]
|
||||
* is input and bb[] is output in polynomial form. Encoding is done by using
|
||||
* a feedback shift register with appropriate connections specified by the
|
||||
* elements of Gg[], which was generated above. Codeword is c(X) =
|
||||
* data(X)*X**(NN-KK)+ b(X)
|
||||
*/
|
||||
int
|
||||
encode_rs(dtype *data, dtype *bb)
|
||||
{
|
||||
register int i, j;
|
||||
gf feedback;
|
||||
|
||||
CLEAR(bb, NN - KK);
|
||||
for (i = KK - 1; i >= 0; i--) {
|
||||
#if (MM != 8)
|
||||
if (data[i] > NN) {
|
||||
return -1; /* Illegal symbol */
|
||||
}
|
||||
#endif
|
||||
feedback = Index_of[data[i] ^ bb[NN - KK - 1]];
|
||||
if (feedback != A0) { /* feedback term is non-zero */
|
||||
for (j = NN - KK - 1; j > 0; j--)
|
||||
if (Gg[j] != A0) {
|
||||
bb[j] = bb[j - 1] ^ Alpha_to[modnn(Gg[j] + feedback)];
|
||||
} else {
|
||||
bb[j] = bb[j - 1];
|
||||
}
|
||||
bb[0] = Alpha_to[modnn(Gg[0] + feedback)];
|
||||
} else {
|
||||
/* feedback term is zero. encoder becomes a
|
||||
* single-byte shifter */
|
||||
for (j = NN - KK - 1; j > 0; j--) {
|
||||
bb[j] = bb[j - 1];
|
||||
}
|
||||
bb[0] = 0;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Performs ERRORS+ERASURES decoding of RS codes. If decoding is successful,
|
||||
* writes the codeword into data[] itself. Otherwise data[] is unaltered.
|
||||
*
|
||||
* Return number of symbols corrected, or -1 if codeword is illegal
|
||||
* or uncorrectable.
|
||||
*
|
||||
* First "no_eras" erasures are declared by the calling program. Then, the
|
||||
* maximum # of errors correctable is t_after_eras = floor((NN-KK-no_eras)/2).
|
||||
* If the number of channel errors is not greater than "t_after_eras" the
|
||||
* transmitted codeword will be recovered. Details of algorithm can be found
|
||||
* in R. Blahut's "Theory ... of Error-Correcting Codes".
|
||||
*/
|
||||
int
|
||||
eras_dec_rs(dtype *data, int *eras_pos, int no_eras)
|
||||
{
|
||||
int deg_lambda, el, deg_omega;
|
||||
int i, j, r;
|
||||
gf u, q, tmp, num1, num2, den, discr_r;
|
||||
gf recd[NN];
|
||||
/* Err+Eras Locator poly and syndrome poly */
|
||||
/*gf lambda[NN-KK + 1], s[NN-KK + 1];
|
||||
gf b[NN-KK + 1], t[NN-KK + 1], omega[NN-KK + 1];
|
||||
gf root[NN-KK], reg[NN-KK + 1], loc[NN-KK];*/
|
||||
gf lambda[NN + 1], s[NN + 1];
|
||||
gf b[NN + 1], t[NN + 1], omega[NN + 1];
|
||||
gf root[NN], reg[NN + 1], loc[NN];
|
||||
int syn_error, count;
|
||||
|
||||
/* data[] is in polynomial form, copy and convert to index form */
|
||||
for (i = NN - 1; i >= 0; i--) {
|
||||
#if (MM != 8)
|
||||
if (data[i] > NN) {
|
||||
return -1; /* Illegal symbol */
|
||||
}
|
||||
#endif
|
||||
recd[i] = Index_of[data[i]];
|
||||
}
|
||||
/* first form the syndromes; i.e., evaluate recd(x) at roots of g(x)
|
||||
* namely @**(B0+i), i = 0, ... ,(NN-KK-1)
|
||||
*/
|
||||
syn_error = 0;
|
||||
for (i = 1; i <= NN - KK; i++) {
|
||||
tmp = 0;
|
||||
for (j = 0; j < NN; j++)
|
||||
if (recd[j] != A0) { /* recd[j] in index form */
|
||||
tmp ^= Alpha_to[modnn(recd[j] + (B0 + i - 1) * j)];
|
||||
}
|
||||
syn_error |= tmp; /* set flag if non-zero syndrome =>
|
||||
* error */
|
||||
/* store syndrome in index form */
|
||||
s[i] = Index_of[tmp];
|
||||
}
|
||||
if (!syn_error) {
|
||||
/*
|
||||
* if syndrome is zero, data[] is a codeword and there are no
|
||||
* errors to correct. So return data[] unmodified
|
||||
*/
|
||||
return 0;
|
||||
}
|
||||
CLEAR(&lambda[1], NN - KK);
|
||||
lambda[0] = 1;
|
||||
if (no_eras > 0) {
|
||||
/* Init lambda to be the erasure locator polynomial */
|
||||
lambda[1] = Alpha_to[eras_pos[0]];
|
||||
for (i = 1; i < no_eras; i++) {
|
||||
u = eras_pos[i];
|
||||
for (j = i + 1; j > 0; j--) {
|
||||
tmp = Index_of[lambda[j - 1]];
|
||||
if (tmp != A0) {
|
||||
lambda[j] ^= Alpha_to[modnn(u + tmp)];
|
||||
}
|
||||
}
|
||||
}
|
||||
#ifdef ERASURE_DEBUG
|
||||
/* find roots of the erasure location polynomial */
|
||||
for (i = 1; i <= no_eras; i++) {
|
||||
reg[i] = Index_of[lambda[i]];
|
||||
}
|
||||
count = 0;
|
||||
for (i = 1; i <= NN; i++) {
|
||||
q = 1;
|
||||
for (j = 1; j <= no_eras; j++)
|
||||
if (reg[j] != A0) {
|
||||
reg[j] = modnn(reg[j] + j);
|
||||
q ^= Alpha_to[reg[j]];
|
||||
}
|
||||
if (!q) {
|
||||
/* store root and error location
|
||||
* number indices
|
||||
*/
|
||||
root[count] = i;
|
||||
loc[count] = NN - i;
|
||||
count++;
|
||||
}
|
||||
}
|
||||
if (count != no_eras) {
|
||||
printf("\n lambda(x) is WRONG\n");
|
||||
return -1;
|
||||
}
|
||||
#ifndef NO_PRINT
|
||||
printf("\n Erasure positions as determined by roots of Eras Loc Poly:\n");
|
||||
for (i = 0; i < count; i++) {
|
||||
printf("%d ", loc[i]);
|
||||
}
|
||||
printf("\n");
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
for (i = 0; i < NN - KK + 1; i++) {
|
||||
b[i] = Index_of[lambda[i]];
|
||||
}
|
||||
|
||||
/*
|
||||
* Begin Berlekamp-Massey algorithm to determine error+erasure
|
||||
* locator polynomial
|
||||
*/
|
||||
r = no_eras;
|
||||
el = no_eras;
|
||||
while (++r <= NN - KK) { /* r is the step number */
|
||||
/* Compute discrepancy at the r-th step in poly-form */
|
||||
discr_r = 0;
|
||||
for (i = 0; i < r; i++) {
|
||||
if ((lambda[i] != 0) && (s[r - i] != A0)) {
|
||||
discr_r ^= Alpha_to[modnn(Index_of[lambda[i]] + s[r - i])];
|
||||
}
|
||||
}
|
||||
discr_r = Index_of[discr_r]; /* Index form */
|
||||
if (discr_r == A0) {
|
||||
/* 2 lines below: B(x) <-- x*B(x) */
|
||||
COPYDOWN(&b[1], b, NN - KK);
|
||||
b[0] = A0;
|
||||
} else {
|
||||
/* 7 lines below: T(x) <-- lambda(x) - discr_r*x*b(x) */
|
||||
t[0] = lambda[0];
|
||||
for (i = 0 ; i < NN - KK; i++) {
|
||||
if (b[i] != A0) {
|
||||
t[i + 1] = lambda[i + 1] ^ Alpha_to[modnn(discr_r + b[i])];
|
||||
} else {
|
||||
t[i + 1] = lambda[i + 1];
|
||||
}
|
||||
}
|
||||
if (2 * el <= r + no_eras - 1) {
|
||||
el = r + no_eras - el;
|
||||
/*
|
||||
* 2 lines below: B(x) <-- inv(discr_r) *
|
||||
* lambda(x)
|
||||
*/
|
||||
for (i = 0; i <= NN - KK; i++) {
|
||||
b[i] = (lambda[i] == 0) ? A0 : modnn(Index_of[lambda[i]] - discr_r + NN);
|
||||
}
|
||||
} else {
|
||||
/* 2 lines below: B(x) <-- x*B(x) */
|
||||
COPYDOWN(&b[1], b, NN - KK);
|
||||
b[0] = A0;
|
||||
}
|
||||
COPY(lambda, t, NN - KK + 1);
|
||||
}
|
||||
}
|
||||
|
||||
/* Convert lambda to index form and compute deg(lambda(x)) */
|
||||
deg_lambda = 0;
|
||||
for (i = 0; i < NN - KK + 1; i++) {
|
||||
lambda[i] = Index_of[lambda[i]];
|
||||
if (lambda[i] != A0) {
|
||||
deg_lambda = i;
|
||||
}
|
||||
}
|
||||
/*
|
||||
* Find roots of the error+erasure locator polynomial. By Chien
|
||||
* Search
|
||||
*/
|
||||
COPY(®[1], &lambda[1], NN - KK);
|
||||
count = 0; /* Number of roots of lambda(x) */
|
||||
for (i = 1; i <= NN; i++) {
|
||||
q = 1;
|
||||
for (j = deg_lambda; j > 0; j--)
|
||||
if (reg[j] != A0) {
|
||||
reg[j] = modnn(reg[j] + j);
|
||||
q ^= Alpha_to[reg[j]];
|
||||
}
|
||||
if (!q) {
|
||||
/* store root (index-form) and error location number */
|
||||
root[count] = i;
|
||||
loc[count] = NN - i;
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
printf("\n Final error positions:\t");
|
||||
for (i = 0; i < count; i++) {
|
||||
printf("%d ", loc[i]);
|
||||
}
|
||||
printf("\n");
|
||||
#endif
|
||||
if (deg_lambda != count) {
|
||||
/*
|
||||
* deg(lambda) unequal to number of roots => uncorrectable
|
||||
* error detected
|
||||
*/
|
||||
return -1;
|
||||
}
|
||||
/*
|
||||
* Compute err+eras evaluator poly omega(x) = s(x)*lambda(x) (modulo
|
||||
* x**(NN-KK)). in index form. Also find deg(omega).
|
||||
*/
|
||||
deg_omega = 0;
|
||||
for (i = 0; i < NN - KK; i++) {
|
||||
tmp = 0;
|
||||
j = (deg_lambda < i) ? deg_lambda : i;
|
||||
for (; j >= 0; j--) {
|
||||
if ((s[i + 1 - j] != A0) && (lambda[j] != A0)) {
|
||||
tmp ^= Alpha_to[modnn(s[i + 1 - j] + lambda[j])];
|
||||
}
|
||||
}
|
||||
if (tmp != 0) {
|
||||
deg_omega = i;
|
||||
}
|
||||
omega[i] = Index_of[tmp];
|
||||
}
|
||||
omega[NN - KK] = A0;
|
||||
|
||||
/*
|
||||
* Compute error values in poly-form. num1 = omega(inv(X(l))), num2 =
|
||||
* inv(X(l))**(B0-1) and den = lambda_pr(inv(X(l))) all in poly-form
|
||||
*/
|
||||
for (j = count - 1; j >= 0; j--) {
|
||||
num1 = 0;
|
||||
for (i = deg_omega; i >= 0; i--) {
|
||||
if (omega[i] != A0) {
|
||||
num1 ^= Alpha_to[modnn(omega[i] + i * root[j])];
|
||||
}
|
||||
}
|
||||
num2 = Alpha_to[modnn(root[j] * (B0 - 1) + NN)];
|
||||
den = 0;
|
||||
|
||||
/* lambda[i+1] for i even is the formal derivative lambda_pr of lambda[i] */
|
||||
for (i = min(deg_lambda, NN - KK - 1) & ~1; i >= 0; i -= 2) {
|
||||
if (lambda[i + 1] != A0) {
|
||||
den ^= Alpha_to[modnn(lambda[i + 1] + i * root[j])];
|
||||
}
|
||||
}
|
||||
if (den == 0) {
|
||||
#ifdef DEBUG
|
||||
printf("\n ERROR: denominator = 0\n");
|
||||
#endif
|
||||
return -1;
|
||||
}
|
||||
/* Apply error to data */
|
||||
if (num1 != 0) {
|
||||
data[loc[j]] ^= Alpha_to[modnn(Index_of[num1] + Index_of[num2] + NN -
|
||||
Index_of[den])];
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
|
||||
#endif /* USE_JPWL */
|
|
@ -1,113 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
|
||||
* Copyright (c) 2005-2006, Dept. of Electronic and Information Engineering, Universita' degli Studi di Perugia, Italy
|
||||
* 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 USE_JPWL
|
||||
|
||||
/**
|
||||
@file rs.h
|
||||
@brief Functions used to compute Reed-Solomon parity and check of byte arrays
|
||||
|
||||
*/
|
||||
|
||||
#ifndef __RS_HEADER__
|
||||
#define __RS_HEADER__
|
||||
|
||||
/** Global definitions for Reed-Solomon encoder/decoder
|
||||
* Phil Karn KA9Q, September 1996
|
||||
*
|
||||
* The parameters MM and KK specify the Reed-Solomon code parameters.
|
||||
*
|
||||
* Set MM to be the size of each code symbol in bits. The Reed-Solomon
|
||||
* block size will then be NN = 2**M - 1 symbols. Supported values are
|
||||
* defined in rs.c.
|
||||
*
|
||||
* Set KK to be the number of data symbols in each block, which must be
|
||||
* less than the block size. The code will then be able to correct up
|
||||
* to NN-KK erasures or (NN-KK)/2 errors, or combinations thereof with
|
||||
* each error counting as two erasures.
|
||||
*/
|
||||
#define MM 8 /* RS code over GF(2**MM) - change to suit */
|
||||
|
||||
/* KK defined in rs.c */
|
||||
|
||||
#define NN ((1 << MM) - 1)
|
||||
|
||||
#if (MM <= 8)
|
||||
typedef unsigned char dtype;
|
||||
#else
|
||||
typedef unsigned int dtype;
|
||||
#endif
|
||||
|
||||
/** Initialization function */
|
||||
void init_rs(int);
|
||||
|
||||
/** These two functions *must* be called in this order (e.g.,
|
||||
* by init_rs()) before any encoding/decoding
|
||||
*/
|
||||
void generate_gf(void); /* Generate Galois Field */
|
||||
void gen_poly(void); /* Generate generator polynomial */
|
||||
|
||||
/** Reed-Solomon encoding
|
||||
* data[] is the input block, parity symbols are placed in bb[]
|
||||
* bb[] may lie past the end of the data, e.g., for (255,223):
|
||||
* encode_rs(&data[0],&data[223]);
|
||||
*/
|
||||
int encode_rs(dtype data[], dtype bb[]);
|
||||
|
||||
/** Reed-Solomon erasures-and-errors decoding
|
||||
* The received block goes into data[], and a list of zero-origin
|
||||
* erasure positions, if any, goes in eras_pos[] with a count in no_eras.
|
||||
*
|
||||
* The decoder corrects the symbols in place, if possible and returns
|
||||
* the number of corrected symbols. If the codeword is illegal or
|
||||
* uncorrectible, the data array is unchanged and -1 is returned
|
||||
*/
|
||||
int eras_dec_rs(dtype data[], int eras_pos[], int no_eras);
|
||||
|
||||
/**
|
||||
Computes the minimum between two integers
|
||||
@param a first integer to compare
|
||||
@param b second integer to compare
|
||||
@return returns the minimum integer between a and b
|
||||
*/
|
||||
#ifndef min
|
||||
#define min(a,b) (((a) < (b)) ? (a) : (b))
|
||||
#endif /* min */
|
||||
|
||||
#endif /* __RS_HEADER__ */
|
||||
|
||||
|
||||
#endif /* USE_JPWL */
|
|
@ -1,64 +0,0 @@
|
|||
# openmj2:
|
||||
set(OPENMJ2_LIBRARY_NAME openmj2)
|
||||
|
||||
include_directories(
|
||||
${OPENJPEG_BINARY_DIR}/src/lib/openjp2 # opj_config.h
|
||||
)
|
||||
|
||||
set(OPENMJ2_SRCS
|
||||
mj2.c
|
||||
mj2_convert.c
|
||||
# FIXME: legacy
|
||||
j2k_lib.c
|
||||
cio.c
|
||||
jp2.c
|
||||
j2k.c
|
||||
tcd.c
|
||||
mct.c
|
||||
t1.c
|
||||
t2.c
|
||||
pi.c
|
||||
bio.c
|
||||
mqc.c
|
||||
tgt.c
|
||||
dwt.c
|
||||
event.c
|
||||
image.c
|
||||
jpt.c
|
||||
raw.c
|
||||
openjpeg.c
|
||||
)
|
||||
|
||||
# Build the library
|
||||
if(WIN32)
|
||||
if(BUILD_SHARED_LIBS)
|
||||
add_definitions(-DOPJ_EXPORTS)
|
||||
else()
|
||||
add_definitions(-DOPJ_STATIC)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# build mj2 lib:
|
||||
add_library(${OPENMJ2_LIBRARY_NAME} ${OPENMJ2_SRCS})
|
||||
# FIXME: We are using an openjpeg 1.5 copy:
|
||||
#target_link_libraries(${OPENMJ2_LIBRARY_NAME} openjp2)
|
||||
if(UNIX)
|
||||
target_link_libraries(${OPENMJ2_LIBRARY_NAME} m)
|
||||
endif()
|
||||
set_target_properties(${OPENMJ2_LIBRARY_NAME} PROPERTIES ${OPENJPEG_LIBRARY_PROPERTIES})
|
||||
if(NOT ${CMAKE_VERSION} VERSION_LESS "2.8.12")
|
||||
target_compile_options(${OPENMJ2_LIBRARY_NAME} PRIVATE ${OPENJPEG_LIBRARY_COMPILE_OPTIONS})
|
||||
endif()
|
||||
|
||||
# Install library
|
||||
install(TARGETS ${OPENMJ2_LIBRARY_NAME}
|
||||
EXPORT OpenMJ2Targets
|
||||
DESTINATION ${OPENJPEG_INSTALL_LIB_DIR}
|
||||
COMPONENT Libraries
|
||||
)
|
||||
|
||||
# Install includes files
|
||||
#install(FILES mj2.h
|
||||
# DESTINATION ${OPENJPEG_INSTALL_INCLUDE_DIR}/${subdir}
|
||||
# COMPONENT Headers
|
||||
#)
|
|
@ -1,206 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2014, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux
|
||||
* Copyright (c) 2003-2014, Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* 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"
|
||||
|
||||
/** @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, int b);
|
||||
/**
|
||||
Read a bit
|
||||
@param bio BIO handle
|
||||
@return Returns the read bit
|
||||
*/
|
||||
static int bio_getbit(opj_bio_t *bio);
|
||||
/**
|
||||
Write a byte
|
||||
@param bio BIO handle
|
||||
@return Returns 0 if successful, returns 1 otherwise
|
||||
*/
|
||||
static int bio_byteout(opj_bio_t *bio);
|
||||
/**
|
||||
Read a byte
|
||||
@param bio BIO handle
|
||||
@return Returns 0 if successful, returns 1 otherwise
|
||||
*/
|
||||
static int bio_bytein(opj_bio_t *bio);
|
||||
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
local functions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
static int 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 1;
|
||||
}
|
||||
*bio->bp++ = bio->buf >> 8;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int 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 1;
|
||||
}
|
||||
bio->buf |= *bio->bp++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void bio_putbit(opj_bio_t *bio, int b)
|
||||
{
|
||||
if (bio->ct == 0) {
|
||||
bio_byteout(bio);
|
||||
}
|
||||
bio->ct--;
|
||||
bio->buf |= b << bio->ct;
|
||||
}
|
||||
|
||||
static int 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);
|
||||
}
|
||||
}
|
||||
|
||||
int bio_numbytes(opj_bio_t *bio)
|
||||
{
|
||||
return (bio->bp - bio->start);
|
||||
}
|
||||
|
||||
void bio_init_enc(opj_bio_t *bio, unsigned char *bp, int 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, unsigned char *bp, int len)
|
||||
{
|
||||
bio->start = bp;
|
||||
bio->end = bp + len;
|
||||
bio->bp = bp;
|
||||
bio->buf = 0;
|
||||
bio->ct = 0;
|
||||
}
|
||||
|
||||
void bio_write(opj_bio_t *bio, int v, int n)
|
||||
{
|
||||
int i;
|
||||
for (i = n - 1; i >= 0; i--) {
|
||||
bio_putbit(bio, (v >> i) & 1);
|
||||
}
|
||||
}
|
||||
|
||||
int bio_read(opj_bio_t *bio, int n)
|
||||
{
|
||||
int i, v;
|
||||
v = 0;
|
||||
for (i = n - 1; i >= 0; i--) {
|
||||
v += bio_getbit(bio) << i;
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
int bio_flush(opj_bio_t *bio)
|
||||
{
|
||||
bio->ct = 0;
|
||||
if (bio_byteout(bio)) {
|
||||
return 1;
|
||||
}
|
||||
if (bio->ct == 7) {
|
||||
bio->ct = 0;
|
||||
if (bio_byteout(bio)) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int bio_inalign(opj_bio_t *bio)
|
||||
{
|
||||
bio->ct = 0;
|
||||
if ((bio->buf & 0xff) == 0xff) {
|
||||
if (bio_bytein(bio)) {
|
||||
return 1;
|
||||
}
|
||||
bio->ct = 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
|
@ -1,131 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2014, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux
|
||||
* Copyright (c) 2003-2014, Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/** @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 */
|
||||
unsigned char *start;
|
||||
/** pointer to the end of the buffer */
|
||||
unsigned char *end;
|
||||
/** pointer to the present position in the buffer */
|
||||
unsigned char *bp;
|
||||
/** temporary place where each byte is read or written */
|
||||
unsigned int buf;
|
||||
/** coder : number of bits free to write. decoder : number of bits read */
|
||||
int 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
|
||||
*/
|
||||
int 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, unsigned char *bp, int len);
|
||||
/**
|
||||
Init decoder
|
||||
@param bio BIO handle
|
||||
@param bp Input buffer
|
||||
@param len Input buffer length
|
||||
*/
|
||||
void bio_init_dec(opj_bio_t *bio, unsigned char *bp, int 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, int v, int n);
|
||||
/**
|
||||
Read bits
|
||||
@param bio BIO handle
|
||||
@param n Number of bits to read
|
||||
@return Returns the corresponding read number
|
||||
*/
|
||||
int bio_read(opj_bio_t *bio, int n);
|
||||
/**
|
||||
Flush bits
|
||||
@param bio BIO handle
|
||||
@return Returns 1 if successful, returns 0 otherwise
|
||||
*/
|
||||
int 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
|
||||
*/
|
||||
int bio_inalign(opj_bio_t *bio);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __BIO_H */
|
||||
|
|
@ -1,214 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2014, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux
|
||||
* Copyright (c) 2003-2014, Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* 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"
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
opj_cio_t* OPJ_CALLCONV opj_cio_open(opj_common_ptr cinfo,
|
||||
unsigned char *buffer, int length)
|
||||
{
|
||||
opj_cp_t *cp = NULL;
|
||||
opj_cio_t *cio = (opj_cio_t*)opj_malloc(sizeof(opj_cio_t));
|
||||
if (!cio) {
|
||||
return NULL;
|
||||
}
|
||||
cio->cinfo = cinfo;
|
||||
if (buffer && length) {
|
||||
/* wrap a user buffer containing the encoded image */
|
||||
cio->openmode = OPJ_STREAM_READ;
|
||||
cio->buffer = buffer;
|
||||
cio->length = length;
|
||||
} else if (!buffer && !length && cinfo) {
|
||||
/* allocate a buffer for the encoded image */
|
||||
cio->openmode = OPJ_STREAM_WRITE;
|
||||
switch (cinfo->codec_format) {
|
||||
case CODEC_J2K:
|
||||
cp = ((opj_j2k_t*)cinfo->j2k_handle)->cp;
|
||||
break;
|
||||
case CODEC_JP2:
|
||||
cp = ((opj_jp2_t*)cinfo->jp2_handle)->j2k->cp;
|
||||
break;
|
||||
default:
|
||||
opj_free(cio);
|
||||
return NULL;
|
||||
}
|
||||
cio->length = (unsigned int)(0.1625 * cp->img_size +
|
||||
2000); /* 0.1625 = 1.3/8 and 2000 bytes as a minimum for headers */
|
||||
cio->buffer = (unsigned char *)opj_malloc(cio->length);
|
||||
if (!cio->buffer) {
|
||||
opj_event_msg(cio->cinfo, EVT_ERROR,
|
||||
"Error allocating memory for compressed bitstream\n");
|
||||
opj_free(cio);
|
||||
return NULL;
|
||||
}
|
||||
} else {
|
||||
opj_free(cio);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Initialize byte IO */
|
||||
cio->start = cio->buffer;
|
||||
cio->end = cio->buffer + cio->length;
|
||||
cio->bp = cio->buffer;
|
||||
|
||||
return cio;
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_cio_close(opj_cio_t *cio)
|
||||
{
|
||||
if (cio) {
|
||||
if (cio->openmode == OPJ_STREAM_WRITE) {
|
||||
/* destroy the allocated buffer */
|
||||
opj_free(cio->buffer);
|
||||
}
|
||||
/* destroy the cio */
|
||||
opj_free(cio);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/*
|
||||
* Get position in byte stream.
|
||||
*/
|
||||
int OPJ_CALLCONV cio_tell(opj_cio_t *cio)
|
||||
{
|
||||
return cio->bp - cio->start;
|
||||
}
|
||||
|
||||
/*
|
||||
* Set position in byte stream.
|
||||
*
|
||||
* pos : position, in number of bytes, from the beginning of the stream
|
||||
*/
|
||||
void OPJ_CALLCONV cio_seek(opj_cio_t *cio, int pos)
|
||||
{
|
||||
cio->bp = cio->start + pos;
|
||||
}
|
||||
|
||||
/*
|
||||
* Number of bytes left before the end of the stream.
|
||||
*/
|
||||
int cio_numbytesleft(opj_cio_t *cio)
|
||||
{
|
||||
return cio->end - cio->bp;
|
||||
}
|
||||
|
||||
/*
|
||||
* Get pointer to the current position in the stream.
|
||||
*/
|
||||
unsigned char *cio_getbp(opj_cio_t *cio)
|
||||
{
|
||||
return cio->bp;
|
||||
}
|
||||
|
||||
/*
|
||||
* Write a byte.
|
||||
*/
|
||||
opj_bool cio_byteout(opj_cio_t *cio, unsigned char v)
|
||||
{
|
||||
if (cio->bp >= cio->end) {
|
||||
opj_event_msg(cio->cinfo, EVT_ERROR, "write error\n");
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
*cio->bp++ = v;
|
||||
return OPJ_TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read a byte.
|
||||
*/
|
||||
unsigned char cio_bytein(opj_cio_t *cio)
|
||||
{
|
||||
if (cio->bp >= cio->end) {
|
||||
opj_event_msg(cio->cinfo, EVT_ERROR,
|
||||
"read error: passed the end of the codestream (start = %d, current = %d, end = %d\n",
|
||||
cio->start, cio->bp, cio->end);
|
||||
return 0;
|
||||
}
|
||||
return *cio->bp++;
|
||||
}
|
||||
|
||||
/*
|
||||
* Write some bytes.
|
||||
*
|
||||
* v : value to write
|
||||
* n : number of bytes to write
|
||||
*/
|
||||
unsigned int OPJ_CALLCONV cio_write(opj_cio_t *cio, unsigned int64 v, int n)
|
||||
{
|
||||
int i;
|
||||
for (i = n - 1; i >= 0; i--) {
|
||||
if (!cio_byteout(cio, (unsigned char)((v >> (i << 3)) & 0xff))) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read some bytes.
|
||||
*
|
||||
* n : number of bytes to read
|
||||
*
|
||||
* return : value of the n bytes read
|
||||
*/
|
||||
unsigned int OPJ_CALLCONV cio_read(opj_cio_t *cio, int n)
|
||||
{
|
||||
int i;
|
||||
unsigned int v;
|
||||
v = 0;
|
||||
for (i = n - 1; i >= 0; i--) {
|
||||
v += cio_bytein(cio) << (i << 3);
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
/*
|
||||
* Skip some bytes.
|
||||
*
|
||||
* n : number of bytes to skip
|
||||
*/
|
||||
void OPJ_CALLCONV cio_skip(opj_cio_t *cio, int n)
|
||||
{
|
||||
cio->bp += n;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,100 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2014, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux
|
||||
* Copyright (c) 2003-2014, Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* 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
|
||||
|
||||
#if defined(_MSC_VER) || defined(__BORLANDC__)
|
||||
#define int64 __int64
|
||||
#else
|
||||
#define int64 long long
|
||||
#endif
|
||||
|
||||
/**
|
||||
@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 */
|
||||
/*@{*/
|
||||
|
||||
/** @name Exported functions (see also openjpeg.h) */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Number of bytes left before the end of the stream
|
||||
@param cio CIO handle
|
||||
@return Returns the number of bytes before the end of the stream
|
||||
*/
|
||||
int cio_numbytesleft(opj_cio_t *cio);
|
||||
/**
|
||||
Get pointer to the current position in the stream
|
||||
@param cio CIO handle
|
||||
@return Returns a pointer to the current position
|
||||
*/
|
||||
unsigned char *cio_getbp(opj_cio_t *cio);
|
||||
/**
|
||||
Write some bytes
|
||||
@param cio CIO handle
|
||||
@param v Value to write
|
||||
@param n Number of bytes to write
|
||||
@return Returns the number of bytes written or 0 if an error occurred
|
||||
*/
|
||||
OPJ_API unsigned int OPJ_CALLCONV cio_write(opj_cio_t *cio, unsigned int64 v,
|
||||
int n);
|
||||
/**
|
||||
Read some bytes
|
||||
@param cio CIO handle
|
||||
@param n Number of bytes to read
|
||||
@return Returns the value of the n bytes read
|
||||
*/
|
||||
OPJ_API unsigned int OPJ_CALLCONV cio_read(opj_cio_t *cio, int n);
|
||||
/**
|
||||
Skip some bytes
|
||||
@param cio CIO handle
|
||||
@param n Number of bytes to skip
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV cio_skip(opj_cio_t *cio, int n);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __CIO_H */
|
||||
|
|
@ -1,965 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2014, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux
|
||||
* Copyright (c) 2003-2014, Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2007, Jonathan Ballard <dzonatas@dzonux.net>
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifdef __SSE__
|
||||
#include <xmmintrin.h>
|
||||
#endif
|
||||
|
||||
#include "opj_includes.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 {
|
||||
int* mem;
|
||||
int dn;
|
||||
int sn;
|
||||
int cas;
|
||||
} dwt_t;
|
||||
|
||||
typedef union {
|
||||
float f[4];
|
||||
} v4;
|
||||
|
||||
typedef struct v4dwt_local {
|
||||
v4* wavelet ;
|
||||
int dn ;
|
||||
int sn ;
|
||||
int cas ;
|
||||
} v4dwt_t ;
|
||||
|
||||
static const float dwt_alpha = 1.586134342f; /* 12994 */
|
||||
static const float dwt_beta = 0.052980118f; /* 434 */
|
||||
static const float dwt_gamma = -0.882911075f; /* -7233 */
|
||||
static const float dwt_delta = -0.443506852f; /* -3633 */
|
||||
|
||||
static const float K = 1.230174105f; /* 10078 */
|
||||
/* FIXME: What is this constant? */
|
||||
static const float 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(int *a, int *b, int dn, int sn, int cas);
|
||||
/**
|
||||
Forward lazy transform (vertical)
|
||||
*/
|
||||
static void dwt_deinterleave_v(int *a, int *b, int dn, int sn, int x, int cas);
|
||||
/**
|
||||
Inverse lazy transform (horizontal)
|
||||
*/
|
||||
static void dwt_interleave_h(dwt_t* h, int *a);
|
||||
/**
|
||||
Inverse lazy transform (vertical)
|
||||
*/
|
||||
static void dwt_interleave_v(dwt_t* v, int *a, int x);
|
||||
/**
|
||||
Forward 5-3 wavelet transform in 1-D
|
||||
*/
|
||||
static void dwt_encode_1(int *a, int dn, int sn, int 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(int *a, int dn, int sn, int cas);
|
||||
/**
|
||||
Explicit calculation of the Quantization Stepsizes
|
||||
*/
|
||||
static void dwt_encode_stepsize(int stepsize, int numbps,
|
||||
opj_stepsize_t *bandno_stepsize);
|
||||
/**
|
||||
Inverse wavelet transform in 2-D.
|
||||
*/
|
||||
static void dwt_decode_tile(opj_tcd_tilecomp_t* tilec, int i, DWT1DFN fn);
|
||||
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#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 double 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 double 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(int *a, int *b, int dn, int sn, int cas)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < sn; i++) {
|
||||
b[i] = a[2 * i + cas];
|
||||
}
|
||||
for (i = 0; i < dn; i++) {
|
||||
b[sn + i] = a[(2 * i + 1 - cas)];
|
||||
}
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Forward lazy transform (vertical). */
|
||||
/* </summary> */
|
||||
static void dwt_deinterleave_v(int *a, int *b, int dn, int sn, int x, int cas)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < sn; i++) {
|
||||
b[i * x] = a[2 * i + cas];
|
||||
}
|
||||
for (i = 0; i < dn; i++) {
|
||||
b[(sn + i)*x] = a[(2 * i + 1 - cas)];
|
||||
}
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Inverse lazy transform (horizontal). */
|
||||
/* </summary> */
|
||||
static void dwt_interleave_h(dwt_t* h, int *a)
|
||||
{
|
||||
int *ai = a;
|
||||
int *bi = h->mem + h->cas;
|
||||
int 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, int *a, int x)
|
||||
{
|
||||
int *ai = a;
|
||||
int *bi = v->mem + v->cas;
|
||||
int 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(int *a, int dn, int sn, int cas)
|
||||
{
|
||||
int 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_(int *a, int dn, int sn, int cas)
|
||||
{
|
||||
int 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(int *a, int dn, int sn, int cas)
|
||||
{
|
||||
int 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(int stepsize, int numbps,
|
||||
opj_stepsize_t *bandno_stepsize)
|
||||
{
|
||||
int 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> */
|
||||
void dwt_encode(opj_tcd_tilecomp_t * tilec)
|
||||
{
|
||||
int i, j, k;
|
||||
int *a = NULL;
|
||||
int *aj = NULL;
|
||||
int *bj = NULL;
|
||||
int w, l;
|
||||
|
||||
w = tilec->x1 - tilec->x0;
|
||||
l = tilec->numresolutions - 1;
|
||||
a = tilec->data;
|
||||
|
||||
for (i = 0; i < l; i++) {
|
||||
int rw; /* width of the resolution level computed */
|
||||
int rh; /* height of the resolution level computed */
|
||||
int rw1; /* width of the resolution level once lower than computed one */
|
||||
int rh1; /* height of the resolution level once lower than computed one */
|
||||
int cas_col; /* 0 = non inversion on horizontal filtering 1 = inversion between low-pass and high-pass filtering */
|
||||
int cas_row; /* 0 = non inversion on vertical filtering 1 = inversion between low-pass and high-pass filtering */
|
||||
int dn, sn;
|
||||
|
||||
rw = tilec->resolutions[l - i].x1 - tilec->resolutions[l - i].x0;
|
||||
rh = tilec->resolutions[l - i].y1 - tilec->resolutions[l - i].y0;
|
||||
rw1 = tilec->resolutions[l - i - 1].x1 - tilec->resolutions[l - i - 1].x0;
|
||||
rh1 = tilec->resolutions[l - i - 1].y1 - tilec->resolutions[l - i - 1].y0;
|
||||
|
||||
cas_row = tilec->resolutions[l - i].x0 % 2;
|
||||
cas_col = tilec->resolutions[l - i].y0 % 2;
|
||||
|
||||
sn = rh1;
|
||||
dn = rh - rh1;
|
||||
bj = (int*)opj_malloc(rh * sizeof(int));
|
||||
for (j = 0; j < rw; j++) {
|
||||
aj = a + j;
|
||||
for (k = 0; k < rh; k++) {
|
||||
bj[k] = aj[k * w];
|
||||
}
|
||||
dwt_encode_1(bj, dn, sn, cas_col);
|
||||
dwt_deinterleave_v(bj, aj, dn, sn, w, cas_col);
|
||||
}
|
||||
opj_free(bj);
|
||||
|
||||
sn = rw1;
|
||||
dn = rw - rw1;
|
||||
bj = (int*)opj_malloc(rw * sizeof(int));
|
||||
for (j = 0; j < rh; j++) {
|
||||
aj = a + j * w;
|
||||
for (k = 0; k < rw; k++) {
|
||||
bj[k] = aj[k];
|
||||
}
|
||||
dwt_encode_1(bj, dn, sn, cas_row);
|
||||
dwt_deinterleave_h(bj, aj, dn, sn, cas_row);
|
||||
}
|
||||
opj_free(bj);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* <summary> */
|
||||
/* Inverse 5-3 wavelet transform in 2-D. */
|
||||
/* </summary> */
|
||||
void dwt_decode(opj_tcd_tilecomp_t* tilec, int numres)
|
||||
{
|
||||
dwt_decode_tile(tilec, numres, &dwt_decode_1);
|
||||
}
|
||||
|
||||
|
||||
/* <summary> */
|
||||
/* Get gain of 5-3 wavelet transform. */
|
||||
/* </summary> */
|
||||
int dwt_getgain(int orient)
|
||||
{
|
||||
if (orient == 0) {
|
||||
return 0;
|
||||
}
|
||||
if (orient == 1 || orient == 2) {
|
||||
return 1;
|
||||
}
|
||||
return 2;
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Get norm of 5-3 wavelet. */
|
||||
/* </summary> */
|
||||
double dwt_getnorm(int level, int orient)
|
||||
{
|
||||
return dwt_norms[orient][level];
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Forward 9-7 wavelet transform in 2-D. */
|
||||
/* </summary> */
|
||||
|
||||
void dwt_encode_real(opj_tcd_tilecomp_t * tilec)
|
||||
{
|
||||
int i, j, k;
|
||||
int *a = NULL;
|
||||
int *aj = NULL;
|
||||
int *bj = NULL;
|
||||
int w, l;
|
||||
|
||||
w = tilec->x1 - tilec->x0;
|
||||
l = tilec->numresolutions - 1;
|
||||
a = tilec->data;
|
||||
|
||||
for (i = 0; i < l; i++) {
|
||||
int rw; /* width of the resolution level computed */
|
||||
int rh; /* height of the resolution level computed */
|
||||
int rw1; /* width of the resolution level once lower than computed one */
|
||||
int rh1; /* height of the resolution level once lower than computed one */
|
||||
int cas_col; /* 0 = non inversion on horizontal filtering 1 = inversion between low-pass and high-pass filtering */
|
||||
int cas_row; /* 0 = non inversion on vertical filtering 1 = inversion between low-pass and high-pass filtering */
|
||||
int dn, sn;
|
||||
|
||||
rw = tilec->resolutions[l - i].x1 - tilec->resolutions[l - i].x0;
|
||||
rh = tilec->resolutions[l - i].y1 - tilec->resolutions[l - i].y0;
|
||||
rw1 = tilec->resolutions[l - i - 1].x1 - tilec->resolutions[l - i - 1].x0;
|
||||
rh1 = tilec->resolutions[l - i - 1].y1 - tilec->resolutions[l - i - 1].y0;
|
||||
|
||||
cas_row = tilec->resolutions[l - i].x0 % 2;
|
||||
cas_col = tilec->resolutions[l - i].y0 % 2;
|
||||
|
||||
sn = rh1;
|
||||
dn = rh - rh1;
|
||||
bj = (int*)opj_malloc(rh * sizeof(int));
|
||||
for (j = 0; j < rw; j++) {
|
||||
aj = a + j;
|
||||
for (k = 0; k < rh; k++) {
|
||||
bj[k] = aj[k * w];
|
||||
}
|
||||
dwt_encode_1_real(bj, dn, sn, cas_col);
|
||||
dwt_deinterleave_v(bj, aj, dn, sn, w, cas_col);
|
||||
}
|
||||
opj_free(bj);
|
||||
|
||||
sn = rw1;
|
||||
dn = rw - rw1;
|
||||
bj = (int*)opj_malloc(rw * sizeof(int));
|
||||
for (j = 0; j < rh; j++) {
|
||||
aj = a + j * w;
|
||||
for (k = 0; k < rw; k++) {
|
||||
bj[k] = aj[k];
|
||||
}
|
||||
dwt_encode_1_real(bj, dn, sn, cas_row);
|
||||
dwt_deinterleave_h(bj, aj, dn, sn, cas_row);
|
||||
}
|
||||
opj_free(bj);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* <summary> */
|
||||
/* Get gain of 9-7 wavelet transform. */
|
||||
/* </summary> */
|
||||
int dwt_getgain_real(int orient)
|
||||
{
|
||||
(void)orient;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Get norm of 9-7 wavelet. */
|
||||
/* </summary> */
|
||||
double dwt_getnorm_real(int level, int orient)
|
||||
{
|
||||
return dwt_norms_real[orient][level];
|
||||
}
|
||||
|
||||
void dwt_calc_explicit_stepsizes(opj_tccp_t * tccp, int prec)
|
||||
{
|
||||
int numbands, bandno;
|
||||
numbands = 3 * tccp->numresolutions - 2;
|
||||
for (bandno = 0; bandno < numbands; bandno++) {
|
||||
double stepsize;
|
||||
int resno, level, orient, gain;
|
||||
|
||||
resno = (bandno == 0) ? 0 : ((bandno - 1) / 3 + 1);
|
||||
orient = (bandno == 0) ? 0 : ((bandno - 1) % 3 + 1);
|
||||
level = tccp->numresolutions - 1 - resno;
|
||||
gain = (tccp->qmfbid == 0) ? 0 : ((orient == 0) ? 0 : (((orient == 1) ||
|
||||
(orient == 2)) ? 1 : 2));
|
||||
if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
|
||||
stepsize = 1.0;
|
||||
} else {
|
||||
double norm = dwt_norms_real[orient][level];
|
||||
stepsize = (1 << (gain)) / norm;
|
||||
}
|
||||
dwt_encode_stepsize((int) floor(stepsize * 8192.0), prec + gain,
|
||||
&tccp->stepsizes[bandno]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* <summary> */
|
||||
/* Determine maximum computed resolution level for inverse wavelet transform */
|
||||
/* </summary> */
|
||||
static int dwt_decode_max_resolution(opj_tcd_resolution_t* restrict r, int i)
|
||||
{
|
||||
int mr = 1;
|
||||
int 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 void dwt_decode_tile(opj_tcd_tilecomp_t* tilec, int numres,
|
||||
DWT1DFN dwt_1D)
|
||||
{
|
||||
dwt_t h;
|
||||
dwt_t v;
|
||||
|
||||
opj_tcd_resolution_t* tr = tilec->resolutions;
|
||||
|
||||
int rw = tr->x1 - tr->x0; /* width of the resolution level computed */
|
||||
int rh = tr->y1 - tr->y0; /* height of the resolution level computed */
|
||||
|
||||
int w = tilec->x1 - tilec->x0;
|
||||
|
||||
h.mem = (int*)opj_aligned_malloc(dwt_decode_max_resolution(tr,
|
||||
numres) * sizeof(int));
|
||||
v.mem = h.mem;
|
||||
|
||||
while (--numres) {
|
||||
int * restrict tiledp = tilec->data;
|
||||
int 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(int));
|
||||
}
|
||||
|
||||
v.dn = rh - v.sn;
|
||||
v.cas = tr->y0 % 2;
|
||||
|
||||
for (j = 0; j < rw; ++j) {
|
||||
int 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);
|
||||
}
|
||||
|
||||
static void v4dwt_interleave_h(v4dwt_t* restrict w, float* restrict a, int x,
|
||||
int size)
|
||||
{
|
||||
float* restrict bi = (float*)(w->wavelet + w->cas);
|
||||
int count = w->sn;
|
||||
int i, k;
|
||||
for (k = 0; k < 2; ++k) {
|
||||
if (count + 3 * x < size && ((size_t) a & 0x0f) == 0 &&
|
||||
((size_t) bi & 0x0f) == 0 && (x & 0x0f) == 0) {
|
||||
/* Fast code path */
|
||||
for (i = 0; i < count; ++i) {
|
||||
int j = i;
|
||||
bi[i * 8 ] = a[j];
|
||||
j += x;
|
||||
bi[i * 8 + 1] = a[j];
|
||||
j += x;
|
||||
bi[i * 8 + 2] = a[j];
|
||||
j += x;
|
||||
bi[i * 8 + 3] = a[j];
|
||||
}
|
||||
} else {
|
||||
/* Slow code path */
|
||||
for (i = 0; i < count; ++i) {
|
||||
int 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 = (float*)(w->wavelet + 1 - w->cas);
|
||||
a += w->sn;
|
||||
size -= w->sn;
|
||||
count = w->dn;
|
||||
}
|
||||
}
|
||||
|
||||
static void v4dwt_interleave_v(v4dwt_t* restrict v, float* restrict a, int x)
|
||||
{
|
||||
v4* restrict bi = v->wavelet + v->cas;
|
||||
int i;
|
||||
for (i = 0; i < v->sn; ++i) {
|
||||
memcpy(&bi[i * 2], &a[i * x], 4 * sizeof(float));
|
||||
}
|
||||
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(float));
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef __SSE__
|
||||
|
||||
static void v4dwt_decode_step1_sse(v4* w, int count, const __m128 c)
|
||||
{
|
||||
__m128* restrict vw = (__m128*) w;
|
||||
int i;
|
||||
/* 4x unrolled loop */
|
||||
for (i = 0; i < count >> 2; ++i) {
|
||||
*vw = _mm_mul_ps(*vw, c);
|
||||
vw += 2;
|
||||
*vw = _mm_mul_ps(*vw, c);
|
||||
vw += 2;
|
||||
*vw = _mm_mul_ps(*vw, c);
|
||||
vw += 2;
|
||||
*vw = _mm_mul_ps(*vw, c);
|
||||
vw += 2;
|
||||
}
|
||||
count &= 3;
|
||||
for (i = 0; i < count; ++i) {
|
||||
*vw = _mm_mul_ps(*vw, c);
|
||||
vw += 2;
|
||||
}
|
||||
}
|
||||
|
||||
static void v4dwt_decode_step2_sse(v4* l, v4* w, int k, int m, __m128 c)
|
||||
{
|
||||
__m128* restrict vl = (__m128*) l;
|
||||
__m128* restrict vw = (__m128*) w;
|
||||
int i;
|
||||
__m128 tmp1, tmp2, tmp3;
|
||||
tmp1 = vl[0];
|
||||
for (i = 0; i < m; ++i) {
|
||||
tmp2 = vw[-1];
|
||||
tmp3 = vw[ 0];
|
||||
vw[-1] = _mm_add_ps(tmp2, _mm_mul_ps(_mm_add_ps(tmp1, tmp3), c));
|
||||
tmp1 = tmp3;
|
||||
vw += 2;
|
||||
}
|
||||
vl = vw - 2;
|
||||
if (m >= k) {
|
||||
return;
|
||||
}
|
||||
c = _mm_add_ps(c, c);
|
||||
c = _mm_mul_ps(c, vl[0]);
|
||||
for (; m < k; ++m) {
|
||||
__m128 tmp = vw[-1];
|
||||
vw[-1] = _mm_add_ps(tmp, c);
|
||||
vw += 2;
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
static void v4dwt_decode_step1(v4* w, int count, const float c)
|
||||
{
|
||||
float* restrict fw = (float*) w;
|
||||
int i;
|
||||
for (i = 0; i < count; ++i) {
|
||||
float tmp1 = fw[i * 8 ];
|
||||
float tmp2 = fw[i * 8 + 1];
|
||||
float tmp3 = fw[i * 8 + 2];
|
||||
float 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, int k, int m, float c)
|
||||
{
|
||||
float* restrict fl = (float*) l;
|
||||
float* restrict fw = (float*) w;
|
||||
int i;
|
||||
for (i = 0; i < m; ++i) {
|
||||
float tmp1_1 = fl[0];
|
||||
float tmp1_2 = fl[1];
|
||||
float tmp1_3 = fl[2];
|
||||
float tmp1_4 = fl[3];
|
||||
float tmp2_1 = fw[-4];
|
||||
float tmp2_2 = fw[-3];
|
||||
float tmp2_3 = fw[-2];
|
||||
float tmp2_4 = fw[-1];
|
||||
float tmp3_1 = fw[0];
|
||||
float tmp3_2 = fw[1];
|
||||
float tmp3_3 = fw[2];
|
||||
float 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) {
|
||||
float c1;
|
||||
float c2;
|
||||
float c3;
|
||||
float c4;
|
||||
c += c;
|
||||
c1 = fl[0] * c;
|
||||
c2 = fl[1] * c;
|
||||
c3 = fl[2] * c;
|
||||
c4 = fl[3] * c;
|
||||
for (; m < k; ++m) {
|
||||
float tmp1 = fw[-4];
|
||||
float tmp2 = fw[-3];
|
||||
float tmp3 = fw[-2];
|
||||
float 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)
|
||||
{
|
||||
int 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(dwt_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), dwt_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> */
|
||||
void dwt_decode_real(opj_tcd_tilecomp_t* restrict tilec, int numres)
|
||||
{
|
||||
v4dwt_t h;
|
||||
v4dwt_t v;
|
||||
|
||||
opj_tcd_resolution_t* res = tilec->resolutions;
|
||||
|
||||
int rw = res->x1 - res->x0; /* width of the resolution level computed */
|
||||
int rh = res->y1 - res->y0; /* height of the resolution level computed */
|
||||
|
||||
int w = tilec->x1 - tilec->x0;
|
||||
|
||||
h.wavelet = (v4*) opj_aligned_malloc((dwt_decode_max_resolution(res,
|
||||
numres) + 5) * sizeof(v4));
|
||||
v.wavelet = h.wavelet;
|
||||
|
||||
while (--numres) {
|
||||
float * restrict aj = (float*) tilec->data;
|
||||
int bufsize = (tilec->x1 - tilec->x0) * (tilec->y1 - tilec->y0);
|
||||
int 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 % 2;
|
||||
|
||||
for (j = rh; j > 3; j -= 4) {
|
||||
int k;
|
||||
v4dwt_interleave_h(&h, aj, w, bufsize);
|
||||
v4dwt_decode(&h);
|
||||
for (k = rw; --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];
|
||||
}
|
||||
aj += w * 4;
|
||||
bufsize -= w * 4;
|
||||
}
|
||||
if (rh & 0x03) {
|
||||
int k;
|
||||
j = rh & 0x03;
|
||||
v4dwt_interleave_h(&h, aj, w, bufsize);
|
||||
v4dwt_decode(&h);
|
||||
for (k = rw; --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];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
v.dn = rh - v.sn;
|
||||
v.cas = res->y0 % 2;
|
||||
|
||||
aj = (float*) tilec->data;
|
||||
for (j = rw; j > 3; j -= 4) {
|
||||
int k;
|
||||
v4dwt_interleave_v(&v, aj, w);
|
||||
v4dwt_decode(&v);
|
||||
for (k = 0; k < rh; ++k) {
|
||||
memcpy(&aj[k * w], &v.wavelet[k], 4 * sizeof(float));
|
||||
}
|
||||
aj += 4;
|
||||
}
|
||||
if (rw & 0x03) {
|
||||
int k;
|
||||
j = rw & 0x03;
|
||||
v4dwt_interleave_v(&v, aj, w);
|
||||
v4dwt_decode(&v);
|
||||
for (k = 0; k < rh; ++k) {
|
||||
memcpy(&aj[k * w], &v.wavelet[k], j * sizeof(float));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
opj_aligned_free(h.wavelet);
|
||||
}
|
||||
|
|
@ -1,119 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2014, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux
|
||||
* Copyright (c) 2003-2014, Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/** @defgroup DWT DWT - Implementation of a discrete wavelet transform */
|
||||
/*@{*/
|
||||
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Forward 5-3 wavelet transform in 2-D.
|
||||
Apply a reversible DWT transform to a component of an image.
|
||||
@param tilec Tile component information (current tile)
|
||||
*/
|
||||
void dwt_encode(opj_tcd_tilecomp_t * tilec);
|
||||
/**
|
||||
Inverse 5-3 wavelet transform 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
|
||||
*/
|
||||
void dwt_decode(opj_tcd_tilecomp_t* tilec, int 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
|
||||
*/
|
||||
int dwt_getgain(int 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
|
||||
*/
|
||||
double dwt_getnorm(int level, int 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)
|
||||
*/
|
||||
void dwt_encode_real(opj_tcd_tilecomp_t * 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
|
||||
*/
|
||||
void dwt_decode_real(opj_tcd_tilecomp_t* tilec, int 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
|
||||
*/
|
||||
int dwt_getgain_real(int 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
|
||||
*/
|
||||
double dwt_getnorm_real(int level, int orient);
|
||||
/**
|
||||
Explicit calculation of the Quantization Stepsizes
|
||||
@param tccp Tile-component coding parameters
|
||||
@param prec Precint analyzed
|
||||
*/
|
||||
void dwt_calc_explicit_stepsizes(opj_tccp_t * tccp, int prec);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __DWT_H */
|
|
@ -1,137 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 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.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/* ==========================================================
|
||||
Utility functions
|
||||
==========================================================*/
|
||||
|
||||
#ifdef OPJ_CODE_NOT_USED
|
||||
#ifndef _WIN32
|
||||
static char*
|
||||
i2a(unsigned i, char *a, unsigned r)
|
||||
{
|
||||
if (i / r > 0) {
|
||||
a = i2a(i / r, a, r);
|
||||
}
|
||||
*a = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[i % r];
|
||||
return a + 1;
|
||||
}
|
||||
|
||||
/**
|
||||
Transforms integer i into an ascii string and stores the result in a;
|
||||
string is encoded in the base indicated by r.
|
||||
@param i Number to be converted
|
||||
@param a String result
|
||||
@param r Base of value; must be in the range 2 - 36
|
||||
@return Returns a
|
||||
*/
|
||||
static char *
|
||||
_itoa(int i, char *a, int r)
|
||||
{
|
||||
r = ((r < 2) || (r > 36)) ? 10 : r;
|
||||
if (i < 0) {
|
||||
*a = '-';
|
||||
*i2a(-i, a + 1, r) = 0;
|
||||
} else {
|
||||
*i2a(i, a, r) = 0;
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
#endif /* !_WIN32 */
|
||||
#endif
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
opj_event_mgr_t* OPJ_CALLCONV opj_set_event_mgr(opj_common_ptr cinfo,
|
||||
opj_event_mgr_t *event_mgr, void *context)
|
||||
{
|
||||
if (cinfo) {
|
||||
opj_event_mgr_t *previous = cinfo->event_mgr;
|
||||
cinfo->event_mgr = event_mgr;
|
||||
cinfo->client_data = context;
|
||||
return previous;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
opj_bool opj_event_msg(opj_common_ptr cinfo, int event_type, const char *fmt,
|
||||
...)
|
||||
{
|
||||
#define MSG_SIZE 512 /* 512 bytes should be more than enough for a short message */
|
||||
opj_msg_callback msg_handler = NULL;
|
||||
|
||||
opj_event_mgr_t *event_mgr = cinfo->event_mgr;
|
||||
if (event_mgr != NULL) {
|
||||
switch (event_type) {
|
||||
case EVT_ERROR:
|
||||
msg_handler = event_mgr->error_handler;
|
||||
break;
|
||||
case EVT_WARNING:
|
||||
msg_handler = event_mgr->warning_handler;
|
||||
break;
|
||||
case EVT_INFO:
|
||||
msg_handler = event_mgr->info_handler;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if (msg_handler == NULL) {
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
} else {
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
|
||||
if ((fmt != NULL) && (event_mgr != NULL)) {
|
||||
va_list arg;
|
||||
int str_length/*, i, j*/; /* UniPG */
|
||||
char message[MSG_SIZE];
|
||||
/* initialize the optional parameter list */
|
||||
va_start(arg, fmt);
|
||||
/* parse the format string and put the result in 'message' */
|
||||
str_length = vsnprintf(message, MSG_SIZE, fmt, arg); /* UniPG */
|
||||
/* deinitialize the optional parameter list */
|
||||
va_end(arg);
|
||||
|
||||
/* output the message to the user program */
|
||||
if (str_length > -1 && str_length < MSG_SIZE) {
|
||||
msg_handler(message, cinfo->client_data);
|
||||
} else {
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
return OPJ_TRUE;
|
||||
}
|
||||
|
|
@ -1,64 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 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 __EVENT_H
|
||||
#define __EVENT_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.
|
||||
*/
|
||||
|
||||
#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) */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Write formatted data to a string and send the string to a user callback.
|
||||
@param cinfo Codec context info
|
||||
@param event_type Event type or callback to use to send the message
|
||||
@param fmt Format-control string (plus optional arguments)
|
||||
@return Returns true if successful, returns false otherwise
|
||||
*/
|
||||
opj_bool opj_event_msg(opj_common_ptr cinfo, int event_type, const char *fmt,
|
||||
...);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __EVENT_H */
|
|
@ -1,71 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2014, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux
|
||||
* Copyright (c) 2003-2014, Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* 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
|
||||
|
||||
#if defined(_MSC_VER) || defined(__BORLANDC__)
|
||||
#define int64 __int64
|
||||
#else
|
||||
#define int64 long long
|
||||
#endif
|
||||
|
||||
/**
|
||||
@file fix.h
|
||||
@brief Implementation of operations of specific multiplication (FIX)
|
||||
|
||||
The functions in FIX.H have for goal to realize specific multiplication.
|
||||
*/
|
||||
|
||||
/** @defgroup FIX FIX - Implementation of operations of specific multiplication */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Multiply two fixed-precision rational numbers.
|
||||
@param a
|
||||
@param b
|
||||
@return Returns a * b
|
||||
*/
|
||||
static INLINE int fix_mul(int a, int b)
|
||||
{
|
||||
int64 temp = (int64) a * (int64) b ;
|
||||
temp += temp & 4096;
|
||||
return (int)(temp >> 13) ;
|
||||
}
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __FIX_H */
|
|
@ -1,99 +0,0 @@
|
|||
/*
|
||||
* The copyright in this software is being made available under the 2-clauses
|
||||
* BSD License, included below. This software may be subject to other third
|
||||
* party and contributor rights, including patent rights, and no such rights
|
||||
* are granted under this license.
|
||||
*
|
||||
* Copyright (c) 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.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
opj_image_t* opj_image_create0(void)
|
||||
{
|
||||
opj_image_t *image = (opj_image_t*)opj_calloc(1, sizeof(opj_image_t));
|
||||
return image;
|
||||
}
|
||||
|
||||
opj_image_t* OPJ_CALLCONV opj_image_create(int numcmpts,
|
||||
opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc)
|
||||
{
|
||||
int compno;
|
||||
opj_image_t *image = NULL;
|
||||
|
||||
image = (opj_image_t*) opj_calloc(1, sizeof(opj_image_t));
|
||||
if (image) {
|
||||
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) {
|
||||
fprintf(stderr, "Unable to allocate memory for image.\n");
|
||||
opj_image_destroy(image);
|
||||
return NULL;
|
||||
}
|
||||
/* 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->bpp = cmptparms[compno].bpp;
|
||||
comp->sgnd = cmptparms[compno].sgnd;
|
||||
comp->data = (int*) opj_calloc(comp->w * comp->h, sizeof(int));
|
||||
if (!comp->data) {
|
||||
fprintf(stderr, "Unable to allocate memory for image.\n");
|
||||
opj_image_destroy(image);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return image;
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_image_destroy(opj_image_t *image)
|
||||
{
|
||||
int 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);
|
||||
}
|
||||
}
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue