walkero
/
openjpeg
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

This commit was manufactured by cvs2svn to create tag 'start'.

This commit is contained in:
no_author 2005-11-08 17:40:41 +00:00
parent 34a4901b8d
commit 220a21bd01
68 changed files with 15132 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
codec/.cvsignore Normal file
View File

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

80
codec/Makefile Normal file
View File

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

114
mj2/compat/getopt.c → codec/compat/getopt.c
View File

@ -35,17 +35,17 @@
#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)getopt.c 8.3 (Berkeley) 4/27/95";
#endif /* LIBC_SCCS and not lint */
#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 */
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)':'
@ -61,56 +61,56 @@ char *const *nargv;
const char *ostr;
{
# define __progname nargv[0]
static char *place = EMSG; /* option letter processing */
char *oli; /* option letter list index */
static char *place = EMSG; /* option letter processing */
char *oli; /* option letter list index */
if (optreset || !*place) { /* update scanning pointer */
optreset = 0;
if (optind >= nargc || *(place = nargv[optind]) != '-') {
place = EMSG;
return (-1);
}
if (place[1] && *++place == '-') { /* found "--" */
++optind;
place = EMSG;
return (-1);
}
} /* option letter okay? */
if ((optopt = (int) *place++) == (int) ':' ||
!(oli = strchr(ostr, optopt))) {
/*
* if the user didn't specify '-' as an option,
* assume it means -1.
*/
if (optopt == (int) '-')
return (-1);
if (!*place)
++optind;
if (opterr && *ostr != ':')
(void) fprintf(stderr,
"%s: illegal option -- %c\n", __progname, optopt);
return (BADCH);
}
if (*++oli != ':') { /* don't need argument */
optarg = NULL;
if (!*place)
++optind;
} else { /* need an argument */
if (*place) /* no white space */
optarg = place;
else if (nargc <= ++optind) { /* no arg */
place = EMSG;
if (*ostr == ':')
return (BADARG);
if (opterr)
(void) fprintf(stderr,
"%s: option requires an argument -- %c\n",
__progname, optopt);
return (BADCH);
} else /* white space */
optarg = nargv[optind];
place = EMSG;
++optind;
}
return (optopt); /* dump back option letter */
if (optreset || !*place) { /* update scanning pointer */
optreset = 0;
if (optind >= nargc || *(place = nargv[optind]) != '-') {
place = EMSG;
return (-1);
}
if (place[1] && *++place == '-') { /* found "--" */
++optind;
place = EMSG;
return (-1);
}
} /* option letter okay? */
if ((optopt = (int) *place++) == (int) ':' ||
!(oli = strchr(ostr, optopt))) {
/*
* if the user didn't specify '-' as an option,
* assume it means -1.
*/
if (optopt == (int) '-')
return (-1);
if (!*place)
++optind;
if (opterr && *ostr != ':')
(void) fprintf(stderr,
"%s: illegal option -- %c\n", __progname, optopt);
return (BADCH);
}
if (*++oli != ':') { /* don't need argument */
optarg = NULL;
if (!*place)
++optind;
} else { /* need an argument */
if (*place) /* no white space */
optarg = place;
else if (nargc <= ++optind) { /* no arg */
place = EMSG;
if (*ostr == ':')
return (BADARG);
if (opterr)
(void) fprintf(stderr,
"%s: option requires an argument -- %c\n",
__progname, optopt);
return (BADCH);
} else /* white space */
optarg = nargv[optind];
place = EMSG;
++optind;
}
return (optopt); /* dump back option letter */
}

2
mj2/compat/getopt.h → codec/compat/getopt.h
View File

@ -11,4 +11,4 @@ extern char *optarg;
extern int getopt(int nargc, char *const *nargv, const char *ostr);
#endif /* _GETOPT_H_ */
#endif /* _GETOPT_H_ */

899
codec/convert.c Normal file
View File

@ -0,0 +1,899 @@
/*
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <openjpeg.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <unistd.h>
#include <string.h>
/* -->> -->> -->> -->>
BMP IMAGE FORMAT
<<-- <<-- <<-- <<-- */
/* UINT2 defines a two byte word */
typedef unsigned short int UINT2;
/* UINT4 defines a four byte word */
typedef unsigned long int UINT4;
typedef struct {
UINT2 bfType; /* 'BM' for Bitmap (19776) */
UINT4 bfSize; /* Size of the file */
UINT2 bfReserved1; /* Reserved : 0 */
UINT2 bfReserved2; /* Reserved : 0 */
UINT4 bfOffBits; /* Offset */
} BITMAPFILEHEADER_t;
typedef struct {
UINT4 biSize; /* Size of the structure in bytes */
UINT4 biWidth; /* Width of the image in pixels */
UINT4 biHeight; /* Heigth of the image in pixels */
UINT2 biPlanes; /* 1 */
UINT2 biBitCount; /* Number of color bits by pixels */
UINT4 biCompression; /* Type of encoding 0: none 1: RLE8 2: RLE4 */
UINT4 biSizeImage; /* Size of the image in bytes */
UINT4 biXpelsPerMeter; /* Horizontal (X) resolution in pixels/meter */
UINT4 biYpelsPerMeter; /* Vertical (Y) resolution in pixels/meter */
UINT4 biClrUsed; /* Number of color used in the image (0: ALL) */
UINT4 biClrImportant; /* Number of important color (0: ALL) */
} BITMAPINFOHEADER_t;
int bmptoimage(char *filename, j2k_image_t * img, int subsampling_dx,
int subsampling_dy, int Dim[2])
{
FILE *IN;
FILE *Compo0 = NULL, *Compo1 = NULL, *Compo2 = NULL;
BITMAPFILEHEADER_t File_h;
BITMAPINFOHEADER_t Info_h;
unsigned char *RGB;
unsigned char *table_R, *table_G, *table_B;
int i, w, h;
int gray_scale = 1, not_end_file = 1, line = 0, col = 0;
unsigned char v, v2;
UINT4 W, H;
IN = fopen(filename, "rb");
if (!IN) {
fprintf(stderr,
"\033[0;33mFailed to open %s for reading !!\033[0;39m\n",
filename);
return 0;
}
File_h.bfType = getc(IN);
File_h.bfType = (getc(IN) << 8) + File_h.bfType;
if (File_h.bfType != 19778) {
printf("Error, not a BMP file!\n");
return 0;
} else {
/* FILE HEADER */
/* ------------- */
File_h.bfSize = getc(IN);
File_h.bfSize = (getc(IN) << 8) + File_h.bfSize;
File_h.bfSize = (getc(IN) << 16) + File_h.bfSize;
File_h.bfSize = (getc(IN) << 24) + File_h.bfSize;
File_h.bfReserved1 = getc(IN);
File_h.bfReserved1 = (getc(IN) << 8) + File_h.bfReserved1;
File_h.bfReserved2 = getc(IN);
File_h.bfReserved2 = (getc(IN) << 8) + File_h.bfReserved2;
File_h.bfOffBits = getc(IN);
File_h.bfOffBits = (getc(IN) << 8) + File_h.bfOffBits;
File_h.bfOffBits = (getc(IN) << 16) + File_h.bfOffBits;
File_h.bfOffBits = (getc(IN) << 24) + File_h.bfOffBits;
/* INFO HEADER */
/* ------------- */
Info_h.biSize = getc(IN);
Info_h.biSize = (getc(IN) << 8) + Info_h.biSize;
Info_h.biSize = (getc(IN) << 16) + Info_h.biSize;
Info_h.biSize = (getc(IN) << 24) + Info_h.biSize;
Info_h.biWidth = getc(IN);
Info_h.biWidth = (getc(IN) << 8) + Info_h.biWidth;
Info_h.biWidth = (getc(IN) << 16) + Info_h.biWidth;
Info_h.biWidth = (getc(IN) << 24) + Info_h.biWidth;
w = Info_h.biWidth;
Info_h.biHeight = getc(IN);
Info_h.biHeight = (getc(IN) << 8) + Info_h.biHeight;
Info_h.biHeight = (getc(IN) << 16) + Info_h.biHeight;
Info_h.biHeight = (getc(IN) << 24) + Info_h.biHeight;
h = Info_h.biHeight;
Info_h.biPlanes = getc(IN);
Info_h.biPlanes = (getc(IN) << 8) + Info_h.biPlanes;
Info_h.biBitCount = getc(IN);
Info_h.biBitCount = (getc(IN) << 8) + Info_h.biBitCount;
Info_h.biCompression = getc(IN);
Info_h.biCompression = (getc(IN) << 8) + Info_h.biCompression;
Info_h.biCompression = (getc(IN) << 16) + Info_h.biCompression;
Info_h.biCompression = (getc(IN) << 24) + Info_h.biCompression;
Info_h.biSizeImage = getc(IN);
Info_h.biSizeImage = (getc(IN) << 8) + Info_h.biSizeImage;
Info_h.biSizeImage = (getc(IN) << 16) + Info_h.biSizeImage;
Info_h.biSizeImage = (getc(IN) << 24) + Info_h.biSizeImage;
Info_h.biXpelsPerMeter = getc(IN);
Info_h.biXpelsPerMeter = (getc(IN) << 8) + Info_h.biXpelsPerMeter;
Info_h.biXpelsPerMeter = (getc(IN) << 16) + Info_h.biXpelsPerMeter;
Info_h.biXpelsPerMeter = (getc(IN) << 24) + Info_h.biXpelsPerMeter;
Info_h.biYpelsPerMeter = getc(IN);
Info_h.biYpelsPerMeter = (getc(IN) << 8) + Info_h.biYpelsPerMeter;
Info_h.biYpelsPerMeter = (getc(IN) << 16) + Info_h.biYpelsPerMeter;
Info_h.biYpelsPerMeter = (getc(IN) << 24) + Info_h.biYpelsPerMeter;
Info_h.biClrUsed = getc(IN);
Info_h.biClrUsed = (getc(IN) << 8) + Info_h.biClrUsed;
Info_h.biClrUsed = (getc(IN) << 16) + Info_h.biClrUsed;
Info_h.biClrUsed = (getc(IN) << 24) + Info_h.biClrUsed;
Info_h.biClrImportant = getc(IN);
Info_h.biClrImportant = (getc(IN) << 8) + Info_h.biClrImportant;
Info_h.biClrImportant = (getc(IN) << 16) + Info_h.biClrImportant;
Info_h.biClrImportant = (getc(IN) << 24) + Info_h.biClrImportant;
/* Read the data and store them in the OUT file */
if (Info_h.biBitCount == 24) {
img->x0 = Dim[0];
img->y0 = Dim[1];
img->x1 =
!Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w -
1) *
subsampling_dx + 1;
img->y1 =
!Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h -
1) *
subsampling_dy + 1;
img->numcomps = 3;
img->comps =
(j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t));
for (i = 0; i < img->numcomps; i++) {
img->comps[i].prec = 8;
img->comps[i].bpp = 8;
img->comps[i].sgnd = 0;
img->comps[i].dx = subsampling_dx;
img->comps[i].dy = subsampling_dy;
}
Compo0 = fopen("Compo0", "wb");
if (!Compo0) {
fprintf(stderr,
"\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n");
}
Compo1 = fopen("Compo1", "wb");
if (!Compo1) {
fprintf(stderr,
"\033[0;33mFailed to open Compo1 for writing !\033[0;39m\n");
}
Compo2 = fopen("Compo2", "wb");
if (!Compo2) {
fprintf(stderr,
"\033[0;33mFailed to open Compo2 for writing !\033[0;39m\n");
}
/* Place the cursor at the beginning of the image information */
fseek(IN, 0, SEEK_SET);
fseek(IN, File_h.bfOffBits, SEEK_SET);
W = Info_h.biWidth;
H = Info_h.biHeight;
if (Info_h.biWidth % 2)
W++;
RGB = (unsigned char *) malloc(3 * W * H * sizeof(unsigned char));
fread(RGB, sizeof(unsigned char), 3 * W * H, IN);
for (i = 0; i < W * H; i++) {
unsigned char R, G, B;
B =
RGB[3 * W * H - ((i * 3) / (3 * W) + 1) * 3 * W +
(i * 3) % (W * 3)];
G =
RGB[3 * W * H - ((i * 3 + 1) / (3 * W) + 1) * 3 * W +
(i * 3 + 1) % (W * 3)];
R =
RGB[3 * W * H - ((i * 3 + 2) / (3 * W) + 1) * 3 * W +
(i * 3 + 2) % (W * 3)];
if ((i % W < W - 1 && Info_h.biWidth % 2) || !(Info_h.biWidth % 2)) {
fprintf(Compo0, "%c", R);
fprintf(Compo1, "%c", G);
fprintf(Compo2, "%c", B);
}
}
fclose(Compo0);
fclose(Compo1);
fclose(Compo2);
free(RGB);
} else if (Info_h.biBitCount == 8 && Info_h.biCompression == 0) {
img->x0 = Dim[0];
img->y0 = Dim[1];
img->x1 =
!Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w -
1) *
subsampling_dx + 1;
img->y1 =
!Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h -
1) *
subsampling_dy + 1;
table_R = (unsigned char *) malloc(256 * sizeof(unsigned char));
table_G = (unsigned char *) malloc(256 * sizeof(unsigned char));
table_B = (unsigned char *) malloc(256 * sizeof(unsigned char));
for (i = 0; i < Info_h.biClrUsed; i++) {
table_B[i] = getc(IN);
table_G[i] = getc(IN);
table_R[i] = getc(IN);
getc(IN);
if (table_R[i] != table_G[i] && table_R[i] != table_B[i]
&& table_G[i] != table_B[i])
gray_scale = 0;
}
/* Place the cursor at the beginning of the image information */
fseek(IN, 0, SEEK_SET);
fseek(IN, File_h.bfOffBits, SEEK_SET);
W = Info_h.biWidth;
H = Info_h.biHeight;
if (Info_h.biWidth % 2)
W++;
RGB = (unsigned char *) malloc(W * H * sizeof(unsigned char));
fread(RGB, sizeof(unsigned char), W * H, IN);
if (gray_scale) {
img->numcomps = 1;
img->comps =
(j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t));
img->comps[0].prec = 8;
img->comps[0].bpp = 8;
img->comps[0].sgnd = 0;
img->comps[0].dx = subsampling_dx;
img->comps[0].dy = subsampling_dy;
Compo0 = fopen("Compo0", "wb");
if (!Compo0) {
fprintf(stderr,
"\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n");
}
for (i = 0; i < W * H; i++) {
if ((i % W < W - 1 && Info_h.biWidth % 2)
|| !(Info_h.biWidth % 2))
fprintf(Compo0, "%c",
table_R[RGB[W * H - ((i) / (W) + 1) * W + (i) % (W)]]);
}
fclose(Compo0);
} else {
img->numcomps = 3;
img->comps =
(j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t));
for (i = 0; i < img->numcomps; i++) {
img->comps[i].prec = 8;
img->comps[i].bpp = 8;
img->comps[i].sgnd = 0;
img->comps[i].dx = subsampling_dx;
img->comps[i].dy = subsampling_dy;
}
Compo0 = fopen("Compo0", "wb");
if (!Compo0) {
fprintf(stderr,
"\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n");
}
Compo1 = fopen("Compo1", "wb");
if (!Compo1) {
fprintf(stderr,
"\033[0;33mFailed to open Compo1 for writing !\033[0;39m\n");
}
Compo2 = fopen("Compo2", "wb");
if (!Compo2) {
fprintf(stderr,
"\033[0;33mFailed to open Compo2 for writing !\033[0;39m\n");
}
for (i = 0; i < W * H; i++) {
if ((i % W < W - 1 && Info_h.biWidth % 2)
|| !(Info_h.biWidth % 2)) {
fprintf(Compo0, "%c",
table_R[RGB[W * H - ((i) / (W) + 1) * W + (i) % (W)]]);
fprintf(Compo1, "%c",
table_G[RGB[W * H - ((i) / (W) + 1) * W + (i) % (W)]]);
fprintf(Compo2, "%c",
table_B[RGB[W * H - ((i) / (W) + 1) * W + (i) % (W)]]);
}
}
fclose(Compo0);
fclose(Compo1);
fclose(Compo2);
}
free(RGB);
} else if (Info_h.biBitCount == 8 && Info_h.biCompression == 1) {
img->x0 = Dim[0];
img->y0 = Dim[1];
img->x1 =
!Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w -
1) *
subsampling_dx + 1;
img->y1 =
!Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h -
1) *
subsampling_dy + 1;
table_R = (unsigned char *) malloc(256 * sizeof(unsigned char));
table_G = (unsigned char *) malloc(256 * sizeof(unsigned char));
table_B = (unsigned char *) malloc(256 * sizeof(unsigned char));
for (i = 0; i < Info_h.biClrUsed; i++) {
table_B[i] = getc(IN);
table_G[i] = getc(IN);
table_R[i] = getc(IN);
getc(IN);
if (table_R[i] != table_G[i] && table_R[i] != table_B[i]
&& table_G[i] != table_B[i])
gray_scale = 0;
}
/* Place the cursor at the beginning of the image information */
fseek(IN, 0, SEEK_SET);
fseek(IN, File_h.bfOffBits, SEEK_SET);
if (gray_scale) {
img->numcomps = 1;
img->comps = (j2k_comp_t *) malloc(sizeof(j2k_comp_t));
img->comps[0].prec = 8;
img->comps[0].bpp = 8;
img->comps[0].sgnd = 0;
img->comps[0].dx = subsampling_dx;
img->comps[0].dy = subsampling_dy;
Compo0 = fopen("Compo0", "wb");
if (!Compo0) {
fprintf(stderr,
"\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n");
}
} else {
img->numcomps = 3;
img->comps =
(j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t));
for (i = 0; i < img->numcomps; i++) {
img->comps[i].prec = 8;
img->comps[i].bpp = 8;
img->comps[i].sgnd = 0;
img->comps[i].dx = subsampling_dx;
img->comps[i].dy = subsampling_dy;
}
Compo0 = fopen("Compo0", "wb");
if (!Compo0) {
fprintf(stderr,
"\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n");
}
Compo1 = fopen("Compo1", "wb");
if (!Compo1) {
fprintf(stderr,
"\033[0;33mFailed to open Compo1 for writing !\033[0;39m\n");
}
Compo2 = fopen("Compo2", "wb");
if (!Compo2) {
fprintf(stderr,
"\033[0;33mFailed to open Compo2 for writing !\033[0;39m\n");
}
}
RGB =
(unsigned char *) malloc(Info_h.biWidth * Info_h.biHeight *
sizeof(unsigned char));
while (not_end_file) {
v = getc(IN);
if (v) {
v2 = getc(IN);
for (i = 0; i < (int) v; i++) {
RGB[line * Info_h.biWidth + col] = v2;
col++;
}
} else {
v = getc(IN);
switch (v) {
case 0:
col = 0;
line++;
break;
case 1:
line++;
not_end_file = 0;
break;
case 2:
printf("No Delta supported\n");
return 1;
break;
default:
for (i = 0; i < v; i++) {
v2 = getc(IN);
RGB[line * Info_h.biWidth + col] = v2;
col++;
}
if (v % 2)
v2 = getc(IN);
}
}
}
if (gray_scale) {
for (line = 0; line < Info_h.biHeight; line++)
for (col = 0; col < Info_h.biWidth; col++)
fprintf(Compo0, "%c",
table_R[(int)
RGB[(Info_h.biHeight - line -
1) * Info_h.biWidth + col]]);
fclose(Compo0);
} else {
for (line = 0; line < Info_h.biHeight; line++)
for (col = 0; col < Info_h.biWidth; col++) {
fprintf(Compo0, "%c",
table_R[(int)
RGB[(Info_h.biHeight - line -
1) * Info_h.biWidth + col]]);
fprintf(Compo1, "%c",
table_G[(int)
RGB[(Info_h.biHeight - line -
1) * Info_h.biWidth + col]]);
fprintf(Compo2, "%c",
table_B[(int)
RGB[(Info_h.biHeight - line -
1) * Info_h.biWidth + col]]);
}
fclose(Compo0);
fclose(Compo1);
fclose(Compo2);
}
free(RGB);
} else
printf
("Other system than 24 bits/pixels or 8 bits (no RLE coding) is not yet implemented [%d]\n",
Info_h.biBitCount);
fclose(IN);
return 1;
}
}
/* -->> -->> -->> -->>
PGX IMAGE FORMAT
<<-- <<-- <<-- <<-- */
unsigned char readuchar(FILE * f)
{
unsigned char c1;
fread(&c1, 1, 1, f);
return c1;
}
unsigned short readushort(FILE * f, int bigendian)
{
unsigned char c1, c2;
fread(&c1, 1, 1, f);
fread(&c2, 1, 1, f);
if (bigendian)
return (c1 << 8) + c2;
else
return (c2 << 8) + c1;
}
unsigned int readuint(FILE * f, int bigendian)
{
unsigned char c1, c2, c3, c4;
fread(&c1, 1, 1, f);
fread(&c2, 1, 1, f);
fread(&c3, 1, 1, f);
fread(&c4, 1, 1, f);
if (bigendian)
return (c1 << 24) + (c2 << 16) + (c3 << 8) + c4;
else
return (c4 << 24) + (c3 << 16) + (c2 << 8) + c1;
}
int pgxtoimage(char *filename, j2k_image_t * img, int tdy,
int subsampling_dx, int subsampling_dy, int Dim[2],
j2k_cp_t cp)
{
FILE *f;
int w, h, prec;
int i, compno, bandno;
char str[256], endian[16];
char sign;
int bigendian;
j2k_comp_t *comp;
img->numcomps = 1;
img->comps = (j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t));
for (compno = 0; compno < img->numcomps; compno++) {
FILE *src;
char tmp[16];
int max = 0;
int Y1;
comp = &img->comps[compno];
sprintf(str, "%s", filename);
f = fopen(str, "rb");
if (!f) {
fprintf(stderr, "Failed to open %s for reading !\n", str);
return 0;
}
if (fscanf(f, "PG %s %c %d %d %d", endian, &sign, &prec, &w, &h) == 5)
{
fgetc(f);
if (!strcmp(endian, "ML"))
bigendian = 1;
else
bigendian = 0;
if (compno == 0) {
img->x0 = Dim[0];
img->y0 = Dim[1];
img->x1 =
!Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w -
1) *
subsampling_dx + 1;
img->y1 =
!Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h -
1) *
subsampling_dy + 1;
} else {
if (w != img->x1 || h != img->y1)
return 0;
}
if (sign == '-') {
comp->sgnd = 1;
} else {
comp->sgnd = 0;
}
comp->prec = prec;
comp->dx = subsampling_dx;
comp->dy = subsampling_dy;
bandno = 1;
Y1 =
cp.ty0 + bandno * cp.tdy <
img->y1 ? cp.ty0 + bandno * cp.tdy : img->y1;
Y1 -= img->y0;
sprintf(tmp, "bandtile%d", bandno); /* bandtile file */
src = fopen(tmp, "wb");
if (!src) {
fprintf(stderr, "failed to open %s for writing !\n", tmp);
}
for (i = 0; i < w * h; i++) {
int v;
if (i == Y1 * w / subsampling_dy && tdy != -1) { /* bandtile is full */
fclose(src);
bandno++;
sprintf(tmp, "bandtile%d", bandno);
src = fopen(tmp, "wb");
if (!src) {
fprintf(stderr, "failed to open %s for writing !\n", tmp);
}
Y1 =
cp.ty0 + bandno * cp.tdy <
img->y1 ? cp.ty0 + bandno * cp.tdy : img->y1;
Y1 -= img->y0;
}
if (comp->prec <= 8) {
if (!comp->sgnd) {
v = readuchar(f);
} else {
v = (char) readuchar(f);
}
} else if (comp->prec <= 16) {
if (!comp->sgnd) {
v = readushort(f, bigendian);
} else {
v = (short) readushort(f, bigendian);
}
} else {
if (!comp->sgnd) {
v = readuint(f, bigendian);
} else {
v = (int) readuint(f, bigendian);
}
}
if (v > max)
max = v;
fprintf(src, "%d ", v);
}
} else {
return 0;
}
fclose(f);
fclose(src);
comp->bpp = int_floorlog2(max) + 1;
}
return 1;
}
/* -->> -->> -->> -->>
PNM IMAGE FORMAT
<<-- <<-- <<-- <<-- */
int pnmtoimage(char *filename, j2k_image_t * img, int subsampling_dx,
int subsampling_dy, int Dim[2])
{
FILE *f;
FILE *Compo0, *Compo1, *Compo2;
int w, h;
int i;
char value;
char comment[256];
f = fopen(filename, "rb");
if (!f) {
fprintf(stderr,
"\033[0;33mFailed to open %s for reading !!\033[0;39m\n",
filename);
return 0;
}
if (fgetc(f) != 'P')
return 0;
value = fgetc(f);
if (value == '2') {
fgetc(f);
if (fgetc(f) == '#') {
fseek(f, 0, SEEK_SET);
fscanf(f, "P2\n");
fgets(comment, 256, f);
fscanf(f, "%d %d\n255", &w, &h);
} else {
fseek(f, 0, SEEK_SET);
fscanf(f, "P2\n%d %d\n255", &w, &h);
}
fgetc(f);
img->x0 = Dim[0];
img->y0 = Dim[1];
img->x1 =
!Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w -
1) *
subsampling_dx + 1;
img->y1 =
!Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h -
1) *
subsampling_dy + 1;
img->numcomps = 1;
img->comps = (j2k_comp_t *) malloc(sizeof(j2k_comp_t));
img->comps[0].prec = 8;
img->comps[0].bpp = 8;
img->comps[0].sgnd = 0;
img->comps[0].dx = subsampling_dx;
img->comps[0].dy = subsampling_dy;
Compo0 = fopen("Compo0", "wb");
if (!Compo0) {
fprintf(stderr,
"\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n");
}
for (i = 0; i < w * h; i++) {
unsigned int l;
fscanf(f, "%d", &l);
fprintf(Compo0, "%c", l);
}
fclose(Compo0);
} else if (value == '5') {
fgetc(f);
if (fgetc(f) == '#') {
fseek(f, 0, SEEK_SET);
fscanf(f, "P5\n");
fgets(comment, 256, f);
fscanf(f, "%d %d\n255", &w, &h);
} else {
fseek(f, 0, SEEK_SET);
fscanf(f, "P5\n%d %d\n255", &w, &h);
}
fgetc(f);
img->x0 = Dim[0];
img->y0 = Dim[1];
img->x1 =
!Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w -
1) *
subsampling_dx + 1;
img->y1 =
!Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h -
1) *
subsampling_dy + 1;
img->numcomps = 1;
img->comps = (j2k_comp_t *) malloc(sizeof(j2k_comp_t));
img->comps[0].prec = 8;
img->comps[0].bpp = 8;
img->comps[0].sgnd = 0;
img->comps[0].dx = subsampling_dx;
img->comps[0].dy = subsampling_dy;
Compo0 = fopen("Compo0", "wb");
if (!Compo0) {
fprintf(stderr,
"\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n");
}
for (i = 0; i < w * h; i++) {
unsigned char l;
fread(&l, 1, 1, f);
fwrite(&l, 1, 1, Compo0);
}
fclose(Compo0);
} else if (value == '3') {
fgetc(f);
if (fgetc(f) == '#') {
fseek(f, 0, SEEK_SET);
fscanf(f, "P3\n");
fgets(comment, 256, f);
fscanf(f, "%d %d\n255", &w, &h);
} else {
fseek(f, 0, SEEK_SET);
fscanf(f, "P3\n%d %d\n255", &w, &h);
}
fgetc(f);
img->x0 = Dim[0];
img->y0 = Dim[1];
img->x1 =
!Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w -
1) *
subsampling_dx + 1;
img->y1 =
!Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h -
1) *
subsampling_dy + 1;
img->numcomps = 3;
img->comps = (j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t));
for (i = 0; i < img->numcomps; i++) {
img->comps[i].prec = 8;
img->comps[i].bpp = 8;
img->comps[i].sgnd = 0;
img->comps[i].dx = subsampling_dx;
img->comps[i].dy = subsampling_dy;
}
Compo0 = fopen("Compo0", "wb");
if (!Compo0) {
fprintf(stderr,
"\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n");
}
Compo1 = fopen("Compo1", "wb");
if (!Compo1) {
fprintf(stderr,
"\033[0;33mFailed to open Compo1 for writing !\033[0;39m\n");
}
Compo2 = fopen("Compo2", "wb");
if (!Compo2) {
fprintf(stderr,
"\033[0;33mFailed to open Compo2 for writing !\033[0;39m\n");
}
for (i = 0; i < w * h; i++) {
unsigned int r, g, b;
fscanf(f, "%d", &r);
fscanf(f, "%d", &g);
fscanf(f, "%d", &b);
fprintf(Compo0, "%c", r);
fprintf(Compo1, "%c", g);
fprintf(Compo2, "%c", b);
}
fclose(Compo0);
fclose(Compo1);
fclose(Compo2);
} else if (value == '6') {
fgetc(f);
if (fgetc(f) == '#') {
fseek(f, 0, SEEK_SET);
fscanf(f, "P6\n");
fgets(comment, 256, f);
fscanf(f, "%d %d\n255", &w, &h);
} else {
fseek(f, 0, SEEK_SET);
fscanf(f, "P6\n%d %d\n255", &w, &h);
}
fgetc(f);
img->x0 = Dim[0];
img->y0 = Dim[1];
img->x1 =
!Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w -
1) *
subsampling_dx + 1;
img->y1 =
!Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h -
1) *
subsampling_dy + 1;
img->numcomps = 3;
img->comps = (j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t));
for (i = 0; i < img->numcomps; i++) {
img->comps[i].prec = 8;
img->comps[i].bpp = 8;
img->comps[i].sgnd = 0;
img->comps[i].dx = subsampling_dx;
img->comps[i].dy = subsampling_dy;
}
Compo0 = fopen("Compo0", "wb");
if (!Compo0) {
fprintf(stderr,
"\033[0;33mFailed to open Compo0 for writing !\033[0;39m\n");
}
Compo1 = fopen("Compo1", "wb");
if (!Compo1) {
fprintf(stderr,
"\033[0;33mFailed to open Compo1 for writing !\033[0;39m\n");
}
Compo2 = fopen("Compo2", "wb");
if (!Compo2) {
fprintf(stderr,
"\033[0;33mFailed to open Compo2 for writing !\033[0;39m\n");
}
for (i = 0; i < w * h; i++) {
unsigned char r, g, b;
fread(&r, 1, 1, f);
fread(&g, 1, 1, f);
fread(&b, 1, 1, f);
fwrite(&r, 1, 1, Compo0);
fwrite(&g, 1, 1, Compo1);
fwrite(&b, 1, 1, Compo2);
}
fclose(Compo0);
fclose(Compo1);
fclose(Compo2);
} else {
return 0;
}
fclose(f);
return 1;
}

39
codec/convert.h Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2002-2003, 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 "j2k.h"
int bmptoimage(char *filename, j2k_image_t * img, int subsampling_dx,
int subsampling_dy, int Dim[2]);
int pgxtoimage(char *filename, j2k_image_t * img, int tdy,
int subsampling_dx, int subsampling_dy, int Dim[2],
j2k_cp_t cp);
int pnmtoimage(char *filename, j2k_image_t * img, int subsampling_dx,
int subsampling_dy, int Dim[2]);

720
codec/image_to_j2k.c Normal file
View File

@ -0,0 +1,720 @@
/*
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2002-2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <openjpeg.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <unistd.h>
#include <string.h>
#ifndef DONT_HAVE_GETOPT
#include <getopt.h>
#else
#include "compat/getopt.h"
#endif
#include "convert.h"
void help_display()
{
printf("HELP\n----\n\n");
printf
("- the option -help displays the readme.txt file on screen\n\n");
printf("List of parameters for the coder JPEG 2000 :\n");
printf("\n");
printf
("- The markers COD and QCD are writed both of two in the main_header and never appear in the tile_header. The markers in the main header are : SOC SIZ COD QCD COM.\n");
printf("\n");
printf
("- This coder can encode mega image, a test was made on a 24000x24000 pixels color image. You need enough disk space memory (twice the original) to encode the image. (i.e. for a 1.5 Gb image you need a minimum of 3Gb of disk memory)\n");
printf("\n");
printf("REMARKS :\n");
printf("---------\n");
printf("\n");
printf
("* the value of rate enter in the code line is the compression factor !\n");
printf("exemple :\n");
printf("\n");
printf
("-r 20,10,1 means quality 1 : compress 20x, quality 2 : compress 10x and quality 3 : compress 1x = lossless\n");
printf("\n");
printf("By default :\n");
printf("------------\n");
printf("\n");
printf(" * lossless\n");
printf(" * 1 tile\n");
printf(" * size of precinct 2^15 x 2^15 (means 1 precinct)\n");
printf(" * size of code-block 64 x 64\n");
printf(" * Number of resolution : 6\n");
printf(" * No SOP marker in the codestream\n");
printf(" * No EPH marker in the codestream\n");
printf(" * No sub-sampling in x and y direction\n");
printf(" * No mode switch activated\n");
printf(" * progression order : LRCP\n");
printf(" * No index file\n");
printf(" * No ROI upshifted\n");
printf(" * No offset of the origin of the image\n");
printf(" * No offset of the origin of the tiles\n");
printf(" * Reversible DWT 5-3\n");
printf("\n");
printf("Parameters :\n");
printf("------------\n");
printf("\n");
printf
("-i : source file (-i source.pnm also *.pgm, *.ppm) required\n");
printf("\n");
printf
("-o : destination file (-o dest.j2k) required\n");
printf("\n");
printf
("-help : Display the help information optional\n ");
printf("\n");
printf
("-r : different rates (-r 20,10,5) optional\n ");
printf("\n");
printf
("-n : Number of resolution (-n 3) optional\n");
printf("\n");
printf
("-b : size of code block (-b 32,32) optional\n");
printf("\n");
printf
("-c : size of precinct (-c 128,128) optional\n");
printf("\n");
printf
("-t : size of tile (-t 512,512) optional\n");
printf("\n");
printf
("-p : progression order (-p LRCP) [LRCP, RLCP, RPCL, PCRL, CPRL] optional\n");
printf("\n");
printf
("-s : subsampling factor (-s 2,2) [-s X,Y] optional\n");
printf("\n");
printf
("-SOP : write SOP marker before each packet optional\n");
printf("\n");
printf
("-EPH : write EPH marker after each header packet optional\n");
printf("\n");
printf
("-M : mode switch (-M 3) [1=BYPASS(LAZY) 2=RESET 4=RESTART(TERMALL) 8=VSC 16=ERTERM(SEGTERM) 32=SEGMARK(SEGSYM)] optional\n");
printf
(" for several mode switch you have to add the value of each mode you want\n");
printf
(" ex : RESTART(4) + RESET(2) + SEGMARK(32) = -M 38\n");
printf("\n");
printf
("-x : Create an index file *.Idx (-x index_name.Idx) optional\n");
printf("\n");
printf
("-ROI:c=%%d,U=%%d : quantization indices upshifted for component c=%%d [\%%d = 0,1,2]\n");
printf
(" with a value of U=%%d [0 <= %%d <= 37] (i.e. -ROI:c=0,U=25) optional\n");
printf("\n");
printf
("-d : offset of the origin of the image (-d 150,300) optional\n");
printf("\n");
printf
("-T : offset of the origin of the tiles (-T 100,75) optional\n");
printf("\n");
printf
("-I : Use the irreversible DWT 9-7 (-I) optional\n");
printf("\n");
printf("IMPORTANT :\n");
printf("-----------\n");
printf("\n");
printf("* subsampling bigger than 2 can produce error\n");
printf("\n");
printf
("The index file respect the structure below :\n");
printf
("---------------------------------------------\n");
printf("\n");
printf("Image_height Image_width\n");
printf("progression order\n");
printf("Tiles_size_X Tiles_size_Y\n");
printf("Components_nb\n");
printf("Layers_nb\n");
printf("decomposition_levels\n");
printf("Precincts_size_X Precincts_size_Y\n");
printf("Main_header_end_position\n");
printf("Codestream_size\n");
printf("Tile0 start_pos end_Theader end_pos\n");
printf("Tile1 '' '' ''\n");
printf("...\n");
printf("TileN '' '' ''\n");
printf("Tpacket_0 Tile layer res. comp. prec. start_pos end_pos\n");
printf("...\n");
printf("Tpacket_M '' '' '' '' '' '' ''\n");
}
int give_progression(char progression[4])
{
if (progression[0] == 'L' && progression[1] == 'R'
&& progression[2] == 'C' && progression[3] == 'P') {
return 0;
} else {
if (progression[0] == 'R' && progression[1] == 'L'
&& progression[2] == 'C' && progression[3] == 'P') {
return 1;
} else {
if (progression[0] == 'R' && progression[1] == 'P'
&& progression[2] == 'C' && progression[3] == 'L') {
return 2;
} else {
if (progression[0] == 'P' && progression[1] == 'C'
&& progression[2] == 'R' && progression[3] == 'L') {
return 3;
} else {
if (progression[0] == 'C' && progression[1] == 'P'
&& progression[2] == 'R' && progression[3] == 'L') {
return 4;
} else {
return -1;
}
}
}
}
}
}
double dwt_norms_97[4][10] = {
{1.000, 1.965, 4.177, 8.403, 16.90, 33.84, 67.69, 135.3, 270.6, 540.9},
{2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0},
{2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0},
{2.080, 3.865, 8.307, 17.18, 34.71, 69.59, 139.3, 278.6, 557.2}
};
int floorlog2(int a)
{
int l;
for (l = 0; a > 1; l++) {
a >>= 1;
}
return l;
}
void encode_stepsize(int stepsize, int numbps, int *expn, int *mant)
{
int p, n;
p = floorlog2(stepsize) - 13;
n = 11 - floorlog2(stepsize);
*mant = (n < 0 ? stepsize >> -n : stepsize << n) & 0x7ff;
*expn = numbps - p;
}
void calc_explicit_stepsizes(j2k_tccp_t * tccp, int prec)
{
int numbands, bandno;
numbands = 3 * tccp->numresolutions - 2;
for (bandno = 0; bandno < numbands; bandno++) {
double stepsize;
int resno, level, orient, gain;
resno = bandno == 0 ? 0 : (bandno - 1) / 3 + 1;
orient = bandno == 0 ? 0 : (bandno - 1) % 3 + 1;
level = tccp->numresolutions - 1 - resno;
gain =
tccp->qmfbid == 0 ? 0 : (orient ==
0 ? 0 : (orient == 1
|| orient == 2 ? 1 : 2));
if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
stepsize = 1.0;
} else {
double norm = dwt_norms_97[orient][level];
stepsize = (1 << (gain + 1)) / norm;
}
encode_stepsize((int) floor(stepsize * 8192.0), prec + gain,
&tccp->stepsizes[bandno].expn,
&tccp->stepsizes[bandno].mant);
}
}
int main(int argc, char **argv)
{
int len;
int NumResolution, numD_min; /* NumResolution : number of resolution */
int Tile_arg; /* Tile_arg = 0 (pas en argument ou = 1 (entre en argument) */
int CSty; /* CSty : coding style */
int Prog_order; /* progression order (default LRCP) */
char progression[4];
int numpocs, numpocs_tile; /* Number of progression order change (POC) default 0 */
int prcw_init, prch_init; /* Initialisation precincts' size */
int cblockw_init, cblockh_init; /* Initialisation codeblocks' size */
int mode, value; /* mode switch (cblk_style) */
int subsampling_dx, subsampling_dy; /* subsampling value for dx and dy */
int ROI_compno, ROI_shift; /* region of interrest */
int Dim[2]; /* portion of the image coded */
int TX0, TY0; /* tile off-set */
j2k_image_t img;
j2k_cp_t cp, cp_init; /* cp_init is used to initialise in multiple tiles */
j2k_tcp_t *tcp, *tcp_init; /* tcp_init is used to initialise in multiple tile */
j2k_poc_t POC[32]; /* POC : used in case of Progression order change */
j2k_poc_t *tcp_poc;
j2k_tccp_t *tccp;
int i, tileno, j;
char *infile = 0;
char *outfile = 0;
char *index = 0;
char *s, S1, S2, S3;
int ir = 0;
/* default value */
/* ------------- */
NumResolution = 6;
CSty = 0;
cblockw_init = 64;
cblockh_init = 64;
cp.tw = 1;
cp.th = 1;
img.index_on = 0;
Prog_order = 0;
numpocs = 0;
mode = 0;
subsampling_dx = 1;
subsampling_dy = 1;
ROI_compno = -1; /* no ROI */
ROI_shift = 0;
Dim[0] = 0;
Dim[1] = 0;
TX0 = 0;
TY0 = 0;
cp.comment = NULL;
cp.disto_alloc = 0;
cp.fixed_alloc = 0;
/* img.PPT=0; */
Tile_arg = 0;
cp_init.tcps = (j2k_tcp_t *) malloc(sizeof(j2k_tcp_t)); /* initialisation if only one tile */
tcp_init = &cp_init.tcps[0];
tcp_init->numlayers = 0;
while (1) {
int c =
getopt(argc, argv, "i:o:r:q:t:n:c:b:x:p:s:d:h:P:S:E:M:R:T:C:I");
if (c == -1)
break;
switch (c) {
case 'i': /* IN fill */
infile = optarg;
s = optarg;
while (*s && *s != '.') {
s++;
}
s++;
S1 = *s;
s++;
S2 = *s;
s++;
S3 = *s;
if ((S1 == 'p' && S2 == 'g' && S3 == 'x')
|| (S1 == 'P' && S2 == 'G' && S3 == 'X')) {
cp.image_type = 0;
break;
}
if ((S1 == 'p' && S2 == 'n' && S3 == 'm')
|| (S1 == 'P' && S2 == 'N' && S3 == 'M') || (S1 == 'p'
&& S2 == 'g'
&& S3 == 'm')
|| (S1 == 'P' && S2 == 'G' && S3 == 'M') || (S1 == 'P'
&& S2 == 'P'
&& S3 == 'M')
|| (S1 == 'p' && S2 == 'p' && S3 == 'm')) {
cp.image_type = 1;
break;
}
if ((S1 == 'b' && S2 == 'm' && S3 == 'p')
|| (S1 == 'B' && S2 == 'M' && S3 == 'P')) {
cp.image_type = 2;
break;
}
fprintf(stderr,
"!! Unrecognized format for infile [accept only *.pnm, *.pgm, *.ppm, *.pgx or *.bmp] !!\n\n");
return 1;
break;
/* ----------------------------------------------------- */
case 'o': /* OUT fill */
outfile = optarg;
break;
/* ----------------------------------------------------- */
case 'r': /* rates */
s = optarg;
while (sscanf(s, "%d", &tcp_init->rates[tcp_init->numlayers]) == 1) {
tcp_init->numlayers++;
while (*s && *s != ',') {
s++;
}
if (!*s)
break;
s++;
}
cp.disto_alloc = 1;
break;
/* ----------------------------------------------------- */
case 'q': /* rates */
s = optarg;
sscanf(s, "%d", &tcp_init->numlayers);
for (i = 0; i < tcp_init->numlayers; i++) {
tcp_init->rates[i] = 1;
}
cp.fixed_alloc = 1;
break;
/* ----------------------------------------------------- */
case 't': /* tiles */
sscanf(optarg, "%d,%d", &cp.tdx, &cp.tdy);
Tile_arg = 1;
break;
/* ----------------------------------------------------- */
case 'n': /* resolution */
sscanf(optarg, "%d", &NumResolution);
break;
/* ----------------------------------------------------- */
case 'c': /* precinct dimension */
sscanf(optarg, "%d,%d", &prcw_init, &prch_init);
CSty |= 0x01;
break;
/* ----------------------------------------------------- */
case 'b': /* code-block dimension */
sscanf(optarg, "%d,%d", &cblockw_init, &cblockh_init);
if (cblockw_init * cblockh_init > 4096 || cblockw_init > 1024
|| cblockw_init < 4 || cblockh_init > 1024 || cblockh_init < 4) {
fprintf(stderr,
"!! Size of code_block error (option -b) !!\n\nRestriction :\n * width*height<=4096\n * 4<=width,height<= 1024\n\n");
return 1;
}
break;
/* ----------------------------------------------------- */
case 'x': /* creation of index file */
index = optarg;
img.index_on = 1;
break;
/* ----------------------------------------------------- */
case 'p': /* progression order */
sscanf(optarg, "%s", progression);
Prog_order = give_progression(progression);
if (Prog_order == -1) {
fprintf(stderr,
"Unrecognized progression order [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n");
return 1;
}
break;
/* ----------------------------------------------------- */
case 's': /* subsampling factor */
if (sscanf(optarg, "%d,%d", &subsampling_dx, &subsampling_dy) != 2) {
fprintf(stderr,
"'-s' sub-sampling argument error ! [-s dx,dy]\n");
return 1;
}
break;
/* ----------------------------------------------------- */
case 'd': /* coordonnate of the reference grid */
if (sscanf(optarg, "%d,%d", &Dim[0], &Dim[1]) != 2) {
fprintf(stderr,
"-d 'coordonnate of the reference grid' argument error !! [-d x0,y0]\n");
return 1;
}
break;
/* ----------------------------------------------------- */
case 'h': /* Display an help description */
help_display();
return 0;
break;
/* ----------------------------------------------------- */
case 'P': /* POC */
fprintf(stderr, "/----------------------------------\\\n");
fprintf(stderr, "| POC option not fully tested !! |\n");
fprintf(stderr, "\\----------------------------------/\n");
s = optarg;
while (sscanf
(s, "T%d=%d,%d,%d,%d,%d,%s", &POC[numpocs].tile,
&POC[numpocs].resno0, &POC[numpocs].compno0,
&POC[numpocs].layno1, &POC[numpocs].resno1,
&POC[numpocs].compno1, POC[numpocs].progorder) == 7) {
POC[numpocs].prg = give_progression(POC[numpocs].progorder);
/* POC[numpocs].tile; */
numpocs++;
while (*s && *s != '/') {
s++;
}
if (!*s)
break;
s++;
}
break;
/* ------------------------------------------------------ */
case 'S': /* SOP marker */
CSty |= 0x02;
break;
/* ------------------------------------------------------ */
case 'E': /* EPH marker */
CSty |= 0x04;
break;
/* ------------------------------------------------------ */
case 'M': /* Mode switch pas tous au point !! */
if (sscanf(optarg, "%d", &value) == 1) {
for (i = 0; i <= 5; i++) {
int cache = value & (1 << i);
if (cache)
mode |= (1 << i);
}
}
break;
/* ------------------------------------------------------ */
case 'R': /* ROI */
if (sscanf(optarg, "OI:c=%d,U=%d", &ROI_compno, &ROI_shift) != 2) {
fprintf(stderr,
"ROI error !! [-ROI:c='compno',U='shift']\n");
return 1;
}
break;
/* ------------------------------------------------------ */
case 'T': /* Tile offset */
if (sscanf(optarg, "%d,%d", &TX0, &TY0) != 2) {
fprintf(stderr,
"-T 'tile offset' argument error !! [-T X0,Y0]");
return 1;
}
break;
/* ------------------------------------------------------ */
case 'C': /* Add a comment */
cp.comment = optarg;
break;
/* ------------------------------------------------------ */
case 'I': /* reversible or not */
ir = 1;
break;
/* ------------------------------------------------------ */
default:
return 1;
}
}
cp.tx0 = TX0;
cp.ty0 = TY0;
/* Error messages */
/* -------------- */
if (!infile || !outfile) {
fprintf(stderr,
"usage: pnmtoj2k -i pnm-file -o j2k-file\n");
return 1;
}
if (cp.disto_alloc & cp.fixed_alloc) {
fprintf(stderr,
"Error: option -r and -q can not be used together !!\n");
return 1;
}
/* if no rate entered, lossless by default */
if (tcp_init->numlayers == 0) {
tcp_init->rates[tcp_init->numlayers] = 1;
tcp_init->numlayers++;
cp.disto_alloc = 1;
}
if (TX0 > Dim[0] || TY0 > Dim[1]) {
fprintf(stderr,
"Error: Tile offset dimension is unnappropriate --> TX0(%d)<=IMG_X0(%d) TYO(%d)<=IMG_Y0(%d) \n",
TX0, Dim[0], TY0, Dim[1]);
return 1;
}
for (i = 0; i < numpocs; i++) {
if (POC[i].prg == -1) {
fprintf(stderr,
"Unrecognized progression order in option -P (POC n %d) [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n",
i + 1);
}
}
switch (cp.image_type) {
case 0:
if (Tile_arg) {
if (!pgxtoimage
(infile, &img, cp.tdy, subsampling_dx, subsampling_dy, Dim,
cp)) {
fprintf(stderr, "not a pgx file\n");
return 1;
}
} else {
if (!pgxtoimage
(infile, &img, -1, subsampling_dx, subsampling_dy, Dim, cp)) {
fprintf(stderr, " not a pgx file\n");
return 1;
}
}
break;
case 1:
if (!pnmtoimage(infile, &img, subsampling_dx, subsampling_dy, Dim)) {
fprintf(stderr, " not a pnm file\n");
return 1;
}
break;
case 2:
if (!bmptoimage(infile, &img, subsampling_dx, subsampling_dy, Dim)) {
fprintf(stderr, " not a bmp file\n");
return 1;
}
break;
}
/* to respect profile - 0 */
/* ---------------------- */
numD_min = 0;
/* while (int_ceildiv(img.x1,(1<<numD_min))-int_ceildiv(img.x0,(1<<numD_min))>120 || int_ceildiv(img.y1,(1<<numD_min))-int_ceildiv(img.y0,(1<<numD_min))>160) numD_min++;
if ((numD_min+1)>NumResolution)
{
fprintf(stderr,"\n********************************************************************************\n\n");
fprintf(stderr, "In view to respect Profile-0, the number of resolution used is %d in place of %d\n\n",numD_min+1,NumResolution);
fprintf(stderr, "********************************************************************************\n\n");
NumResolution=numD_min+1;
} */
if (Tile_arg == 1) {
cp.tw = int_ceildiv(img.x1 - cp.tx0, cp.tdx);
cp.th = int_ceildiv(img.y1 - cp.ty0, cp.tdy);
} else {
cp.tdx = img.x1 - cp.tx0;
cp.tdy = img.y1 - cp.ty0;
}
/* Init the mutiple tiles */
/* ---------------------- */
cp.tcps = (j2k_tcp_t *) malloc(cp.tw * cp.th * sizeof(j2k_tcp_t));
for (tileno = 0; tileno < cp.tw * cp.th; tileno++) {
tcp = &cp.tcps[tileno];
tcp->numlayers = tcp_init->numlayers;
for (j = 0; j < tcp->numlayers; j++) {
tcp->rates[j] = tcp_init->rates[j];
}
tcp->csty = CSty;
tcp->prg = Prog_order;
tcp->mct = img.numcomps == 3 ? 1 : 0;
numpocs_tile = 0;
if (numpocs) { /* intialisation of POC */
for (i = 0; i < numpocs; i++) {
if (tileno == POC[i].tile - 1 || POC[i].tile == -1) {
tcp_poc = &tcp->pocs[numpocs_tile];
tcp_poc->resno0 = POC[numpocs_tile].resno0;
tcp_poc->compno0 = POC[numpocs_tile].compno0;
tcp_poc->layno1 = POC[numpocs_tile].layno1;
tcp_poc->resno1 = POC[numpocs_tile].resno1;
tcp_poc->compno1 = POC[numpocs_tile].compno1;
tcp_poc->prg = POC[numpocs_tile].prg;
tcp_poc->tile = POC[numpocs_tile].tile;
numpocs_tile++;
}
}
}
tcp->numpocs = numpocs_tile;
tcp->tccps = (j2k_tccp_t *) malloc(img.numcomps * sizeof(j2k_tccp_t));
for (i = 0; i < img.numcomps; i++) {
tccp = &tcp->tccps[i];
tccp->csty = CSty & 0x01; /* 0 => one precinct || 1 => custom precinct */
tccp->numresolutions = NumResolution;
tccp->cblkw = int_floorlog2(cblockw_init);
tccp->cblkh = int_floorlog2(cblockh_init);
tccp->cblksty = mode;
tccp->qmfbid = ir ? 0 : 1;
tccp->qntsty = ir ? J2K_CCP_QNTSTY_SEQNT : J2K_CCP_QNTSTY_NOQNT;
tccp->numgbits = 2;
if (i == ROI_compno)
tccp->roishift = ROI_shift;
else
tccp->roishift = 0;
if (CSty & J2K_CCP_CSTY_PRT) {
for (j = 0; j < tccp->numresolutions; j++) {
int size_prcw, size_prch;
size_prcw = prcw_init >> (tccp->numresolutions - j - 1);
size_prch = prch_init >> (tccp->numresolutions - j - 1);
if (size_prcw < 1) {
tccp->prcw[j] = 1;
} else {
tccp->prcw[j] =
int_floorlog2(prcw_init >> (tccp->numresolutions - j - 1));
}
if (size_prch < 1) {
tccp->prch[j] = 1;
} else {
tccp->prch[j] =
int_floorlog2(prch_init >> (tccp->numresolutions - j - 1));
}
}
} else {
for (j = 0; j < tccp->numresolutions; j++) {
tccp->prcw[j] = 15;
tccp->prch[j] = 15;
}
}
calc_explicit_stepsizes(tccp, img.comps[i].prec);
}
}
len = j2k_encode(&img, &cp, outfile, cp.tdx * cp.tdy * 2, index);
if (len == 0) {
fprintf(stderr, "failed to encode image\n");
return 1;
}
if (cp.image_type) { /* PNM PGM PPM */
/* Remove the temporary file Compo */
/* ------------------------------- */
for (i = 0; i < img.numcomps; i++) {
char tmp[256];
sprintf(tmp, "Compo%d", i);
if (unlink(tmp) == -1) {
fprintf(stderr, "failed to kill %s file !\n",
tmp);
}
}
} else { /* PGX */
/* Kill temporary bandtile file for cleaning the memory space on user's disk */
for (i = 0; i < cp.th; i++) {
char tmp;
sprintf(&tmp, "bandtile%d", i + 1);
if (unlink(&tmp) == -1) {
fprintf(stderr, "failed to kill %s file !\n",
&tmp);
}
}
}
return 0;
}

350
codec/j2k_to_image.c Normal file
View File

@ -0,0 +1,350 @@
/* Copyright (c) 2001 David Janssens
* Copyright (c) 2002 Yannick Verschueren
* Copyright (c) 2002 Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
*
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <openjpeg.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int ceildiv(int a, int b)
{
return (a + b - 1) / b;
}
int main(int argc, char **argv)
{
FILE *f;
char *src;
char *dest, S1, S2, S3;
int len;
j2k_image_t *img;
j2k_cp_t *cp;
int w, h, max;
int i, image_type = -1;
if (argc < 3) {
fprintf(stderr, "usage: %s j2k-file pnm-file\n", argv[0]);
return 1;
}
f = fopen(argv[1], "rb");
if (!f) {
fprintf(stderr, "failed to open %s for reading\n", argv[1]);
return 1;
}
dest = argv[2];
while (*dest && *dest != '.') {
dest++;
}
dest++;
S1 = *dest;
dest++;
S2 = *dest;
dest++;
S3 = *dest;
if ((S1 == 'p' && S2 == 'g' && S3 == 'x')
|| (S1 == 'P' && S2 == 'G' && S3 == 'X')) {
image_type = 0;
}
if ((S1 == 'p' && S2 == 'n' && S3 == 'm')
|| (S1 == 'P' && S2 == 'N' && S3 == 'M') || (S1 == 'p' && S2 == 'g'
&& S3 == 'm')
|| (S1 == 'P' && S2 == 'G' && S3 == 'M') || (S1 == 'P' && S2 == 'P'
&& S3 == 'M')
|| (S1 == 'p' && S2 == 'p' && S3 == 'm')) {
image_type = 1;
}
if ((S1 == 'b' && S2 == 'm' && S3 == 'p')
|| (S1 == 'B' && S2 == 'M' && S3 == 'P')) {
image_type = 2;
}
if (image_type == -1) {
fprintf(stderr,
"\033[0;33m!! Unrecognized format for infile [accept only *.pnm, *.pgm, *.ppm, *.pgx or *.bmp] !!\033[0;39m\n\n");
return 1;
}
fseek(f, 0, SEEK_END);
len = ftell(f);
fseek(f, 0, SEEK_SET);
src = (char *) malloc(len);
fread(src, 1, len, f);
fclose(f);
if (!j2k_decode(src, len, &img, &cp)) {
fprintf(stderr, "j2k_to_image: failed to decode image!\n");
return 1;
}
free(src);
/* ------------------ CREATE OUT IMAGE WITH THE RIGHT FORMAT ----------------------- */
/* ------------------------ / */
/* / */
/* FORMAT : PNM, PGM or PPM / */
/* / */
/* ------------------------ / */
if (image_type == 1) { /* PNM PGM PPM */
if (img->numcomps == 3 && img->comps[0].dx == img->comps[1].dx
&& img->comps[1].dx == img->comps[2].dx
&& img->comps[0].dy == img->comps[1].dy
&& img->comps[1].dy == img->comps[2].dy
&& img->comps[0].prec == img->comps[1].prec
&& img->comps[1].prec == img->comps[2].prec) {
f = fopen(argv[2], "wb");
w = ceildiv(img->x1 - img->x0, img->comps[0].dx);
h = ceildiv(img->y1 - img->y0, img->comps[0].dy);
max = (1 << img->comps[0].prec) - 1;
fprintf(f, "P6\n%d %d\n%d\n", w, h, max);
for (i = 0; i < w * h; i++) {
char r, g, b;
r = img->comps[0].data[i];
g = img->comps[1].data[i];
b = img->comps[2].data[i];
fprintf(f, "%c%c%c", r, g, b);
}
fclose(f);
} else {
int compno;
for (compno = 0; compno < img->numcomps; compno++) {
char name[256];
if (img->numcomps > 1) {
sprintf(name, "%d.%s", compno, argv[2]);
} else {
sprintf(name, "%s", argv[2]);
}
f = fopen(name, "wb");
w = ceildiv(img->x1 - img->x0, img->comps[compno].dx);
h = ceildiv(img->y1 - img->y0, img->comps[compno].dy);
max = (1 << img->comps[compno].prec) - 1;
fprintf(f, "P5\n%d %d\n%d\n", w, h, max);
for (i = 0; i < w * h; i++) {
char l;
l = img->comps[compno].data[i];
fprintf(f, "%c", l);
}
fclose(f);
}
}
} else
/* ------------------------ / */
/* / */
/* FORMAT : PGX / */
/* / */
/* ------------------------ / */
if (image_type == 0) { /* PGX */
int compno;
for (compno = 0; compno < img->numcomps; compno++) {
j2k_comp_t *comp = &img->comps[compno];
char name[256];
/* sprintf(name, "%s-%d.pgx", argv[2], compno); */
sprintf(name, "%s", argv[2]);
f = fopen(name, "wb");
w = ceildiv(img->x1 - img->x0, comp->dx);
h = ceildiv(img->y1 - img->y0, comp->dy);
fprintf(f, "PG LM %c %d %d %d\n", comp->sgnd ? '-' : '+', comp->prec,
w, h);
for (i = 0; i < w * h; i++) {
int v = img->comps[compno].data[i];
if (comp->prec <= 8) {
char c = (char) v;
fwrite(&c, 1, 1, f);
} else if (comp->prec <= 16) {
short s = (short) v;
fwrite(&s, 2, 1, f);
} else {
fwrite(&v, 4, 1, f);
}
}
fclose(f);
}
} else
/* ------------------------ / */
/* / */
/* FORMAT : BMP / */
/* / */
/* ------------------------ / */
if (image_type == 2) { /* BMP */
if (img->numcomps == 3 && img->comps[0].dx == img->comps[1].dx
&& img->comps[1].dx == img->comps[2].dx
&& img->comps[0].dy == img->comps[1].dy
&& img->comps[1].dy == img->comps[2].dy
&& img->comps[0].prec == img->comps[1].prec
&& img->comps[1].prec == img->comps[2].prec) {
/* -->> -->> -->> -->>
24 bits color
<<-- <<-- <<-- <<-- */
f = fopen(argv[2], "wb");
w = ceildiv(img->x1 - img->x0, img->comps[0].dx);
h = ceildiv(img->y1 - img->y0, img->comps[0].dy);
fprintf(f, "BM");
/* FILE HEADER */
/* ------------- */
fprintf(f, "%c%c%c%c",
(unsigned char) (h * w * 3 + 3 * h * (w % 2) + 54) & 0xff,
(unsigned char) ((h * w * 3 + 3 * h * (w % 2) + 54) >> 8) &
0xff,
(unsigned char) ((h * w * 3 + 3 * h * (w % 2) + 54) >> 16) &
0xff,
(unsigned char) ((h * w * 3 + 3 * h * (w % 2) + 54) >> 24) &
0xff);
fprintf(f, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff,
((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
fprintf(f, "%c%c%c%c", (54) & 0xff, ((54) >> 8) & 0xff,
((54) >> 16) & 0xff, ((54) >> 24) & 0xff);
/* INFO HEADER */
/* ------------- */
fprintf(f, "%c%c%c%c", (40) & 0xff, ((40) >> 8) & 0xff,
((40) >> 16) & 0xff, ((40) >> 24) & 0xff);
fprintf(f, "%c%c%c%c", (unsigned char) ((w) & 0xff),
(unsigned char) ((w) >> 8) & 0xff,
(unsigned char) ((w) >> 16) & 0xff,
(unsigned char) ((w) >> 24) & 0xff);
fprintf(f, "%c%c%c%c", (unsigned char) ((h) & 0xff),
(unsigned char) ((h) >> 8) & 0xff,
(unsigned char) ((h) >> 16) & 0xff,
(unsigned char) ((h) >> 24) & 0xff);
fprintf(f, "%c%c", (1) & 0xff, ((1) >> 8) & 0xff);
fprintf(f, "%c%c", (24) & 0xff, ((24) >> 8) & 0xff);
fprintf(f, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff,
((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
fprintf(f, "%c%c%c%c",
(unsigned char) (3 * h * w + 3 * h * (w % 2)) & 0xff,
(unsigned char) ((h * w * 3 + 3 * h * (w % 2)) >> 8) & 0xff,
(unsigned char) ((h * w * 3 + 3 * h * (w % 2)) >> 16) & 0xff,
(unsigned char) ((h * w * 3 + 3 * h * (w % 2)) >> 24) &
0xff);
fprintf(f, "%c%c%c%c", (7834) & 0xff, ((7834) >> 8) & 0xff,
((7834) >> 16) & 0xff, ((7834) >> 24) & 0xff);
fprintf(f, "%c%c%c%c", (7834) & 0xff, ((7834) >> 8) & 0xff,
((7834) >> 16) & 0xff, ((7834) >> 24) & 0xff);
fprintf(f, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff,
((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
fprintf(f, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff,
((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
for (i = 0; i < w * h; i++) {
unsigned char R, G, B;
R = img->comps[0].data[w * h - ((i) / (w) + 1) * w + (i) % (w)];
G = img->comps[1].data[w * h - ((i) / (w) + 1) * w + (i) % (w)];
B = img->comps[2].data[w * h - ((i) / (w) + 1) * w + (i) % (w)];
fprintf(f, "%c%c%c", B, G, R);
if (((i + 1) % w == 0 && w % 2))
fprintf(f, "%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff,
((0) >> 16) & 0xff);
}
fclose(f);
} else { /* Gray-scale */
/* -->> -->> -->> -->>
8 bits non code (Gray scale)
<<-- <<-- <<-- <<-- */
f = fopen(argv[2], "wb");
w = ceildiv(img->x1 - img->x0, img->comps[0].dx);
h = ceildiv(img->y1 - img->y0, img->comps[0].dy);
fprintf(f, "BM");
/* FILE HEADER */
/* ------------- */
fprintf(f, "%c%c%c%c",
(unsigned char) (h * w + 54 + 1024 + h * (w % 2)) & 0xff,
(unsigned char) ((h * w + 54 + 1024 + h * (w % 2)) >> 8) &
0xff,
(unsigned char) ((h * w + 54 + 1024 + h * (w % 2)) >> 16) &
0xff,
(unsigned char) ((h * w + 54 + 1024 + w * (w % 2)) >> 24) &
0xff);
fprintf(f, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff,
((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
fprintf(f, "%c%c%c%c", (54 + 1024) & 0xff, ((54 + 1024) >> 8) & 0xff,
((54 + 1024) >> 16) & 0xff, ((54 + 1024) >> 24) & 0xff);
/* INFO HEADER */
/* ------------- */
fprintf(f, "%c%c%c%c", (40) & 0xff, ((40) >> 8) & 0xff,
((40) >> 16) & 0xff, ((40) >> 24) & 0xff);
fprintf(f, "%c%c%c%c", (unsigned char) ((w) & 0xff),
(unsigned char) ((w) >> 8) & 0xff,
(unsigned char) ((w) >> 16) & 0xff,
(unsigned char) ((w) >> 24) & 0xff);
fprintf(f, "%c%c%c%c", (unsigned char) ((h) & 0xff),
(unsigned char) ((h) >> 8) & 0xff,
(unsigned char) ((h) >> 16) & 0xff,
(unsigned char) ((h) >> 24) & 0xff);
fprintf(f, "%c%c", (1) & 0xff, ((1) >> 8) & 0xff);
fprintf(f, "%c%c", (8) & 0xff, ((8) >> 8) & 0xff);
fprintf(f, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff,
((0) >> 16) & 0xff, ((0) >> 24) & 0xff);
fprintf(f, "%c%c%c%c", (unsigned char) (h * w + h * (w % 2)) & 0xff,
(unsigned char) ((h * w + h * (w % 2)) >> 8) & 0xff,
(unsigned char) ((h * w + h * (w % 2)) >> 16) & 0xff,
(unsigned char) ((h * w + h * (w % 2)) >> 24) & 0xff);
fprintf(f, "%c%c%c%c", (7834) & 0xff, ((7834) >> 8) & 0xff,
((7834) >> 16) & 0xff, ((7834) >> 24) & 0xff);
fprintf(f, "%c%c%c%c", (7834) & 0xff, ((7834) >> 8) & 0xff,
((7834) >> 16) & 0xff, ((7834) >> 24) & 0xff);
fprintf(f, "%c%c%c%c", (256) & 0xff, ((256) >> 8) & 0xff,
((256) >> 16) & 0xff, ((256) >> 24) & 0xff);
fprintf(f, "%c%c%c%c", (256) & 0xff, ((256) >> 8) & 0xff,
((256) >> 16) & 0xff, ((256) >> 24) & 0xff);
}
for (i = 0; i < 256; i++) {
fprintf(f, "%c%c%c%c", i, i, i, 0);
}
for (i = 0; i < w * h; i++) {
fprintf(f, "%c",
img->comps[0].data[w * h - ((i) / (w) + 1) * w + (i) % (w)]);
if (((i + 1) % w == 0 && w % 2))
fprintf(f, "%c", 0);
}
}
return 0;
}

105
codec/readme.txt Normal file
View File

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

23
indexer_JPIP/Makefile Normal file
View File

@ -0,0 +1,23 @@
CC = gcc
LDFLAGS = -lm
CFLAGS = -Wall
all: index_create
bio.o : bio.c bio.h
cio.o : cio.c cio.h
int.o : int.c
pi.o : pi.c pi.h int.h
index_create.o : index_create.c j2k.h cio.h tcd.h int.h
t2.o : t2.c t2.h tcd.h bio.h j2k.h pi.h tgt.h int.h cio.h
tgt.o : tgt.c bio.h tgt.h
tcd.o : tcd.c tcd.h t2.h int.h
jpip.o : jpip.c j2k.h cio.h tcd.h int.h
jp2.o : jp2.c j2k.h cio.h tcd.h int.h
index_create : bio.o cio.o int.o pi.o t2.o tgt.o tcd.o index_create.o jpip.o jp2.o
clean:
rm -rf *.o *.*~ *~ core.*

163
indexer_JPIP/bio.c Normal file
View File

@ -0,0 +1,163 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 "bio.h"
#include <setjmp.h>
static unsigned char *bio_start, *bio_end, *bio_bp;
static unsigned int bio_buf;
static int bio_ct;
extern jmp_buf j2k_error;
/// <summary>
/// Number of bytes written.
/// </summary>
int bio_numbytes() {
return bio_bp-bio_start;
}
/// <summary>
/// Init encoder.
/// </summary>
/// <param name="bp">Output buffer</param>
/// <param name="len">Output buffer length</param>
void bio_init_enc(unsigned char *bp, int len) {
bio_start=bp;
bio_end=bp+len;
bio_bp=bp;
bio_buf=0;
bio_ct=8;
}
/// <summary>
/// Init decoder.
/// </summary>
/// <param name="bp">Input buffer</param>
/// <param name="len">Input buffer length</param>
void bio_init_dec(unsigned char *bp, int len) {
bio_start=bp;
bio_end=bp+len;
bio_bp=bp;
bio_buf=0;
bio_ct=0;
}
/// <summary>
/// Write byte.
/// </summary>
int bio_byteout() {
bio_buf=(bio_buf<<8)&0xffff;
bio_ct=bio_buf==0xff00?7:8;
if (bio_bp>=bio_end) return 1; //longjmp(j2k_error, 1);
*bio_bp++=bio_buf>>8;
return 0;
}
/// <summary>
/// Read byte.
/// </summary>
int bio_bytein() {
bio_buf=(bio_buf<<8)&0xffff;
bio_ct=bio_buf==0xff00?7:8;
if (bio_bp>=bio_end) return 1; //longjmp(j2k_error, 1);
bio_buf|=*bio_bp++;
return 0;
}
/// <summary>
/// Write bit.
/// </summary>
/// <param name="b">Bit to write (0 or 1)</param>
void bio_putbit(int b) {
if (bio_ct==0) {
bio_byteout();
}
bio_ct--;
bio_buf|=b<<bio_ct;
}
/// <summary>
/// Read bit.
/// </summary>
int bio_getbit() {
if (bio_ct==0) {
bio_bytein();
}
bio_ct--;
return (bio_buf>>bio_ct)&1;
}
/// <summary>
/// Write bits.
/// </summary>
/// <param name="v">Value of bits</param>
/// <param name="n">Number of bits to write</param>
void bio_write(int v, int n) {
int i;
for (i=n-1; i>=0; i--) {
bio_putbit((v>>i)&1);
}
}
/// <summary>
/// Read bits.
/// </summary>
/// <param name="n">Number of bits to read</param>
int bio_read(int n) {
int i, v;
v=0;
for (i=n-1; i>=0; i--) {
v+=bio_getbit()<<i;
}
return v;
}
/// <summary>
/// Flush bits.
/// </summary>
int bio_flush() {
bio_ct=0;
bio_byteout();
if (bio_ct==7) {
bio_ct=0;
if ( bio_byteout()) return 1;;
}
return 0;
}
/// <summary>
/// </summary>
int bio_inalign() {
bio_ct=0;
if ((bio_buf&0xff)==0xff) {
if( bio_bytein()) return 1;
bio_ct=0;
}
return 0;
}

40
indexer_JPIP/bio.h Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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
int bio_numbytes();
void bio_init_enc(unsigned char *bp, int len);
void bio_init_dec(unsigned char *bp, int len);
void bio_write(int v, int n);
int bio_read(int n);
int bio_flush();
int bio_inalign();
#endif

127
indexer_JPIP/cio.c Normal file
View File

@ -0,0 +1,127 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 "cio.h"
#include <setjmp.h>
static unsigned char *cio_start, *cio_end, *cio_bp;
extern jmp_buf j2k_error;
/// <summary>
/// Number of bytes written.
/// </summary>
int cio_numbytes() {
return cio_bp-cio_start;
}
/// <summary>
/// Get position in byte stream.
/// </summary>
int cio_tell() {
return cio_bp-cio_start;
}
/// <summary>
/// Set position in byte stream.
/// </summary>
void cio_seek(int pos) {
cio_bp=cio_start+pos;
}
/// <summary>
/// Number of bytes left before the end of the stream.
/// </summary>
int cio_numbytesleft() {
return cio_end-cio_bp;
}
/// <summary>
/// Get pointer to the current position in the stream.
/// </summary>
unsigned char *cio_getbp() {
return cio_bp;
}
/// <summary>
/// Initialize byte IO.
/// </summary>
void cio_init(unsigned char *bp, int len) {
cio_start=bp;
cio_end=bp+len;
cio_bp=bp;
}
/// <summary>
/// Write a byte.
/// </summary>
void cio_byteout(unsigned char v) {
if (cio_bp>=cio_end) longjmp(j2k_error, 1);
*cio_bp++=v;
}
/// <summary>
/// Read a byte.
/// </summary>
unsigned char cio_bytein() {
if (cio_bp>=cio_end) longjmp(j2k_error, 1);
return *cio_bp++;
}
/// <summary>
/// Write a byte.
/// </summary>
//void cio_write(unsigned int v, int n) {
void cio_write(long long v, int n) {
int i;
for (i=n-1; i>=0; i--)
{
cio_byteout((unsigned char)((v>>(i<<3))&0xff));
}
}
/// <summary>
/// Read some bytes.
/// </summary>
unsigned int cio_read(int n) {
int i;
unsigned int v;
v=0;
for (i=n-1; i>=0; i--) {
v+=cio_bytein()<<(i<<3);
}
return v;
}
/// <summary>
/// Write some bytes.
/// </summary>
void cio_skip(int n) {
cio_bp+=n;
}

43
indexer_JPIP/cio.h Normal file
View File

@ -0,0 +1,43 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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
int cio_tell();
void cio_seek(int pos);
int cio_numbytes();
int cio_numbytesleft();
unsigned char *cio_getbp();
void cio_init(unsigned char *bp, int len);
//void cio_write(unsigned int v, int n);
void cio_write(long long v, int n);
unsigned int cio_read(int n);
void cio_skip(int n);
#endif

42
indexer_JPIP/fix.c Normal file
View File

@ -0,0 +1,42 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 "fix.h"
#ifdef WIN32
#define int64 __int64
#else
#define int64 long long
#endif
/// <summary>
/// Multiply two fixed-precision rational numbers.
/// </summary>
int fix_mul(int a, int b) {
return (int)((int64)a*(int64)b>>13);
}

34
indexer_JPIP/fix.h Normal file
View File

@ -0,0 +1,34 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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
int fix_mul(int a, int b);
#endif

765
indexer_JPIP/index_create.c Normal file
View File

@ -0,0 +1,765 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 <setjmp.h>
#include <math.h>
#include <unistd.h>
#include "j2k.h"
#include "cio.h"
#include "tcd.h"
#include "int.h"
#include "jpip.h"
#include "jp2.h"
#define J2K_MS_SOC 0xff4f
#define J2K_MS_SOT 0xff90
#define J2K_MS_SOD 0xff93
#define J2K_MS_EOC 0xffd9
#define J2K_MS_SIZ 0xff51
#define J2K_MS_COD 0xff52
#define J2K_MS_COC 0xff53
#define J2K_MS_RGN 0xff5e
#define J2K_MS_QCD 0xff5c
#define J2K_MS_QCC 0xff5d
#define J2K_MS_POC 0xff5f
#define J2K_MS_TLM 0xff55
#define J2K_MS_PLM 0xff57
#define J2K_MS_PLT 0xff58
#define J2K_MS_PPM 0xff60
#define J2K_MS_PPT 0xff61
#define J2K_MS_SOP 0xff91
#define J2K_MS_EPH 0xff92
#define J2K_MS_CRG 0xff63
#define J2K_MS_COM 0xff64
#define J2K_STATE_MHSOC 0x0001
#define J2K_STATE_MHSIZ 0x0002
#define J2K_STATE_MH 0x0004
#define J2K_STATE_TPHSOT 0x0008
#define J2K_STATE_TPH 0x0010
#define J2K_STATE_MT 0x0020
jmp_buf j2k_error;
static int j2k_state;
static int j2k_curtileno;
static j2k_tcp_t j2k_default_tcp;
static unsigned char *j2k_eot;
static j2k_image_t *j2k_img;
static j2k_cp_t *j2k_cp;
static unsigned char **j2k_tile_data;
static int *j2k_tile_len;
static info_image_t img;
void j2k_clean() {
int tileno = 0;
int compno, resno, precno;
tcd_free(j2k_img,j2k_cp);
for (tileno=0;tileno<j2k_cp->tw*j2k_cp->th;tileno++) {
info_tile_t *tile_Idx = &img.tile[tileno];
for (compno=0;compno<img.Comp;compno++)
{
info_compo_t *compo_Idx = &tile_Idx->compo[compno];
for(resno=0;resno<img.Decomposition+1;resno++)
{
info_reso_t *reso_Idx = &compo_Idx->reso[resno];
for (precno=0;precno<img.tile[tileno].pw*img.tile[tileno].ph;precno++)
{
info_prec_t *prec_Idx = &reso_Idx->prec[precno];
free(prec_Idx->layer);
}
free(reso_Idx->prec);
}
free(compo_Idx->reso);
}
free(tile_Idx->compo);
}
free(img.tile);
free(img.marker);
}
void j2k_read_soc() {
j2k_state=J2K_STATE_MHSIZ;
}
void j2k_read_siz() {
int len, i;
len=cio_read(2);
// <INDEX>
img.marker[img.num_marker].type=J2K_MS_SIZ;
img.marker[img.num_marker].start_pos=cio_tell()-2;
img.marker[img.num_marker].len=len;
img.num_marker++;
// </INDEX>
cio_read(2); // Rsiz (capabilities)
j2k_img->x1=cio_read(4); // Xsiz
j2k_img->y1=cio_read(4); // Ysiz
j2k_img->x0=cio_read(4); // X0siz
j2k_img->y0=cio_read(4); // Y0siz
j2k_cp->tdx=cio_read(4); // XTsiz
j2k_cp->tdy=cio_read(4); // YTsiz
j2k_cp->tx0=cio_read(4); // XT0siz
j2k_cp->ty0=cio_read(4); // YTOsiz
j2k_img->numcomps=cio_read(2); // Csiz
j2k_img->comps=(j2k_comp_t*)malloc(j2k_img->numcomps*sizeof(j2k_comp_t));
for (i=0; i<j2k_img->numcomps; i++) {
int tmp, w, h;
tmp=cio_read(1);
j2k_img->comps[i].prec=(tmp&0x7f)+1;
j2k_img->comps[i].sgnd=tmp>>7;
j2k_img->comps[i].dx=cio_read(1);
j2k_img->comps[i].dy=cio_read(1);
w=int_ceildiv(j2k_img->x1-j2k_img->x0, j2k_img->comps[i].dx);
h=int_ceildiv(j2k_img->y1-j2k_img->y0, j2k_img->comps[i].dy);
j2k_img->comps[i].data=(int*)malloc(sizeof(int)*w*h);
}
j2k_cp->tw=int_ceildiv(j2k_img->x1-j2k_img->x0, j2k_cp->tdx);
j2k_cp->th=int_ceildiv(j2k_img->y1-j2k_img->y0, j2k_cp->tdy);
j2k_cp->tcps=(j2k_tcp_t*)calloc(sizeof(j2k_tcp_t), j2k_cp->tw*j2k_cp->th);
j2k_default_tcp.tccps=(j2k_tccp_t*)calloc(sizeof(j2k_tccp_t), j2k_img->numcomps);
for (i=0; i<j2k_cp->tw*j2k_cp->th; i++) {
j2k_cp->tcps[i].tccps=(j2k_tccp_t*)calloc(sizeof(j2k_tccp_t), j2k_img->numcomps);
}
j2k_tile_data=(unsigned char**)calloc(j2k_cp->tw*j2k_cp->th, sizeof(char*));
j2k_tile_len=(int*)calloc(j2k_cp->tw*j2k_cp->th, sizeof(int));
j2k_state=J2K_STATE_MH;
// <INDEX>
img.Im_w=j2k_img->x1-j2k_img->x0;
img.Im_h=j2k_img->y1-j2k_img->y0;
img.Tile_x=j2k_cp->tdx;
img.Tile_y=j2k_cp->tdy;
img.Comp=j2k_img->numcomps;
img.tw=j2k_cp->tw;
img.th=j2k_cp->th;
img.tile=(info_tile_t*)malloc((img.tw*img.th)*sizeof(info_tile_t));
//</INDEX>
}
void j2k_read_com() {
int len;
len=cio_read(2);
// <INDEX>
if (j2k_state==J2K_STATE_MH)
{
if (!img.marker_mul.num_COM)
img.marker_mul.COM=(info_marker_t*)malloc(sizeof(info_marker_t));
else
img.marker_mul.COM=realloc(img.marker_mul.COM,(1+img.marker_mul.num_COM)*sizeof(info_marker_t));
img.marker_mul.COM[img.marker_mul.num_COM].type=J2K_MS_COM;
img.marker_mul.COM[img.marker_mul.num_COM].start_pos=cio_tell()-2;
img.marker_mul.COM[img.marker_mul.num_COM].len=len;
img.marker_mul.num_COM++;
}
// </INDEX>
cio_skip(len-2);
}
void j2k_read_cox(int compno) {
int i;
j2k_tcp_t *tcp;
j2k_tccp_t *tccp;
tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
tccp=&tcp->tccps[compno];
tccp->numresolutions=cio_read(1)+1;
img.Decomposition=tccp->numresolutions-1; // <INDEX>
tccp->cblkw=cio_read(1)+2;
tccp->cblkh=cio_read(1)+2;
tccp->cblksty=cio_read(1);
tccp->qmfbid=cio_read(1);
if (tccp->csty&J2K_CP_CSTY_PRT) {
for (i=0; i<tccp->numresolutions; i++) {
int tmp=cio_read(1);
tccp->prcw[i]=tmp&0xf;
tccp->prch[i]=tmp>>4;
}
}
}
void j2k_read_cod() {
int len, i, pos;
j2k_tcp_t *tcp;
tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
len=cio_read(2);
// <INDEX>
if (j2k_state==J2K_STATE_MH)
{
if (!img.marker_mul.num_COD)
img.marker_mul.COD=(info_marker_t*)malloc(sizeof(info_marker_t));
else
img.marker_mul.COD=realloc(img.marker_mul.COD,(1+img.marker_mul.num_COD)*sizeof(info_marker_t));
img.marker_mul.COD[img.marker_mul.num_COD].type=J2K_MS_COD;
img.marker_mul.COD[img.marker_mul.num_COD].start_pos=cio_tell()-2;
img.marker_mul.COD[img.marker_mul.num_COD].len=len;
img.marker_mul.num_COD++;
}
// </INDEX>
tcp->csty=cio_read(1);
tcp->prg=cio_read(1);
tcp->numlayers=cio_read(2);
tcp->mct=cio_read(1);
pos=cio_tell();
for (i=0; i<j2k_img->numcomps; i++) {
tcp->tccps[i].csty=tcp->csty&J2K_CP_CSTY_PRT;
cio_seek(pos);
j2k_read_cox(i);
}
//<INDEX>
img.Prog=tcp->prg;
img.Layer=tcp->numlayers;
//</INDEX>
}
void j2k_read_coc() {
int len, compno;
j2k_tcp_t *tcp;
tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
len=cio_read(2);
// <INDEX>
if (j2k_state==J2K_STATE_MH)
{
if (!img.marker_mul.num_COC)
img.marker_mul.COC=(info_marker_t*)malloc(sizeof(info_marker_t));
else
img.marker_mul.COC=realloc(img.marker_mul.COC,(1+img.marker_mul.num_COC)*sizeof(info_marker_t));
img.marker_mul.COC[img.marker_mul.num_COC].type=J2K_MS_COC;
img.marker_mul.COC[img.marker_mul.num_COC].start_pos=cio_tell()-2;
img.marker_mul.COC[img.marker_mul.num_COC].len=len;
img.marker_mul.num_COC++;
}
// </INDEX>
compno=cio_read(j2k_img->numcomps<=256?1:2);
tcp->tccps[compno].csty=cio_read(1);
j2k_read_cox(compno);
}
void j2k_read_qcx(int compno, int len) {
int tmp;
j2k_tcp_t *tcp;
j2k_tccp_t *tccp;
int bandno, numbands;
tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
tccp=&tcp->tccps[compno];
tmp=cio_read(1);
tccp->qntsty=tmp&0x1f;
tccp->numgbits=tmp>>5;
numbands=tccp->qntsty==J2K_CCP_QNTSTY_SIQNT?1:(tccp->qntsty==J2K_CCP_QNTSTY_NOQNT?len-1:(len-1)/2);
for (bandno=0; bandno<numbands; bandno++) {
int expn, mant;
if (tccp->qntsty==J2K_CCP_QNTSTY_NOQNT) { // WHY STEPSIZES WHEN NOQNT ?
expn=cio_read(1)>>3;
mant=0;
} else {
tmp=cio_read(2);
expn=tmp>>11;
mant=tmp&0x7ff;
}
tccp->stepsizes[bandno].expn=expn;
tccp->stepsizes[bandno].mant=mant;
}
}
void j2k_read_qcd() {
int len, i, pos;
len=cio_read(2);
// <INDEX>
if (j2k_state==J2K_STATE_MH)
{
img.marker[img.num_marker].type=J2K_MS_QCD;
img.marker[img.num_marker].start_pos=cio_tell()-2;
img.marker[img.num_marker].len=len;
img.num_marker++;
}
// </INDEX>
pos=cio_tell();
for (i=0; i<j2k_img->numcomps; i++) {
cio_seek(pos);
j2k_read_qcx(i, len-2);
}
}
void j2k_read_qcc() {
int len, compno;
len=cio_read(2);
// <INDEX>
if (j2k_state==J2K_STATE_MH)
{
if (!img.marker_mul.num_QCC)
img.marker_mul.QCC=(info_marker_t*)malloc(sizeof(info_marker_t));
else
img.marker_mul.QCC=realloc(img.marker_mul.QCC,(1+img.marker_mul.num_QCC)*sizeof(info_marker_t));
img.marker_mul.QCC[img.marker_mul.num_QCC].type=J2K_MS_QCC;
img.marker_mul.QCC[img.marker_mul.num_QCC].start_pos=cio_tell()-2;
img.marker_mul.QCC[img.marker_mul.num_QCC].len=len;
img.marker_mul.num_QCC++;
}
// </INDEX>
compno=cio_read(j2k_img->numcomps<=256?1:2);
j2k_read_qcx(compno, len-2-(j2k_img->numcomps<=256?1:2));
}
void j2k_read_poc() {
int len, numpchgs, i;
j2k_tcp_t *tcp;
fprintf(stderr, "WARNING: POC marker segment processing not fully implemented\n");
tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
len=cio_read(2);
// <INDEX>
if (j2k_state==J2K_STATE_MH)
{
img.marker[img.num_marker].type=J2K_MS_POC;
img.marker[img.num_marker].start_pos=cio_tell()-2;
img.marker[img.num_marker].len=len;
img.num_marker++;
}
// </INDEX>
numpchgs=(len-2)/(5+2*(j2k_img->numcomps<=256?1:2));
for (i=0; i<numpchgs; i++) {
j2k_poc_t *poc;
poc=&tcp->pocs[i];
poc->resno0=cio_read(1);
poc->compno0=cio_read(j2k_img->numcomps<=256?1:2);
poc->layno1=cio_read(2);
poc->resno1=cio_read(1);
poc->compno1=cio_read(j2k_img->numcomps<=256?1:2);
poc->prg=cio_read(1);
}
}
void j2k_read_crg() {
int len;
len=cio_read(2);
// <INDEX>
if (j2k_state==J2K_STATE_MH)
{
img.marker[img.num_marker].type=J2K_MS_CRG;
img.marker[img.num_marker].start_pos=cio_tell()-2;
img.marker[img.num_marker].len=len;
img.num_marker++;
}
// </INDEX>
fprintf(stderr, "WARNING: CRG marker segment processing not implemented\n");
cio_skip(len-2);
}
void j2k_read_tlm() {
int len;
len=cio_read(2);
// <INDEX>
if (j2k_state==J2K_STATE_MH)
{
if (!img.marker_mul.num_TLM)
img.marker_mul.TLM=(info_marker_t*)malloc(sizeof(info_marker_t));
else
img.marker_mul.TLM=realloc(img.marker_mul.TLM,(1+img.marker_mul.num_TLM)*sizeof(info_marker_t));
img.marker_mul.TLM[img.marker_mul.num_TLM].type=J2K_MS_TLM;
img.marker_mul.TLM[img.marker_mul.num_TLM].start_pos=cio_tell()-2;
img.marker_mul.TLM[img.marker_mul.num_TLM].len=len;
img.marker_mul.num_TLM++;
}
// </INDEX>
fprintf(stderr, "WARNING: TLM marker segment processing not implemented\n");
cio_skip(len-2);
}
void j2k_read_plm() {
int len;
len=cio_read(2);
// <INDEX>
if (j2k_state==J2K_STATE_MH)
{
if (!img.marker_mul.num_PLM)
img.marker_mul.PLM=(info_marker_t*)malloc(sizeof(info_marker_t));
else
img.marker_mul.PLM=realloc(img.marker_mul.PLM,(1+img.marker_mul.num_PLM)*sizeof(info_marker_t));
img.marker_mul.PLM[img.marker_mul.num_PLM].type=J2K_MS_PLM;
img.marker_mul.PLM[img.marker_mul.num_PLM].start_pos=cio_tell()-2;
img.marker_mul.PLM[img.marker_mul.num_PLM].len=len;
img.marker_mul.num_PLM++;
}
// </INDEX>
fprintf(stderr, "WARNING: PLM marker segment processing not implemented\n");
cio_skip(len-2);
}
void j2k_read_plt() {
int len;
len=cio_read(2);
fprintf(stderr, "WARNING: PLT marker segment processing not implemented\n");
cio_skip(len-2);
}
void j2k_read_ppm() {
int len;
len=cio_read(2);
// <INDEX>
if (j2k_state==J2K_STATE_MH)
{
img.marker[img.num_marker].type=J2K_MS_PPM;
img.marker[img.num_marker].start_pos=cio_tell()-2;
img.marker[img.num_marker].len=len;
img.num_marker++;
}
// </INDEX>
fprintf(stderr, "WARNING: PPM marker segment processing not implemented\n");
cio_skip(len-2);
}
void j2k_read_ppt() {
int len;
len=cio_read(2);
fprintf(stderr, "WARNING: PPT marker segment processing not implemented\n");
cio_skip(len-2);
}
void j2k_read_sot() {
int len, tileno, totlen, partno, numparts, i;
j2k_tcp_t *tcp;
j2k_tccp_t *tmp;
len=cio_read(2);
tileno=cio_read(2);
//<INDEX>
if (!tileno) img.Main_head_end=cio_tell()-6; // Correction End = First byte of first SOT
img.tile[tileno].start_pos=cio_tell()-6;
img.tile[tileno].num_tile=tileno;
// </INDEX>
totlen=cio_read(4);
if (!totlen) totlen = cio_numbytesleft() + 8;
img.tile[tileno].end_pos=totlen+img.tile[tileno].start_pos; // <INDEX>
partno=cio_read(1);
numparts=cio_read(1);
j2k_curtileno=tileno;
j2k_eot=cio_getbp()-12+totlen;
j2k_state=J2K_STATE_TPH;
tcp=&j2k_cp->tcps[j2k_curtileno];
tmp=tcp->tccps;
*tcp=j2k_default_tcp;
tcp->tccps=tmp;
for (i=0; i<j2k_img->numcomps; i++) {
tcp->tccps[i]=j2k_default_tcp.tccps[i];
}
}
void j2k_read_sod() {
int len;
unsigned char *data;
img.tile[j2k_curtileno].end_header=cio_tell()-1; //<INDEX>
len=int_min(j2k_eot-cio_getbp(), cio_numbytesleft());
j2k_tile_len[j2k_curtileno]+=len;
data=(unsigned char*)realloc(j2k_tile_data[j2k_curtileno], j2k_tile_len[j2k_curtileno]);
memcpy(data, cio_getbp(), len);
j2k_tile_data[j2k_curtileno]=data;
cio_skip(len);
j2k_state=J2K_STATE_TPHSOT;
}
void j2k_read_rgn() {
int len, compno, roisty;
j2k_tcp_t *tcp;
tcp=j2k_state==J2K_STATE_TPH?&j2k_cp->tcps[j2k_curtileno]:&j2k_default_tcp;
len=cio_read(2);
// <INDEX>
if (j2k_state==J2K_STATE_MH)
{
if (!img.marker_mul.num_RGN)
img.marker_mul.RGN=(info_marker_t*)malloc(sizeof(info_marker_t));
else
img.marker_mul.RGN=realloc(img.marker_mul.RGN,(1+img.marker_mul.num_RGN)*sizeof(info_marker_t));
img.marker_mul.RGN[img.marker_mul.num_RGN].type=J2K_MS_RGN;
img.marker_mul.RGN[img.marker_mul.num_RGN].start_pos=cio_tell()-2;
img.marker_mul.RGN[img.marker_mul.num_RGN].len=len;
img.marker_mul.num_RGN++;
}
// </INDEX>
compno=cio_read(j2k_img->numcomps<=256?1:2);
roisty=cio_read(1);
tcp->tccps[compno].roishift=cio_read(1);
}
void j2k_read_eoc() {
int tileno;
tcd_init(j2k_img, j2k_cp, &img);
for (tileno=0; tileno<j2k_cp->tw*j2k_cp->th; tileno++) {
tcd_decode_tile(j2k_tile_data[tileno], j2k_tile_len[tileno], tileno, &img);
}
j2k_state=J2K_STATE_MT;
longjmp(j2k_error, 1);
}
void j2k_read_unk() {
fprintf(stderr, "warning: unknown marker\n");
}
int j2k_index_JPIP(char *Idx_file, char *J2K_file, int len){
FILE *dest;
char *index;
int pos_iptr, end_pos;
int len_cidx, pos_cidx;
int len_jp2c, pos_jp2c;
int len_fidx, pos_fidx;
dest=fopen(Idx_file, "wb");
if (!dest) {
fprintf(stderr,"Failed to open %s for reading !!\n",Idx_file);
return 0;
}
// INDEX MODE JPIP
index=(char*)malloc(len);
cio_init(index, len);
jp2_write_jp();
jp2_write_ftyp();
jp2_write_jp2h(j2k_img);
jp2_write_dbtl(Idx_file);
pos_iptr=cio_tell();
cio_skip(24); // IPTR further !
pos_jp2c=cio_tell();
len_jp2c=jp2_write_jp2c(J2K_file);
pos_cidx=cio_tell();
len_cidx=jpip_write_cidx(pos_jp2c+8,img, j2k_cp); // Correction len_jp2C --> pos_jp2c+8
pos_fidx=cio_tell();
len_fidx=jpip_write_fidx(pos_jp2c, len_jp2c, pos_cidx, len_cidx);
end_pos=cio_tell();
cio_seek(pos_iptr);
jpip_write_iptr(pos_fidx,len_fidx);
cio_seek(end_pos);
fwrite(index, 1, cio_tell(), dest);
free(index);
fclose(dest);
return 1;
}
typedef struct {
int id;
int states;
void (*handler)();
} j2k_dec_mstabent_t;
j2k_dec_mstabent_t j2k_dec_mstab[]={
{J2K_MS_SOC, J2K_STATE_MHSOC, j2k_read_soc},
{J2K_MS_SOT, J2K_STATE_MH|J2K_STATE_TPHSOT, j2k_read_sot},
{J2K_MS_SOD, J2K_STATE_TPH, j2k_read_sod},
{J2K_MS_EOC, J2K_STATE_TPHSOT, j2k_read_eoc},
{J2K_MS_SIZ, J2K_STATE_MHSIZ, j2k_read_siz},
{J2K_MS_COD, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_cod},
{J2K_MS_COC, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_coc},
{J2K_MS_RGN, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_rgn},
{J2K_MS_QCD, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_qcd},
{J2K_MS_QCC, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_qcc},
{J2K_MS_POC, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_poc},
{J2K_MS_TLM, J2K_STATE_MH, j2k_read_tlm},
{J2K_MS_PLM, J2K_STATE_MH, j2k_read_plm},
{J2K_MS_PLT, J2K_STATE_TPH, j2k_read_plt},
{J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm},
{J2K_MS_PPT, J2K_STATE_TPH, j2k_read_ppt},
{J2K_MS_SOP, 0, 0},
{J2K_MS_CRG, J2K_STATE_MH, j2k_read_crg},
{J2K_MS_COM, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_com},
{0, J2K_STATE_MH|J2K_STATE_TPH, j2k_read_unk}
};
j2k_dec_mstabent_t *j2k_dec_mstab_lookup(int id) {
j2k_dec_mstabent_t *e;
for (e=j2k_dec_mstab; e->id!=0; e++) {
if (e->id==id) {
break;
}
}
return e;
}
LIBJ2K_API int j2k_decode(unsigned char *src, int len, j2k_image_t **image, j2k_cp_t **cp) {
if (setjmp(j2k_error)) {
if (j2k_state!=J2K_STATE_MT) {
fprintf(stderr, "WARNING: incomplete bitstream\n");
return 0;
}
return cio_numbytes();
}
j2k_img=(j2k_image_t*)malloc(sizeof(j2k_image_t));
j2k_cp=(j2k_cp_t*)malloc(sizeof(j2k_cp_t));
*image=j2k_img;
*cp=j2k_cp;
j2k_state=J2K_STATE_MHSOC;
cio_init(src, len);
for (;;) {
j2k_dec_mstabent_t *e;
int id=cio_read(2);
if (id>>8!=0xff) {
fprintf(stderr, "%.8x: expected a marker instead of %x\n", cio_tell()-2, id);
return 0;
}
e=j2k_dec_mstab_lookup(id);
if (!(j2k_state & e->states)) {
fprintf(stderr, "%.8x: unexpected marker %x\n", cio_tell()-2, id);
return 0;
}
if (e->handler) {
(*e->handler)();
}
}
}
#ifdef WIN32
#include <windows.h>
BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
switch (ul_reason_for_call) {
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
#endif
extern info_image_t img;
int main(int argc, char **argv)
{
FILE *src;
int totlen;
char *j2kfile;
j2k_image_t *imgg;
j2k_cp_t *cp;
if (argc!=3)
{
fprintf(stderr,"\nERROR in entry : index_create J2K-file Idx-file\n\n");
return 0;
}
src=fopen(argv[1], "rb");
if (!src) {
fprintf(stderr,"Failed to open %s for reading !!\n",argv[1]);
return 0;
}
// length of the codestream
fseek(src, 0, SEEK_END);
totlen=ftell(src);
fseek(src, 0, SEEK_SET);
j2kfile=(char*)malloc(totlen);
fread(j2kfile, 1, totlen, src);
img.marker=(info_marker_t*)malloc(32*sizeof(info_marker_t));
img.num_marker=0;
img.marker_mul.num_COD=0;
img.marker_mul.num_COC=0;
img.marker_mul.num_RGN=0;
img.marker_mul.num_QCC=0;
img.marker_mul.num_TLM=0;
img.marker_mul.num_PLM=0;
img.marker_mul.num_COM=0;
// decode
if (!j2k_decode(j2kfile, totlen, &imgg, &cp)) {
fprintf(stderr, "Index_creator: failed to decode image!\n");
return 1;
}
free(j2kfile);
fseek(src, 0, SEEK_SET);
img.codestream_size=totlen;
j2k_index_JPIP(argv[2],argv[1],totlen*2>30000?totlen*2:30000);
fclose(src);
j2k_clean();
return 1;
}

89
indexer_JPIP/int.c Normal file
View File

@ -0,0 +1,89 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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.
*/
/// <summary>
/// Get the minimum of two integers.
/// </summary>
int int_min(int a, int b) {
return a<b?a:b;
}
/// <summary>
/// Get the maximum of two integers.
/// </summary>
int int_max(int a, int b) {
return a>b?a:b;
}
/// <summary>
/// Clamp an integer inside an interval.
/// </summary>
int int_clamp(int a, int min, int max) {
if (a<min) return min;
if (a>max) return max;
return a;
}
/// <summary>
/// Get absolute value of integer.
/// </summary>
int int_abs(int a) {
return a<0?-a:a;
}
/// <summary>
/// Divide an integer and round upwards.
/// </summary>
int int_ceildiv(int a, int b) {
return (a+b-1)/b;
}
/// <summary>
/// Divide an integer by a power of 2 and round upwards.
/// </summary>
int int_ceildivpow2(int a, int b) {
return (a+(1<<b)-1)>>b;
}
/// <summary>
/// Divide an integer by a power of 2 and round downwards.
/// </summary>
int int_floordivpow2(int a, int b) {
return a>>b;
}
/// <summary>
/// Get logarithm of an integer and round downwards.
/// </summary>
int int_floorlog2(int a) {
int l;
for (l=0; a>1; l++) {
a>>=1;
}
return l;
}

41
indexer_JPIP/int.h Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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
int int_min(int a, int b);
int int_max(int a, int b);
int int_clamp(int a, int min, int max);
int int_abs(int a);
int int_ceildiv(int a, int b);
int int_ceildivpow2(int a, int b);
int int_floordivpow2(int a, int b);
int int_floorlog2(int a);
#endif

222
indexer_JPIP/j2k.h Normal file
View File

@ -0,0 +1,222 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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.
*/
#define VERSION "0.0.8"
#ifdef WIN32
#ifdef LIBJ2K_EXPORTS
#define LIBJ2K_API __declspec(dllexport)
#else
#define LIBJ2K_API __declspec(dllimport)
#endif
#else
#define LIBJ2K_API
#endif
#ifndef __J2K_H
#define __J2K_H
#define J2K_MAXRLVLS 33
#define J2K_MAXBANDS (3*J2K_MAXRLVLS+1)
#define J2K_CP_CSTY_PRT 0x01
#define J2K_CP_CSTY_SOP 0x02
#define J2K_CP_CSTY_EPH 0x04
#define J2K_CCP_CSTY_PRT 0x01
#define J2K_CCP_CBLKSTY_LAZY 0x01
#define J2K_CCP_CBLKSTY_RESET 0x02
#define J2K_CCP_CBLKSTY_TERMALL 0x04
#define J2K_CCP_CBLKSTY_VSC 0x08
#define J2K_CCP_CBLKSTY_PTERM 0x10
#define J2K_CCP_CBLKSTY_SEGSYM 0x20
#define J2K_CCP_QNTSTY_NOQNT 0
#define J2K_CCP_QNTSTY_SIQNT 1
#define J2K_CCP_QNTSTY_SEQNT 2
typedef struct
{
int dx, dy; // XRsiz, YRsiz
int prec; // precision
int bpp; // deapth of image in bits
int sgnd; // signed
int *data; // image-component data
} j2k_comp_t;
typedef struct {
int x0, y0; // XOsiz, YOsiz
int x1, y1; // Xsiz, Ysiz
int numcomps; // number of components
int index_on; // 0 = no index || 1 = index
//int PPT;
j2k_comp_t *comps; // image-components
} j2k_image_t;
typedef struct {
int expn; // exponent
int mant; // mantissa
} j2k_stepsize_t;
typedef struct {
int csty; // coding style
int numresolutions; // number of resolutions
int cblkw; // width of code-blocks
int cblkh; // height of code-blocks
int cblksty; // code-block coding style
int qmfbid; // discrete wavelet transform identifier
int qntsty; // quantisation style
j2k_stepsize_t stepsizes[J2K_MAXBANDS]; // stepsizes used for quantisation
int numgbits; // number of guard bits
int roishift; // Region Of Interest shift
int prcw[J2K_MAXRLVLS]; // Precinct width
int prch[J2K_MAXRLVLS]; // Precinct height
} j2k_tccp_t;
typedef struct {
int resno0, compno0;
int layno1, resno1, compno1;
int prg;
int tile;
char progorder[4];
} j2k_poc_t;
typedef struct {
int csty; // coding style
int prg; // progression order
int numlayers; // number of layers
int mct; // multi-component transform identifier
int rates[100]; // rates of layers
int numpocs; // number of progression order changes
j2k_poc_t pocs[32]; // progression order changes
j2k_tccp_t *tccps; // tile-component coding parameters
} j2k_tcp_t;
typedef struct {
int tx0, ty0; // XTOsiz, YTOsiz
int tdx, tdy; // XTsiz, YTsiz
int tw, th;
j2k_tcp_t *tcps; // tile coding parameters
} j2k_cp_t;
typedef struct {
int len;
int len_header;
int offset;
} info_layer_t;
typedef struct {
info_layer_t *layer;
} info_prec_t;
typedef struct {
info_prec_t *prec;
} info_reso_t;
typedef struct {
info_reso_t *reso;
} info_compo_t;
typedef struct {
int num_tile; // Number of Tile
int start_pos; // Start position
int end_header; // End position of the header
int end_pos; // End position
int pw, ph; // number of precinct by tile
int num_packet; // number of packet in the tile
info_compo_t *compo; // component [packet]
} info_tile_t; // index struct
typedef struct {
int type; // type of marker [SIZ, QCD, POC, PPM, CRG] appearing only once
int start_pos; // Start position of the marker
int len; // Length of the marker
} info_marker_t; // index struct
typedef struct{
info_marker_t *COD;
int num_COD;
info_marker_t *COC;
int num_COC;
info_marker_t *RGN;
int num_RGN;
info_marker_t *QCC;
int num_QCC;
info_marker_t *TLM;
int num_TLM;
info_marker_t *PLM;
int num_PLM;
info_marker_t *PPM;
int num_PPM;
info_marker_t *COM;
int num_COM;
} info_marker_mul_t; // index struct
typedef struct {
int index_on;
int num; // numero of packet
int index_write; // writing the packet inthe index with t2_encode_packets
int Im_w, Im_h; // Image width and Height
int Prog; // progression order
int Tile_x, Tile_y; // Number of Tile in X and Y
int tw, th;
int Comp; // Component numbers
int Layer; // number of layer
int Decomposition; // number of decomposition
int pw, ph; // nombre precinct in X and Y
int pdx, pdy; // size of precinct in X and Y
int Main_head_end; // Main header position
int codestream_size; // codestream's size
info_tile_t *tile; // information concerning tiles inside image
info_marker_t *marker; // information concerning markers inside image [only one apparition]
info_marker_mul_t marker_mul; // information concerning markers inside image [multiple apparition]
int num_marker; // number of marker
int num_packet_max; // MAximum number of packet
} info_image_t; // index struct
/*
* Encode an image into a JPEG-2000 codestream
* i: image to encode
* cp: coding parameters
* dest: destination buffer
* len: length of destination buffer
* index : index file name
*/
LIBJ2K_API int j2k_encode(j2k_image_t *i, j2k_cp_t *cp,char *outfile, int len,char *index);
//LIBJ2K_API int j2k_encode(j2k_image_t *i, j2k_cp_t *cp,unsigned char *dest, int len);
/*
* Decode an image from a JPEG-2000 codestream
* src: source buffer
* len: length of source buffer
* i: decode image
* cp: coding parameters that were used to encode the image
*/
LIBJ2K_API int j2k_decode(unsigned char *src, int len, j2k_image_t **i, j2k_cp_t **cp);
#endif

259
indexer_JPIP/jp2.c Normal file
View File

@ -0,0 +1,259 @@
/*
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 <setjmp.h>
#include <math.h>
#include <unistd.h>
#include "j2k.h"
#include "cio.h"
#include "tcd.h"
#include "int.h"
#define JPIP_JPIP 0x6a706970
#define JP2_JP 0x6a502020
#define JP2_FTYP 0x66747970
#define JP2_JP2H 0x6a703268
#define JP2_IHDR 0x69686472
#define JP2_COLR 0x636f6c72
#define JP2_JP2C 0x6a703263
#define JP2_URL 0x75726c20
#define JP2_DBTL 0x6474626c
#define JP2_BPCC 0x62706363
#define JP2 0x6a703220
void jp2_write_url(char *Idx_file)
{
int len, lenp, i;
char str[256];
sprintf(str, "%s", Idx_file);
lenp=cio_tell();
cio_skip(4);
cio_write(JP2_URL, 4); // DBTL
cio_write(0,1); // VERS
cio_write(0,3); // FLAG
for (i=0; i<strlen(str); i++) {
cio_write(str[i], 1);
}
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len,4); // L
cio_seek(lenp+len);
}
void jp2_write_dbtl(char *Idx_file)
{
int len, lenp;
lenp=cio_tell();
cio_skip(4);
cio_write(JP2_DBTL, 4); // DBTL
cio_write(1,2); // NDR : Only 1
jp2_write_url(Idx_file); // URL Box
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len,4); // L
cio_seek(lenp+len);
}
int jp2_write_ihdr(j2k_image_t *j2k_img)
{
int len, lenp,i;
int depth_0,depth, sign, BPC_ok=1;
lenp=cio_tell();
cio_skip(4);
cio_write(JP2_IHDR, 4); // IHDR
cio_write(j2k_img->y1-j2k_img->x0,4); // HEIGHT
cio_write(j2k_img->x1-j2k_img->x0,4); // WIDTH
cio_write(j2k_img->numcomps,2); // NC
depth_0=j2k_img->comps[0].prec-1;
sign=j2k_img->comps[0].sgnd;
for(i=1;i<j2k_img->numcomps;i++)
{
depth=j2k_img->comps[i].prec-1;
sign=j2k_img->comps[i].sgnd;
if(depth_0!=depth) BPC_ok=0;
}
if (BPC_ok)
cio_write(depth_0+(sign<<7),1);
else
cio_write(255,1);
cio_write(7,1); // C : Always 7
cio_write(1,1); // UnkC, colorspace unknow
cio_write(0,1); // IPR, no intellectual property
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len,4); // L
cio_seek(lenp+len);
return BPC_ok;
}
void jp2_write_bpcc(j2k_image_t *j2k_img)
{
int len, lenp, i;
lenp=cio_tell();
cio_skip(4);
cio_write(JP2_BPCC, 4); // BPCC
for(i=0;i<j2k_img->numcomps;i++)
cio_write(j2k_img->comps[i].prec-1+(j2k_img->comps[i].sgnd<<7),1);
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len,4); // L
cio_seek(lenp+len);
}
void jp2_write_colr(int BPC_ok, j2k_image_t *j2k_img)
{
int len, lenp, meth;
lenp=cio_tell();
cio_skip(4);
cio_write(JP2_COLR, 4); // COLR
if ((j2k_img->numcomps==1 || j2k_img->numcomps==3) && (BPC_ok && j2k_img->comps[0].prec==8))
meth=1;
else
meth=2;
cio_write(meth,1); // METH
cio_write(0,1); // PREC
cio_write(0,1); // APPROX
if (meth==1)
cio_write(j2k_img->numcomps>1?16:17,4); // EnumCS
if (meth==2)
cio_write(0,1); // PROFILE (??)
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len,4); // L
cio_seek(lenp+len);
}
void jp2_write_jp2h(j2k_image_t *j2k_img)
{
int len, lenp, BPC_ok;
lenp=cio_tell();
cio_skip(4);
cio_write(JP2_JP2H, 4); // JP2H
BPC_ok=jp2_write_ihdr(j2k_img);
if (!BPC_ok)
jp2_write_bpcc(j2k_img);
jp2_write_colr(BPC_ok, j2k_img);
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len,4); // L
cio_seek(lenp+len);
}
void jp2_write_ftyp()
{
int len, lenp;
lenp=cio_tell();
cio_skip(4);
cio_write(JP2_FTYP, 4); // FTYP
cio_write(JP2,4); // BR
cio_write(0,4); // MinV
cio_write(JP2,4); // CL0 : JP2
cio_write(JPIP_JPIP,4); // CL1 : JPIP
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len,4); // L
cio_seek(lenp+len);
}
int jp2_write_jp2c(char *J2K_file)
{
int len, lenp, totlen, i;
FILE *src;
char *j2kfile;
lenp=cio_tell();
cio_skip(4);
cio_write(JP2_JP2C, 4); // JP2C
src=fopen(J2K_file, "rb");
fseek(src, 0, SEEK_END);
totlen=ftell(src);
fseek(src, 0, SEEK_SET);
j2kfile=(char*)malloc(totlen);
fread(j2kfile, 1, totlen, src);
fclose(src);
for (i=0;i<totlen;i++)
cio_write(j2kfile[i],1);
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len,4); // L
cio_seek(lenp+len);
return lenp;
}
void jp2_write_jp()
{
int len, lenp;
lenp=cio_tell();
cio_skip(4);
cio_write(JP2_JP, 4); // JP
cio_write(0x0d0a870a,4);
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len,4); // L
cio_seek(lenp+len);
}

40
indexer_JPIP/jp2.h Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 "j2k.h"
void jp2_write_url(char *Idx_file);
void jp2_write_dbtl(char *Idx_file);
void jp2_write_jp2h(j2k_image_t *j2k_img);
void jp2_write_ftyp();
int jp2_write_jp2c(char *J2K_file);
void jp2_write_jp();

489
indexer_JPIP/jpip.c Normal file
View File

@ -0,0 +1,489 @@
/*
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 <setjmp.h>
#include <math.h>
#include <unistd.h>
#include "j2k.h"
#include "cio.h"
#include "tcd.h"
#include "int.h"
#define JPIP_CIDX 0x63696478
#define JPIP_CPTR 0x63707472
#define JPIP_MANF 0x6d616e66
#define JPIP_FAIX 0x66616978
#define JPIP_MHIX 0x6d686978
#define JPIP_TPIX 0x74706978
#define JPIP_THIX 0x74686978
#define JPIP_PPIX 0x70706978
#define JPIP_PHIX 0x70686978
#define JPIP_FIDX 0x66696478
#define JPIP_FPTR 0x66707472
#define JPIP_PRXY 0x70727879
#define JPIP_IPTR 0x69707472
#define JP2C 0x6a703263
static info_marker_t marker_jpip[32], marker_local_jpip[32]; // SIZE to precise !
static int num_marker_jpip, num_marker_local_jpip;
void jpip_write_cptr(int offset, info_image_t img) // Codestream finder box (box)
{
int len, lenp;
lenp=cio_tell();
cio_skip(4); // L [at the end]
cio_write(JPIP_CPTR,4); // T
cio_write(0,2); // DR A PRECISER !!
cio_write(0,2); // CONT
cio_write(offset,8); // COFF A PRECISER !!
cio_write(img.codestream_size,8); // CLEN
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); // L
cio_seek(lenp+len);
}
void jpip_write_manf(int second, int v, info_marker_t *marker) // Manifest box (box)
{
int len, lenp, i;
lenp=cio_tell();
cio_skip(4); // L [at the end]
cio_write(JPIP_MANF,4); // T
if (second) // Write only during the second pass
{
for(i=0;i<v;i++)
{
cio_write(marker[i].len,4);
cio_write(marker[i].type,4);
}
}
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); // L
cio_seek(lenp+len);
}
int jpip_write_mhix(info_image_t img) // Main Header Index Table (box)
{
int len, lenp, i;
lenp=cio_tell();
cio_skip(4); // L [at the end]
cio_write(JPIP_MHIX, 4); // CIDX
cio_write(img.Main_head_end,8); // TLEN
for(i=0;i<img.num_marker;i++) // Marker restricted to 1 apparition
{
cio_write(img.marker[i].type,2);
cio_write(0,2);
cio_write(img.marker[i].start_pos,8);
cio_write(img.marker[i].len,2);
}
// Marker NOT restricted to 1 apparition
for(i=img.marker_mul.num_COD-1;i>=0;i--) // COD
{
cio_write(img.marker_mul.COD[i].type,2);
cio_write(i,2);
cio_write(img.marker_mul.COD[i].start_pos,8);
cio_write(img.marker_mul.COD[i].len,2);
}
for(i=img.marker_mul.num_COC-1;i>=0;i--) // COC
{
cio_write(img.marker_mul.COC[i].type,2);
cio_write(i,2);
cio_write(img.marker_mul.COC[i].start_pos,8);
cio_write(img.marker_mul.COC[i].len,2);
}
for(i=img.marker_mul.num_RGN-1;i>=0;i--) // RGN
{
cio_write(img.marker_mul.RGN[i].type,2);
cio_write(i,2);
cio_write(img.marker_mul.RGN[i].start_pos,8);
cio_write(img.marker_mul.RGN[i].len,2);
}
for(i=img.marker_mul.num_QCC-1;i>=0;i--) // QCC
{
cio_write(img.marker_mul.QCC[i].type,2);
cio_write(i,2);
cio_write(img.marker_mul.QCC[i].start_pos,8);
cio_write(img.marker_mul.QCC[i].len,2);
}
for(i=img.marker_mul.num_TLM-1;i>=0;i--) // TLM
{
cio_write(img.marker_mul.TLM[i].type,2);
cio_write(i,2);
cio_write(img.marker_mul.TLM[i].start_pos,8);
cio_write(img.marker_mul.TLM[i].len,2);
}
for(i=img.marker_mul.num_PLM-1;i>=0;i--) // PLM
{
cio_write(img.marker_mul.PLM[i].type,2);
cio_write(i,2);
cio_write(img.marker_mul.PLM[i].start_pos,8);
cio_write(img.marker_mul.PLM[i].len,2);
}
for(i=img.marker_mul.num_COM-1;i>=0;i--) // COM
{
cio_write(img.marker_mul.COM[i].type,2);
cio_write(i,2);
cio_write(img.marker_mul.COM[i].start_pos,8);
cio_write(img.marker_mul.COM[i].len,2);
}
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); // L
cio_seek(lenp+len);
return len;
}
int jpip_write_faix(int v, int compno, info_image_t img, j2k_cp_t *j2k_cp) // Fragment array Index box
{
int len, lenp, i;
int version = 0;
int tileno, resno, precno, layno, num_packet=0;
lenp=cio_tell();
cio_skip(4); // L [at the end]
cio_write(JPIP_FAIX, 4); // MHIX
cio_write(version,1); // Version 0 = 4 bytes
switch(v)
{
case 0: // TPIX
cio_write(1,version?8:4); // NMAX
cio_write(img.tw*img.th,version?8:4); // M
for (i=0;i<img.tw*img.th;i++)
{
cio_write(img.tile[i].start_pos,version?8:4);
cio_write(img.tile[i].end_pos-img.tile[i].start_pos,version?8:4);
}
break;
case 1: // THIX
cio_write(1,version?8:4); // NMAX
cio_write(img.tw*img.th,version?8:4); // M
for (i=0;i<img.tw*img.th;i++)
{
cio_write(img.tile[i].start_pos,version?8:4);
cio_write(img.tile[i].end_header-img.tile[i].start_pos,version?8:4);
}
break;
case 2: // PPIX NOT FINISHED !!
cio_write(img.num_packet_max,version?8:4); // NMAX
cio_write(img.tw*img.th,version?8:4); // M
for(tileno=0;tileno<img.tw*img.th;tileno++)
{
info_tile_t *tile_Idx = &img.tile[tileno];
info_compo_t *compo_Idx = &tile_Idx->compo[compno];
int correction;
if(j2k_cp->tcps[tileno].csty&J2K_CP_CSTY_EPH)
correction=3;
else
correction=1;
for(resno=0;resno<img.Decomposition+1;resno++)
{
info_reso_t *reso_Idx = &compo_Idx->reso[resno];
for (precno=0;precno<img.tile[tileno].pw*img.tile[tileno].ph;precno++)
{
info_prec_t *prec_Idx = &reso_Idx->prec[precno];
for(layno=0;layno<img.Layer;layno++)
{
info_layer_t *layer_Idx = &prec_Idx->layer[layno];
cio_write(layer_Idx->offset,version?8:4);
cio_write((layer_Idx->len_header-correction)?0:layer_Idx->len,version?8:4);
num_packet++;
}
}
}
}
// PADDING
while (num_packet<img.num_packet_max)
{
cio_write(0,version?8:4);
cio_write(0,version?8:4);
num_packet++;
}
break;
case 3: // PHIX NOT FINISHED !!
cio_write(img.num_packet_max,version?8:4); // NMAX
cio_write(img.tw*img.th,version?8:4); // M
for(tileno=0;tileno<img.tw*img.th;tileno++)
{
info_tile_t *tile_Idx = &img.tile[tileno];
info_compo_t *compo_Idx = &tile_Idx->compo[compno];
int correction;
if(j2k_cp->tcps[tileno].csty&J2K_CP_CSTY_EPH)
correction=3;
else
correction=1;
for(resno=0;resno<img.Decomposition+1;resno++)
{
info_reso_t *reso_Idx = &compo_Idx->reso[resno];
for (precno=0;precno<img.tile[tileno].pw*img.tile[tileno].ph;precno++)
{
info_prec_t *prec_Idx = &reso_Idx->prec[precno];
for(layno=0;layno<img.Layer;layno++)
{
info_layer_t *layer_Idx = &prec_Idx->layer[layno];
cio_write(layer_Idx->offset,version?8:4);
cio_write((layer_Idx->len_header-correction)?0:layer_Idx->len_header,version?8:4);
num_packet++;
}
}
}
}
// PADDING
while (num_packet<img.num_packet_max)
{
cio_write(0,version?8:4);
cio_write(0,version?8:4);
num_packet++;
}
break;
}
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); // L
cio_seek(lenp+len);
return len;
}
int jpip_write_tpix(info_image_t img, j2k_cp_t *j2k_cp) // Tile-part Index Table box (superbox)
{
int len, lenp;
lenp=cio_tell();
cio_skip(4); // L [at the end]
cio_write(JPIP_TPIX, 4); // TPIX
jpip_write_faix(0,0,img, j2k_cp);
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); // L
cio_seek(lenp+len);
return len;
}
int jpip_write_thix(info_image_t img, j2k_cp_t *j2k_cp) // Tile header Index Table box (superbox)
{
int len, lenp;
lenp=cio_tell();
cio_skip(4); // L [at the end]
cio_write(JPIP_THIX, 4); // THIX
jpip_write_faix(1,0,img, j2k_cp);
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); // L
cio_seek(lenp+len);
return len;
}
int jpip_write_ppix(info_image_t img,j2k_cp_t *j2k_cp) // Precinct Packet Index Table box (superbox)
{
int len, lenp, compno, i;
for (i=0;i<2;i++)
{
if (i) cio_seek(lenp);
lenp=cio_tell();
cio_skip(4); // L [at the end]
cio_write(JPIP_PPIX, 4); // PPIX
jpip_write_manf(i,img.Comp,marker_local_jpip);
num_marker_local_jpip=img.Comp;
for (compno=0; compno<img.Comp; compno++)
{
marker_local_jpip[compno].len=jpip_write_faix(2,compno,img, j2k_cp);
marker_local_jpip[compno].type=JPIP_FAIX;
}
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); // L
cio_seek(lenp+len);
}
return len;
}
int jpip_write_phix(info_image_t img, j2k_cp_t *j2k_cp) // Packet Header Index Table Box (superbox)
{
int len, lenp=0, compno, i;
for (i=0;i<2;i++)
{
if (i) cio_seek(lenp);
lenp=cio_tell();
cio_skip(4); // L [at the end]
cio_write(JPIP_PHIX, 4); // PHIX
jpip_write_manf(i,img.Comp,marker_local_jpip);
for (compno=0; compno<img.Comp; compno++)
{
marker_local_jpip[compno].len=jpip_write_faix(3,compno,img, j2k_cp);
marker_local_jpip[compno].type=JPIP_FAIX;
}
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); // L
cio_seek(lenp+len);
}
return len;
}
int jpip_write_cidx(int offset, info_image_t img, j2k_cp_t *j2k_cp) // Codestream index box (superbox)
{
int len, lenp=0, i;
num_marker_jpip=0;
for (i=0;i<2;i++)
{
if(i)
cio_seek(lenp);
lenp=cio_tell();
cio_skip(4); // L [at the end]
cio_write(JPIP_CIDX, 4); // CIDX
jpip_write_cptr(offset, img);
jpip_write_manf(i,num_marker_jpip, marker_jpip); // A definir
num_marker_jpip=0;
marker_jpip[num_marker_jpip].len=jpip_write_mhix(img);
marker_jpip[num_marker_jpip].type=JPIP_MHIX;
num_marker_jpip++;
marker_jpip[num_marker_jpip].len=jpip_write_tpix(img, j2k_cp);
marker_jpip[num_marker_jpip].type=JPIP_TPIX;
num_marker_jpip++;
marker_jpip[num_marker_jpip].len=jpip_write_thix(img, j2k_cp);
marker_jpip[num_marker_jpip].type=JPIP_THIX;
num_marker_jpip++;
marker_jpip[num_marker_jpip].len=jpip_write_ppix(img, j2k_cp);
marker_jpip[num_marker_jpip].type=JPIP_PPIX;
num_marker_jpip++;
marker_jpip[num_marker_jpip].len=jpip_write_phix(img, j2k_cp);
marker_jpip[num_marker_jpip].type=JPIP_PHIX;
num_marker_jpip++;
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); // L
cio_seek(lenp+len);
}
return len;
}
void jpip_write_iptr(int offset, int length)
{
int len, lenp;
lenp=cio_tell();
cio_skip(4); // L [at the end]
cio_write(JPIP_IPTR, 4); // IPTR
cio_write(offset,8);
cio_write(length,8);
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); // L
cio_seek(lenp+len);
}
void jpip_write_prxy(int offset_jp2c, int length_jp2c, int offset_idx, int length_idx)
{
int len, lenp;
lenp=cio_tell();
cio_skip(4); // L [at the end]
cio_write(JPIP_PRXY, 4); // IPTR
cio_write(offset_jp2c,8); // OOFF
cio_write(length_jp2c,4); // OBH part 1
cio_write(JP2C,4); // OBH part 2
cio_write(1,1); // NI
cio_write(offset_idx,8); // IOFF
cio_write(length_idx,4); // IBH part 1
cio_write(JPIP_CIDX,4); // IBH part 2
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); // L
cio_seek(lenp+len);
}
int jpip_write_fidx(int offset_jp2c, int length_jp2c, int offset_idx, int length_idx)
{
int len, lenp;
lenp=cio_tell();
cio_skip(4); // L [at the end]
cio_write(JPIP_FIDX, 4); // IPTR
jpip_write_prxy(offset_jp2c, length_jp2c, offset_idx, offset_jp2c);
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); // L
cio_seek(lenp+len);
return len;
}

37
indexer_JPIP/jpip.h Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 "j2k.h"
// Codestream index box (superbox)
int jpip_write_cidx(int offset, info_image_t img, j2k_cp_t *j2k_cp);
// Index Finder Box
void jpip_write_iptr(int offset, int length);
// File Index Box
int jpip_write_fidx(int offset_jp2c, int length_jp2c, int offset_idx, int length_idx);

434
indexer_JPIP/pi.c Normal file
View File

@ -0,0 +1,434 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 "pi.h"
#include "int.h"
#include <stdlib.h>
#include <stdio.h>
/// <summary>
/// Create a packet iterator.
/// </summary>
pi_iterator_t *pi_create(j2k_image_t *img, j2k_cp_t *cp, int tileno) {
int p, q;
int compno, resno,pino, layno, precno;
int maxres=0;
pi_iterator_t *pi;
j2k_tcp_t *tcp;
j2k_tccp_t *tccp;
tcp=&cp->tcps[tileno];
pi=(pi_iterator_t*)malloc((tcp->numpocs+1)*sizeof(pi_iterator_t));
for (pino=0;pino<tcp->numpocs+1;pino++) // change
{
p=tileno%cp->tw;
q=tileno/cp->tw;
pi[pino].tx0=int_max(cp->tx0+p*cp->tdx, img->x0);
pi[pino].ty0=int_max(cp->ty0+q*cp->tdy, img->y0);
pi[pino].tx1=int_min(cp->tx0+(p+1)*cp->tdx, img->x1);
pi[pino].ty1=int_min(cp->ty0+(q+1)*cp->tdy, img->y1);
pi[pino].numcomps=img->numcomps;
pi[pino].comps=(pi_comp_t*)malloc(img->numcomps*sizeof(pi_comp_t));
for (compno=0; compno<pi->numcomps; compno++)
{
int tcx0, tcy0, tcx1, tcy1;
pi_comp_t *comp=&pi[pino].comps[compno];
tccp=&tcp->tccps[compno];
comp->dx=img->comps[compno].dx;
comp->dy=img->comps[compno].dy;
comp->numresolutions=tccp->numresolutions;
comp->resolutions=(pi_resolution_t*)malloc(comp->numresolutions*sizeof(pi_resolution_t));
tcx0=int_ceildiv(pi->tx0, comp->dx);
tcy0=int_ceildiv(pi->ty0, comp->dy);
tcx1=int_ceildiv(pi->tx1, comp->dx);
tcy1=int_ceildiv(pi->ty1, comp->dy);
if (comp->numresolutions>maxres) {
maxres=comp->numresolutions;
}
for (resno=0; resno<comp->numresolutions; resno++)
{
int levelno;
int rx0, ry0, rx1, ry1;
int px0, py0, px1, py1;
pi_resolution_t *res=&comp->resolutions[resno];
if (tccp->csty&J2K_CCP_CSTY_PRT) {
res->pdx=tccp->prcw[resno];
res->pdy=tccp->prch[resno];
} else {
res->pdx=15;
res->pdy=15;
}
levelno=comp->numresolutions-1-resno;
rx0=int_ceildivpow2(tcx0, levelno);
ry0=int_ceildivpow2(tcy0, levelno);
rx1=int_ceildivpow2(tcx1, levelno);
ry1=int_ceildivpow2(tcy1, levelno);
px0=int_floordivpow2(rx0, res->pdx)<<res->pdx;
py0=int_floordivpow2(ry0, res->pdy)<<res->pdy;
px1=int_ceildivpow2(rx1, res->pdx)<<res->pdx;
py1=int_ceildivpow2(ry1, res->pdy)<<res->pdy;
res->pw=(px1-px0)>>res->pdx;
res->ph=(py1-py0)>>res->pdy;
}
}
for (layno=0; layno<10; layno++)
{
for (resno=0; resno<10; resno++)
{
for (compno=0; compno<3; compno++)
{
for (precno=0; precno<99; precno++)
{
pi[pino].include[layno][resno][compno][precno]=0;
}
}
}
}
if (pino==tcp->numpocs)
{
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=img->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;
}
/// <summary>
/// Get next packet in layer=resolution-component-precinct order.
/// </summary>
int pi_next_lrcp(pi_iterator_t *pi) {
pi_comp_t *comp;
pi_resolution_t *res;
if (!pi->first)
{
comp=&pi->comps[pi->compno];
res=&comp->resolutions[pi->resno];
goto 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->numresolutions)
{
continue;
}
res=&comp->resolutions[pi->resno];
for (pi->precno=0; pi->precno<res->pw*res->ph; pi->precno++)
{
if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno])
{
pi->include[pi->layno][pi->resno][pi->compno][pi->precno]=1;
return 1;
}
skip: ;
}
}
}
}
return 0;
}
/// <summary>
/// Get next packet in resolution-layer-component-precinct order.
/// </summary>
int pi_next_rlcp(pi_iterator_t *pi) {
pi_comp_t *comp;
pi_resolution_t *res;
if (!pi->first) {
comp=&pi->comps[pi->compno];
res=&comp->resolutions[pi->resno];
goto 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->numresolutions) {
continue;
}
res=&comp->resolutions[pi->resno];
for (pi->precno=0; pi->precno<res->pw*res->ph; pi->precno++) {
if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno])
{
pi->include[pi->layno][pi->resno][pi->compno][pi->precno]=1;
return 1;
}
skip: ;
}
}
}
}
return 0;
}
/// <summary>
/// Get next packet in resolution-precinct-component-layer order.
/// </summary>
int pi_next_rpcl(pi_iterator_t *pi) {
pi_comp_t *comp;
pi_resolution_t *res;
if (!pi->first) {
goto 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->numresolutions; resno++) {
int dx, dy;
res=&comp->resolutions[resno];
dx=comp->dx*(1<<(res->pdx+comp->numresolutions-1-resno));
dy=comp->dy*(1<<(res->pdy+comp->numresolutions-1-resno));
pi->dx=!pi->dx?dx:int_min(pi->dx, dx);
pi->dy=!pi->dy?dy:int_min(pi->dy, dy);
}
}
}
for (pi->resno=pi->poc.resno0; pi->resno<pi->poc.resno1; pi->resno++) {
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 levelno;
int trx0, try0;
int rpx, rpy;
int prci, prcj;
comp=&pi->comps[pi->compno];
if (pi->resno>=comp->numresolutions) {
continue;
}
res=&comp->resolutions[pi->resno];
levelno=comp->numresolutions-1-pi->resno;
trx0=int_ceildiv(pi->tx0, comp->dx<<levelno);
try0=int_ceildiv(pi->ty0, comp->dy<<levelno);
rpx=res->pdx+levelno;
rpy=res->pdy+levelno;
if (!(pi->x%(comp->dx<<rpx)==0||(pi->x==pi->tx0&&(trx0<<levelno)%(1<<rpx)))) {
continue;
}
if (!(pi->y%(comp->dy<<rpy)==0||(pi->y==pi->ty0&&(try0<<levelno)%(1<<rpx)))) {
continue;
}
prci=int_floordivpow2(int_ceildiv(pi->x, comp->dx<<levelno), res->pdx)-int_floordivpow2(trx0, res->pdx);
prcj=int_floordivpow2(int_ceildiv(pi->y, comp->dy<<levelno), res->pdy)-int_floordivpow2(try0, res->pdy);
pi->precno=prci+prcj*res->pw;
for (pi->layno=0; pi->layno<pi->poc.layno1; pi->layno++) {
if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno])
{
pi->include[pi->layno][pi->resno][pi->compno][pi->precno]=1;
return 1;
}
skip: ;
}
}
}
}
}
return 0;
}
/// <summary>
/// Get next packet in precinct-component-resolution-layer order.
/// </summary>
int pi_next_pcrl(pi_iterator_t *pi) {
pi_comp_t *comp;
pi_resolution_t *res;
if (!pi->first) {
comp=&pi->comps[pi->compno];
goto 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->numresolutions; resno++) {
int dx, dy;
res=&comp->resolutions[resno];
dx=comp->dx*(1<<(res->pdx+comp->numresolutions-1-resno));
dy=comp->dy*(1<<(res->pdy+comp->numresolutions-1-resno));
pi->dx=!pi->dx?dx:int_min(pi->dx, dx);
pi->dy=!pi->dy?dy:int_min(pi->dy, dy);
}
}
}
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->numresolutions); pi->resno++) {
int levelno;
int trx0, try0;
int rpx, rpy;
int prci, prcj;
res=&comp->resolutions[pi->resno];
levelno=comp->numresolutions-1-pi->resno;
trx0=int_ceildiv(pi->tx0, comp->dx<<levelno);
try0=int_ceildiv(pi->ty0, comp->dy<<levelno);
rpx=res->pdx+levelno;
rpy=res->pdy+levelno;
if (!(pi->x%(comp->dx<<rpx)==0||(pi->x==pi->tx0&&(trx0<<levelno)%(1<<rpx)))) {
continue;
}
if (!(pi->y%(comp->dy<<rpy)==0||(pi->y==pi->ty0&&(try0<<levelno)%(1<<rpx)))) {
continue;
}
prci=int_floordivpow2(int_ceildiv(pi->x, comp->dx<<levelno), res->pdx)-int_floordivpow2(trx0, res->pdx);
prcj=int_floordivpow2(int_ceildiv(pi->y, comp->dy<<levelno), res->pdy)-int_floordivpow2(try0, res->pdy);
pi->precno=prci+prcj*res->pw;
for (pi->layno=0; pi->layno<pi->poc.layno1; pi->layno++) {
if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno])
{
pi->include[pi->layno][pi->resno][pi->compno][pi->precno]=1;
return 1;
}
skip: ;
}
}
}
}
}
return 0;
}
/// <summary>
/// Get next packet in component-precinct-resolution-layer order.
/// </summary>
int pi_next_cprl(pi_iterator_t *pi) {
pi_comp_t *comp;
pi_resolution_t *res;
if (!pi->first) {
comp=&pi->comps[pi->compno];
goto 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;
for (resno=0; resno<comp->numresolutions; resno++) {
int dx, dy;
res=&comp->resolutions[resno];
dx=comp->dx*(1<<(res->pdx+comp->numresolutions-1-resno));
dy=comp->dy*(1<<(res->pdy+comp->numresolutions-1-resno));
pi->dx=!pi->dx?dx:int_min(pi->dx, dx);
pi->dy=!pi->dy?dy:int_min(pi->dy, dy);
}
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->numresolutions); pi->resno++) {
int levelno;
int trx0, try0;
int rpx, rpy;
int prci, prcj;
res=&comp->resolutions[pi->resno];
levelno=comp->numresolutions-1-pi->resno;
trx0=int_ceildiv(pi->tx0, comp->dx<<levelno);
try0=int_ceildiv(pi->ty0, comp->dy<<levelno);
rpx=res->pdx+levelno;
rpy=res->pdy+levelno;
if (!(pi->x%(comp->dx<<rpx)==0||(pi->x==pi->tx0&&(trx0<<levelno)%(1<<rpx)))) {
continue;
}
if (!(pi->y%(comp->dy<<rpy)==0||(pi->y==pi->ty0&&(try0<<levelno)%(1<<rpx)))) {
continue;
}
prci=int_floordivpow2(int_ceildiv(pi->x, comp->dx<<levelno), res->pdx)-int_floordivpow2(trx0, res->pdx);
prcj=int_floordivpow2(int_ceildiv(pi->y, comp->dy<<levelno), res->pdy)-int_floordivpow2(try0, res->pdy);
pi->precno=prci+prcj*res->pw;
for (pi->layno=0; pi->layno<pi->poc.layno1; pi->layno++) {
if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno])
{
pi->include[pi->layno][pi->resno][pi->compno][pi->precno]=1;
return 1;
}
skip: ;
}
}
}
}
}
return 0;
}
/// <summary>
/// Get next packet.
/// </summary>
int pi_next(pi_iterator_t *pi) {
switch (pi->poc.prg) {
case 0:
return pi_next_lrcp(pi);
case 1:
return pi_next_rlcp(pi);
case 2:
return pi_next_rpcl(pi);
case 3:
return pi_next_pcrl(pi);
case 4:
return pi_next_cprl(pi);
}
return 0;
}

73
indexer_JPIP/pi.h Normal file
View File

@ -0,0 +1,73 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 __PI_H
#define __PI_H
#include "j2k.h"
#include "tcd.h"
typedef struct {
int pdx, pdy;
int pw, ph;
} pi_resolution_t;
typedef struct {
int dx, dy;
int numresolutions;
pi_resolution_t *resolutions;
} pi_comp_t;
typedef struct {
int include[10][10][3][99];
int compno, resno, precno, layno; // component, resolution, precinct and layer that indentify the packet
int first;
j2k_poc_t poc;
int numcomps;
pi_comp_t *comps;
int tx0, ty0, tx1, ty1;
int x, y, dx, dy;
} pi_iterator_t; // packet iterator
/*
* Create a packet iterator
* img: raw image for which the packets will be listed
* cp: coding paremeters
* tileno: number that identifies the tile for which to list the packets
* return value: returns a packet iterator that points to the first packet of the tile
*/
pi_iterator_t *pi_create(j2k_image_t *img, j2k_cp_t *cp, int tileno);
/*
* Modify the packet iterator to point to the next packet
* pi: packet iterator to modify
* return value: returns 0 if pi pointed to the last packet or else returns 1
*/
int pi_next(pi_iterator_t *pi);
#endif

254
indexer_JPIP/t2.c Normal file
View File

@ -0,0 +1,254 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 "t2.h"
#include "tcd.h"
#include "bio.h"
#include "j2k.h"
#include "pi.h"
#include "tgt.h"
#include "int.h"
#include "cio.h"
#include <stdio.h>
#include <setjmp.h>
#include <string.h>
#include <stdlib.h>
#define RESTART 0x04
extern jmp_buf j2k_error;
int t2_getcommacode() {
int n;
for (n=0; bio_read(1); n++) {}
return n;
}
int t2_getnumpasses()
{
int n;
if (!bio_read(1)) return 1;
if (!bio_read(1)) return 2;
if ((n=bio_read(2))!=3) return 3+n;
if ((n=bio_read(5))!=31) return 6+n;
return 37+bio_read(7);
}
void t2_init_seg(tcd_seg_t *seg, int cblksty) {
seg->numpasses=0;
seg->len=0;
seg->maxpasses=cblksty&J2K_CCP_CBLKSTY_TERMALL?1:100;
}
int t2_decode_packet(unsigned char *src, int len, tcd_tile_t *tile, j2k_tcp_t *tcp, int compno, int resno, int precno, int layno, info_layer_t *layer_Idx) {
int bandno, cblkno;
tcd_tilecomp_t *tilec=&tile->comps[compno];
tcd_resolution_t *res=&tilec->resolutions[resno];
unsigned char *c=src;
unsigned char *d=c;
int e;
int present;
if (layno==0) {
for (bandno=0; bandno<res->numbands; bandno++) {
tcd_band_t *band=&res->bands[bandno];
tcd_precinct_t *prc=&band->precincts[precno];
tgt_reset(prc->incltree);
tgt_reset(prc->imsbtree);
for (cblkno=0; cblkno<prc->cw*prc->ch; cblkno++) {
tcd_cblk_t *cblk=&prc->cblks[cblkno];
cblk->numsegs=0;
}
}
}
if (tcp->csty&J2K_CP_CSTY_SOP) {
c+=6;
}
bio_init_dec(c, src+len-c);
present=bio_read(1);
if (!present) {
bio_inalign();
c+=bio_numbytes();
return c-src;
}
for (bandno=0; bandno<res->numbands; bandno++) {
tcd_band_t *band=&res->bands[bandno];
tcd_precinct_t *prc=&band->precincts[precno];
for (cblkno=0; cblkno<prc->cw*prc->ch; cblkno++) {
int included, increment, n;
tcd_cblk_t *cblk=&prc->cblks[cblkno];
tcd_seg_t *seg;
if (!cblk->numsegs) {
included=tgt_decode(prc->incltree, cblkno, layno+1);
} else {
included=bio_read(1);
}
if (!included) {
cblk->numnewpasses=0;
continue;
}
if (!cblk->numsegs) {
int i, numimsbs;
for (i=0; !tgt_decode(prc->imsbtree, cblkno, i); i++) {}
numimsbs=i-1;
cblk->numbps=band->numbps-numimsbs;
cblk->numlenbits=3;
}
cblk->numnewpasses=t2_getnumpasses();
increment=t2_getcommacode();
cblk->numlenbits+=increment;
if (!cblk->numsegs) {
seg=&cblk->segs[0];
t2_init_seg(seg, tcp->tccps[compno].cblksty);
} else {
seg=&cblk->segs[cblk->numsegs-1];
if (seg->numpasses==seg->maxpasses) {
t2_init_seg(++seg, tcp->tccps[compno].cblksty);
}
}
n=cblk->numnewpasses;
do {
seg->numnewpasses=int_min(seg->maxpasses-seg->numpasses, n);
seg->newlen=bio_read(cblk->numlenbits+int_floorlog2(seg->numnewpasses));
n-=seg->numnewpasses;
if (n>0) {
t2_init_seg(++seg, tcp->tccps[compno].cblksty);
}
} while (n>0);
}
}
if(bio_inalign()) return -999;
c+=bio_numbytes();
if (tcp->csty&J2K_CP_CSTY_EPH) {
c+=2;
}
// INDEX
layer_Idx->len_header=c-d;
if (tcp->csty&J2K_CP_CSTY_SOP)
layer_Idx->len_header-=6;
// \INDEX --> END OF HEADER !!
for (bandno=0; bandno<res->numbands; bandno++) {
tcd_band_t *band=&res->bands[bandno];
tcd_precinct_t *prc=&band->precincts[precno];
for (cblkno=0; cblkno<prc->cw*prc->ch; cblkno++) {
tcd_cblk_t *cblk=&prc->cblks[cblkno];
tcd_seg_t *seg;
if (!cblk->numnewpasses) continue;
if (!cblk->numsegs) {
seg=&cblk->segs[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);
}
}
//<INDEX>
e=c-d;
layer_Idx->len=e;
//</INDEX>
return c-src;
}
int t2_decode_packets(unsigned char *src, int len, j2k_image_t *img, j2k_cp_t *cp, int tileno, tcd_tile_t *tile, info_image_t *imgg) {
unsigned char *c=src;
pi_iterator_t *pi;
int pino, compno,e;
int position=imgg->tile[tileno].end_header+1;
info_tile_t *tile_Idx;
info_compo_t *compo_Idx;
info_reso_t *reso_Idx;
info_prec_t *prec_Idx;
info_layer_t *layer_Idx;
tile_Idx=&imgg->tile[tileno];
tile_Idx->num_packet=0;
pi=pi_create(img, cp, tileno);
for (pino=0; pino<=cp->tcps[tileno].numpocs;pino++)
{
while (pi_next(&pi[pino])) {
compo_Idx=&tile_Idx->compo[pi[pino].compno];
reso_Idx=&compo_Idx->reso[pi[pino].resno];
prec_Idx=&reso_Idx->prec[pi[pino].precno];
layer_Idx=&prec_Idx->layer[pi[pino].layno];
layer_Idx->offset=position;
e=t2_decode_packet(c, src+len-c, tile, &cp->tcps[tileno], pi[pino].compno, pi[pino].resno, pi[pino].precno, pi[pino].layno,layer_Idx);
if (e==-999)
{
break;
} else
c+=e;
position+=e;
tile_Idx->num_packet++;
}
// FREE space memory taken by pi
for (compno=0; compno<pi[pino].numcomps; compno++)
{
free(pi[pino].comps[compno].resolutions);
}
free(pi[pino].comps);
}
free(pi);
if (e==-999)
return e;
else
{
imgg->num_packet_max=int_max(imgg->num_packet_max,tile_Idx->num_packet);
return c-src;
}
}

46
indexer_JPIP/t2.h Normal file
View File

@ -0,0 +1,46 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 __T2_H
#define __T2_H
#include "tcd.h"
#include "j2k.h"
/*
* Decode the packets of a tile from a source buffer
* src: the source buffer
* len: length of the source buffer
* img: destination image
* cp: image coding parameters
* tileno: number that identifies the tile for which to decode the packets
* tile: tile for which to decode the packets
*/
int t2_decode_packets(unsigned char *src, int len, j2k_image_t *img, j2k_cp_t *cp, int tileno, tcd_tile_t *tile, info_image_t *imgg);
#endif

292
indexer_JPIP/tcd.c Normal file
View File

@ -0,0 +1,292 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 "tcd.h"
#include "int.h"
#include "t2.h"
#include <setjmp.h>
#include <float.h>
#include <stdio.h>
#include <time.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
static tcd_image_t tcd_image;
static j2k_image_t *tcd_img;
static j2k_cp_t *tcd_cp;
static tcd_tile_t *tcd_tile;
static j2k_tcp_t *tcd_tcp;
static int tcd_tileno;
extern jmp_buf j2k_error;
void tcd_init(j2k_image_t *img, j2k_cp_t *cp, info_image_t *imgg) {
int tileno, compno, resno, bandno, precno, cblkno;
tcd_img=img;
tcd_cp=cp;
tcd_image.tw=cp->tw;
tcd_image.th=cp->th;
tcd_image.tiles=(tcd_tile_t*)malloc(cp->tw*cp->th*sizeof(tcd_tile_t));
for (tileno=0; tileno<cp->tw*cp->th; tileno++) {
j2k_tcp_t *tcp=&cp->tcps[tileno];
tcd_tile_t *tile=&tcd_image.tiles[tileno];
// cfr p59 ISO/IEC FDIS15444-1 : 2000 (18 august 2000)
int p=tileno%cp->tw; // si numerotation matricielle ..
int q=tileno/cp->tw; // .. coordonnees de la tile (q,p) q pour ligne et p pour colonne
info_tile_t *tile_Idx=&imgg->tile[tileno]; // INDEX
// 4 borders of the tile rescale on the image if necessary
tile->x0=int_max(cp->tx0+p*cp->tdx, img->x0);
tile->y0=int_max(cp->ty0+q*cp->tdy, img->y0);
tile->x1=int_min(cp->tx0+(p+1)*cp->tdx, img->x1);
tile->y1=int_min(cp->ty0+(q+1)*cp->tdy, img->y1);
tile->numcomps=img->numcomps;
tile->comps=(tcd_tilecomp_t*)malloc(img->numcomps*sizeof(tcd_tilecomp_t));
tile_Idx->compo=(info_compo_t*)malloc(img->numcomps*sizeof(info_compo_t)); // INDEX
for (compno=0; compno<tile->numcomps; compno++) {
j2k_tccp_t *tccp=&tcp->tccps[compno];
tcd_tilecomp_t *tilec=&tile->comps[compno];
info_compo_t *compo_Idx=&tile_Idx->compo[compno]; // INDEX
// border of each tile component (global)
tilec->x0=int_ceildiv(tile->x0, img->comps[compno].dx);
tilec->y0=int_ceildiv(tile->y0, img->comps[compno].dy);
tilec->x1=int_ceildiv(tile->x1, img->comps[compno].dx);
tilec->y1=int_ceildiv(tile->y1, img->comps[compno].dy);
tilec->data=(int*)malloc(sizeof(int)*(tilec->x1-tilec->x0)*(tilec->y1-tilec->y0));
tilec->numresolutions=tccp->numresolutions;
tilec->resolutions=(tcd_resolution_t*)malloc(tilec->numresolutions*sizeof(tcd_resolution_t));
compo_Idx->reso=(info_reso_t*)malloc(tilec->numresolutions*sizeof(info_reso_t)); // INDEX
for (resno=0; resno<tilec->numresolutions; resno++) {
int pdx, pdy;
int levelno=tilec->numresolutions-1-resno;
int tlprcxstart, tlprcystart, brprcxend, brprcyend;
int tlcbgxstart, tlcbgystart, brcbgxend, brcbgyend;
int cbgwidthexpn, cbgheightexpn;
int cblkwidthexpn, cblkheightexpn;
tcd_resolution_t *res=&tilec->resolutions[resno];
info_reso_t *res_Idx=&compo_Idx->reso[resno]; // INDEX
int precno_Idx; // INDEX
// border for each resolution level (global)
res->x0=int_ceildivpow2(tilec->x0, levelno);
res->y0=int_ceildivpow2(tilec->y0, levelno);
res->x1=int_ceildivpow2(tilec->x1, levelno);
res->y1=int_ceildivpow2(tilec->y1, levelno);
res->numbands=resno==0?1:3;
// p. 35, table A-23, ISO/IEC FDIS154444-1 : 2000 (18 august 2000)
if (tccp->csty&J2K_CCP_CSTY_PRT) {
pdx=tccp->prcw[resno];
pdy=tccp->prch[resno];
} else {
pdx=15;
pdy=15;
}
// p. 64, B.6, ISO/IEC FDIS15444-1 : 2000 (18 august 2000)
tlprcxstart=int_floordivpow2(res->x0, pdx)<<pdx;
tlprcystart=int_floordivpow2(res->y0, pdy)<<pdy;
brprcxend=int_ceildivpow2(res->x1, pdx)<<pdx;
brprcyend=int_ceildivpow2(res->y1, pdy)<<pdy;
res->pw=(brprcxend-tlprcxstart)>>pdx;
res->ph=(brprcyend-tlprcystart)>>pdy;
// <INDEX>
imgg->tile[tileno].pw=res->pw;
imgg->tile[tileno].ph=res->ph;
res_Idx->prec=(info_prec_t*)malloc(res->pw*res->ph*sizeof(info_prec_t));
for (precno_Idx=0;precno_Idx<res->pw*res->ph;precno_Idx++)
{
info_prec_t *prec_Idx = &res_Idx->prec[precno_Idx];
prec_Idx->layer=(info_layer_t*)malloc(imgg->Layer*sizeof(info_layer_t));
}
imgg->pw=res->pw; // old parser version
imgg->ph=res->ph; // old parser version
imgg->pdx=1<<pdx;
imgg->pdy=1<<pdy;
// </INDEX>
if (resno==0) {
tlcbgxstart=tlprcxstart;
tlcbgystart=tlprcystart;
brcbgxend=brprcxend;
brcbgyend=brprcyend;
cbgwidthexpn=pdx;
cbgheightexpn=pdy;
} else {
tlcbgxstart=int_ceildivpow2(tlprcxstart, 1);
tlcbgystart=int_ceildivpow2(tlprcystart, 1);
brcbgxend=int_ceildivpow2(brprcxend, 1);
brcbgyend=int_ceildivpow2(brprcyend, 1);
cbgwidthexpn=pdx-1;
cbgheightexpn=pdy-1;
}
cblkwidthexpn=int_min(tccp->cblkw, cbgwidthexpn);
cblkheightexpn=int_min(tccp->cblkh, cbgheightexpn);
for (bandno=0; bandno<res->numbands; bandno++) {
int x0b, y0b;
tcd_band_t *band=&res->bands[bandno];
band->bandno=resno==0?0:bandno+1;
x0b=(band->bandno==1)||(band->bandno==3)?1:0;
y0b=(band->bandno==2)||(band->bandno==3)?1:0;
if (band->bandno==0) {
// band border (global)
band->x0=int_ceildivpow2(tilec->x0, levelno);
band->y0=int_ceildivpow2(tilec->y0, levelno);
band->x1=int_ceildivpow2(tilec->x1, levelno);
band->y1=int_ceildivpow2(tilec->y1, levelno);
} else {
// band border (global)
band->x0=int_ceildivpow2(tilec->x0-(1<<levelno)*x0b, levelno+1);
band->y0=int_ceildivpow2(tilec->y0-(1<<levelno)*y0b, levelno+1);
band->x1=int_ceildivpow2(tilec->x1-(1<<levelno)*x0b, levelno+1);
band->y1=int_ceildivpow2(tilec->y1-(1<<levelno)*y0b, levelno+1);
}
band->precincts=(tcd_precinct_t*)malloc(res->pw*res->ph*sizeof(tcd_precinct_t));
for (precno=0; precno<res->pw*res->ph; precno++) {
int tlcblkxstart, tlcblkystart, brcblkxend, brcblkyend;
int cbgxstart=tlcbgxstart+(precno%res->pw)*(1<<cbgwidthexpn);
int cbgystart=tlcbgystart+(precno/res->pw)*(1<<cbgheightexpn);
int cbgxend=cbgxstart+(1<<cbgwidthexpn);
int cbgyend=cbgystart+(1<<cbgheightexpn);
tcd_precinct_t *prc=&band->precincts[precno];
// precinct size (global)
prc->x0=int_max(cbgxstart, band->x0);
prc->y0=int_max(cbgystart, band->y0);
prc->x1=int_min(cbgxend, band->x1);
prc->y1=int_min(cbgyend, band->y1);
tlcblkxstart=int_floordivpow2(prc->x0, cblkwidthexpn)<<cblkwidthexpn;
tlcblkystart=int_floordivpow2(prc->y0, cblkheightexpn)<<cblkheightexpn;
brcblkxend=int_ceildivpow2(prc->x1, cblkwidthexpn)<<cblkwidthexpn;
brcblkyend=int_ceildivpow2(prc->y1, cblkheightexpn)<<cblkheightexpn;
prc->cw=(brcblkxend-tlcblkxstart)>>cblkwidthexpn;
prc->ch=(brcblkyend-tlcblkystart)>>cblkheightexpn;
prc->cblks=(tcd_cblk_t*)malloc(prc->cw*prc->ch*sizeof(tcd_cblk_t));
prc->incltree=tgt_create(prc->cw, prc->ch);
prc->imsbtree=tgt_create(prc->cw, prc->ch);
for (cblkno=0; cblkno<prc->cw*prc->ch; cblkno++) {
int cblkxstart=tlcblkxstart+(cblkno%prc->cw)*(1<<cblkwidthexpn);
int cblkystart=tlcblkystart+(cblkno/prc->cw)*(1<<cblkheightexpn);
int cblkxend=cblkxstart+(1<<cblkwidthexpn);
int cblkyend=cblkystart+(1<<cblkheightexpn);
tcd_cblk_t *cblk=&prc->cblks[cblkno];
// code-block size (global)
cblk->x0=int_max(cblkxstart, prc->x0);
cblk->y0=int_max(cblkystart, prc->y0);
cblk->x1=int_min(cblkxend, prc->x1);
cblk->y1=int_min(cblkyend, prc->y1);
}
}
}
}
}
}
}
void tcd_free(j2k_image_t *img, j2k_cp_t *cp) {
int tileno, compno, resno, bandno, precno;
tcd_img=img;
tcd_cp=cp;
tcd_image.tw=cp->tw;
tcd_image.th=cp->th;
for (tileno=0; tileno<tcd_image.tw*tcd_image.th; tileno++)
{
// j2k_tcp_t *tcp=&cp->tcps[curtileno];
tcd_tile_t *tile=&tcd_image.tiles[tileno];
for (compno=0; compno<tile->numcomps; compno++)
{
tcd_tilecomp_t *tilec=&tile->comps[compno];
for (resno=0; resno<tilec->numresolutions; resno++)
{
tcd_resolution_t *res=&tilec->resolutions[resno];
for (bandno=0; bandno<res->numbands; bandno++)
{
tcd_band_t *band=&res->bands[bandno];
for (precno=0; precno<res->pw*res->ph; precno++)
{
tcd_precinct_t *prc=&band->precincts[precno];
if (prc->incltree!=NULL)
tgt_destroy(prc->incltree);
if (prc->imsbtree!=NULL)
tgt_destroy(prc->imsbtree);
free(prc->cblks);
} // for (precno
free(band->precincts);
} // for (bandno
} // for (resno
free(tilec->resolutions);
} // for (compno
free(tile->comps);
} // for (tileno
free(tcd_image.tiles);
}
int tcd_decode_tile(unsigned char *src, int len, int tileno, info_image_t *imgg) {
int l;
int eof=0;
tcd_tile_t *tile;
tcd_tileno=tileno;
tcd_tile=&tcd_image.tiles[tileno];
tcd_tcp=&tcd_cp->tcps[tileno];
tile=tcd_tile;
l=t2_decode_packets(src, len, tcd_img, tcd_cp, tileno, tile, imgg);
if (l==-999)
{
eof=1;
fprintf(stderr, "tcd_decode: incomplete bistream\n");
}
if (eof) {
longjmp(j2k_error, 1);
}
l=1;
return l;
}

137
indexer_JPIP/tcd.h Normal file
View File

@ -0,0 +1,137 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 __TCD_H
#define __TCD_H
#include "j2k.h"
#include "tgt.h"
typedef struct {
int numpasses;
int len;
unsigned char *data;
int maxpasses;
int numnewpasses;
int newlen;
} tcd_seg_t;
typedef struct {
int rate;
double distortiondec;
} tcd_pass_t;
typedef struct {
int numpasses;
int len;
unsigned char *data;
} tcd_layer_t;
typedef struct {
int x0, y0, x1, y1;
int numbps;
int numlenbits;
int len;
int numpasses;
int numnewpasses;
int numsegs;
tcd_seg_t segs[100];
unsigned char data[8192];
int numpassesinlayers;
tcd_layer_t layers[100];
int totalpasses;
tcd_pass_t passes[100];
} tcd_cblk_t;
typedef struct {
int x0, y0, x1, y1;
int cw, ch;
tcd_cblk_t *cblks;
tgt_tree_t *incltree;
tgt_tree_t *imsbtree;
} tcd_precinct_t;
typedef struct {
int x0, y0, x1, y1;
int bandno;
tcd_precinct_t *precincts;
int numbps;
int stepsize;
} tcd_band_t;
typedef struct {
int x0, y0, x1, y1;
int previous_x0, previous_y0, previous_x1, previous_y1; // usefull for the DWT
int cas_col, cas_row; // usefull for the DWT
int pw, ph;
int numbands;
tcd_band_t bands[3];
} tcd_resolution_t;
typedef struct {
int x0, y0, x1, y1;
int previous_row, previous_col; // usefull for the DWT
int numresolutions;
tcd_resolution_t *resolutions;
int *data;
} tcd_tilecomp_t;
typedef struct {
int x0, y0, x1, y1;
int numcomps;
//int PPT;
//int len_ppt;
tcd_tilecomp_t *comps;
} tcd_tile_t;
typedef struct {
int tw, th;
tcd_tile_t *tiles;
} tcd_image_t;
/*
* Initialize the tile coder/decoder
* img: raw image
* cp: coding parameters
* imgg: creation of index file
*/
void tcd_init(j2k_image_t *img, j2k_cp_t *cp, info_image_t *imgg);
void tcd_free(j2k_image_t *img, j2k_cp_t *cp);
/*
* Decode a tile from a buffer into a raw image
* src: source buffer
* len: length of the source buffer
* tileno: number that identifies the tile that will be decoded
* imgg : Structure for index file
*/
int tcd_decode_tile(unsigned char *src, int len, int tileno, info_image_t *imgg);
#endif

170
indexer_JPIP/tgt.c Normal file
View File

@ -0,0 +1,170 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 "tgt.h"
#include "bio.h"
#include <stdlib.h>
#include <stdio.h>
/// <summary>
/// Reset tag-tree.
/// </summary>
void tgt_reset(tgt_tree_t *tree)
{
int i;
for (i=0; i<tree->numnodes; i++) {
tree->nodes[i].value=999;
tree->nodes[i].low=0;
tree->nodes[i].known=0;
}
}
/// <summary>
/// Create tag-tree.
/// </summary>
tgt_tree_t *tgt_create(int numleafsh, int numleafsv)
{
int nplh[32];
int nplv[32];
tgt_node_t *node;
tgt_node_t *parentnode;
tgt_node_t *parentnode0;
tgt_tree_t *tree;
int i, j, k;
int numlvls;
int n;
tree=(tgt_tree_t*)malloc(sizeof(tgt_tree_t));
tree->numleafsh=numleafsh;
tree->numleafsv=numleafsv;
numlvls=0;
nplh[0]=numleafsh;
nplv[0]=numleafsv;
tree->numnodes=0;
do {
n=nplh[numlvls]*nplv[numlvls];
nplh[numlvls+1]=(nplh[numlvls]+1)/2;
nplv[numlvls+1]=(nplv[numlvls]+1)/2;
tree->numnodes+=n;
++numlvls;
} while (n>1);
tree->nodes=(tgt_node_t*)malloc(tree->numnodes*sizeof(tgt_node_t));
node=tree->nodes;
parentnode=&tree->nodes[tree->numleafsh*tree->numleafsv];
parentnode0=parentnode;
for (i=0; i<numlvls-1; ++i) {
for (j=0; j<nplv[i]; ++j) {
k=nplh[i];
while (--k>=0) {
node->parent=parentnode;
++node;
if (--k >= 0) {
node->parent=parentnode;
++node;
}
++parentnode;
}
if ((j&1)||j==nplv[i]-1) {
parentnode0=parentnode;
} else {
parentnode=parentnode0;
parentnode0+=nplh[i];
}
}
}
node->parent=0;
tgt_reset(tree);
return tree;
}
/// <summary>
/// Destroy tag-tree.
/// </summary>
void tgt_destroy(tgt_tree_t *t) {
free(t->nodes);
free(t);
}
/// <summary>
/// Set the value of a leaf of the tag-tree.
/// </summary>
void tgt_setvalue(tgt_tree_t *tree, int leafno, int value) {
tgt_node_t *node;
node=&tree->nodes[leafno];
while (node && node->value>value) {
node->value=value;
node=node->parent;
}
}
/// <summary>
/// Decode the value of a leaf of the tag-tree.
/// </summary>
int tgt_decode(tgt_tree_t *tree, int leafno, int threshold)
{
tgt_node_t *stk[31];
tgt_node_t **stkptr;
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(1)) {
node->value=low;
} else {
++low;
}
}
node->low=low;
if (stkptr==stk) {
break;
}
node=*--stkptr;
}
return (node->value<threshold)?1:0;
}

80
indexer_JPIP/tgt.h Normal file
View File

@ -0,0 +1,80 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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
typedef struct tgt_node {
struct tgt_node *parent;
int value;
int low;
int known;
} tgt_node_t;
typedef struct {
int numleafsh;
int numleafsv;
int numnodes;
tgt_node_t *nodes;
} tgt_tree_t;
/*
* Create a tag-tree
* numleafsh: width of the array of leafs of the tree
* numleafsv: height of the array of leafs of the tree
*/
tgt_tree_t *tgt_create(int numleafsh, int numleafsv);
/*
* Reset a tag-tree (set all leafs to 0)
* tree: tag-tree to reset
*/
void tgt_reset(tgt_tree_t *tree);
/*
* Destroy a tag-tree, liberating memory
* tree: tag-tree to destroy
*/
void tgt_destroy(tgt_tree_t *tree);
/*
* Set the value of a leaf of a tag-tree
* tree: tag-tree to modify
* leafno: number that identifies the leaf to modify
* value: new value of the leaf
*/
void tgt_setvalue(tgt_tree_t *tree, int leafno, int value);
/*
* Decode the value of a leaf of the tag-tree up to a given threshold
* leafno: number that identifies the leaf to decode
* threshold: threshold to use when decoding value of the leaf
*/
int tgt_decode(tgt_tree_t *tree, int leafno, int threshold);
#endif

35
j2kviewer/build.xml Normal file
View File

@ -0,0 +1,35 @@
<project name="seb_j2kviewer" default="dist" basedir=".">
<description>Seb's J2K viewer</description>
<property name="src" location="src" />
<property name="build" location="build"/>
<property name="dist" location="dist" />
<target name="init">
<tstamp/>
<mkdir dir="${build}"/>
</target>
<target name="compile" depends="init">
<javac srcdir="${src}" destdir="${build}"/>
</target>
<target name="dist" depends="compile">
<mkdir dir="${dist}"/>
<jar jarfile="${dist}/seb_j2kviewer-${DSTAMP}.jar"
basedir="${build}" manifest="${dist}/manifest.txt"/>
<exec dir="${dist}" executable="ln">
<arg line="-sf seb_j2kviewer-${DSTAMP}.jar seb_j2kviewer.jar"/>
</exec>
</target>
<target name="clean">
<delete dir="${build}"/>
<delete dir="${dist}"/>
</target>
<target name="test" depends="dist">
<exec executable="appletviewer"><arg line="dist.html"/></exec>
</target>
<target name="build_test" depends="compile">
<exec executable="appletviewer"><arg line="compile.html"/></exec>
</target>
<target name="build_testj" depends="compile">
<exec executable="java"><arg line="-classpath build ImageViewer girl"/></exec>
</target>
</project>

212
j2kviewer/src/Exec.java Normal file
View File

@ -0,0 +1,212 @@
import java.io.*;
// This appears in Core Web Programming from
// Prentice Hall Publishers, and may be freely used
// or adapted. 1997 Marty Hall, hall@apl.jhu.edu.
/** A class that eases the pain of running external
* processes from applications.
* Lets you run a program three ways:
* <OL>
* <LI><B>exec</B>: Execute the command, returning
* immediately even if the command is still
* running. This would be appropriate
* for printing a file.
* <LI><B>execWait</B>: Execute the command, but
* don't return until the command finishes.
* This would be appropriate for
* sequential commands where the first depends
* on the second having finished (e.g.
* <CODE>javac</CODE> followed by
* <CODE>java</CODE>).
* <LI><B>execPrint</B>: Execute the command and
* print the output. This would be appropriate
* for the UNIX command <CODE>ls</CODE>.
* </OL>
* Note that the PATH is not taken into account,
* so you must specify the <B>full</B> pathname to
* the command, and shell builtin commands
* will not work. For instance, on Unix the above
* three examples might look like:
* <OL>
* <LI><PRE>Exec.exec("/usr/ucb/lpr Some-File");</PRE>
* <LI><PRE>
* Exec.execWait("/usr/local/bin/javac Foo.java");
* Exec.execWait("/usr/local/bin/java Foo");
* </PRE>
* <LI><PRE>Exec.execPrint("/usr/bin/ls -al");</PRE>
* </OL>
*
* @author Marty Hall
* (<A HREF="mailto:hall@apl.jhu.edu">
* hall@apl.jhu.edu</A>)
* @version 1.0 1997
*/
public class Exec {
//----------------------------------------------------
private static boolean verbose = true;
/** Determines if the Exec class should print which
* commands are being executed, and print error
* messages if a problem is found. Default is true.
*
* @param verboseFlag true: print messages.
* false: don't.
*/
public static void setVerbose(boolean verboseFlag) {
verbose = verboseFlag;
}
/** Will Exec print status messages? */
public static boolean getVerbose() {
return(verbose);
}
//----------------------------------------------------
/** Starts a process to execute the command. Returns
* immediately, even if the new process is still
* running.
*
* @param command The <B>full</B> pathname of the
* command to be executed. No shell builtins
* (e.g. "cd") or shell meta-chars (e.g. ">")
* allowed.
* @return false if a problem is known to occur, but
* since this returns immediately, problems
* aren't usually found in time.
* Returns true otherwise.
*/
public static boolean exec(String command) {
return(exec(command, false, false));
}
//----------------------------------------------------
/** Starts a process to execute the command. Waits
* for the process to finish before returning.
*
* @param command The <B>full</B> pathname of the
* command to be executed. No shell builtins
* or shell meta-chars allowed.
* @return false if a problem is known to occur,
* either due to an exception or from the
* subprocess returning a non-zero value.
* Returns true otherwise.
*/
public static boolean execWait(String command) {
return(exec(command, false, true));
}
//----------------------------------------------------
/** Starts a process to execute the command. Prints
* all output the command gives.
*
* @param command The <B>full</B> pathname of the
* command to be executed. No shell builtins
* or shell meta-chars allowed.
* @return false if a problem is known to occur,
* either due to an exception or from the
* subprocess returning a non-zero value.
* Returns true otherwise.
*/
public static boolean execPrint(String command) {
return(exec(command, true, false));
}
//----------------------------------------------------
// This creates a Process object via
// Runtime.getRuntime.exec(). Depending on the
// flags, it may call waitFor on the process
// to avoid continuing until the process terminates,
// or open an input stream from the process to read
// the results.
private static boolean exec(String command,
boolean printResults,
boolean wait) {
if (verbose) {
printSeparator();
System.out.println("Executing '" + command + "'.");
}
try {
// Start running command, returning immediately.
Process p = Runtime.getRuntime().exec(command);
// Print the output. Since we read until
// there is no more input, this causes us
// to wait until the process is completed
if(printResults) {
BufferedInputStream buffer =
new BufferedInputStream(p.getInputStream());
DataInputStream commandResult =
new DataInputStream(buffer);
String s = null;
try {
while ((s = commandResult.readLine()) != null)
System.out.println("Output: " + s);
commandResult.close();
if (p.exitValue() != 0) {
if (verbose)
printError(command +
" -- p.exitValue() != 0");
return(false);
}
// Ignore read errors; they mean process is done
} catch (Exception e) {}
// If you don't print the results, then you
// need to call waitFor to stop until the process
// is completed
} else if (wait) {
try {
System.out.println(" ");
int returnVal = p.waitFor();
if (returnVal != 0) {
if (verbose)
printError(command);
return(false);
}
} catch (Exception e) {
if (verbose)
printError(command, e);
return(false);
}
}
} catch (Exception e) {
if (verbose)
printError(command, e);
return(false);
}
return(true);
}
//----------------------------------------------------
private static void printError(String command,
Exception e) {
System.out.println("Error doing exec(" +
command + "): " + e.getMessage());
System.out.println("Did you specify the full " +
"pathname?");
}
private static void printError(String command) {
System.out.println("Error executing '" +
command + "'.");
}
//----------------------------------------------------
private static void printSeparator() {
System.out.println
("==============================================");
}
//----------------------------------------------------
}

222
j2kviewer/src/ImageViewer.java Normal file
View File

@ -0,0 +1,222 @@
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.image.*;
import java.awt.geom.*;
import java.net.URL;
import javax.swing.border.*;
import java.util.*;
import java.io.*;
public class ImageViewer extends JApplet
{
private class zoomLevel {
int x1, y1, x2, y2, zf;
zoomLevel() {}
zoomLevel(zoomLevel zl)
{
x1 = zl.x1;
y1 = zl.y1;
x2 = zl.x2;
y2 = zl.y2;
zf = zl.zf;
}
}
private BufferedImage bi;
private Graphics2D big;
private MML myMML;
private int iw, ih;
private int selected = 0, imgId;
private Image img;
private PgmImage pgm = new PgmImage();
private String cmdline = new String();
private static String hostname;
private static boolean isApplet = true;
private boolean fullRefresh = false;
private Point offset = new Point(0,0);
private zoomLevel zl = new zoomLevel();
private Rectangle rect = new Rectangle();
private Stack zoomStack = new Stack();
private static String j2kfilename;
public int getX() { return offset.x; }
public int getY() { return offset.y; }
public int getWidth() { return iw; }
public int getHeight() { return ih; }
public void destroy()
{
}
public void zoomIn()
{
Dimension asz = this.getSize();
int maxzf = 3;
int coef = 1;
int r;
cmdline =
"/bin/sh get.sh " + j2kfilename + " " + iw
+ " " + ih + " " + rect.x + " " + rect.y + " "
+ rect.width + " " + rect.height;
Exec.execPrint(cmdline);
rect.x = rect.y = rect.width = rect.height = 0;
img = pgm.open("out.pgm");
iw = img.getWidth(this);
ih = img.getHeight(this);
bi = new BufferedImage(iw, ih, BufferedImage.TYPE_INT_RGB);
big = bi.createGraphics();
selected = 0;
fullRefresh = true;
repaint();
}
public void zoomOut()
{
}
public void init()
{
String str;
int port;
imgId = 4;
if (isApplet && (((hostname = this.getParameter("hostname")) == null)
|| hostname.equals("")))
hostname = "localhost";
if (!isApplet || ((str = this.getParameter("cmdPort")) == null)) {
port = 3000;
} else {
port = new Integer(str).intValue();
}
this.setSize(512, 512);
Dimension asz = this.getSize();
zl.x2 = asz.width;
zl.y2 = asz.height;
cmdline =
"/bin/sh get.sh " + j2kfilename + " " + asz.width
+ " " + asz.height + " " + zl.x1 + " " + zl.y1 + " "
+ zl.x2 + " " + zl.y2;
Exec.execPrint(cmdline);
img = pgm.open("out.pgm");
iw = img.getWidth(this);
ih = img.getHeight(this);
setBackground(Color.black);
bi = new BufferedImage(iw, ih, BufferedImage.TYPE_INT_RGB);
big = bi.createGraphics();
myMML = new MML(this);
addMouseListener(myMML);
addMouseMotionListener(myMML);
}
public void setSelected(int state)
{
if (state != selected) {
selected = state;
repaint();
}
}
public boolean isInsideRect(int x, int y)
{
return rect.contains(x - offset.x, y - offset.y);
}
public void setRGeom(int x1, int y1, int x2, int y2)
{
rect.x = Math.min(x1,x2) - offset.x;
rect.y = Math.min(y1,y2) - offset.y;
rect.width = Math.abs(x2-x1);
rect.height = Math.abs(y2-y1);
}
public void paint(Graphics g)
{
Graphics2D g2 = (Graphics2D) g;
Dimension asz = this.getSize();
if (fullRefresh) {
g2.clearRect(0, 0, asz.width, asz.height);
fullRefresh = false;
}
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
g2.setRenderingHint(RenderingHints.KEY_RENDERING,
RenderingHints.VALUE_RENDER_QUALITY);
big.setColor(Color.black);
offset.x = (int) (asz.width - iw) / 2;
offset.y = (int) (asz.height - ih) / 2;
big.drawImage(img, 0, 0, this);
big.setPaint(Color.red);
if ((rect.width > 0) && (rect.height > 0))
big.draw(rect);
if (selected == 1)
shadeExt(big, 0, 0, 0, 64);
else if (selected == 2) {
shadeExt(big, 0, 0, 0, 255);
selected = 1;
}
g2.drawImage(bi, offset.x, offset.y, this);
}
private void shadeRect(Graphics2D g2, int r, int g, int b, int a)
{
g2.setPaint(new Color(r, g, b, a));
g2.fillRect(rect.x + 1, rect.y + 1, rect.width - 1, rect.height - 1);
}
private void shadeExt(Graphics2D g2, int r, int g, int b, int a)
{
g2.setPaint(new Color(r, g, b, a));
g2.fillRect(0, 0, iw, rect.y); /* _N_ */
g2.fillRect(rect.x + rect.width + 1, rect.y,
iw - rect.x - rect.width - 1, rect.height + 1); /* E */
g2.fillRect(0, rect.y, rect.x, rect.height + 1); /* W */
g2.fillRect(0, rect.y + rect.height + 1,
iw, ih - rect.y - rect.height - 1); /* _S_ */
}
protected URL getURL(String filename)
{
URL codeBase = this.getCodeBase();
URL url = null;
try {
url = new URL(codeBase, filename);
} catch (java.net.MalformedURLException e) {
System.out.println("Couldn't create image: badly specified URL");
return null;
}
return url;
}
public static void main(String s[])
{
if (s.length > 0)
j2kfilename = s[0];
else
j2kfilename = "girl";
System.out.println(j2kfilename);
isApplet = false;
JFrame f = new JFrame("ImageViewer");
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {System.exit(0);}
});
JApplet applet = new ImageViewer();
f.getContentPane().add("Center", applet);
applet.init();
f.pack();
f.setSize(new Dimension(550,550));
f.show();
}
}

85
j2kviewer/src/MML.java Normal file
View File

@ -0,0 +1,85 @@
import java.awt.event.*;
class MML implements MouseMotionListener, MouseListener
{
public void mouseExited(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {}
public void mouseClicked(MouseEvent e) {}
private ImageViewer applet;
private int x1, y1, x2, y2, zf, btn;
private boolean zoomrq;
public MML(ImageViewer iv)
{
x1 = y1 = -1;
applet = iv;
zoomrq = false;
zf = 0;
}
private boolean isInside(int x, int y)
{
x -= applet.getX();
y -= applet.getY();
return (x >= 0) && (x < applet.getWidth())
&& (y >= 0) && (y < applet.getHeight());
}
public void mousePressed(MouseEvent e)
{
btn = e.getButton();
if (applet.isInsideRect(e.getX(), e.getY())) {
applet.setSelected(2);
applet.repaint();
zoomrq = true;
} else {
applet.setRGeom(0, 0, 0, 0);
applet.setSelected(0);
applet.repaint();
x1 = y1 = -1;
}
}
public void mouseReleased(MouseEvent e)
{
if (zoomrq && (e.getButton() == 1)) {
applet.zoomIn();
zoomrq = false;
} else if (e.getButton() == 3) {
applet.zoomOut();
zoomrq = false;
}
}
public void mouseMoved(MouseEvent e)
{
applet.setSelected(applet.isInsideRect(e.getX(), e.getY()) ? 1 : 0);
}
public void mouseDragged(MouseEvent e)
{
String str;
if (btn == 1) {
x2 = e.getX();
y2 = e.getY();
applet.setSelected(0);
zoomrq = false;
if (isInside(x2, y2)) {
str = "[IN ]";
if (x1 == -1) {
x1 = x2;
y1 = y2;
} else {
applet.setRGeom(x1, y1, x2, y2);
applet.repaint();
}
} else {
str = "[OUT]";
}
}
}
}

93
j2kviewer/src/PgmImage.java Normal file
View File

@ -0,0 +1,93 @@
import java.awt.*;
import java.awt.image.*;
import java.net.*;
import java.io.*;
import java.util.regex.*;
class PgmImage extends Component
{
private Socket s;
private BufferedReader in;
private int x, y;
PgmImage()
{
}
private String read()
{
try { return in.readLine(); }
catch (IOException e) {
e.printStackTrace();
return null;
}
}
public Image open(String filename)
{
String str;
Pattern pat;
Matcher mat;
int bytes, width, height, depth;
FileInputStream fis;
try {
in = new BufferedReader(
new InputStreamReader(
fis = new FileInputStream(
new File(filename))));
pat = Pattern.compile("^P5$");
mat = pat.matcher(str = read());
mat.matches();
pat = Pattern.compile("^(\\d+) (\\d+)$");
mat = pat.matcher(str = read());
mat.matches();
x = new Integer(mat.group(1)).intValue();
y = new Integer(mat.group(2)).intValue();
width = x;
height = y;
depth = 1;
pat = Pattern.compile("^255$");
mat = pat.matcher(str = read());
mat.matches();
bytes = x*y;
char[] buf = new char[bytes];
int r, offset = 0;
while (bytes > 0) {
try { r = in.read(buf, offset, bytes); offset += r; bytes -= r; }
catch (IOException e) { e.printStackTrace(); }
}
int[] buf2 = new int[buf.length];
if (depth == 3) {
for (int i = 0; i < buf.length/3; ++i)
buf2[i] = 0xFF << 24 | buf[3*i] << 16 | buf[3*i+1] << 8 | buf[3*i+2];
} else {
for (int i = 0; i < buf.length; ++i)
buf2[i] = 0xFF << 24 | buf[i] << 16 | buf[i] << 8 | buf[i];
}
fis.close();
return createImage(new MemoryImageSource(width, height, buf2, 0, width));
} catch (IOException e) { e.printStackTrace(); }
return null;
}
public void close()
{
}
public boolean bye()
{
return true;
}
public int getXOffset()
{
return x;
}
public int getYOffset()
{
return y;
}
}

6
libopenjpeg/.cvsignore Normal file
View File

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

67
libopenjpeg/Makefile Normal file
View File

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

182
libopenjpeg/bio.c Normal file
View File

@ -0,0 +1,182 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 "bio.h"
#include <stdio.h>
#include <setjmp.h>
static unsigned char *bio_start, *bio_end, *bio_bp;
static unsigned int bio_buf;
static int bio_ct;
extern jmp_buf j2k_error;
/* <summary> */
/* Number of bytes written. */
/* </summary> */
int bio_numbytes()
{
return bio_bp - bio_start;
}
/* <summary> */
/* Init encoder. */
/* </summary> */
/* <param name="bp">Output buffer</param> */
/* <param name="len">Output buffer length</param> */
void bio_init_enc(unsigned char *bp, int len)
{
bio_start = bp;
bio_end = bp + len;
bio_bp = bp;
bio_buf = 0;
bio_ct = 8;
}
/* <summary> */
/* Init decoder. */
/* </summary> */
/* <param name="bp">Input buffer</param> */
/* <param name="len">Input buffer length</param> */
void bio_init_dec(unsigned char *bp, int len)
{
bio_start = bp;
bio_end = bp + len;
bio_bp = bp;
bio_buf = 0;
bio_ct = 0;
}
/* <summary> */
/* Write byte. --> function modified to eliminate longjmp !!! */
/* </summary> */
int bio_byteout()
{
bio_buf = (bio_buf << 8) & 0xffff;
bio_ct = bio_buf == 0xff00 ? 7 : 8;
if (bio_bp >= bio_end)
return 1;
*bio_bp++ = bio_buf >> 8;
return 0;
}
/* <summary> */
/* Read byte. --> function modified to eliminate longjmp !! */
/* </summary> */
int bio_bytein()
{
bio_buf = (bio_buf << 8) & 0xffff;
bio_ct = bio_buf == 0xff00 ? 7 : 8;
if (bio_bp >= bio_end)
return 1;
bio_buf |= *bio_bp++;
return 0;
}
/* <summary> */
/* Write bit. */
/* </summary> */
/* <param name="b">Bit to write (0 or 1)</param> */
void bio_putbit(int b)
{
if (bio_ct == 0) {
bio_byteout();
}
bio_ct--;
bio_buf |= b << bio_ct;
}
/* <summary> */
/* Read bit. */
/* </summary> */
int bio_getbit()
{
if (bio_ct == 0) {
bio_bytein();
}
bio_ct--;
return (bio_buf >> bio_ct) & 1;
}
/* <summary> */
/* Write bits. */
/* </summary> */
/* <param name="v">Value of bits</param> */
/* <param name="n">Number of bits to write</param> */
void bio_write(int v, int n)
{
int i;
for (i = n - 1; i >= 0; i--) {
bio_putbit((v >> i) & 1);
}
}
/* <summary> */
/* Read bits. */
/* </summary> */
/* <param name="n">Number of bits to read</param> */
int bio_read(int n)
{
int i, v;
v = 0;
for (i = n - 1; i >= 0; i--) {
v += bio_getbit() << i;
}
return v;
}
/* <summary> */
/* Flush bits. MOdified to eliminate longjmp !! */
/* </summary> */
int bio_flush()
{
bio_ct = 0;
if (bio_byteout())
return 1;
if (bio_ct == 7) {
bio_ct = 0;
if (bio_byteout())
return 1;
}
return 0;
}
/* <summary> */
/* </summary> */
int bio_inalign()
{
bio_ct = 0;
if ((bio_buf & 0xff) == 0xff) {
if (bio_bytein())
return 1;
bio_ct = 0;
}
return 0;
}

40
libopenjpeg/bio.h Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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
int bio_numbytes();
void bio_init_enc(unsigned char *bp, int len);
void bio_init_dec(unsigned char *bp, int len);
void bio_write(int v, int n);
int bio_read(int n);
int bio_flush(); /* modified to eliminated longjmp !! */
int bio_inalign(); /* modified to eliminated longjmp !! */
#endif

136
libopenjpeg/cio.c Normal file
View File

@ -0,0 +1,136 @@
/*
* Copyright (c) 2001-2002, David Janssens
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "cio.h"
#include <setjmp.h>
static unsigned char *cio_start, *cio_end, *cio_bp;
extern jmp_buf j2k_error;
/* <summary> */
/* Number of bytes written. */
/* </summary> */
int cio_numbytes()
{
return cio_bp - cio_start;
}
/* <summary> */
/* Get position in byte stream. */
/* </summary> */
int cio_tell()
{
return cio_bp - cio_start;
}
/* <summary> */
/* Set position in byte stream. */
/* </summary> */
void cio_seek(int pos)
{
cio_bp = cio_start + pos;
}
/* <summary> */
/* Number of bytes left before the end of the stream. */
/* </summary> */
int cio_numbytesleft()
{
return cio_end - cio_bp;
}
/* <summary> */
/* Get pointer to the current position in the stream. */
/* </summary> */
unsigned char *cio_getbp()
{
return cio_bp;
}
/* <summary> */
/* Initialize byte IO. */
/* </summary> */
void cio_init(unsigned char *bp, int len)
{
cio_start = bp;
cio_end = bp + len;
cio_bp = bp;
}
/* <summary> */
/* Write a byte. */
/* </summary> */
void cio_byteout(unsigned char v)
{
if (cio_bp >= cio_end)
longjmp(j2k_error, 1);
*cio_bp++ = v;
}
/* <summary> */
/* Read a byte. */
/* </summary> */
unsigned char cio_bytein()
{
if (cio_bp >= cio_end)
longjmp(j2k_error, 1);
return *cio_bp++;
}
/* <summary> */
/* Write a byte. */
/* </summary> */
void cio_write(unsigned int v, int n)
{
int i;
for (i = n - 1; i >= 0; i--) {
cio_byteout((unsigned char) ((v >> (i << 3)) & 0xff));
}
}
/* <summary> */
/* Read some bytes. */
/* </summary> */
unsigned int cio_read(int n)
{
int i;
unsigned int v;
v = 0;
for (i = n - 1; i >= 0; i--) {
v += cio_bytein() << (i << 3);
}
return v;
}
/* <summary> */
/* Write some bytes. */
/* </summary> */
void cio_skip(int n)
{
cio_bp += n;
}

40
libopenjpeg/cio.h Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright (c) 2001-2002, David Janssens
* 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
int cio_tell();
void cio_seek(int pos);
int cio_numbytes();
int cio_numbytesleft();
unsigned char *cio_getbp();
void cio_init(unsigned char *bp, int len);
void cio_write(unsigned int v, int n);
unsigned int cio_read(int n);
void cio_skip(int n);
#endif

681
libopenjpeg/dwt.c Normal file
View File

@ -0,0 +1,681 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2002-2003, 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 "dwt.h"
#include "int.h"
#include "fix.h"
#include "tcd.h"
#include <stdlib.h>
#include <stdio.h>
#define S(i) a[x*(i)*2]
#define D(i) a[x*(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> */
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> */
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}
};
/* Add Patrick */
static int *b = NULL;
static int lastSizeOfB = 0;
void dwt_clean()
{
if (b != NULL) {
free(b);
}
b = NULL;
lastSizeOfB = 0;
}
/* \ Add Patrick */
/* <summary> */
/* Forward lazy transform. */
/* </summary> */
void dwt_deinterleave(int *a, int n, int x, int res, int cas)
{
int dn, sn, i;
sn = res;
dn = n - res;
if (lastSizeOfB != n) {
if (b != NULL)
free(b);
b = (int *) malloc(n * sizeof(int));
lastSizeOfB = n;
}
if (cas) {
for (i = 0; i < sn; i++)
b[i] = a[(2 * i + 1) * x];
for (i = 0; i < dn; i++)
b[sn + i] = a[2 * i * x];
} else {
for (i = 0; i < sn; i++)
b[i] = a[2 * i * x];
for (i = 0; i < dn; i++)
b[sn + i] = a[(2 * i + 1) * x];
}
for (i = 0; i < n; i++)
a[i * x] = b[i];
}
/* <summary> */
/* Forward lazy transform. */
/* </summary> */
void dwt_deinterleave_real(int *a, int n, int x, int res, int cas)
{
int dn, sn, i;
sn = res;
dn = n - res;
if (lastSizeOfB != n) {
if (b != NULL)
free(b);
b = (int *) malloc(n * sizeof(int));
lastSizeOfB = n;
}
if (cas) {
for (i = 0; i < sn; i++)
b[i] = a[(2 * i + 1) * x];
for (i = 0; i < dn; i++)
b[sn + i] = a[2 * i * x];
} else {
for (i = 0; i < sn; i++)
b[i] = a[2 * i * x];
for (i = 0; i < dn; i++)
b[sn + i] = a[(2 * i + 1) * x];
}
for (i = 0; i < n; i++)
a[i * x] = b[i];
}
/* <summary> */
/* Inverse lazy transform. */
/* </summary> */
void dwt_interleave(int *a, int n, int x, int res, int cas)
{
int dn, sn, i;
sn = res;
dn = n - res;
if (lastSizeOfB != n) {
if (b != NULL)
free(b);
b = (int *) malloc(n * sizeof(int));
lastSizeOfB = n;
}
if (cas) {
for (i = 0; i < sn; i++)
b[2 * i + 1] = a[i * x];
for (i = 0; i < dn; i++)
b[2 * i] = a[(sn + i) * x];
} else {
for (i = 0; i < sn; i++)
b[2 * i] = a[i * x];
for (i = 0; i < dn; i++)
b[2 * i + 1] = a[(sn + i) * x];
}
for (i = 0; i < n; i++)
a[i * x] = b[i];
}
/* <summary> */
/* Inverse lazy transform. */
/* </summary> */
void dwt_interleave_real(int *a, int n, int x, int res, int cas)
{
int dn, sn, i;
sn = res;
dn = n - res;
if (lastSizeOfB != n) {
if (b != NULL)
free(b);
b = (int *) malloc(n * sizeof(int));
lastSizeOfB = n;
}
if (cas) {
for (i = 0; i < sn; i++)
b[2 * i + 1] = a[i * x];
for (i = 0; i < dn; i++)
b[2 * i] = a[(sn + i) * x];
} else {
for (i = 0; i < sn; i++)
b[2 * i] = a[i * x];
for (i = 0; i < dn; i++)
b[2 * i + 1] = a[(sn + i) * x];
}
for (i = 0; i < n; i++)
a[i * x] = b[i];
}
/* <summary> */
/* Forward 5-3 wavelet tranform in 1-D. */
/* </summary> */
void dwt_encode_1(int *a, int n, int x, int res, int cas)
{
int dn, sn, i = 0;
sn = res;
dn = n - res;
if (cas) {
if (!sn && dn == 1) /* NEW : CASE ONE ELEMENT */
S(i) *= 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;
}
} else {
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;
}
}
dwt_deinterleave(a, n, x, res, cas);
}
/* <summary> */
/* Inverse 5-3 wavelet tranform in 1-D. */
/* </summary> */
void dwt_decode_1(int *a, int n, int x, int res, int cas)
{
int dn, sn, i = 0;
/* dn=n/2; */
/* sn=(n+1)/2; */
sn = res;
dn = n - res;
dwt_interleave(a, n, x, res, cas);
if (cas) {
if (!sn && dn == 1) /* NEW : CASE ONE ELEMENT */
S(i) /= 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;
}
} else {
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;
}
}
}
/* <summary> */
/* Forward 5-3 wavelet tranform in 2-D. */
/* </summary> */
void dwt_encode(int *a, int w, int h, tcd_tilecomp_t * tilec, int l)
{
int i, j, rw, rh, rw1, rh1;
int previous_rw, previous_rh, previous_rw1, previous_rh1;
for (i = 0; i < l; i++) {
int cas_col = 0;
int cas_row = 0;
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;
/* Check the different cases for that it's necessary to invert high pass and low pass filter */
if (tilec->previous_row) {
previous_rw =
tilec->resolutions[l - i].previous_x1 - tilec->resolutions[l -
i].
previous_x0;
previous_rw1 =
tilec->resolutions[l - i - 1].previous_x1 - tilec->resolutions[l -
i -
1].
previous_x0;
/* inversion on the previous and propagation of the inversion on the other tile */
if ((previous_rw1 > previous_rw - previous_rw1 && rw1 == rw - rw1)
|| (tilec->resolutions[l - i - 1].cas_row
&& previous_rw1 == previous_rw - previous_rw1))
cas_row = 1;
}
if (tilec->previous_col) {
previous_rh =
tilec->resolutions[l - i].previous_y1 - tilec->resolutions[l -
i].
previous_y0;
previous_rh1 =
tilec->resolutions[l - i - 1].previous_y1 - tilec->resolutions[l -
i -
1].
previous_y0;
/* inversion on the previous and propagation of the inversion on the other tile */
if ((previous_rh1 > previous_rh - previous_rh1 && rh1 == rh - rh1)
|| (tilec->resolutions[l - i - 1].cas_col
&& previous_rh1 == previous_rh - previous_rh1))
cas_col = 1;
}
/* subband LL shorter than LH or HL */
if (rw1 < rw - rw1)
cas_row = 1;
if (rh1 < rh - rh1)
cas_col = 1;
/* OFFSET IMAGE (If origin of the resolution is odd and first tile on the row or column) */
if (!tilec->previous_row && ((tilec->resolutions[l - i].x0 % 2) == 1))
cas_row = 1;
if (!tilec->previous_col && ((tilec->resolutions[l - i].y0 % 2) == 1))
cas_col = 1;
tilec->resolutions[l - i - 1].cas_row = cas_row;
tilec->resolutions[l - i - 1].cas_col = cas_col;
for (j = 0; j < rw; j++)
dwt_encode_1(a + j, rh, w, rh1, cas_col);
for (j = 0; j < rh; j++)
dwt_encode_1(a + j * w, rw, 1, rw1, cas_row);
}
dwt_clean();
}
/* <summary> */
/* Inverse 5-3 wavelet tranform in 2-D. */
/* </summary> */
void dwt_decode(int *a, int w, int h, tcd_tilecomp_t * tilec, int l,
tcd_tilecomp_t * row_tilec, tcd_tilecomp_t * col_tilec)
{
int i, j, rw, rh, rw1, rh1;
int previous_rw, previous_rh, previous_rw1, previous_rh1;
for (i = l - 1; i >= 0; i--) {
int cas_col = 0;
int cas_row = 0;
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;
if (tilec->previous_row) {
previous_rw =
tilec->resolutions[l - i].previous_x1 - tilec->resolutions[l -
i].
previous_x0;
previous_rw1 =
tilec->resolutions[l - i - 1].previous_x1 - tilec->resolutions[l -
i -
1].
previous_x0;
if ((previous_rw1 > previous_rw - previous_rw1 && rw1 == rw - rw1)
|| (row_tilec->resolutions[l - i - 1].cas_row
&& previous_rw1 == previous_rw - previous_rw1))
cas_row = 1;
}
if (tilec->previous_col) {
previous_rh =
tilec->resolutions[l - i].previous_y1 - tilec->resolutions[l -
i].
previous_y0;
previous_rh1 =
tilec->resolutions[l - i - 1].previous_y1 - tilec->resolutions[l -
i -
1].
previous_y0;
if ((previous_rh1 > previous_rh - previous_rh1 && rh1 == rh - rh1)
|| (col_tilec->resolutions[l - i - 1].cas_col
&& previous_rh1 == previous_rh - previous_rh1))
cas_col = 1;
}
if (rw1 < rw - rw1)
cas_row = 1;
if (rh1 < rh - rh1)
cas_col = 1;
/* OFFSET IMAGE (If origin of the resolution is odd and first tile on the row or column) */
if (!tilec->previous_row && ((tilec->resolutions[l - i].x0 % 2) == 1))
cas_row = 1;
if (!tilec->previous_col && ((tilec->resolutions[l - i].y0 % 2) == 1))
cas_col = 1;
tilec->resolutions[l - i - 1].cas_row = cas_row;
tilec->resolutions[l - i - 1].cas_col = cas_col;
for (j = 0; j < rh; j++)
dwt_decode_1(a + j * w, rw, 1, rw1, cas_row);
for (j = 0; j < rw; j++)
dwt_decode_1(a + j, rh, w, rh1, cas_col);
}
dwt_clean();
}
/* <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 1-D. */
/* </summary> */
void dwt_encode_1_real(int *a, int n, int x, int res, int cas)
{
int dn, sn, i = 0;
dn = n - res;
sn = res;
if (cas) {
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);
for (i = 0; i < sn; i++)
D(i) = fix_mul(D(i), 6660);
}
} else {
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);
for (i = 0; i < sn; i++)
S(i) = fix_mul(S(i), 6660);
}
}
dwt_deinterleave_real(a, n, x, res, cas);
}
/* <summary> */
/* Inverse 9-7 wavelet transform in 1-D. */
/* </summary> */
void dwt_decode_1_real(int *a, int n, int x, int res, int cas)
{
int dn, sn, i = 0;
dn = n - res;
sn = res;
dwt_interleave_real(a, n, x, res, cas);
if (cas) {
if ((sn > 0) || (dn > 1)) { /* NEW : CASE ONE ELEMENT */
for (i = 0; i < sn; i++)
D(i) = fix_mul(D(i), 10076);
for (i = 0; i < dn; i++)
S(i) = fix_mul(S(i), 13320);
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(DD_(i) + DD_(i - 1), 7233);
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), 12993);
}
} else {
if ((dn > 0) || (sn > 1)) { /* NEW : CASE ONE ELEMENT */
for (i = 0; i < sn; i++)
S(i) = fix_mul(S(i), 10076);
for (i = 0; i < dn; i++)
D(i) = fix_mul(D(i), 13320);
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(S_(i) + S_(i + 1), 7233);
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), 12993);
}
}
}
/* <summary> */
/* Forward 9-7 wavelet transform in 2-D. */
/* </summary> */
void dwt_encode_real(int *a, int w, int h, tcd_tilecomp_t * tilec, int l)
{
int i, j, rw, rh, rw1, rh1;
int previous_rw, previous_rh, previous_rw1, previous_rh1;
for (i = 0; i < l; i++) {
int cas_col = 0;
int cas_row = 0;
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;
if (tilec->previous_row) {
previous_rw =
tilec->resolutions[l - i].previous_x1 - tilec->resolutions[l -
i].
previous_x0;
previous_rw1 =
tilec->resolutions[l - i - 1].previous_x1 - tilec->resolutions[l -
i -
1].
previous_x0;
if ((previous_rw1 > previous_rw - previous_rw1 && rw1 == rw - rw1)
|| (tilec->resolutions[l - i - 1].cas_row
&& previous_rw1 == previous_rw - previous_rw1))
cas_row = 1;
}
if (tilec->previous_col) {
previous_rh =
tilec->resolutions[l - i].previous_y1 - tilec->resolutions[l -
i].
previous_y0;
previous_rh1 =
tilec->resolutions[l - i - 1].previous_y1 - tilec->resolutions[l -
i -
1].
previous_y0;
if ((previous_rh1 > previous_rh - previous_rh1 && rh1 == rh - rh1)
|| (tilec->resolutions[l - i - 1].cas_col
&& previous_rh1 == previous_rh - previous_rh1))
cas_col = 1;
}
if (rw1 < rw - rw1)
cas_row = 1;
if (rh1 < rh - rh1)
cas_col = 1;
/* OFFSET IMAGE (If origin of the resolution is odd and first tile on the row or column) */
if (!tilec->previous_row && ((tilec->resolutions[l - i].x0 % 2) == 1))
cas_row = 1;
if (!tilec->previous_col && ((tilec->resolutions[l - i].y0 % 2) == 1))
cas_col = 1;
tilec->resolutions[l - i - 1].cas_row = cas_row;
tilec->resolutions[l - i - 1].cas_col = cas_col;
for (j = 0; j < rw; j++)
dwt_encode_1_real(a + j, rh, w, rh1, cas_col);
for (j = 0; j < rh; j++)
dwt_encode_1_real(a + j * w, rw, 1, rw1, cas_row);
}
}
/* <summary> */
/* Inverse 9-7 wavelet transform in 2-D. */
/* </summary> */
void dwt_decode_real(int *a, int w, int h, tcd_tilecomp_t * tilec, int l,
tcd_tilecomp_t * row_tilec,
tcd_tilecomp_t * col_tilec)
{
int i, j, rw, rh, rw1, rh1;
int previous_rw, previous_rh, previous_rw1, previous_rh1;
for (i = l - 1; i >= 0; i--) {
int cas_col = 0;
int cas_row = 0;
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;
if (tilec->previous_row) {
previous_rw =
tilec->resolutions[l - i].previous_x1 - tilec->resolutions[l -
i].
previous_x0;
previous_rw1 =
tilec->resolutions[l - i - 1].previous_x1 - tilec->resolutions[l -
i -
1].
previous_x0;
if ((previous_rw1 > previous_rw - previous_rw1 && rw1 == rw - rw1)
|| (row_tilec->resolutions[l - i - 1].cas_row
&& previous_rw1 == previous_rw - previous_rw1))
cas_row = 1;
}
if (tilec->previous_col) {
previous_rh =
tilec->resolutions[l - i].previous_y1 - tilec->resolutions[l -
i].
previous_y0;
previous_rh1 =
tilec->resolutions[l - i - 1].previous_y1 - tilec->resolutions[l -
i -
1].
previous_y0;
if ((previous_rh1 > previous_rh - previous_rh1 && rh1 == rh - rh1)
|| (col_tilec->resolutions[l - i - 1].cas_col
&& previous_rh1 == previous_rh - previous_rh1))
cas_col = 1;
}
if (rw1 < rw - rw1)
cas_row = 1;
if (rh1 < rh - rh1)
cas_col = 1;
/* OFFSET IMAGE (If origin of the resolution is odd and first tile on the row or column) */
if (!tilec->previous_row && ((tilec->resolutions[l - i].x0 % 2) == 1))
cas_row = 1;
if (!tilec->previous_col && ((tilec->resolutions[l - i].y0 % 2) == 1))
cas_col = 1;
tilec->resolutions[l - i - 1].cas_row = cas_row;
tilec->resolutions[l - i - 1].cas_col = cas_col;
for (j = 0; j < rh; j++)
dwt_decode_1_real(a + j * w, rw, 1, rw1, cas_row);
for (j = 0; j < rw; j++)
dwt_decode_1_real(a + j, rh, w, rh1, cas_col);
}
}
/* <summary> */
/* Get gain of 9-7 wavelet transform. */
/* </summary> */
int dwt_getgain_real(int 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];
}

98
libopenjpeg/dwt.h Normal file
View File

@ -0,0 +1,98 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2002-2003, 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 "tcd.h"
#ifndef __DWT_H
#define __DWT_H
/*
* Apply a reversible DWT transform to a component of an image
* a: samples of the component
* w: width of the component
* h: height of the component
* l: number of decomposition levels in the DWT
*/
/* void dwt_encode(int* a, int w, int h, int l); */
void dwt_encode(int *a, int w, int h, tcd_tilecomp_t * tilec, int l);
/*
* Apply a reversible inverse DWT transform to a component of an image
* a: samples of the component
* w: width of the component
* h: height of the component
* l: number of decomposition levels in the DWT
*/
void dwt_decode(int *a, int w, int h, tcd_tilecomp_t * tilec, int l,
tcd_tilecomp_t * row_tilec, tcd_tilecomp_t * col_tilec);
/* void dwt_decode(int* a, int w, int h,tcd_tilecomp_t *tilec, int l); */
/*
* Get the gain of a subband for the reversible DWT
* orient: number that identifies the subband (0->LL, 1->HL, 2->LH, 3->HH)
*/
int dwt_getgain(int orient);
/*
* Get the norm of a wavelet function of a subband at a specified level for the reversible DWT
* level: level of the wavelet function
* orient: band of the wavelet function
*/
double dwt_getnorm(int level, int orient);
/*
* Apply an irreversible DWT transform to a component of an image
* a: samples of the component
* w: width of the component
* h: height of the component
* l: number of decomposition levels in the DWT
*/
void dwt_encode_real(int *a, int w, int h, tcd_tilecomp_t * tilec, int l);
/*
* Apply an irreversible inverse DWT transform to a component of an image
* a: samples of the component
* w: width of the component
* h: height of the component
* l: number of decomposition levels in the DWT
*/
void dwt_decode_real(int *a, int w, int h, tcd_tilecomp_t * tilec, int l,
tcd_tilecomp_t * row_tilec,
tcd_tilecomp_t * col_tilec);
/*
* Get the gain of a subband for the irreversible DWT
* orient: number that identifies the subband (0->LL, 1->HL, 2->LH, 3->HH)
*/
int dwt_getgain_real(int orient);
/*
* Get the norm of a wavelet function of a subband at a specified level for the irreversible DWT
* level: level of the wavelet function
* orient: band of the wavelet function
*/
double dwt_getnorm_real(int level, int orient);
#endif

41
libopenjpeg/fix.c Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright (c) 2001-2002, David Janssens
* 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 "fix.h"
#ifdef DAVID_WIN32
#define int64 __int64
#else
#define int64 long long
#endif
/* <summary> */
/* Multiply two fixed-precision rational numbers. */
/* </summary> */
int fix_mul(int a, int b)
{
return (int) ((int64) a * (int64) b >> 13);
}

33
libopenjpeg/fix.h Normal file
View File

@ -0,0 +1,33 @@
/*
* Copyright (c) 2001-2002, David Janssens
* 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
int fix_mul(int a, int b);
#endif

97
libopenjpeg/int.c Normal file
View File

@ -0,0 +1,97 @@
/*
* Copyright (c) 2001-2002, David Janssens
* 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.
*/
/* <summary> */
/* Get the minimum of two integers. */
/* </summary> */
int int_min(int a, int b)
{
return a < b ? a : b;
}
/* <summary> */
/* Get the maximum of two integers. */
/* </summary> */
int int_max(int a, int b)
{
return a > b ? a : b;
}
/* <summary> */
/* Clamp an integer inside an interval. */
/* </summary> */
int int_clamp(int a, int min, int max)
{
if (a < min)
return min;
if (a > max)
return max;
return a;
}
/* <summary> */
/* Get absolute value of integer. */
/* </summary> */
int int_abs(int a)
{
return a < 0 ? -a : a;
}
/* <summary> */
/* Divide an integer and round upwards. */
/* </summary> */
int int_ceildiv(int a, int b)
{
return (a + b - 1) / b;
}
/* <summary> */
/* Divide an integer by a power of 2 and round upwards. */
/* </summary> */
int int_ceildivpow2(int a, int b)
{
return (a + (1 << b) - 1) >> b;
}
/* <summary> */
/* Divide an integer by a power of 2 and round downwards. */
/* </summary> */
int int_floordivpow2(int a, int b)
{
return a >> b;
}
/* <summary> */
/* Get logarithm of an integer and round downwards. */
/* </summary> */
int int_floorlog2(int a)
{
int l;
for (l = 0; a > 1; l++) {
a >>= 1;
}
return l;
}

39
libopenjpeg/int.h Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright (c) 2001-2002, David Janssens
* 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
int int_min(int a, int b);
int int_max(int a, int b);
int int_clamp(int a, int min, int max);
int int_abs(int a);
int int_ceildiv(int a, int b);
int int_ceildivpow2(int a, int b);
int int_floordivpow2(int a, int b);
int int_floorlog2(int a);
#endif

1153
libopenjpeg/j2k.c Normal file
View File

File diff suppressed because it is too large Load Diff

185
libopenjpeg/j2k.h Normal file
View File

@ -0,0 +1,185 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2002-2003, 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.
*/
#define VERSION "0.0.8"
#ifdef DAVID_WIN32
#ifdef LIBJ2K_EXPORTS
#define LIBJ2K_API __declspec(dllexport)
#else
#define LIBJ2K_API __declspec(dllimport)
#endif
#else
#define LIBJ2K_API
#endif
#ifndef __J2K_H
#define __J2K_H
#define J2K_MAXRLVLS 33
#define J2K_MAXBANDS (3*J2K_MAXRLVLS+1)
#define J2K_CP_CSTY_PRT 0x01
#define J2K_CP_CSTY_SOP 0x02
#define J2K_CP_CSTY_EPH 0x04
#define J2K_CCP_CSTY_PRT 0x01
#define J2K_CCP_CBLKSTY_LAZY 0x01
#define J2K_CCP_CBLKSTY_RESET 0x02
#define J2K_CCP_CBLKSTY_TERMALL 0x04
#define J2K_CCP_CBLKSTY_VSC 0x08
#define J2K_CCP_CBLKSTY_PTERM 0x10
#define J2K_CCP_CBLKSTY_SEGSYM 0x20
#define J2K_CCP_QNTSTY_NOQNT 0
#define J2K_CCP_QNTSTY_SIQNT 1
#define J2K_CCP_QNTSTY_SEQNT 2
typedef struct {
int dx, dy; /* XRsiz, YRsiz */
int prec; /* precision */
int bpp; /* deapth of image in bits */
int sgnd; /* signed */
int *data; /* image-component data */
} j2k_comp_t;
typedef struct {
int x0, y0; /* XOsiz, YOsiz */
int x1, y1; /* Xsiz, Ysiz */
int numcomps; /* number of components */
int index_on; /* 0 = no index || 1 = index */
/* int PPT; */
j2k_comp_t *comps; /* image-components */
} j2k_image_t;
typedef struct {
int expn; /* exponent */
int mant; /* mantissa */
} j2k_stepsize_t;
typedef struct {
int csty; /* coding style */
int numresolutions; /* number of resolutions */
int cblkw; /* width of code-blocks */
int cblkh; /* height of code-blocks */
int cblksty; /* code-block coding style */
int qmfbid; /* discrete wavelet transform identifier */
int qntsty; /* quantisation style */
j2k_stepsize_t stepsizes[J2K_MAXBANDS]; /* stepsizes used for quantisation */
int numgbits; /* number of guard bits */
int roishift; /* Region Of Interest shift */
int prcw[J2K_MAXRLVLS]; /* Precinct width */
int prch[J2K_MAXRLVLS]; /* Precinct height */
} j2k_tccp_t;
typedef struct {
int resno0, compno0;
int layno1, resno1, compno1;
int prg;
int tile;
char progorder[4];
} j2k_poc_t;
typedef struct {
int csty; /* coding style */
int prg; /* progression order */
int numlayers; /* number of layers */
int mct; /* multi-component transform identifier */
int rates[100]; /* rates of layers */
int numpocs; /* number of progression order changes */
j2k_poc_t pocs[32]; /* progression order changes */
j2k_tccp_t *tccps; /* tile-component coding parameters */
} j2k_tcp_t;
typedef struct {
int image_type; /* 0: PNM, PGM, PPM 1: PGX */
int disto_alloc; /* Allocation by rate/distortion */
int fixed_alloc; /* Allocation by fixed layer */
int tx0, ty0; /* XTOsiz, YTOsiz */
int tdx, tdy; /* XTsiz, YTsiz */
char *comment; /* comment for coding */
int tw, th;
j2k_tcp_t *tcps; /* tile coding parameters */
} j2k_cp_t;
typedef struct {
int start_pos, end_pos; /* start and end position */
double disto;
} info_packet; /* Index struct */
typedef struct {
int num_tile; /* Number of Tile */
int start_pos; /* Start position */
int end_header; /* End position of the header */
int end_pos; /* End position */
int pw, ph; /* number of precinct by tile */
info_packet *packet; /* information concerning packets inside tile */
} info_tile; /* index struct */
typedef struct {
int index_on;
double D_max; /* ADD for Marcela */
int num; /* numero of packet */
int index_write; /* writing the packet inthe index with t2_encode_packets */
int Im_w, Im_h; /* Image width and Height */
int Prog; /* progression order */
int Tile_x, Tile_y; /* Number of Tile in X and Y */
int tw, th;
int Comp; /* Component numbers */
int Layer; /* number of layer */
int Decomposition; /* number of decomposition */
int pw, ph; /* nombre precinct in X and Y */
int pdx, pdy; /* size of precinct in X and Y */
int Main_head_end; /* Main header position */
int codestream_size; /* codestream's size */
info_tile *tile; /* information concerning tiles inside image */
} info_image; /* index struct */
/*
* Encode an image into a JPEG-2000 codestream
* i: image to encode
* cp: coding parameters
* dest: destination buffer
* len: length of destination buffer
* index : index file name
*/
LIBJ2K_API int j2k_encode(j2k_image_t * i, j2k_cp_t * cp, char *outfile,
int len, char *index);
/* LIBJ2K_API int j2k_encode(j2k_image_t *i, j2k_cp_t *cp,unsigned char *dest, int len); */
/*
* Decode an image from a JPEG-2000 codestream
* src: source buffer
* len: length of source buffer
* i: decode image
* cp: coding parameters that were used to encode the image
*/
LIBJ2K_API int j2k_decode(unsigned char *src, int len, j2k_image_t ** i,
j2k_cp_t ** cp);
#endif

134
libopenjpeg/mct.c Normal file
View File

@ -0,0 +1,134 @@
/*
* Copyright (c) 2001-2002, David Janssens
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "mct.h"
#include "fix.h"
/* <summary> */
/* This table contains the norms of the basis function of the reversible MCT. */
/* </summary> */
double mct_norms[3] = { 1.732, .8292, .8292 };
/* <summary> */
/* This table contains the norms of the basis function of the irreversible MCT. */
/* </summary> */
double mct_norms_real[3] = { 1.732, 1.805, 1.573 };
/* <summary> */
/* Foward 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> */
/* Foward 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];
}

74
libopenjpeg/mct.h Normal file
View File

@ -0,0 +1,74 @@
/*
* Copyright (c) 2001-2002, David Janssens
* 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
/*
* Apply a reversible multi-component transform to an image
* R: samples for red component
* G: samples for green component
* B: samples blue component
* n: number of samples for each component
*/
void mct_encode(int *R, int *G, int *B, int n);
/*
* Apply a reversible multi-component inverse transform to an image
* Y: samples for luminance component
* U: samples for red chrominance component
* V: samples for blue chrominance component
* n: number of samples for each component
*/
void mct_decode(int *V, int *U, int *Y, int n);
/*
* Get norm of the basis function used for the reversible multi-component transform
* compno: number of the component (0->Y, 1->U, 2->V)
*/
double mct_getnorm(int compno);
/*
* Apply an irreversible multi-component transform to an image
* R: samples for red component
* G: samples for green component
* B: samples blue component
* n: number of samples for each component
*/
void mct_encode_real(int *c0, int *c1, int *c2, int n);
/*
* Apply an irreversible multi-component inverse transform to an image
* Y: samples for luminance component
* U: samples for red chrominance component
* V: samples for blue chrominance component
* 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
* compno: number of the component (0->Y, 1->U, 2->V)
*/
double mct_getnorm_real(int compno);
#endif

588
libopenjpeg/mqc.c Normal file
View File

@ -0,0 +1,588 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2002-2003, 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 "mqc.h"
#include <stdio.h>
/* <summary> */
/* This struct defines the state of a context. */
/* </summary> */
typedef struct mqc_state_s {
unsigned int qeval; /* the probability of the Least Probable Symbol (0.75->0x8000, 1.5->0xffff) */
int mps; /* the Most Probable Symbol (0 or 1) */
struct mqc_state_s *nmps; /* next state if the next encoded symbol is the MPS */
struct mqc_state_s *nlps; /* next state if the next encoded symbol is the LPS */
} mqc_state_t;
/* <summary> */
/* This array defines all the possible states for a context. */
/* </summary> */
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]},
};
#define MQC_NUMCTXS 32
unsigned int mqc_c;
unsigned int mqc_a;
unsigned int mqc_ct;
unsigned char *mqc_bp;
unsigned char *mqc_start;
unsigned char *mqc_end;
mqc_state_t *mqc_ctxs[MQC_NUMCTXS];
mqc_state_t **mqc_curctx;
/* <summary> */
/* Return the number of bytes already encoded. */
/* </summary> */
int mqc_numbytes()
{
return mqc_bp - mqc_start;
}
/* <summary> */
/* Output a byte, doing bit-stuffing if necessary. */
/* After a 0xff byte, the next byte must be smaller than 0x90 */
/* </summary> */
void mqc_byteout()
{
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;
}
}
}
}
/* <summary> */
/* Renormalize mqc_a and mqc_c while encoding, so that mqc_a stays between 0x8000 and 0x10000 */
/* </summary> */
void mqc_renorme()
{
do {
mqc_a <<= 1;
mqc_c <<= 1;
mqc_ct--;
if (mqc_ct == 0) {
mqc_byteout();
}
} while ((mqc_a & 0x8000) == 0);
}
/* <summary> */
/* Encode the most probable symbol. */
/* </summary> */
void mqc_codemps()
{
mqc_a -= (*mqc_curctx)->qeval;
if ((mqc_a & 0x8000) == 0) {
if (mqc_a < (*mqc_curctx)->qeval) {
mqc_a = (*mqc_curctx)->qeval;
} else {
mqc_c += (*mqc_curctx)->qeval;
}
*mqc_curctx = (*mqc_curctx)->nmps;
mqc_renorme();
} else {
mqc_c += (*mqc_curctx)->qeval;
}
}
/* <summary> */
/* Encode the most least symbol. */
/* </summary> */
void mqc_codelps()
{
mqc_a -= (*mqc_curctx)->qeval;
if (mqc_a < (*mqc_curctx)->qeval) {
mqc_c += (*mqc_curctx)->qeval;
} else {
mqc_a = (*mqc_curctx)->qeval;
}
*mqc_curctx = (*mqc_curctx)->nlps;
mqc_renorme();
}
/* <summary> */
/* Initialize encoder. */
/* </summary> */
/* <param name="bp">Output buffer.</param> */
void mqc_init_enc(unsigned char *bp)
{
mqc_setcurctx(0);
mqc_a = 0x8000;
mqc_c = 0;
mqc_bp = bp - 1;
mqc_ct = 12;
if (*mqc_bp == 0xff) {
mqc_ct = 13;
}
mqc_start = bp;
}
/* <summary> */
/* Set current context. */
/* </summary> */
/* <param name="ctxno">Context number.</param> */
void mqc_setcurctx(int ctxno)
{
mqc_curctx = &mqc_ctxs[ctxno];
}
/* <summary> */
/* Encode a symbol using the MQ-coder. */
/* </summary> */
/* <param name="d"> The symbol to be encoded (0 or 1).</param> */
void mqc_encode(int d)
{
if ((*mqc_curctx)->mps == d) {
mqc_codemps();
} else {
mqc_codelps();
}
}
/* <summary> */
/* Fill mqc_c with 1's for flushing */
/* </summary> */
void mqc_setbits()
{
unsigned int tempc = mqc_c + mqc_a;
mqc_c |= 0xffff;
if (mqc_c >= tempc) {
mqc_c -= 0x8000;
}
}
/* <summary> */
/* Flush encoded data. */
/* </summary> */
void mqc_flush()
{
mqc_setbits();
mqc_c <<= mqc_ct;
mqc_byteout();
mqc_c <<= mqc_ct;
mqc_byteout();
if (*mqc_bp != 0xff) {
mqc_bp++;
}
}
/* <summary> */
/* not fully implemented and tested !! */
/* BYPASS mode switch, initialization operation */
/* JPEG 2000 p 505 */
/* </summary> */
void mqc_bypass_init_enc()
{
mqc_c = 0;
mqc_ct = 8;
if (*mqc_bp == 0xff) {
mqc_ct = 7;
}
}
/* <summary> */
/* not fully implemented and tested !! */
/* BYPASS mode switch, coding operation */
/* JPEG 2000 p 505 */
/* </summary> */
void mqc_bypass_enc(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;
}
}
/* <summary> */
/* not fully implemented and tested !! */
/* BYPASS mode switch, flush operation */
/* </summary> */
int mqc_bypass_flush_enc()
{
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;
}
/* <summary> */
/* RESET mode switch */
/* </summary> */
void mqc_reset_enc()
{
mqc_resetstates();
mqc_setstate(18, 0, 46);
mqc_setstate(0, 0, 3);
mqc_setstate(1, 0, 4);
}
/* <summary> */
/* mode switch RESTART (TERMALL) */
/* </summary> */
int mqc_restart_enc()
{
int correction = 1;
/* <flush part> */
int n = 27 - 15 - mqc_ct;
mqc_c <<= mqc_ct;
while (n > 0) {
mqc_byteout();
n -= mqc_ct;
mqc_c <<= mqc_ct;
}
mqc_byteout();
return correction;
}
/* <summary> */
/* mode switch RESTART (TERMALL) reinitialisation */
/* </summary> */
void mqc_restart_init_enc()
{
/* <Re-init part> */
mqc_a = 0x8000;
mqc_c = 0;
mqc_ct = 12;
mqc_bp--;
if (*mqc_bp == 0xff) {
mqc_ct = 13;
}
}
/* <summary> */
/* ERTERM mode switch */
/* </summary> */
void mqc_erterm_enc()
{
int k = 11 - mqc_ct + 1;
while (k > 0) {
mqc_c <<= mqc_ct;
mqc_ct = 0;
mqc_byteout();
k -= mqc_ct;
}
if (*mqc_bp != 0xff) {
mqc_byteout();
}
}
/* <summary> */
/* SEGMARK mode switch (SEGSYM) */
/* </summary> */
void mqc_segmark_enc()
{
int i;
mqc_setcurctx(18);
for (i = 1; i < 5; i++) {
mqc_encode(i % 2);
}
}
/* <summary> */
/* </summary> */
int mqc_mpsexchange()
{
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;
}
/* <summary> */
/* </summary> */
int mqc_lpsexchange()
{
int d;
if (mqc_a < (*mqc_curctx)->qeval) {
mqc_a = (*mqc_curctx)->qeval;
d = (*mqc_curctx)->mps;
*mqc_curctx = (*mqc_curctx)->nmps;
} else {
mqc_a = (*mqc_curctx)->qeval;
d = 1 - (*mqc_curctx)->mps;
*mqc_curctx = (*mqc_curctx)->nlps;
}
return d;
}
/* <summary> */
/* Input a byte. */
/* </summary> */
void mqc_bytein()
{
if (mqc_bp != mqc_end) {
unsigned int c;
if (mqc_bp + 1 != mqc_end) {
c = *(mqc_bp + 1);
} else {
c = 0xff;
}
if (*mqc_bp == 0xff) {
if (c > 0x8f) {
mqc_c += 0xff00;
mqc_ct = 8;
} else {
mqc_bp++;
mqc_c += c << 9;
mqc_ct = 7;
}
} else {
mqc_bp++;
mqc_c += c << 8;
mqc_ct = 8;
}
} else {
mqc_c += 0xff00;
mqc_ct = 8;
}
}
/* <summary> */
/* Renormalize mqc_a and mqc_c while decoding. */
/* </summary> */
void mqc_renormd()
{
do {
if (mqc_ct == 0) {
mqc_bytein();
}
mqc_a <<= 1;
mqc_c <<= 1;
mqc_ct--;
} while (mqc_a < 0x8000);
}
/* <summary> */
/* Initialize decoder. */
/* </summary> */
void mqc_init_dec(unsigned char *bp, int len)
{
mqc_setcurctx(0);
mqc_start = bp;
mqc_end = bp + len;
mqc_bp = bp;
mqc_c = *mqc_bp << 16;
mqc_bytein();
mqc_c <<= 7;
mqc_ct -= 7;
mqc_a = 0x8000;
}
/* <summary> */
/* Decode a symbol. */
/* </summary> */
int mqc_decode()
{
int d;
mqc_a -= (*mqc_curctx)->qeval;
if ((mqc_c >> 16) < (*mqc_curctx)->qeval) {
d = mqc_lpsexchange();
mqc_renormd();
} else {
mqc_c -= (*mqc_curctx)->qeval << 16;
if ((mqc_a & 0x8000) == 0) {
d = mqc_mpsexchange();
mqc_renormd();
} else {
d = (*mqc_curctx)->mps;
}
}
return d;
}
/* <summary> */
/* Reset states of all contexts. */
/* </summary> */
void mqc_resetstates()
{
int i;
for (i = 0; i < MQC_NUMCTXS; i++) {
mqc_ctxs[i] = mqc_states;
}
}
/* <summary> */
/* Set the state for a context. */
/* </summary> */
/* <param name="ctxno">Context number</param> */
/* <param name="msb">Most significant bit</param> */
/* <param name="prob">Index to the probability of symbols</param> */
void mqc_setstate(int ctxno, int msb, int prob)
{
mqc_ctxs[ctxno] = &mqc_states[msb + (prob << 1)];
}

127
libopenjpeg/mqc.h Normal file
View File

@ -0,0 +1,127 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2002-2003, 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
/*
* Return the number of bytes written/read since initialisation
*/
int mqc_numbytes();
/*
* 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)
*/
void mqc_resetstates();
/*
* Set the state of a particular context
* ctxno: number that identifies the context
* msb: the MSB of the new state of the context
* prob: number that identifies the probability of the symbols for the new state of the context
*/
void mqc_setstate(int ctxno, int msb, int prob);
/*
* Initialize the encoder
* bp: pointer to the start of the buffer where the bytes will be written
*/
void mqc_init_enc(unsigned char *bp);
/*
* Set the current context used for coding/decoding
* ctxno: number that identifies the context
*/
void mqc_setcurctx(int ctxno);
/*
* Encode a bit
* d: bit to encode (0 or 1)
*/
void mqc_encode(int d);
/*
* Flush the encoder, so that all remaining data is written
*/
void mqc_flush();
/*
* BYPASS mode switch
*/
void mqc_bypass_init_enc();
/*
* BYPASS mode switch
*/
void mqc_bypass_enc();
/*
* BYPASS mode switch
*/
int mqc_bypass_flush_enc();
/*
* RESET mode switch
*/
void mqc_reset_enc();
/*
* RESTART mode switch (TERMALL)
*/
int mqc_restart_enc();
/*
* RESTART mode switch (TERMALL)
*/
void mqc_restart_init_enc();
/*
* ERTERM mode switch (PTERM)
*/
void mqc_erterm_enc();
/*
* SEGMARK mode switch (SEGSYM)
*/
void mqc_segmark_enc();
/*
* Initialize the decoder
* bp: pointer to the start of the buffer from which the bytes will be read
* len: length of the input buffer
*/
void mqc_init_dec(unsigned char *bp, int len);
/*
* Decode a bit (returns 0 or 1)
*/
int mqc_decode();
#endif

48
libopenjpeg/openjpeg.h Normal file
View File

@ -0,0 +1,48 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 __OPENJPEG_H
#define __OPENJPEG_H
#include <j2k.h>
#include <tcd.h>
#include <bio.h>
#include <cio.h>
#include <dwt.h>
#include <fix.h>
#include <int.h>
#include <mct.h>
#include <mqc.h>
#include <pi.h>
#include <raw.h>
#include <t1.h>
#include <t2.h>
#include <tgt.h>
#endif

488
libopenjpeg/pi.c Normal file
View File

@ -0,0 +1,488 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, 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 "pi.h"
#include "int.h"
#include <stdlib.h>
#include <stdio.h>
/* <summary> */
/* Create a packet iterator. */
/* </summary> */
pi_iterator_t *pi_create(j2k_image_t * img, j2k_cp_t * cp, int tileno)
{
int p, q;
int compno, resno, pino, layno, precno;
int maxres = 0;
pi_iterator_t *pi;
j2k_tcp_t *tcp;
j2k_tccp_t *tccp;
tcp = &cp->tcps[tileno];
pi =
(pi_iterator_t *) malloc((tcp->numpocs + 1) * sizeof(pi_iterator_t));
for (pino = 0; pino < tcp->numpocs + 1; pino++) { /* change */
p = tileno % cp->tw;
q = tileno / cp->tw;
/* pi->tx0=int_max(cp->tx0+p*cp->tdx, img->x0);
pi->ty0=int_max(cp->ty0+q*cp->tdy, img->y0);
pi->tx1=int_min(cp->tx0+(p+1)*cp->tdx, img->x1);
pi->ty1=int_min(cp->ty0+(q+1)*cp->tdy, img->y1);
pi->numcomps=img->numcomps;
pi->comps=(pi_comp_t*)malloc(img->numcomps*sizeof(pi_comp_t)); */
pi[pino].tx0 = int_max(cp->tx0 + p * cp->tdx, img->x0);
pi[pino].ty0 = int_max(cp->ty0 + q * cp->tdy, img->y0);
pi[pino].tx1 = int_min(cp->tx0 + (p + 1) * cp->tdx, img->x1);
pi[pino].ty1 = int_min(cp->ty0 + (q + 1) * cp->tdy, img->y1);
pi[pino].numcomps = img->numcomps;
pi[pino].comps =
(pi_comp_t *) malloc(img->numcomps * sizeof(pi_comp_t));
for (compno = 0; compno < pi->numcomps; compno++) {
int tcx0, tcy0, tcx1, tcy1;
/* pi_comp_t *comp=&pi->comps[compno]; */
pi_comp_t *comp = &pi[pino].comps[compno];
tccp = &tcp->tccps[compno];
comp->dx = img->comps[compno].dx;
comp->dy = img->comps[compno].dy;
comp->numresolutions = tccp->numresolutions;
comp->resolutions =
(pi_resolution_t *) malloc(comp->numresolutions *
sizeof(pi_resolution_t));
tcx0 = int_ceildiv(pi->tx0, comp->dx);
tcy0 = int_ceildiv(pi->ty0, comp->dy);
tcx1 = int_ceildiv(pi->tx1, comp->dx);
tcy1 = int_ceildiv(pi->ty1, comp->dy);
if (comp->numresolutions > maxres) {
maxres = comp->numresolutions;
}
for (resno = 0; resno < comp->numresolutions; resno++) {
int levelno;
int rx0, ry0, rx1, ry1;
int px0, py0, px1, py1;
pi_resolution_t *res = &comp->resolutions[resno];
if (tccp->csty & J2K_CCP_CSTY_PRT) {
res->pdx = tccp->prcw[resno];
res->pdy = tccp->prch[resno];
} else {
res->pdx = 15;
res->pdy = 15;
}
levelno = comp->numresolutions - 1 - resno;
rx0 = int_ceildivpow2(tcx0, levelno);
ry0 = int_ceildivpow2(tcy0, levelno);
rx1 = int_ceildivpow2(tcx1, levelno);
ry1 = int_ceildivpow2(tcy1, levelno);
px0 = int_floordivpow2(rx0, res->pdx) << res->pdx;
py0 = int_floordivpow2(ry0, res->pdy) << res->pdy;
px1 = int_ceildivpow2(rx1, res->pdx) << res->pdx;
py1 = int_ceildivpow2(ry1, res->pdy) << res->pdy;
res->pw = (px1 - px0) >> res->pdx;
res->ph = (py1 - py0) >> res->pdy;
}
}
/* pi->first=1;
pi->poc.resno0=0;
pi->poc.compno0=0;
pi->poc.layno1=tcp->numlayers;
pi->poc.resno1=maxres;
pi->poc.compno1=img->numcomps;
pi->poc.prg=tcp->prg; */
for (layno = 0; layno < 10; layno++) {
/* pi_comp_t *compo; */
/* pi_resolution_t *res; */
for (resno = 0; resno < 10; resno++) {
for (compno = 0; compno < 3; compno++) {
/* compo=&pi[pino].comps[compno]; */
/* res=&compo->resolutions[pi->resno]; */
for (precno = 0; precno < 99; precno++) {
pi[pino].include[layno][resno][compno][precno] = 0;
}
}
}
}
if (pino == tcp->numpocs) {
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 = img->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;
}
/* <summary> */
/* Get next packet in layer=resolution-component-precinct order. */
/* </summary> */
int pi_next_lrcp(pi_iterator_t * pi)
{
pi_comp_t *comp;
pi_resolution_t *res;
if (!pi->first) {
comp = &pi->comps[pi->compno];
res = &comp->resolutions[pi->resno];
goto 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->numresolutions) {
continue;
}
res = &comp->resolutions[pi->resno];
for (pi->precno = 0; pi->precno < res->pw * res->ph; pi->precno++) {
if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno]) {
pi->include[pi->layno][pi->resno][pi->compno][pi->precno] = 1;
return 1;
}
skip:;
}
}
}
}
return 0;
}
/* <summary> */
/* Get next packet in resolution-layer-component-precinct order. */
/* </summary> */
int pi_next_rlcp(pi_iterator_t * pi)
{
pi_comp_t *comp;
pi_resolution_t *res;
if (!pi->first) {
comp = &pi->comps[pi->compno];
res = &comp->resolutions[pi->resno];
goto 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->numresolutions) {
continue;
}
res = &comp->resolutions[pi->resno];
for (pi->precno = 0; pi->precno < res->pw * res->ph; pi->precno++) {
if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno]) {
pi->include[pi->layno][pi->resno][pi->compno][pi->precno] = 1;
return 1;
}
skip:;
}
}
}
}
return 0;
}
/* <summary> */
/* Get next packet in resolution-precinct-component-layer order. */
/* </summary> */
int pi_next_rpcl(pi_iterator_t * pi)
{
pi_comp_t *comp;
pi_resolution_t *res;
if (!pi->first) {
goto 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->numresolutions; resno++) {
int dx, dy;
res = &comp->resolutions[resno];
dx =
comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
dy =
comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
}
}
}
for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {
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 levelno;
int trx0, try0;
int rpx, rpy;
int prci, prcj;
comp = &pi->comps[pi->compno];
if (pi->resno >= comp->numresolutions) {
continue;
}
res = &comp->resolutions[pi->resno];
levelno = comp->numresolutions - 1 - pi->resno;
trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
rpx = res->pdx + levelno;
rpy = res->pdy + levelno;
if (!
(pi->x % (comp->dx << rpx) == 0
|| (pi->x == pi->tx0 && (trx0 << levelno) % (1 << rpx)))) {
continue;
}
if (!
(pi->y % (comp->dy << rpy) == 0
|| (pi->y == pi->ty0 && (try0 << levelno) % (1 << rpx)))) {
continue;
}
prci =
int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno),
res->pdx) - int_floordivpow2(trx0, res->pdx);
prcj =
int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno),
res->pdy) - int_floordivpow2(try0, res->pdy);
pi->precno = prci + prcj * res->pw;
for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {
if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno]) {
pi->include[pi->layno][pi->resno][pi->compno][pi->precno] =
1;
return 1;
}
skip:;
}
}
}
}
}
return 0;
}
/* <summary> */
/* Get next packet in precinct-component-resolution-layer order. */
/* </summary> */
int pi_next_pcrl(pi_iterator_t * pi)
{
pi_comp_t *comp;
pi_resolution_t *res;
if (!pi->first) {
comp = &pi->comps[pi->compno];
goto 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->numresolutions; resno++) {
int dx, dy;
res = &comp->resolutions[resno];
dx =
comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
dy =
comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
}
}
}
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->numresolutions);
pi->resno++) {
int levelno;
int trx0, try0;
int rpx, rpy;
int prci, prcj;
res = &comp->resolutions[pi->resno];
levelno = comp->numresolutions - 1 - pi->resno;
trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
rpx = res->pdx + levelno;
rpy = res->pdy + levelno;
if (!
(pi->x % (comp->dx << rpx) == 0
|| (pi->x == pi->tx0 && (trx0 << levelno) % (1 << rpx)))) {
continue;
}
if (!
(pi->y % (comp->dy << rpy) == 0
|| (pi->y == pi->ty0 && (try0 << levelno) % (1 << rpx)))) {
continue;
}
prci =
int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno),
res->pdx) - int_floordivpow2(trx0, res->pdx);
prcj =
int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno),
res->pdy) - int_floordivpow2(try0, res->pdy);
pi->precno = prci + prcj * res->pw;
for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {
if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno]) {
pi->include[pi->layno][pi->resno][pi->compno][pi->precno] =
1;
return 1;
}
skip:;
}
}
}
}
}
return 0;
}
/* <summary> */
/* Get next packet in component-precinct-resolution-layer order. */
/* </summary> */
int pi_next_cprl(pi_iterator_t * pi)
{
pi_comp_t *comp;
pi_resolution_t *res;
if (!pi->first) {
comp = &pi->comps[pi->compno];
goto 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;
for (resno = 0; resno < comp->numresolutions; resno++) {
int dx, dy;
res = &comp->resolutions[resno];
dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
}
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->numresolutions);
pi->resno++) {
int levelno;
int trx0, try0;
int rpx, rpy;
int prci, prcj;
res = &comp->resolutions[pi->resno];
levelno = comp->numresolutions - 1 - pi->resno;
trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
rpx = res->pdx + levelno;
rpy = res->pdy + levelno;
if (!
(pi->x % (comp->dx << rpx) == 0
|| (pi->x == pi->tx0 && (trx0 << levelno) % (1 << rpx)))) {
continue;
}
if (!
(pi->y % (comp->dy << rpy) == 0
|| (pi->y == pi->ty0 && (try0 << levelno) % (1 << rpx)))) {
continue;
}
prci =
int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno),
res->pdx) - int_floordivpow2(trx0, res->pdx);
prcj =
int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno),
res->pdy) - int_floordivpow2(try0, res->pdy);
pi->precno = prci + prcj * res->pw;
for (pi->layno = 0; pi->layno < pi->poc.layno1; pi->layno++) {
if (!pi->include[pi->layno][pi->resno][pi->compno][pi->precno]) {
pi->include[pi->layno][pi->resno][pi->compno][pi->precno] =
1;
return 1;
}
skip:;
}
}
}
}
}
return 0;
}
/* <summary> */
/* Get next packet. */
/* </summary> */
int pi_next(pi_iterator_t * pi)
{
switch (pi->poc.prg) {
case 0:
return pi_next_lrcp(pi);
case 1:
return pi_next_rlcp(pi);
case 2:
return pi_next_rpcl(pi);
case 3:
return pi_next_pcrl(pi);
case 4:
return pi_next_cprl(pi);
}
return 0;
}

71
libopenjpeg/pi.h Normal file
View File

@ -0,0 +1,71 @@
/*
* Copyright (c) 2001-2002, David Janssens
* 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
#include "j2k.h"
#include "tcd.h"
typedef struct {
int pdx, pdy;
int pw, ph;
} pi_resolution_t;
typedef struct {
int dx, dy;
int numresolutions;
pi_resolution_t *resolutions;
} pi_comp_t;
typedef struct {
int include[10][10][3][99];
int compno, resno, precno, layno; /* component, resolution, precinct and layer that indentify the packet */
int first;
j2k_poc_t poc;
int numcomps;
pi_comp_t *comps;
int tx0, ty0, tx1, ty1;
int x, y, dx, dy;
} pi_iterator_t; /* packet iterator */
/*
* Create a packet iterator
* img: raw image for which the packets will be listed
* cp: coding paremeters
* tileno: number that identifies the tile for which to list the packets
* return value: returns a packet iterator that points to the first packet of the tile
*/
pi_iterator_t *pi_create(j2k_image_t * img, j2k_cp_t * cp, int tileno);
/*
* Modify the packet iterator to point to the next packet
* pi: packet iterator to modify
* return value: returns 0 if pi pointed to the last packet or else returns 1
*/
int pi_next(pi_iterator_t * pi);
#endif

129
libopenjpeg/raw.c Normal file
View File

@ -0,0 +1,129 @@
/*
* Copyright (c) 2002-2003, Antonin Descampe
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "raw.h"
unsigned char raw_c;
unsigned int raw_ct, raw_lenmax, raw_len;
unsigned char *raw_bp;
unsigned char *raw_start;
unsigned char *raw_end;
/* <summary> */
/* Return the number of bytes already encoded. */
/* </summary> */
int raw_numbytes()
{
return raw_bp - raw_start;
}
/* <summary> */
/* Initialize raw-encoder. */
/* </summary> */
/* <param name="bp">Output buffer.</param> */
void raw_init_enc(unsigned char *bp)
{
raw_bp = bp - 1;
raw_c = 0;
raw_ct = 7;
raw_start = bp;
}
/* <summary> */
/* Encode a symbol using the RAW-coder. */
/* </summary> */
/* <param name="d"> The symbol to be encoded (0 or 1).</param> */
void raw_encode(int d)
{
/* raw_c+=d; */
raw_ct--;
raw_c += (d << raw_ct);
if (raw_ct == 0) {
raw_bp++;
*raw_bp = raw_c;
raw_ct = 7;
if (raw_c == 0xff) {
raw_ct = 6;
}
raw_c = 0;
}
/*else
{
raw_ct--;
raw_c<<=1;
} */
}
/* <summary> */
/* Flush encoded data. */
/* </summary> */
void raw_flush()
{
char first = 1;
int prev = 1;
while (raw_ct != 7) {
raw_encode(first ? 0 : !(prev));
prev = first ? 0 : !(prev);
first = 0;
}
}
/* <summary> */
/* Initialize raw-decoder. */
/* </summary> */
void raw_init_dec(unsigned char *bp, int len)
{
raw_start = bp;
raw_lenmax = len;
raw_len = 0;
raw_c = 0;
raw_ct = 0;
}
/* <summary> */
/* Decode a symbol using raw-decoder. Cfr p.506 TAUBMAN */
/* </summary> */
int raw_decode()
{
int d;
if (raw_ct == 0) {
raw_ct = 8;
if (raw_len == raw_lenmax)
raw_c = 0xff;
else {
if (raw_c == 0xff)
raw_ct = 7;
raw_c = *(raw_start + raw_len);
raw_len++;
}
}
raw_ct--;
d = (raw_c >> raw_ct) & 0x01;
return d;
}

72
libopenjpeg/raw.h Normal file
View File

@ -0,0 +1,72 @@
/*
* Copyright (c) 2002-2003, Antonin Descampe
* Copyright (c) 2002-2003, 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
/*
* Return the number of bytes written/read since initialisation
*/
int raw_numbytes();
/*
* Initialize the encoder
* bp: pointer to the start of the buffer where the bytes will be written
*/
void raw_init_enc(unsigned char *bp);
/*
* Encode a bit
* d: bit to encode (0 or 1)
*/
void raw_encode(int d);
/*
* Flush the encoder, so that all remaining data is written
*/
void raw_flush();
/*
* Initialize the decoder
* bp: pointer to the start of the buffer from which the bytes will be read
* len: length of the input buffer
*/
void raw_init_dec(unsigned char *bp, int len);
/*
* Decode a bit (returns 0 or 1)
*/
int raw_decode();
#endif /*
*/

1077
libopenjpeg/t1.c Normal file
View File

File diff suppressed because it is too large Load Diff

52
libopenjpeg/t1.h Normal file
View File

@ -0,0 +1,52 @@
/*
* Copyright (c) 2001-2002, David Janssens
* 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
#include "tcd.h"
#include "j2k.h"
/*
* Initialize the look-up tables of the Tier-1 coder/decoder
*/
void t1_init_luts();
/*
* Encode the code-blocks of a tile
* tile: the tile to encode
* tcp: tile coding parameters
*/
void t1_encode_cblks(tcd_tile_t * tile, j2k_tcp_t * tcp);
/*
* Decode the code-blocks of a tile
* tile: the tile to encode
* tcp: tile coding parameters
*/
void t1_decode_cblks(tcd_tile_t * tile, j2k_tcp_t * tcp);
#endif

505
libopenjpeg/t2.c Normal file
View File

@ -0,0 +1,505 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2002-2003, 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 "t2.h"
#include "tcd.h"
#include "bio.h"
#include "j2k.h"
#include "pi.h"
#include "tgt.h"
#include "int.h"
#include "cio.h"
#include <stdio.h>
#include <setjmp.h>
#include <string.h>
#include <stdlib.h>
#define RESTART 0x04
extern jmp_buf j2k_error;
void t2_putcommacode(int n)
{
while (--n >= 0) {
bio_write(1, 1);
}
bio_write(0, 1);
}
int t2_getcommacode()
{
int n;
for (n = 0; bio_read(1); n++) {
}
return n;
}
/* <summary> */
/* Variable length code for signalling delta Zil (truncation point) */
/* <val> n : delta Zil */
/* <\summary> */
void t2_putnumpasses(int n)
{
if (n == 1) {
bio_write(0, 1);
} else if (n == 2) {
bio_write(2, 2);
} else if (n <= 5) {
bio_write(0xc | (n - 3), 4);
} else if (n <= 36) {
bio_write(0x1e0 | (n - 6), 9);
} else if (n <= 164) {
bio_write(0xff80 | (n - 37), 16);
}
}
int t2_getnumpasses()
{
int n;
if (!bio_read(1))
return 1;
if (!bio_read(1))
return 2;
if ((n = bio_read(2)) != 3)
return 3 + n;
if ((n = bio_read(5)) != 31)
return 6 + n;
return 37 + bio_read(7);
}
int t2_encode_packet(tcd_tile_t * tile, j2k_tcp_t * tcp, int compno,
int resno, int precno, int layno, unsigned char *dest,
int len, info_image * info_IM, int tileno)
{
int bandno, cblkno;
unsigned char *sop = 0, *eph = 0;
tcd_tilecomp_t *tilec = &tile->comps[compno];
tcd_resolution_t *res = &tilec->resolutions[resno];
unsigned char *c = dest;
/* int PPT=tile->PPT, ppt_len=0; */
/* FILE *PPT_file; */
/* <SOP 0xff91> */
if (tcp->csty & J2K_CP_CSTY_SOP) {
sop = (unsigned char *) malloc(6 * sizeof(unsigned char));
sop[0] = 255;
sop[1] = 145;
sop[2] = 0;
sop[3] = 4;
sop[4] = (info_IM->num % 65536) / 256;
sop[5] = (info_IM->num % 65536) % 256;
memcpy(c, sop, 6);
free(sop);
c += 6;
}
/* </SOP> */
if (!layno) {
for (bandno = 0; bandno < res->numbands; bandno++) {
tcd_band_t *band = &res->bands[bandno];
tcd_precinct_t *prc = &band->precincts[precno];
tgt_reset(prc->incltree);
tgt_reset(prc->imsbtree);
for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
tcd_cblk_t *cblk = &prc->cblks[cblkno];
cblk->numpasses = 0;
tgt_setvalue(prc->imsbtree, cblkno, band->numbps - cblk->numbps);
}
}
}
bio_init_enc(c, len);
bio_write(1, 1); /* Empty header bit */
/* Writing Packet header */
for (bandno = 0; bandno < res->numbands; bandno++) {
tcd_band_t *band = &res->bands[bandno];
tcd_precinct_t *prc = &band->precincts[precno];
for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
tcd_cblk_t *cblk = &prc->cblks[cblkno];
tcd_layer_t *layer = &cblk->layers[layno];
if (!cblk->numpasses && layer->numpasses) {
tgt_setvalue(prc->incltree, cblkno, layno);
}
}
for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
tcd_cblk_t *cblk = &prc->cblks[cblkno];
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(prc->incltree, cblkno, layno + 1);
} else {
bio_write(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(prc->imsbtree, cblkno, 999);
}
/* number of coding passes included */
t2_putnumpasses(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++) {
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(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++) {
tcd_pass_t *pass = &cblk->passes[passno];
nump++;
len += pass->len;
if (pass->term
|| passno == (cblk->numpasses + layer->numpasses) - 1) {
bio_write(len, cblk->numlenbits + int_floorlog2(nump));
len = 0;
nump = 0;
}
}
}
}
if (bio_flush())
return -999; /* modified to eliminate longjmp !! */
c += bio_numbytes();
/* <EPH 0xff92> */
if (tcp->csty & J2K_CP_CSTY_EPH) {
eph = (unsigned char *) malloc(2 * sizeof(unsigned char));
eph[0] = 255;
eph[1] = 146;
memcpy(c, eph, 2);
free(eph);
c += 2;
}
/* </EPH> */
/* } */
/* Writing the packet body */
for (bandno = 0; bandno < res->numbands; bandno++) {
tcd_band_t *band = &res->bands[bandno];
tcd_precinct_t *prc = &band->precincts[precno];
for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
tcd_cblk_t *cblk = &prc->cblks[cblkno];
tcd_layer_t *layer = &cblk->layers[layno];
if (!layer->numpasses) { /* ADD for index Cfr. Marcela --> delta disto by packet */
if (info_IM->index_write && info_IM->index_on) {
info_tile *info_TL = &info_IM->tile[tileno];
info_packet *info_PK = &info_TL->packet[info_IM->num];
info_PK->disto = layer->disto;
if (info_IM->D_max < info_PK->disto)
info_IM->D_max = info_PK->disto;
} /* </ADD> */
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 (info_IM->index_write && info_IM->index_on) {
info_tile *info_TL = &info_IM->tile[tileno];
info_packet *info_PK = &info_TL->packet[info_IM->num];
info_PK->disto = layer->disto;
if (info_IM->D_max < info_PK->disto)
info_IM->D_max = info_PK->disto;
} /* </ADD> */
}
}
return c - dest;
}
void t2_init_seg(tcd_seg_t * seg, int cblksty, int first)
{
seg->numpasses = 0;
seg->len = 0;
if (cblksty & J2K_CCP_CBLKSTY_TERMALL)
seg->maxpasses = 1;
else if (cblksty & J2K_CCP_CBLKSTY_LAZY) {
if (first)
seg->maxpasses = 10;
else
seg->maxpasses = (((seg - 1)->maxpasses == 1)
|| ((seg - 1)->maxpasses == 10)) ? 2 : 1;
} else
seg->maxpasses = 109;
}
int t2_decode_packet(unsigned char *src, int len, tcd_tile_t * tile,
j2k_tcp_t * tcp, int compno, int resno, int precno,
int layno)
{
int bandno, cblkno;
tcd_tilecomp_t *tilec = &tile->comps[compno];
tcd_resolution_t *res = &tilec->resolutions[resno];
unsigned char *c = src;
int present;
if (layno == 0) {
for (bandno = 0; bandno < res->numbands; bandno++) {
tcd_band_t *band = &res->bands[bandno];
tcd_precinct_t *prc = &band->precincts[precno];
tgt_reset(prc->incltree);
tgt_reset(prc->imsbtree);
for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
tcd_cblk_t *cblk = &prc->cblks[cblkno];
cblk->numsegs = 0;
}
}
}
if (tcp->csty & J2K_CP_CSTY_SOP) {
c += 6;
}
bio_init_dec(c, src + len - c);
present = bio_read(1);
if (!present) {
bio_inalign();
c += bio_numbytes();
return c - src;
}
for (bandno = 0; bandno < res->numbands; bandno++) {
tcd_band_t *band = &res->bands[bandno];
tcd_precinct_t *prc = &band->precincts[precno];
for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
int included, increment, n;
tcd_cblk_t *cblk = &prc->cblks[cblkno];
tcd_seg_t *seg;
/* if cblk not yet included before --> inclusion tagtree */
if (!cblk->numsegs) {
included = tgt_decode(prc->incltree, cblkno, layno + 1);
/* else one bit */
} else {
included = bio_read(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(prc->imsbtree, cblkno, i); i++) {
}
numimsbs = i - 1;
cblk->numbps = band->numbps - numimsbs;
cblk->numlenbits = 3;
}
/* number of coding passes */
cblk->numnewpasses = t2_getnumpasses();
increment = t2_getcommacode();
/* 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(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())
return -999;
c += bio_numbytes();
if (tcp->csty & J2K_CP_CSTY_EPH) {
c += 2;
}
for (bandno = 0; bandno < res->numbands; bandno++) {
tcd_band_t *band = &res->bands[bandno];
tcd_precinct_t *prc = &band->precincts[precno];
for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
tcd_cblk_t *cblk = &prc->cblks[cblkno];
tcd_seg_t *seg;
if (!cblk->numnewpasses)
continue;
if (!cblk->numsegs) {
seg = &cblk->segs[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(j2k_image_t * img, j2k_cp_t * cp, int tileno,
tcd_tile_t * tile, int maxlayers,
unsigned char *dest, int len, info_image * info_IM)
{
unsigned char *c = dest;
int e = 0;
pi_iterator_t *pi;
int pino, compno;
pi = pi_create(img, cp, tileno);
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].compno,
pi[pino].resno, pi[pino].precno, pi[pino].layno,
c, dest + len - c, info_IM, tileno);
if (e == -999) {
break;
} else
c += e;
/* INDEX >> */
if (info_IM->index_write && info_IM->index_on) {
info_tile *info_TL = &info_IM->tile[tileno];
info_packet *info_PK = &info_TL->packet[info_IM->num];
if (!info_IM->num) {
info_PK->start_pos = info_TL->end_header + 1;
} else {
info_PK->start_pos =
info_TL->packet[info_IM->num - 1].end_pos + 1;
}
info_PK->end_pos = info_PK->start_pos + e - 1;
}
/* << INDEX */
if ((info_IM->index_write
&& cp->tcps[tileno].csty & J2K_CP_CSTY_SOP)
|| (info_IM->index_write && info_IM->index_on)) {
info_IM->num++;
}
}
}
/* FREE space memory taken by pi */
for (compno = 0; compno < pi[pino].numcomps; compno++) {
free(pi[pino].comps[compno].resolutions);
}
free(pi[pino].comps);
}
free(pi);
if (e == -999)
return e;
else
return c - dest;
}
int t2_decode_packets(unsigned char *src, int len, j2k_image_t * img,
j2k_cp_t * cp, int tileno, tcd_tile_t * tile)
{
unsigned char *c = src;
pi_iterator_t *pi;
int pino, compno, e = 0;
pi = pi_create(img, cp, tileno);
for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++) {
while (pi_next(&pi[pino])) {
e =
t2_decode_packet(c, src + len - c, tile, &cp->tcps[tileno],
pi[pino].compno, pi[pino].resno, pi[pino].precno,
pi[pino].layno);
if (e == -999) { /* ADD */
break;
} else
c += e;
}
/* FREE space memory taken by pi */
for (compno = 0; compno < pi[pino].numcomps; compno++) {
free(pi[pino].comps[compno].resolutions);
}
free(pi[pino].comps);
}
free(pi);
if (e == -999)
return e;
else
return c - src;
}

59
libopenjpeg/t2.h Normal file
View File

@ -0,0 +1,59 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2002-2003, 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 __T2_H
#define __T2_H
#include "tcd.h"
#include "j2k.h"
/*
* Encode the packets of a tile to a destination buffer
* img: the source image
* cp: the image coding parameters
* tile: the tile for which to write the packets
* dest: the destination buffer
* len: the length of the destination buffer
*/
int t2_encode_packets(j2k_image_t * img, j2k_cp_t * cp, int tileno,
tcd_tile_t * tile, int maxlayers,
unsigned char *dest, int len, info_image * info_IM);
/*
* Decode the packets of a tile from a source buffer
* src: the source buffer
* len: length of the source buffer
* img: destination image
* cp: image coding parameters
* tileno: number that identifies the tile for which to decode the packets
* tile: tile for which to decode the packets
*/
int t2_decode_packets(unsigned char *src, int len, j2k_image_t * img,
j2k_cp_t * cp, int tileno, tcd_tile_t * tile);
#endif

1637
libopenjpeg/tcd.c Normal file
View File

File diff suppressed because it is too large Load Diff

159
libopenjpeg/tcd.h Normal file
View File

@ -0,0 +1,159 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2002-2003, 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 __TCD_H
#define __TCD_H
#include "j2k.h"
#include "tgt.h"
typedef struct {
int numpasses;
int len;
unsigned char *data;
int maxpasses;
int numnewpasses;
int newlen;
} tcd_seg_t;
typedef struct {
int rate;
double distortiondec;
int term, len;
} tcd_pass_t;
typedef struct {
int numpasses;
int len;
double disto; /* add for index (Cfr. Marcela) */
unsigned char *data;
} tcd_layer_t;
typedef struct {
int x0, y0, x1, y1;
int numbps;
int numlenbits;
int len;
int numpasses;
int numnewpasses;
int numsegs;
tcd_seg_t segs[100];
unsigned char data[8192];
int numpassesinlayers;
tcd_layer_t layers[100];
int totalpasses;
tcd_pass_t passes[100];
} tcd_cblk_t;
typedef struct {
int x0, y0, x1, y1;
int cw, ch;
tcd_cblk_t *cblks;
tgt_tree_t *incltree;
tgt_tree_t *imsbtree;
} tcd_precinct_t;
typedef struct {
int x0, y0, x1, y1;
int bandno;
tcd_precinct_t *precincts;
int numbps;
int stepsize;
} tcd_band_t;
typedef struct {
int x0, y0, x1, y1;
int previous_x0, previous_y0, previous_x1, previous_y1; /* usefull for the DWT */
int cas_col, cas_row; /* usefull for the DWT */
int pw, ph; /* , old_pw,old_ph, old_pw_max,old_ph_max; */
int numbands;
tcd_band_t bands[3];
} tcd_resolution_t;
typedef struct {
int x0, y0, x1, y1;
int previous_row, previous_col; /* usefull for the DWT */
int numresolutions;
tcd_resolution_t *resolutions;
int *data;
} tcd_tilecomp_t;
typedef struct {
int x0, y0, x1, y1;
int numcomps;
/* int PPT; */
/* int len_ppt; */
tcd_tilecomp_t *comps;
} tcd_tile_t;
typedef struct {
int tw, th;
tcd_tile_t *tiles;
} tcd_image_t;
/*
* Initialize the tile coder/decoder
* img: raw image
* cp: coding parameters
* info_IM: creation of index file
*/
void tcd_init_encode(j2k_image_t * img, j2k_cp_t * cp, int curtileno);
void tcd_malloc_encode(j2k_image_t * img, j2k_cp_t * cp, int curtileno);
void tcd_init(j2k_image_t * img, j2k_cp_t * cp);
void tcd_free_encode(j2k_image_t * img, j2k_cp_t * cp, int curtileno);
/*
* Encode a tile from the raw image into a buffer, format pnm, pgm or ppm
* tileno: number that identifies one of the tiles to be encoded
* dest: destination buffer
* len: length of destination buffer
*/
int tcd_encode_tile_pxm(int tileno, unsigned char *dest, int len,
info_image * info_IM);
/*
* Encode a tile from the raw image into a buffer, format pgx
* tileno: number that identifies one of the tiles to be encoded
* dest: destination buffer
* len: length of destination buffer
*/
int tcd_encode_tile_pgx(int tileno, unsigned char *dest, int len,
info_image * info_IM);
/*
* Decode a tile from a buffer into a raw image
* src: source buffer
* len: length of the source buffer
* tileno: number that identifies the tile that will be decoded
*/
int tcd_decode_tile(unsigned char *src, int len, int tileno);
#endif

225
libopenjpeg/tgt.c Normal file
View File

@ -0,0 +1,225 @@
/*
* Copyright (c) 2001-2002, David Janssens
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "tgt.h"
#include "bio.h"
#include <stdlib.h>
#include <stdio.h>
/* <summary> */
/* Reset tag-tree. */
/* </summary> */
void tgt_reset(tgt_tree_t * tree)
{
int i;
/* new */
if (!tree || tree == NULL)
return;
for (i = 0; i < tree->numnodes; i++) {
tree->nodes[i].value = 999;
tree->nodes[i].low = 0;
tree->nodes[i].known = 0;
}
}
/* <summary> */
/* Create tag-tree. */
/* </summary> */
tgt_tree_t *tgt_create(int numleafsh, int numleafsv)
{
int nplh[32];
int nplv[32];
tgt_node_t *node;
tgt_node_t *parentnode;
tgt_node_t *parentnode0;
tgt_tree_t *tree;
int i, j, k;
int numlvls;
int n;
tree = (tgt_tree_t *) malloc(sizeof(tgt_tree_t));
tree->numleafsh = numleafsh;
tree->numleafsv = numleafsv;
numlvls = 0;
nplh[0] = numleafsh;
nplv[0] = numleafsv;
tree->numnodes = 0;
do {
n = nplh[numlvls] * nplv[numlvls];
nplh[numlvls + 1] = (nplh[numlvls] + 1) / 2;
nplv[numlvls + 1] = (nplv[numlvls] + 1) / 2;
tree->numnodes += n;
++numlvls;
} while (n > 1);
/* ADD */
if (tree->numnodes == 0) {
free(tree);
return NULL;
}
tree->nodes = (tgt_node_t *) malloc(tree->numnodes * sizeof(tgt_node_t));
node = tree->nodes;
parentnode = &tree->nodes[tree->numleafsh * tree->numleafsv];
parentnode0 = parentnode;
for (i = 0; i < numlvls - 1; ++i) {
for (j = 0; j < nplv[i]; ++j) {
k = nplh[i];
while (--k >= 0) {
node->parent = parentnode;
++node;
if (--k >= 0) {
node->parent = parentnode;
++node;
}
++parentnode;
}
if ((j & 1) || j == nplv[i] - 1) {
parentnode0 = parentnode;
} else {
parentnode = parentnode0;
parentnode0 += nplh[i];
}
}
}
node->parent = 0;
tgt_reset(tree);
return tree;
}
/* <summary> */
/* Destroy tag-tree. */
/* </summary> */
void tgt_destroy(tgt_tree_t * t)
{
free(t->nodes);
free(t);
}
/* <summary> */
/* Set the value of a leaf of the tag-tree. */
/* </summary> */
void tgt_setvalue(tgt_tree_t * tree, int leafno, int value)
{
tgt_node_t *node;
node = &tree->nodes[leafno];
while (node && node->value > value) {
node->value = value;
node = node->parent;
}
}
/* <summary> */
/* Encode the value of a leaf of the tag-tree. */
/* </summary> */
void tgt_encode(tgt_tree_t * tree, int leafno, int threshold)
{
tgt_node_t *stk[31];
tgt_node_t **stkptr;
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(1, 1);
node->known = 1;
}
break;
}
bio_write(0, 1);
++low;
}
node->low = low;
if (stkptr == stk)
break;
node = *--stkptr;
}
}
/* <summary> */
/* Decode the value of a leaf of the tag-tree. */
/* </summary> */
int tgt_decode(tgt_tree_t * tree, int leafno, int threshold)
{
tgt_node_t *stk[31];
tgt_node_t **stkptr;
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(1)) {
node->value = low;
} else {
++low;
}
}
node->low = low;
if (stkptr == stk) {
break;
}
node = *--stkptr;
}
return (node->value < threshold) ? 1 : 0;
}

85
libopenjpeg/tgt.h Normal file
View File

@ -0,0 +1,85 @@
/*
* Copyright (c) 2001-2002, David Janssens
* 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
typedef struct tgt_node {
struct tgt_node *parent;
int value;
int low;
int known;
} tgt_node_t;
typedef struct {
int numleafsh;
int numleafsv;
int numnodes;
tgt_node_t *nodes;
} tgt_tree_t;
/*
* Create a tag-tree
* numleafsh: width of the array of leafs of the tree
* numleafsv: height of the array of leafs of the tree
*/
tgt_tree_t *tgt_create(int numleafsh, int numleafsv);
/*
* Reset a tag-tree (set all leafs to 0)
* tree: tag-tree to reset
*/
void tgt_reset(tgt_tree_t * tree);
/*
* Destroy a tag-tree, liberating memory
* tree: tag-tree to destroy
*/
void tgt_destroy(tgt_tree_t * tree);
/*
* Set the value of a leaf of a tag-tree
* tree: tag-tree to modify
* leafno: number that identifies the leaf to modify
* value: new value of the leaf
*/
void tgt_setvalue(tgt_tree_t * tree, int leafno, int value);
/*
* Encode the value of a leaf of the tag-tree up to a given threshold
* leafno: number that identifies the leaf to encode
* threshold: threshold to use when encoding value of the leaf
*/
void tgt_encode(tgt_tree_t * tree, int leafno, int threshold);
/*
* Decode the value of a leaf of the tag-tree up to a given threshold
* leafno: number that identifies the leaf to decode
* threshold: threshold to use when decoding value of the leaf
*/
int tgt_decode(tgt_tree_t * tree, int leafno, int threshold);
#endif