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

backport r882:893 to openjpeg-1.5 branch

Browse Source
This commit is contained in:
Antonin Descampe 2011-08-27 12:53:38 +00:00
parent 9ec5e8cf9a
commit d15f01b6e3
79 changed files with 2662 additions and 5003 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
Makefile.am
View File

@ -28,18 +28,18 @@ missing
EXTRA_DIST = \
CMake/CheckHaveGetopt.cmake \
CMake/OpenJPEGConfig.cmake.in \
testing/CTestCustom.cmake.in \
testing/CTestConfig.cmake \
CMakeLists.txt \
LICENSE \
AUTHORS \
CHANGES \
README \
INSTALL \
LICENSE \
NEWS \
README \
THANKS \
bootstrap.sh \
libopenjpeg1.pc.cmake \
libopenjpeg1.pc.in \
opj_configh.cmake.in \
opj_config.h.in.user \
m4/opj_check_lib.m4 \
m4/opj_doxygen.m4 \
m4/pkg.m4
@ -53,7 +53,11 @@ doc:
@cd doc && make doc
install-data-hook:
if HAVE_WIN32
$(LN_S) -f libopenjpeg1.pc $(DESTDIR)$(pkgconfigdir)/libopenjpeg.pc
else
$(LN_S) -nf libopenjpeg1.pc $(DESTDIR)$(pkgconfigdir)/libopenjpeg.pc
endif
@echo -e " (PC)\t$(pkgconfigdir)/libopenjpeg1.pc" >> $(top_builddir)/report.txt
@echo -e " (LN)\t$(pkgconfigdir)/libopenjpeg.pc" >> $(top_builddir)/report.txt
if WANT_JPWL

14
applications/jpip/CHANGES
View File

@ -5,6 +5,20 @@ What's New for OpenJPIP
! : changed
+ : added
August 26, 2011
* [antonin] fixed cmake and autotools files to reflect recent indexer changes in JPIP
! [kaori] indexer using the latest openjpeg library
* [antonin] fixed cmake and autotools files to reflect recent changes in JPIP
! [kaori] fixed Makefile.nix to load openjpeg library from this archive
August 25, 2011
+ [kaori] added tid request support to JPIP client
+ [kaori] added quit JPIP server request
August 24, 2011
+ [kaori] added cachemodel_manager, which had been managed in target_manager previously
+ [kaori] added tid request support to JPIP server
August 16, 2011
* [antonin] fixed cmake support for openjpip

7
applications/jpip/README
View File

@ -90,6 +90,11 @@ Server:
2. Launch opj_server from the server terminal:
% spawn-fcgi -f ./opj_server -p 3000 -n
For shutting down JPIP server:
%GET http://hostname/myFCGI?quitJPIP
Notice, http://hostname/myFCGI is the HTTP server URI (myFCGI refers to opj_server by the server setting)
Requst message "quitJPIP" can be changed in Makfile, modify -DQUIT_SIGNAL=\"quitJPIP\"
Client:
1. Launch image decoding server, and keep it alive as long as image viewers are open
@ -127,7 +132,7 @@ An example to encode a TIF image "copenhague1.tif" at resolution 4780x4050, 8bit
% ./kdu_compress -i copenhague1.tif -o copenhague1.j2k Corder=RPCL ORGtparts=R Stiles={256,256}
2. JP2 encoding with embedding indexing data
% ./index_create copenhague1.j2k copenhague1.jp2 2
% ./j2k_to_idxjp2 copenhague1.j2k copenhague1.jp2
<Option>
3. Embed metadata into JP2 file

1
applications/jpip/libopenjpip/CMakeLists.txt
View File

@ -21,6 +21,7 @@ ${CMAKE_CURRENT_SOURCE_DIR}/ihdrbox_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/manfbox_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/mhixbox_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/target_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/cachemodel_manager.c
)
# Build the library

4
applications/jpip/libopenjpip/Makefile.am
View File

@ -21,6 +21,7 @@ ihdrbox_manager.c \
manfbox_manager.c \
mhixbox_manager.c \
target_manager.c \
cachemodel_manager.c \
bool.h \
boxheader_manager.h \
box_manager.h \
@ -36,7 +37,8 @@ metadata_manager.h \
mhixbox_manager.h \
msgqueue_manager.h \
placeholder_manager.h \
target_manager.h
target_manager.h \
cachemodel_manager.h
libopenjpip_server_la_CPPFLAGS = \
-I. \

1
applications/jpip/libopenjpip/box_manager.c
View File

@ -28,6 +28,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>

1
applications/jpip/libopenjpip/box_manager.h
View File

@ -31,7 +31,6 @@
#ifndef BOX_MANAGER_H_
# define BOX_MANAGER_H_
#include <stdio.h>
#include "byte_manager.h"
//! box parameters

1
applications/jpip/libopenjpip/boxheader_manager.c
View File

@ -28,6 +28,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdlib.h>

1
applications/jpip/libopenjpip/byte_manager.c
View File

@ -28,6 +28,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>

2
applications/jpip/libopenjpip/byte_manager.h
View File

@ -31,8 +31,6 @@
#ifndef BYTE_MANAGER_H_
# define BYTE_MANAGER_H_
#include <stdio.h>
//! 1Byte parameter type
typedef unsigned char Byte_t;

151
applications/jpip/libopenjpip/cachemodel_manager.c Normal file
View File

@ -0,0 +1,151 @@
/*
* $Id$
*
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2011, Professor Benoit Macq
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include "cachemodel_manager.h"
#include "faixbox_manager.h"
#ifdef SERVER
#include "fcgi_stdio.h"
#define logstream FCGI_stdout
#else
#define FCGI_stdout stdout
#define FCGI_stderr stderr
#define logstream stderr
#endif //SERVER
cachemodellist_param_t * gene_cachemodellist()
{
cachemodellist_param_t *cachemodellist;
cachemodellist = (cachemodellist_param_t *)malloc( sizeof(cachemodellist_param_t));
cachemodellist->first = NULL;
cachemodellist->last = NULL;
return cachemodellist;
}
cachemodel_param_t * gene_cachemodel( cachemodellist_param_t *cachemodellist, target_param_t *target)
{
cachemodel_param_t *cachemodel;
faixbox_param_t *tilepart;
size_t numOfelem;
cachemodel = (cachemodel_param_t *)malloc( sizeof(cachemodel_param_t));
refer_target( target, &cachemodel->target);
cachemodel->mhead_model = false;
tilepart = target->codeidx->tilepart;
numOfelem = get_nmax( tilepart)*get_m( tilepart);
cachemodel->tp_model = (bool *)calloc( 1, numOfelem*sizeof(bool));
cachemodel->next = NULL;
if( cachemodellist){
if( cachemodellist->first) // there are one or more entries
cachemodellist->last->next = cachemodel;
else // first entry
cachemodellist->first = cachemodel;
cachemodellist->last = cachemodel;
}
#ifndef SERVER
fprintf( logstream, "local log: cachemodel generated\n");
#endif
return cachemodel;
}
void print_cachemodel( cachemodel_param_t cachemodel)
{
Byte8_t TPnum; // num of tile parts in each tile
int i, j, k, n;
fprintf( logstream, "target: %s\n", cachemodel.target->filename);
fprintf( logstream, "\t main header model: %d\n", cachemodel.mhead_model);
fprintf( logstream, "\t tile part model:\n");
TPnum = get_nmax( cachemodel.target->codeidx->tilepart);
for( i=0, n=0; i<cachemodel.target->codeidx->YTnum; i++){
for( j=0; j<cachemodel.target->codeidx->XTnum; j++){
for( k=0; k<TPnum; k++)
fprintf( logstream, "%d", cachemodel.tp_model[n++]);
fprintf( logstream, " ");
}
fprintf( logstream, "\n");
}
}
cachemodel_param_t * search_cachemodel( target_param_t *target, cachemodellist_param_t *cachemodellist)
{
cachemodel_param_t *foundcachemodel;
foundcachemodel = cachemodellist->first;
while( foundcachemodel != NULL){
if( foundcachemodel->target == target)
return foundcachemodel;
foundcachemodel = foundcachemodel->next;
}
return NULL;
}
void delete_cachemodellist( cachemodellist_param_t **cachemodellist)
{
cachemodel_param_t *cachemodelPtr, *cachemodelNext;
cachemodelPtr = (*cachemodellist)->first;
while( cachemodelPtr != NULL){
cachemodelNext=cachemodelPtr->next;
delete_cachemodel( &cachemodelPtr);
cachemodelPtr=cachemodelNext;
}
free(*cachemodellist);
}
void delete_cachemodel( cachemodel_param_t **cachemodel)
{
unrefer_target( (*cachemodel)->target);
free( (*cachemodel)->tp_model);
#ifndef SERVER
fprintf( logstream, "local log: cachemodel deleted\n");
#endif
free( *cachemodel);
}

102
applications/jpip/libopenjpip/cachemodel_manager.h Normal file
View File

@ -0,0 +1,102 @@
/*
* $Id$
*
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2011, Professor Benoit Macq
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CACHEMODEL_MANAGER_H_
# define CACHEMODEL_MANAGER_H_
#include "bool.h"
#include "target_manager.h"
//! Cache model parameters
typedef struct cachemodel_param{
target_param_t *target; //!< reference pointer to the target
bool mhead_model; //!< main header model, if sent, 1, else 0
bool *tp_model; //!< dynamic array pointer of tile part model, if sent, 1, else 0
struct cachemodel_param *next; //!< pointer to the next cache model
} cachemodel_param_t;
//! Cache model list parameters
typedef struct cachemodellist_param{
cachemodel_param_t *first; //!< first cache model pointer of the list
cachemodel_param_t *last; //!< last cache model pointer of the list
} cachemodellist_param_t;
/**
* generate a cache model list
*
* @return pointer to the generated cache model list
*/
cachemodellist_param_t * gene_cachemodellist();
/**
* generate a session under the sesion list
*
* @param[in] cachemodellist cachemodel list to insert the generated cache model
* @param[in] target pointer the reference target
* @return pointer to the generated cache model
*/
cachemodel_param_t * gene_cachemodel( cachemodellist_param_t *cachemodellist, target_param_t *target);
/**
* print cache model
*
* @param[in] cachemodel cache model
*/
void print_cachemodel( cachemodel_param_t cachemodel);
/**
* search a cache model of a target
*
* @param[in] target refering target
* @param[in] cachemodellist cache model list
* @return found cache model pointer
*/
cachemodel_param_t * search_cachemodel( target_param_t *target, cachemodellist_param_t *cachemodellist);
/**
* delete a cache model
*
* @param[in] cachemodel address of the cachemodel pointer
*/
void delete_cachemodel( cachemodel_param_t **cachemodel);
/**
* delete cachemodel list
*
* @param[in,out] cachemodellist address of the cachemodel list pointer
*/
void delete_cachemodellist( cachemodellist_param_t **cachemodellist);
#endif /* !CACHEMODEL_MANAGER_H_ */

1
applications/jpip/libopenjpip/codestream_manager.h
View File

@ -31,7 +31,6 @@
#ifndef CODESTREAM_MANAGER_H_
# define CODESTREAM_MANAGER_H_
#include <stdio.h>
#include "byte_manager.h"
//! codestream parameters

2
applications/jpip/libopenjpip/comMakefile.mk
View File

@ -10,7 +10,7 @@ all: $(LIBNAME)
$(LIBNAME): target_manager.o byte_manager.o box_manager.o boxheader_manager.o manfbox_manager.o \
mhixbox_manager.o marker_manager.o codestream_manager.o faixbox_manager.o index_manager.o \
msgqueue_manager.o metadata_manager.o placeholder_manager.o ihdrbox_manager.o imgreg_manager.o
msgqueue_manager.o metadata_manager.o placeholder_manager.o ihdrbox_manager.o imgreg_manager.o cachemodel_manager.o
ar r $@ $^
clean:

34
applications/jpip/libopenjpip/index_manager.c
View File

@ -28,6 +28,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <sys/types.h>
@ -35,6 +36,7 @@
#include <unistd.h>
#include <string.h>
#include "bool.h"
#include "index_manager.h"
#include "box_manager.h"
#include "manfbox_manager.h"
@ -145,31 +147,10 @@ void print_index( index_param_t index)
print_allmetadata( index.metadatalist);
}
void print_cachemodel( index_param_t index)
{
Byte8_t TPnum; // num of tile parts in each tile
int i, j, k, n;
TPnum = get_nmax( index.tilepart);
fprintf( logstream, "\t main header model: %d\n", index.mhead_model);
fprintf( logstream, "\t tile part model:\n");
for( i=0, n=0; i<index.YTnum; i++){
for( j=0; j<index.XTnum; j++){
for( k=0; k<TPnum; k++)
fprintf( logstream, "%d", index.tp_model[n++]);
fprintf( logstream, " ");
}
fprintf( logstream, "\n");
}
}
void delete_index( index_param_t **index)
{
delete_metadatalist( &((*index)->metadatalist));
delete_faixbox( &((*index)->tilepart));
free( (*index)->tp_model);
free(*index);
}
@ -365,7 +346,6 @@ bool set_mainmhixdata( box_param_t *cidx_box, codestream_param_t codestream, ind
if( !(mhix_box = gene_boxbyType( cidx_box->fd, get_DBoxoff( cidx_box), get_DBoxlen( cidx_box), "mhix")))
return false;
jp2idx->mhead_model = 0;
jp2idx->mhead_length = fetch_DBox8bytebigendian( mhix_box, 0);
mhix = gene_mhixbox( mhix_box);
@ -383,8 +363,6 @@ bool set_tpixdata( box_param_t *cidx_box, index_param_t *jp2idx)
{
box_param_t *tpix_box; //!< tpix box
box_param_t *faix_box; //!< faix box
faixbox_param_t *faix; //!< faix
size_t numOfelem;
if( !(tpix_box = gene_boxbyType( cidx_box->fd, get_DBoxoff( cidx_box), get_DBoxlen( cidx_box), "tpix")))
return false;
@ -392,14 +370,8 @@ bool set_tpixdata( box_param_t *cidx_box, index_param_t *jp2idx)
if( !(faix_box = gene_boxbyType( tpix_box->fd, get_DBoxoff( tpix_box), get_DBoxlen( tpix_box), "faix")))
return false;
faix = gene_faixbox( faix_box);
jp2idx->tilepart = faix;
numOfelem = get_nmax( faix)*get_m( faix);
jp2idx->tilepart = gene_faixbox( faix_box);
jp2idx->tp_model = (bool *)malloc( numOfelem*sizeof(bool));
memset( jp2idx->tp_model, 0, numOfelem*sizeof(bool));
//delete_faixbox( &faix); // currently the jp2idx element
free( tpix_box);
free( faix_box);

12
applications/jpip/libopenjpip/index_manager.h
View File

@ -31,8 +31,6 @@
#ifndef INDEX_MANAGER_H_
# define INDEX_MANAGER_H_
#include <stdio.h>
#include "bool.h"
#include "byte_manager.h"
#include "faixbox_manager.h"
#include "metadata_manager.h"
@ -72,9 +70,6 @@ typedef struct index_param{
Byte_t YRsiz[3]; //!< vertical separation of a sample of
//!component with respect to the reference grid
faixbox_param_t *tilepart; //!< tile part information from tpix box
bool mhead_model; //!< main header model, if sent, 1, else 0
bool *tp_model; //!< dynamic array pointer of tile part
//!model, if sent, 1, else 0
} index_param_t;
@ -94,13 +89,6 @@ index_param_t * parse_jp2file( int fd);
*/
void print_index( index_param_t index);
/**
* print cache model
*
* @param[in] index index parameters
*/
void print_cachemodel( index_param_t index);
/**
* delete index

1
applications/jpip/libopenjpip/metadata_manager.c
View File

@ -28,6 +28,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>

59
applications/jpip/libopenjpip/msgqueue_manager.c
View File

@ -28,6 +28,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <sys/types.h>
@ -57,7 +58,7 @@
#define MAINHEADER_MSG 6
#define METADATA_MSG 8
msgqueue_param_t * gene_msgqueue( bool stateless, target_param_t *target)
msgqueue_param_t * gene_msgqueue( bool stateless, cachemodel_param_t *cachemodel)
{
msgqueue_param_t *msgqueue;
@ -67,7 +68,7 @@ msgqueue_param_t * gene_msgqueue( bool stateless, target_param_t *target)
msgqueue->last = NULL;
msgqueue->stateless = stateless;
msgqueue->target = target;
msgqueue->cachemodel = cachemodel;
return msgqueue;
}
@ -86,8 +87,8 @@ void delete_msgqueue( msgqueue_param_t **msgqueue)
free( ptr);
ptr = next;
}
if( (*msgqueue)->stateless && (*msgqueue)->target)
delete_target( &((*msgqueue)->target));
if( (*msgqueue)->stateless && (*msgqueue)->cachemodel)
delete_cachemodel( &((*msgqueue)->cachemodel));
free(*msgqueue);
}
@ -124,10 +125,12 @@ void enqueue_message( message_param_t *msg, msgqueue_param_t *msgqueue);
void enqueue_mainheader( msgqueue_param_t *msgqueue)
{
cachemodel_param_t *cachemodel;
target_param_t *target;
message_param_t *msg;
target = msgqueue->target;
cachemodel = msgqueue->cachemodel;
target = cachemodel->target;
msg = (message_param_t *)malloc( sizeof(message_param_t));
@ -144,11 +147,12 @@ void enqueue_mainheader( msgqueue_param_t *msgqueue)
enqueue_message( msg, msgqueue);
target->codeidx->mhead_model = true;
cachemodel->mhead_model = true;
}
void enqueue_tile( int tile_id, int level, msgqueue_param_t *msgqueue)
{
cachemodel_param_t *cachemodel;
target_param_t *target;
bool *tp_model;
Byte8_t numOftparts; // num of tile parts par tile
@ -159,7 +163,8 @@ void enqueue_tile( int tile_id, int level, msgqueue_param_t *msgqueue)
Byte8_t binOffset, binLength;
int i;
target = msgqueue->target;
cachemodel = msgqueue->cachemodel;
target = cachemodel->target;
codeidx = target->codeidx;
tilepart = codeidx->tilepart;
@ -171,7 +176,7 @@ void enqueue_tile( int tile_id, int level, msgqueue_param_t *msgqueue)
return;
}
tp_model = &codeidx->tp_model[ tile_id*numOftparts];
tp_model = &cachemodel->tp_model[ tile_id*numOftparts];
binOffset=0;
for( i=0; i<numOftparts-level; i++){
@ -213,7 +218,7 @@ void enqueue_metadata( int meta_id, msgqueue_param_t *msgqueue)
metadata_param_t *metadata;
Byte8_t binOffset;
metadatalist = msgqueue->target->codeidx->metadatalist;
metadatalist = msgqueue->cachemodel->target->codeidx->metadatalist;
metadata = search_metadata( meta_id, metadatalist);
if( !metadata){
@ -243,7 +248,7 @@ void enqueue_box( int meta_id, boxlist_param_t *boxlist, msgqueue_param_t *msgqu
box = boxlist->first;
while( box){
msg = gene_metamsg( meta_id, *binOffset, box->length, box->offset, NULL, msgqueue->target->csn);
msg = gene_metamsg( meta_id, *binOffset, box->length, box->offset, NULL, msgqueue->cachemodel->target->csn);
enqueue_message( msg, msgqueue);
*binOffset += box->length;
@ -258,7 +263,7 @@ void enqueue_phld( int meta_id, placeholderlist_param_t *phldlist, msgqueue_para
phld = phldlist->first;
while( phld){
msg = gene_metamsg( meta_id, *binOffset, phld->LBox, 0, phld, msgqueue->target->csn);
msg = gene_metamsg( meta_id, *binOffset, phld->LBox, 0, phld, msgqueue->cachemodel->target->csn);
enqueue_message( msg, msgqueue);
*binOffset += phld->LBox;
@ -270,7 +275,7 @@ void enqueue_boxcontents( int meta_id, boxcontents_param_t *boxcontents, msgqueu
{
message_param_t *msg;
msg = gene_metamsg( meta_id, *binOffset, boxcontents->length, boxcontents->offset, NULL, msgqueue->target->csn);
msg = gene_metamsg( meta_id, *binOffset, boxcontents->length, boxcontents->offset, NULL, msgqueue->cachemodel->target->csn);
enqueue_message( msg, msgqueue);
*binOffset += boxcontents->length;
@ -357,7 +362,7 @@ void emit_stream_from_msgqueue( msgqueue_param_t *msgqueue)
if( msg->phld)
emit_placeholder( msg->phld);
else
emit_body( msg, msgqueue->target->fd);
emit_body( msg, msgqueue->cachemodel->target->fd);
msg = msg->next;
}
@ -738,31 +743,45 @@ Byte_t * recons_codestream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte
Byte_t *codestream = NULL;
int last_tileID;
int tileID;
bool found;
Byte8_t binOffset;
*codelen = 0;
// main header first
ptr = msgqueue->first;
binOffset = 0;
while(( ptr = search_message( MAINHEADER_MSG, -1, csn, ptr))!=NULL){
codestream = add_msgstream( ptr, jpipstream, codestream, codelen);
if( ptr->bin_offset == binOffset){
codestream = add_msgstream( ptr, jpipstream, codestream, codelen);
binOffset += ptr->length;
}
ptr = ptr->next;
}
last_tileID = get_last_tileID( msgqueue, csn);
for( tileID=0; tileID <= last_tileID; tileID++){
bool found = false;
found = false;
binOffset = 0;
ptr = msgqueue->first;
while(( ptr = search_message( TILE_MSG, tileID, csn, ptr))!=NULL){
found = true;
codestream = add_msgstream( ptr, jpipstream, codestream, codelen);
if( ptr->bin_offset == binOffset){
found = true;
codestream = add_msgstream( ptr, jpipstream, codestream, codelen);
binOffset += ptr->length;
}
ptr = ptr->next;
}
ptr = msgqueue->first;
while(( ptr = search_message( EXT_TILE_MSG, tileID, csn, ptr))!=NULL){
if( ptr->aux >= minlev){
found = true;
codestream = add_msgstream( ptr, jpipstream, codestream, codelen);
if( ptr->bin_offset == binOffset){
found = true;
codestream = add_msgstream( ptr, jpipstream, codestream, codelen);
binOffset += ptr->length;
}
}
ptr = ptr->next;
}

13
applications/jpip/libopenjpip/msgqueue_manager.h
View File

@ -31,10 +31,9 @@
#ifndef MSGQUEUE_MANAGER_H_
# define MSGQUEUE_MANAGER_H_
#include <stdio.h>
#include "bool.h"
#include "byte_manager.h"
#include "target_manager.h"
#include "cachemodel_manager.h"
#include "placeholder_manager.h"
//! message parameters
@ -56,17 +55,17 @@ typedef struct msgqueue_param{
message_param_t *first; //!< first message pointer of the list
message_param_t *last; //!< last message pointer of the list
bool stateless; //!< if this is a stateless message queue
target_param_t *target; //!< reference target pointer
cachemodel_param_t *cachemodel; //!< reference cachemodel pointer
} msgqueue_param_t;
/**
* generate message queue
*
* @param[in] stateless if this is a stateless message queue
* @param[in] target reference target pointer
* @return generated message queue pointer
* @param[in] stateless if this is a stateless message queue
* @param[in] cachemodel cachemodel pointer
* @return generated message queue pointer
*/
msgqueue_param_t * gene_msgqueue( bool stateless, target_param_t *target);
msgqueue_param_t * gene_msgqueue( bool stateless, cachemodel_param_t *cachemodel);
/**
* delete message queue

1
applications/jpip/libopenjpip/placeholder_manager.c
View File

@ -28,6 +28,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "placeholder_manager.h"

55
applications/jpip/libopenjpip/target_manager.c
View File

@ -35,6 +35,7 @@
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include "target_manager.h"
#ifdef SERVER
@ -68,14 +69,13 @@ targetlist_param_t * gene_targetlist()
*/
int open_jp2file( char filename[]);
target_param_t * gene_target( char *targetname)
target_param_t * gene_target( targetlist_param_t *targetlist, char *targetname)
{
target_param_t *target;
int fd;
index_param_t *jp2idx;
static int last_csn = 0;
if( targetname[0]=='\0'){
fprintf( FCGI_stderr, "Error: exception, no targetname in gene_target()\n");
return NULL;
@ -92,16 +92,39 @@ target_param_t * gene_target( char *targetname)
}
target = (target_param_t *)malloc( sizeof(target_param_t));
snprintf( target->tid, MAX_LENOFTID, "%x-%x", (unsigned int)time(NULL), (unsigned int)rand());
strcpy( target->filename, targetname);
target->fd = fd;
target->csn = last_csn++;
target->codeidx = jp2idx;
target->num_of_use = 0;
target->next=NULL;
if( targetlist->first) // there are one or more entries
targetlist->last->next = target;
else // first entry
targetlist->first = target;
targetlist->last = target;
#ifndef SERVER
fprintf( logstream, "local log: target %s generated\n", targetname);
#endif
return target;
}
void refer_target( target_param_t *reftarget, target_param_t **ptr)
{
*ptr = reftarget;
reftarget->num_of_use++;
}
void unrefer_target( target_param_t *target)
{
target->num_of_use--;
}
void delete_target( target_param_t **target)
{
close( (*target)->fd);
@ -146,14 +169,21 @@ void delete_targetlist(targetlist_param_t **targetlist)
free( *targetlist);
}
void print_target( target_param_t *target)
{
fprintf( logstream, "target:\n");
fprintf( logstream, "\t tid=%s\n", target->tid);
fprintf( logstream, "\t csn=%d\n", target->csn);
fprintf( logstream, "\t target=%s\n\n", target->filename);
}
void print_alltarget( targetlist_param_t *targetlist)
{
target_param_t *ptr;
ptr = targetlist->first;
while( ptr != NULL){
fprintf( logstream,"csn=%d\n", ptr->csn);
fprintf( logstream,"target=%s\n", ptr->filename);
print_target( ptr);
ptr=ptr->next;
}
}
@ -174,6 +204,23 @@ target_param_t * search_target( char targetname[], targetlist_param_t *targetlis
return NULL;
}
target_param_t * search_targetBytid( char tid[], targetlist_param_t *targetlist)
{
target_param_t *foundtarget;
foundtarget = targetlist->first;
while( foundtarget != NULL){
if( strcmp( tid, foundtarget->tid) == 0)
return foundtarget;
foundtarget = foundtarget->next;
}
return NULL;
}
int open_jp2file( char filename[])
{
int fd;

42
applications/jpip/libopenjpip/target_manager.h
View File

@ -33,15 +33,20 @@
#include "index_manager.h"
//! maximum length of target identifier
#define MAX_LENOFTID 30
//! maximum length of target name
#define MAX_LENOFTARGET 128
//! target parameters
typedef struct target_param{
char tid[MAX_LENOFTID]; //!< taregt identifier
char filename[MAX_LENOFTARGET]; //!< file name
int fd; //!< file descriptor
int csn; //!< codestream number
index_param_t *codeidx; //!< index information of codestream
int num_of_use; //!< numbers of sessions refering to this target
struct target_param *next; //!< pointer to the next target
} target_param_t;
@ -65,12 +70,29 @@ targetlist_param_t * gene_targetlist();
/**
* generate a target
*
* @param[in] targetlist target list to insert the generated target
* @param[in] targetname target file name
* @return pointer to the generated target
*/
target_param_t * gene_target( char *targetname);
target_param_t * gene_target( targetlist_param_t *targetlist, char *targetname);
/**
* refer a target, used to make a new cache model
*
* @param[in] reftarget reference target pointer
* @param[out] ptr address of feeding target pointer
*/
void refer_target( target_param_t *reftarget, target_param_t **ptr);
/**
* refer a target, used to make a new cache model
*
* @param[in] target reference pointer to the target
*/
void unrefer_target( target_param_t *target);
/**
* delete a target
*
@ -95,6 +117,14 @@ void delete_target_in_list( target_param_t **target, targetlist_param_t *targetl
*/
void delete_targetlist(targetlist_param_t **targetlist);
/**
* print target parameters
*
* @param[in] target target pointer
*/
void print_target( target_param_t *target);
/**
* print all target parameters
*
@ -112,5 +142,15 @@ void print_alltarget( targetlist_param_t *targetlist);
*/
target_param_t * search_target( char targetname[], targetlist_param_t *targetlist);
/**
* search a target by tid
*
* @param[in] tid target identifier
* @param[in] targetlist target list pointer
* @return found target pointer
*/
target_param_t * search_targetBytid( char tid[], targetlist_param_t *targetlist);
#endif /* !TARGET_MANAGER_H_ */

12
applications/jpip/opj_client/opj_dec_server/Makefile.nix
View File

@ -1,7 +1,9 @@
LIBDIR = ../../libopenjpip
LIBFNAME = $(LIBDIR)/libopenjpip_local.a
CFLAGS = -O3 -Wall -I$(LIBDIR)
LDFLAGS = -L$(LIBDIR) -lm -lopenjpeg -lopenjpip_local
J2KINCDIR = ../../../../libopenjpeg
J2KLIBDIR = $(J2KINCDIR)/.libs
JPIPLIBDIR = ../../libopenjpip
LIBFNAME = $(JPIPLIBDIR)/libopenjpip_local.a $(J2KLIBDIR)/libopenjpeg.a
CFLAGS = -O3 -Wall -I$(JPIPLIBDIR) -I$(J2KINCDIR)
LDFLAGS = -L$(JPIPLIBDIR) -L$(J2KLIBDIR) -lm -lopenjpip_local
#-lws2_32
ALL = opj_dec_server
@ -9,6 +11,6 @@ ALL = opj_dec_server
all: $(ALL)
opj_dec_server: opj_dec_server.o jp2k_decoder.o imgsock_manager.o jpipstream_manager.o cache_manager.o $(LIBFNAME)
$(CC) $(CFLAGS) $< jp2k_decoder.o imgsock_manager.o jpipstream_manager.o cache_manager.o $(LDFLAGS) -o $@
$(CC) $(CFLAGS) $< jp2k_decoder.o imgsock_manager.o jpipstream_manager.o cache_manager.o $(LDFLAGS) $(LIBFNAME) -o $@
clean:
rm -f $(ALL) *.o *~

12
applications/jpip/opj_client/opj_dec_server/cache_manager.c
View File

@ -61,12 +61,13 @@ void delete_cachelist(cachelist_param_t **cachelist)
free( *cachelist);
}
cache_param_t * gene_cache( char *targetname, int csn, char *cid)
cache_param_t * gene_cache( char *targetname, int csn, char *tid, char *cid)
{
cache_param_t *cache;
cache = (cache_param_t *)malloc( sizeof(cache_param_t));
strcpy( cache->filename, targetname);
strcpy( cache->tid, tid);
cache->csn = csn;
cache->cid = (char **)malloc( sizeof(char *));
*cache->cid = (char *)malloc( MAX_LENOFCID);
@ -175,6 +176,14 @@ void add_cachecid( char *cid, cache_param_t *cache)
cache->numOfcid ++;
}
void update_cachetid( char *tid, cache_param_t *cache)
{
if( tid[0] != '0' && strcmp( tid, cache->tid) !=0){
fprintf( stderr, "tid is updated to %s for %s\n", tid, cache->filename);
strcpy( cache->tid, tid);
}
}
void remove_cidInCache( char *cid, cache_param_t *cache);
void remove_cachecid( char *cid, cachelist_param_t *cachelist)
@ -225,6 +234,7 @@ void print_cache( cache_param_t *cache)
fprintf( stdout,"cache\n");
fprintf( stdout,"\t filename: %s\n", cache->filename);
fprintf( stdout,"\t tid: %s\n", cache->tid);
fprintf( stdout,"\t csn: %d\n", cache->csn);
fprintf( stdout,"\t cid:");

17
applications/jpip/opj_client/opj_dec_server/cache_manager.h
View File

@ -37,9 +37,13 @@
//! maximum length of target name
#define MAX_LENOFTARGET 128
//! maximum length of target identifier
#define MAX_LENOFTID 30
//! cache parameters
typedef struct cache_param{
char filename[MAX_LENOFTARGET]; //!< file name
char tid[MAX_LENOFTID]; //!< taregt identifier
int csn; //!< codestream number
char **cid; //!< dynamic array of channel identifiers
int numOfcid; //!< number of cids
@ -74,10 +78,11 @@ void delete_cachelist(cachelist_param_t **cachelist);
*
* @param[in] targetname target file name
* @param[in] csn codestream number
* @param[in] tid target identifier
* @param[in] cid channel identifier
* @return pointer to the generated cache
*/
cache_param_t * gene_cache( char *targetname, int csn, char *cid);
cache_param_t * gene_cache( char *targetname, int csn, char *tid, char *cid);
/**
* delete a cache
@ -132,6 +137,16 @@ cache_param_t * search_cacheBycid( char cid[], cachelist_param_t *cachelist);
*/
void add_cachecid( char *cid, cache_param_t *cache);
/**
* update tid of a cache
*
* @param[in] tid target identifier
* @param[in] cache cache pointer
*/
void update_cachetid( char *tid, cache_param_t *cache);
/**
* remove cid in cache
*

38
applications/jpip/opj_client/opj_dec_server/imgsock_manager.c
View File

@ -94,7 +94,7 @@ msgtype_t identify_clientmsg( SOCKET connected_socket)
{
int receive_size;
char buf[BUF_LEN];
char *magicid[] = { "JPIP-stream", "PNM request", "XML request", "CID request", "CID destroy", "JP2 save", "QUIT"};
char *magicid[] = { "JPIP-stream", "PNM request", "XML request", "TID request", "CID request", "CID destroy", "JP2 save", "QUIT"};
int i;
receive_size = receive_line( connected_socket, buf);
@ -106,7 +106,7 @@ msgtype_t identify_clientmsg( SOCKET connected_socket)
for( i=0; i<NUM_OF_MSGTYPES; i++){
if( strncasecmp( magicid[i], buf, strlen(magicid[i])) == 0){
printf("Client message: %s\n", magicid[i]);
printf("%s\n", magicid[i]);
return i;
}
}
@ -115,10 +115,10 @@ msgtype_t identify_clientmsg( SOCKET connected_socket)
return MSGERROR;
}
Byte_t * receive_JPIPstream( SOCKET connected_socket, char *target, char *cid, int *streamlen)
Byte_t * receive_JPIPstream( SOCKET connected_socket, char *target, char *tid, char *cid, int *streamlen)
{
Byte_t *jpipstream=NULL, *ptr;
char buf[BUF_LEN], versionstring[] = "version 1.1";
char buf[BUF_LEN], versionstring[] = "version 1.2";
int linelen, redlen, remlen;
target[0] = 0;
@ -137,6 +137,10 @@ Byte_t * receive_JPIPstream( SOCKET connected_socket, char *target, char *cid, i
if( strstr( buf, "jp2")){
// register cid option
strcpy( target, buf);
if((linelen = receive_line( connected_socket, buf)) == 0)
return NULL;
strcpy( tid, buf);
if((linelen = receive_line( connected_socket, buf)) == 0)
return NULL;
@ -147,9 +151,8 @@ Byte_t * receive_JPIPstream( SOCKET connected_socket, char *target, char *cid, i
}
*streamlen = atoi( buf);
fprintf( stderr, "Receiveing Data length: %d\n", *streamlen);
fprintf( stderr, "Receive Data: %d Bytes\n", *streamlen);
jpipstream = (unsigned char *)malloc( (*streamlen));
ptr = jpipstream;
remlen = (*streamlen);
@ -162,7 +165,6 @@ Byte_t * receive_JPIPstream( SOCKET connected_socket, char *target, char *cid, i
remlen -= redlen;
ptr = ptr + redlen;
}
fprintf( stderr, " done\n");
return jpipstream;
}
@ -183,17 +185,29 @@ void send_XMLstream( SOCKET connected_socket, Byte_t *xmlstream, int length)
send_stream( connected_socket, xmlstream, length);
}
void send_IDstream( SOCKET connected_socket, char *id, int idlen, char *label);
void send_CIDstream( SOCKET connected_socket, char *cid, int cidlen)
{
send_IDstream( connected_socket, cid, cidlen, "CID");
}
void send_TIDstream( SOCKET connected_socket, char *tid, int tidlen)
{
send_IDstream( connected_socket, tid, tidlen, "TID");
}
void send_IDstream( SOCKET connected_socket, char *id, int idlen, char *label)
{
Byte_t header[4];
header[0] = 'C';
header[1] = 'I';
header[2] = 'D';
header[3] = cidlen & 0xff;
header[0] = label[0];
header[1] = label[1];
header[2] = label[2];
header[3] = idlen & 0xff;
send_stream( connected_socket, header, 4);
send_stream( connected_socket, cid, cidlen);
send_stream( connected_socket, id, idlen);
}
void send_PNMstream( SOCKET connected_socket, Byte_t *pnmstream, unsigned int width, unsigned int height, unsigned int numofcomp, Byte_t maxval)

32
applications/jpip/opj_client/opj_dec_server/imgsock_manager.h
View File

@ -48,8 +48,8 @@ typedef int SOCKET;
*/
SOCKET open_listeningsocket();
#define NUM_OF_MSGTYPES 7
typedef enum eMSGTYPE{ JPIPSTREAM, PNMREQ, XMLREQ, CIDREQ, CIDDST, JP2SAVE, QUIT, MSGERROR} msgtype_t;
#define NUM_OF_MSGTYPES 8
typedef enum eMSGTYPE{ JPIPSTREAM, PNMREQ, XMLREQ, TIDREQ, CIDREQ, CIDDST, JP2SAVE, QUIT, MSGERROR} msgtype_t;
/**
* indeitify client message type
@ -64,11 +64,12 @@ msgtype_t identify_clientmsg( SOCKET connected_socket);
*
* @param [in] connected_socket file descriptor of the connected socket
* @param [out] target received target file name (if not received, null string)
* @param [out] tid received target identifier (if not received, null string)
* @param [out] cid received channel identifier (if not received, null string)
* @param [out] streamlen length of the received codestream
* @return JPT- JPP- codestream
*/
Byte_t * receive_JPIPstream( SOCKET connected_socket, char *target, char *cid, int *streamlen);
Byte_t * receive_JPIPstream( SOCKET connected_socket, char *target, char *tid, char *cid, int *streamlen);
/**
* send PGM/PPM image stream to the client
@ -91,6 +92,15 @@ void send_PNMstream( SOCKET connected_socket, Byte_t *pnmstream, unsigned int wi
*/
void send_XMLstream( SOCKET connected_socket, Byte_t *xmlstream, int length);
/**
* send TID data stream to the client
*
* @param [in] connected_socket file descriptor of the connected socket
* @param [in] tid tid string
* @param [in] tidlen legnth of the tid string
*/
void send_TIDstream( SOCKET connected_socket, char *tid, int tidlen);
/**
* send CID data stream to the client
*
@ -125,7 +135,7 @@ int receive_line(SOCKET connected_socket, char *buf);
*\section sec1 JPIP-stream
* Cache JPT- JPP- stream in server
*
* client -> server: JPIP-stream\\n version 1.1\\n (optional for cid registration: targetnamestring\\n cidstring\\n) bytelengthvalue\\n data \n
* client -> server: JPIP-stream\\n version 1.1\\n (optional for cid registration: targetnamestring\\n tidstring\\n cidstring\\n) bytelengthvalue\\n data \n
* server -> client: 1 or 0 (of 1Byte response signal)
*
*\section sec2 PNM request
@ -140,25 +150,31 @@ int receive_line(SOCKET connected_socket, char *buf);
* client -> server: XML request\\n \n
* server -> client: XML (3Byte) length (2Byte Big endian) data
*
*\section sec4 CID request
*\section sec4 TID request
* Get target ID of target image
*
* client -> server: TID request\\n targetname\\n \n
* server -> client: TID (3Byte) length (1Byte) tiddata
*
*\section sec5 CID request
* Get Channel ID of identical target image
*
* client -> server: CID request\\n targetname\\n \n
* server -> client: CID (3Byte) length (1Byte) ciddata
*
*\section sec5 CID destroy
*\section sec6 CID destroy
* Close Channel ID
*
* client -> server: CID destroy\\n ciddata \n
* server -> client: 1 or 0 (of 1Byte response signal)
*
*\section sec6 JP2 save
*\section sec7 JP2 save
* Save in JP2 file format
*
* client -> server: JP2 save\\n ciddata \n
* server -> client: 1 or 0 (of 1Byte response signal)
*
*\section sec7 QUIT
*\section sec8 QUIT
* Quit the opj_dec_server program
*
* client -> server: quit or QUIT

1
applications/jpip/opj_client/opj_dec_server/jp2k_decoder.c
View File

@ -28,6 +28,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "jp2k_decoder.h"

44
applications/jpip/opj_client/opj_dec_server/opj_dec_server.c
View File

@ -99,6 +99,14 @@ void handle_PNMreqMSG( SOCKET connected_socket, Byte_t *jpipstream, msgqueue_par
*/
void handle_XMLreqMSG( SOCKET connected_socket, Byte_t *jpipstream, cachelist_param_t *cachelist);
/**
* handle TargetID request message
*
* @param[in] connected_socket socket descriptor
* @param[in] cachelist cache list pointer
*/
void handle_TIDreqMSG( SOCKET connected_socket, cachelist_param_t *cachelist);
/**
* handle ChannelID request message
*
@ -163,6 +171,10 @@ int main(int argc, char *argv[]){
case XMLREQ:
handle_XMLreqMSG( connected_socket, jpipstream, cachelist);
break;
case TIDREQ:
handle_TIDreqMSG( connected_socket, cachelist);
break;
case CIDREQ:
handle_CIDreqMSG( connected_socket, cachelist);
@ -183,7 +195,7 @@ int main(int argc, char *argv[]){
break;
}
printf("cut the connection. listening to port\n");
printf("\t end of the connection\n\n");
if( closesocket(connected_socket) != 0){
perror("close");
return -1;
@ -201,7 +213,7 @@ int main(int argc, char *argv[]){
if( msgqueue)
delete_msgqueue( &msgqueue);
// save_codestream( jpipstream, jpipstreamlen, "jpt");
//save_codestream( jpipstream, jpipstreamlen, "jpt");
free( jpipstream);
#ifdef _WIN32
@ -221,10 +233,10 @@ void handle_JPIPstreamMSG( SOCKET connected_socket, cachelist_param_t *cachelist
Byte_t *newjpipstream;
int newstreamlen = 0;
cache_param_t *cache;
char target[MAX_LENOFTARGET], cid[MAX_LENOFCID];
char target[MAX_LENOFTARGET], tid[MAX_LENOFTID], cid[MAX_LENOFCID];
metadatalist_param_t *metadatalist;
newjpipstream = receive_JPIPstream( connected_socket, target, cid, &newstreamlen);
newjpipstream = receive_JPIPstream( connected_socket, target, tid, cid, &newstreamlen);
parse_JPIPstream( newjpipstream, newstreamlen, *streamlen, msgqueue);
@ -235,11 +247,13 @@ void handle_JPIPstreamMSG( SOCKET connected_socket, cachelist_param_t *cachelist
parse_metamsg( msgqueue, *jpipstream, *streamlen, metadatalist);
// cid registration
if( target[0] != 0 && cid[0] != 0){
if((cache = search_cache( target, cachelist)))
if( target[0] != 0 && tid[0] != 0 && cid[0] != 0){
if((cache = search_cache( target, cachelist))){
add_cachecid( cid, cache);
update_cachetid( tid, cache);
}
else{
cache = gene_cache( target, msgqueue->last->csn, cid);
cache = gene_cache( target, msgqueue->last->csn, tid, cid);
insert_cache_into_list( cache, cachelist);
}
}
@ -294,6 +308,22 @@ void handle_XMLreqMSG( SOCKET connected_socket, Byte_t *jpipstream, cachelist_pa
free( xmlstream);
}
void handle_TIDreqMSG( SOCKET connected_socket, cachelist_param_t *cachelist)
{
char target[MAX_LENOFTARGET], *tid = NULL;
cache_param_t *cache;
int tidlen = 0;
receive_line( connected_socket, target);
cache = search_cache( target, cachelist);
if( cache){
tid = cache->tid;
tidlen = strlen(tid);
}
send_TIDstream( connected_socket, tid, tidlen);
}
void handle_CIDreqMSG( SOCKET connected_socket, cachelist_param_t *cachelist)
{
char target[MAX_LENOFTARGET], *cid = NULL;

BIN
applications/jpip/opj_client/opj_viewer/dist/opj_viewer-20110711.jar → applications/jpip/opj_client/opj_viewer/dist/opj_viewer-20110825.jar vendored
View File

Binary file not shown.

2
applications/jpip/opj_client/opj_viewer/dist/opj_viewer.jar vendored
View File

@ -1 +1 @@
opj_viewer-20110711.jar
opj_viewer-20110825.jar

13
applications/jpip/opj_client/opj_viewer/src/ImageManager.java
View File

@ -50,16 +50,19 @@ public class ImageManager extends JPIPHttpClient
String refcid = ImgdecClient.query_cid( j2kfilename);
byte[] jpipstream;
if( refcid == null)
jpipstream = super.requestViewWindow( j2kfilename, reqfw, reqfh, true);
if( refcid == null){
String reftid = ImgdecClient.query_tid( j2kfilename);
if( reftid == null)
jpipstream = super.requestViewWindow( j2kfilename, reqfw, reqfh, true);
else
jpipstream = super.requestViewWindow( j2kfilename, reftid, reqfw, reqfh, true);
}
else
jpipstream = super.requestViewWindow( reqfw, reqfh, refcid, true);
System.err.println( "decoding to PNM image");
pnmimage = ImgdecClient.decode_jpipstream( jpipstream, j2kfilename, cid, fw, fh);
pnmimage = ImgdecClient.decode_jpipstream( jpipstream, j2kfilename, tid, cid, fw, fh);
System.err.println( " done");
// System.out.println( "fw: " + fw + " fh: " + fh + "pnm w: ");
return pnmimage.createROIImage( rx, ry, rw, rh);
}

50
applications/jpip/opj_client/opj_viewer/src/ImgdecClient.java
View File

@ -40,9 +40,9 @@ public class ImgdecClient{
return get_PNMstream( cid, fw, fh);
}
public static PnmImage decode_jpipstream( byte[] jpipstream, String j2kfilename, String cid, int fw, int fh)
public static PnmImage decode_jpipstream( byte[] jpipstream, String j2kfilename, String tid, String cid, int fw, int fh)
{
send_JPIPstream( jpipstream, j2kfilename, cid);
send_JPIPstream( jpipstream, j2kfilename, tid, cid);
return get_PNMstream( cid, fw, fh);
}
@ -56,7 +56,7 @@ public class ImgdecClient{
System.err.println("Sending " + jpipstream.length + "Data Bytes to decodingServer");
os.writeBytes("JPIP-stream\n");
os.writeBytes("version 1.1\n");
os.writeBytes("version 1.2\n");
os.writeBytes( jpipstream.length + "\n");
os.write( jpipstream, 0, jpipstream.length);
@ -71,7 +71,7 @@ public class ImgdecClient{
}
}
public static void send_JPIPstream( byte[] jpipstream, String j2kfilename, String cid)
public static void send_JPIPstream( byte[] jpipstream, String j2kfilename, String tid, String cid)
{
try{
Socket imgdecSocket = new Socket( "localhost", 5000);
@ -85,8 +85,12 @@ public class ImgdecClient{
System.err.println("Sending " + length + "Data Bytes to decodingServer");
os.writeBytes("JPIP-stream\n");
os.writeBytes("version 1.1\n");
os.writeBytes("version 1.2\n");
os.writeBytes( j2kfilename + "\n");
if( tid == null)
os.writeBytes( "0\n");
else
os.writeBytes( tid + "\n");
os.writeBytes( cid + "\n");
os.writeBytes( length + "\n");
os.write( jpipstream, 0, length);
@ -189,7 +193,27 @@ public class ImgdecClient{
public static String query_cid( String j2kfilename)
{
String cid = null;
int []retmsglabel = new int[3];
retmsglabel[0] = 67;
retmsglabel[1] = 73;
retmsglabel[2] = 68;
return query_id( "CID request", j2kfilename, retmsglabel);
}
public static String query_tid( String j2kfilename)
{
int []retmsglabel = new int[3];
retmsglabel[0] = 84;
retmsglabel[1] = 73;
retmsglabel[2] = 68;
return query_id( "TID request", j2kfilename, retmsglabel);
}
public static String query_id( String reqmsghead, String j2kfilename, int[] retmsglabel)
{
String id = null;
try{
Socket imgdecSocket = new Socket( "localhost", 5000);
@ -197,23 +221,23 @@ public class ImgdecClient{
DataInputStream is = new DataInputStream( imgdecSocket.getInputStream());
byte []header = new byte[4];
os.writeBytes("CID request\n");
os.writeBytes( reqmsghead + "\n");
os.writeBytes( j2kfilename + "\n");
read_stream( is, header, 4);
if( header[0] == 67 && header[1] == 73 && header[2] == 68){
if( header[0] == retmsglabel[0] && header[1] == retmsglabel[1] && header[2] == retmsglabel[2]){
int length = header[3]&0xff;
if( length > 0){
byte []ciddata = new byte[ length];
read_stream( is, ciddata, length);
cid = new String( ciddata);
byte []iddata = new byte[ length];
read_stream( is, iddata, length);
id = new String( iddata);
}
}
else
System.err.println("Error in query_cid(), not starting with CID");
System.err.println("Error in query_id("+ reqmsghead + "), wrong to start with " + header);
}
catch (UnknownHostException e) {
System.err.println("Trying to connect to unknown host: " + e);
@ -221,7 +245,7 @@ public class ImgdecClient{
System.err.println("IOException: " + e);
}
return cid;
return id;
}
public static void read_stream( DataInputStream is, byte []stream, int length)

67
applications/jpip/opj_client/opj_viewer/src/JPIPHttpClient.java
View File

@ -40,6 +40,7 @@ public class JPIPHttpClient
protected int rx, ry;
protected int rw, rh;
protected String cid;
protected String tid;
public JPIPHttpClient( String URI)
{
@ -48,6 +49,7 @@ public class JPIPHttpClient
rx = ry = -1;
rw = rh = -1;
cid = null;
tid = null;
}
public int getFw(){ return fw;}
@ -75,45 +77,57 @@ public class JPIPHttpClient
public byte[] requestViewWindow( int reqfw, int reqfh, String reqcid)
{
return requestViewWindow( null, reqfw, reqfh, -1, -1, -1, -1, reqcid, false);
return requestViewWindow( null, null, reqfw, reqfh, -1, -1, -1, -1, reqcid, false);
}
public byte[] requestViewWindow( int reqfw, int reqfh, int reqrx, int reqry, int reqrw, int reqrh, String reqcid)
{
return requestViewWindow( null, reqfw, reqfh, reqrx, reqry, reqrw, reqrh, reqcid, false);
return requestViewWindow( null, null, reqfw, reqfh, reqrx, reqry, reqrw, reqrh, reqcid, false);
}
public byte[] requestViewWindow( String target, int reqfw, int reqfh)
{
return requestViewWindow( target, reqfw, reqfh, -1, -1, -1, -1, null, false);
return requestViewWindow( target, null, reqfw, reqfh, -1, -1, -1, -1, null, false);
}
public byte[] requestViewWindow( String target, int reqfw, int reqfh, boolean reqcnew)
{
if( cid == null) // 1 channel allocation only
return requestViewWindow( target, reqfw, reqfh, -1, -1, -1, -1, null, reqcnew);
return requestViewWindow( target, null, reqfw, reqfh, -1, -1, -1, -1, null, reqcnew);
else
return null;
}
public byte[] requestViewWindow( String target, String reqtid, int reqfw, int reqfh, boolean reqcnew)
{
if( cid == null) // 1 channel allocation only
return requestViewWindow( target, reqtid, reqfw, reqfh, -1, -1, -1, -1, null, reqcnew);
else
return null;
}
public byte[] requestViewWindow( String target, int reqfw, int reqfh, int reqrx, int reqry, int reqrw, int reqrh)
{
return requestViewWindow( target, reqfw, reqfh, reqrx, reqry, reqrw, reqrh, null, false);
return requestViewWindow( target, null, reqfw, reqfh, reqrx, reqry, reqrw, reqrh, null, false);
}
public byte[] requestViewWindow( int reqfw, int reqfh, String reqcid, boolean reqcnew)
{
return requestViewWindow( null, reqfw, reqfh, -1, -1, -1, -1, reqcid, reqcnew);
return requestViewWindow( null, null, reqfw, reqfh, -1, -1, -1, -1, reqcid, reqcnew);
}
public byte[] requestViewWindow( String target,
int reqfw, int reqfh,
int reqrx, int reqry,
int reqrw, int reqrh,
String reqcid, boolean reqcnew)
public byte[] requestViewWindow( String target,
String reqtid,
int reqfw, int reqfh,
int reqrx, int reqry,
int reqrw, int reqrh,
String reqcid, boolean reqcnew)
{
String urlstring = const_urlstring( target, reqfw, reqfh, reqrx, reqry, reqrw, reqrh, reqcid, reqcnew);
if( reqtid != null)
tid = reqtid;
String urlstring = const_urlstring( target, reqtid, reqfw, reqfh, reqrx, reqry, reqrw, reqrh, reqcid, reqcnew);
return GETrequest( urlstring);
}
@ -146,10 +160,17 @@ public class JPIPHttpClient
urlconn.setRequestMethod("GET");
urlconn.setInstanceFollowRedirects(false);
urlconn.connect();
Map<String,java.util.List<String>> headers = urlconn.getHeaderFields();
java.util.List<String> hvaluelist;
String status = headers.get(null).get(0);
System.err.println( status);
if( !status.contains("OK"))
System.err.println( headers.get("Reason"));
System.err.println( headers.get("Content-type"));
if(( hvaluelist = headers.get("JPIP-fsiz")) != null){
String hvalueline = hvaluelist.get(0);
fw = Integer.valueOf( hvalueline.substring( 0, hvalueline.indexOf(','))).intValue();
@ -178,9 +199,15 @@ public class JPIPHttpClient
System.err.println("cid: " + cid);
}
if(( hvaluelist = headers.get("JPIP-tid")) != null){
String hvalueline = hvaluelist.get(0);
tid = hvalueline.substring( hvalueline.indexOf('=')+1);
System.err.println("tid: " + tid);
}
InputStream input = urlconn.getInputStream();
buflen = input.available();
if( buflen > 0){
ByteArrayOutputStream tmpstream = new ByteArrayOutputStream();
byte[] buf = new byte[ 1024];
@ -230,11 +257,12 @@ public class JPIPHttpClient
}
urlconn.disconnect();
return jpipstream;
}
private String const_urlstring( String target,
private String const_urlstring( String target,
String reqtid,
int reqfw, int reqfh,
int reqrx, int reqry,
int reqrw, int reqrh,
@ -250,6 +278,11 @@ public class JPIPHttpClient
urlstring = urlstring.concat( "&");
urlstring = urlstring.concat( "target=" + target);
}
if( reqtid != null){
if( !urlstring.endsWith("?"))
urlstring = urlstring.concat( "&");
urlstring = urlstring.concat( "tid=" + reqtid);
}
if( reqfw != -1 && reqfh != -1){
if( !urlstring.endsWith("?"))
urlstring = urlstring.concat( "&");

BIN
applications/jpip/opj_client/opj_viewer_xerces/dist/opj_viewer_xerces-20110711.jar → applications/jpip/opj_client/opj_viewer_xerces/dist/opj_viewer_xerces-20110825.jar vendored
View File

Binary file not shown.

2
applications/jpip/opj_client/opj_viewer_xerces/dist/opj_viewer_xerces.jar vendored
View File

@ -1 +1 @@
opj_viewer_xerces-20110711.jar
opj_viewer_xerces-20110825.jar

3
applications/jpip/opj_server/Makefile.am
View File

@ -9,7 +9,8 @@ opj_server_CPPFLAGS = \
-I$(top_srcdir)/applications/jpip/libopenjpip \
-I$(top_builddir)/applications/jpip/libopenjpip \
@FCGI_CFLAGS@ \
-DSERVER
-DSERVER \
-DQUIT_SIGNAL=\"quitJPIP\"
opj_server_CFLAGS =
opj_server_LDADD = $(top_builddir)/applications/jpip/libopenjpip/libopenjpip_server.la @FCGI_LIBS@ -lm
opj_server_SOURCES = \

3
applications/jpip/opj_server/Makefile.nix
View File

@ -1,6 +1,7 @@
LIBDIR = ../libopenjpip
LIBFNAME = $(LIBDIR)/libopenjpip_server.a
CFLAGS = -O3 -Wall -m32 -DSERVER -I$(LIBDIR)
CFLAGS = -O3 -Wall -m32 -DSERVER -DQUIT_SIGNAL=\"quitJPIP\" -I$(LIBDIR)
LDFLAGS = -L$(LIBDIR) -lm -lfcgi -lopenjpip_server
ALL = opj_server

16
applications/jpip/opj_server/channel_manager.c
View File

@ -54,23 +54,21 @@ channellist_param_t * gene_channellist()
return channellist;
}
channel_param_t * gene_channel( query_param_t query_param, target_param_t *target, channellist_param_t *channellist)
channel_param_t * gene_channel( query_param_t query_param, cachemodel_param_t *cachemodel, channellist_param_t *channellist)
{
channel_param_t *channel;
// set the target
if( !target){
if( !cachemodel){
fprintf( FCGI_stdout, "Status: 404\r\n");
fprintf( FCGI_stdout, "Reason: cnew cancelled\r\n");
return NULL;
}
channel = (channel_param_t *)malloc( sizeof(channel_param_t));
channel->target = target;
channel->cachemodel = cachemodel;
// set channel ID and get present time
snprintf( channel->cid, MAX_LENOFCID, "%x%x", (unsigned int)time( &channel->start_tm), (unsigned int)rand());;
snprintf( channel->cid, MAX_LENOFCID, "%x%x", (unsigned int)time( &channel->start_tm), (unsigned int)rand());
channel->next=NULL;
@ -141,7 +139,7 @@ void print_allchannel( channellist_param_t *channellist)
ptr = channellist->first;
while( ptr != NULL){
fprintf( logstream,"channel-ID=%s \t target=%s\n", ptr->cid, ptr->target->filename);
fprintf( logstream,"channel-ID=%s \t target=%s\n", ptr->cid, ptr->cachemodel->target->filename);
ptr=ptr->next;
}
}

17
applications/jpip/opj_server/channel_manager.h
View File

@ -33,16 +33,15 @@
#include <time.h>
#include "query_parser.h"
#include "target_manager.h"
#include "cachemodel_manager.h"
//! Channel parameters
typedef struct channel_param{
target_param_t *target; //!< reference pointer to the target
char cid[MAX_LENOFCID]; //!< channel identifier
// - a record of the client's capabilities and preferences
// - to the extent that the server queues requests
time_t start_tm; //!< starting time
struct channel_param *next; //!< pointer to the next channel
cachemodel_param_t *cachemodel; //!< reference pointer to the cache model
char cid[MAX_LENOFCID]; //!< channel identifier
// - a record of the client's capabilities and preferences to the extent that the server queues requests
time_t start_tm; //!< starting time
struct channel_param *next; //!< pointer to the next channel
} channel_param_t;
@ -65,11 +64,11 @@ channellist_param_t * gene_channellist();
* generate a channel under the channel list
*
* @param[in] query_param query parameters
* @param[in] target reference target
* @param[in] cachemodel reference cachemodel
* @param[in] channellist channel list pointer
* @return pointer to the generated channel
*/
channel_param_t * gene_channel( query_param_t query_param, target_param_t *target, channellist_param_t *channellist);
channel_param_t * gene_channel( query_param_t query_param, cachemodel_param_t *cachemodel, channellist_param_t *channellist);
/**
* set channel variable parameters

234
applications/jpip/opj_server/opj_server.c
View File

@ -55,6 +55,9 @@
#include "imgreg_manager.h"
#include "msgqueue_manager.h"
#ifndef QUIT_SIGNAL
#define QUIT_SIGNAL "quitJPIP"
#endif
#ifdef SERVER
#include "fcgi_stdio.h"
@ -70,13 +73,87 @@
*
* @param[in] query_param structured query
* @param[in] sessionlist session list pointer
* @param[in] targetlist target list pointer
* @param[in,out] msgqueue address of the message queue pointer
* @return if succeeded (true) or failed (false)
*/
bool parse_JPIPrequest( query_param_t query_param,
sessionlist_param_t *sessionlist,
targetlist_param_t *targetlist,
msgqueue_param_t **msgqueue);
int main(void)
{
sessionlist_param_t *sessionlist;
targetlist_param_t *targetlist;
bool parse_status;
sessionlist = gene_sessionlist();
targetlist = gene_targetlist();
#ifdef SERVER
char *query_string;
while(FCGI_Accept() >= 0)
#else
char query_string[128];
while((fgets( query_string, 128, stdin))[0] != '\n' )
#endif
{
#ifdef SERVER
query_string = getenv("QUERY_STRING");
#endif //SERVER
if( strcmp( query_string, QUIT_SIGNAL) == 0)
break;
fprintf( FCGI_stdout, "Content-type: image/jpt-stream\r\n");
query_param_t query_param;
msgqueue_param_t *msgqueue;
parse_query( query_string, &query_param);
#ifndef SERVER
print_queryparam( query_param);
#endif
msgqueue = NULL;
if( !(parse_status = parse_JPIPrequest( query_param, sessionlist, targetlist, &msgqueue)))
fprintf( FCGI_stderr, "Error: JPIP request failed\n");
fprintf( FCGI_stdout, "\r\n");
#ifndef SERVER
// if( parse_status)
// print_allsession( sessionlist);
print_msgqueue( msgqueue);
#endif
emit_stream_from_msgqueue( msgqueue);
delete_msgqueue( &msgqueue);
}
fprintf( FCGI_stderr, "JPIP server terminated by a client request\n");
delete_sessionlist( &sessionlist);
delete_targetlist( &targetlist);
return 0;
}
/**
* REQUEST: target identification by target or tid request
*
* @param[in] query_param structured query
* @param[in] targetlist target list pointer
* @param[out] target address of target pointer
* @return if succeeded (true) or failed (false)
*/
bool identify_target( query_param_t query_param, targetlist_param_t *targetlist, target_param_t **target);
/**
* REQUEST: channel association
@ -97,12 +174,14 @@ bool associate_channel( query_param_t query_param,
*
* @param[in] query_param structured query
* @param[in] sessionlist session list pointer
* @param[in] target requested target pointer
* @param[in,out] cursession address of the associated/opened session pointer
* @param[in,out] curchannel address of the associated/opened channel pointer
* @return if succeeded (true) or failed (false)
*/
bool open_channel( query_param_t query_param,
sessionlist_param_t *sessionlist,
target_param_t *target,
session_param_t **cursession,
channel_param_t **curchannel);
@ -124,82 +203,39 @@ bool close_channel( query_param_t query_param,
* REQUEST: view-window (fsiz)
*
* @param[in] query_param structured query
* @param[in] target requested target pointer
* @param[in,out] cursession associated session pointer
* @param[in,out] curchannel associated channel pointer
* @param[in,out] msgqueue address of the message queue pointer
* @return if succeeded (true) or failed (false)
*/
bool gene_JPTstream( query_param_t query_param,
target_param_t *target,
session_param_t *cursession,
channel_param_t *curchannel,
msgqueue_param_t **msgqueue);
int main(void)
{
sessionlist_param_t *sessionlist;
bool parse_status;
sessionlist = gene_sessionlist();
#ifdef SERVER
char *query_string;
while(FCGI_Accept() >= 0)
#else
char query_string[128];
while((fgets( query_string, 128, stdin))[0] != '\n' )
#endif
{
#ifdef SERVER
query_string = getenv("QUERY_STRING");
#endif //SERVER
fprintf( FCGI_stdout, "Content-type: image/jpt-stream\r\n");
query_param_t query_param;
msgqueue_param_t *msgqueue;
parse_query( query_string, &query_param);
#ifndef SERVER
print_queryparam( query_param);
#endif
msgqueue = NULL;
parse_status = parse_JPIPrequest( query_param, sessionlist, &msgqueue);
fprintf( FCGI_stdout, "\r\n");
#ifndef SERVER
// if( parse_status)
// print_allsession( sessionlist);
print_msgqueue( msgqueue);
#endif
emit_stream_from_msgqueue( msgqueue);
delete_msgqueue( &msgqueue);
}
delete_sessionlist( &sessionlist);
return 0;
}
bool parse_JPIPrequest( query_param_t query_param,
sessionlist_param_t *sessionlist,
targetlist_param_t *targetlist,
msgqueue_param_t **msgqueue)
{
target_param_t *target = NULL;
session_param_t *cursession = NULL;
channel_param_t *curchannel = NULL;
if( query_param.cid[0] != '\0')
if( query_param.target[0] != '\0' || query_param.tid[0] != '\0'){
if( !identify_target( query_param, targetlist, &target))
return false;
}
if( query_param.cid[0] != '\0'){
if( !associate_channel( query_param, sessionlist, &cursession, &curchannel))
return false;
}
if( query_param.cnew){
if( !open_channel( query_param, sessionlist, &cursession, &curchannel))
if( !open_channel( query_param, sessionlist, target, &cursession, &curchannel))
return false;
}
if( query_param.cclose[0][0] != '\0')
@ -207,12 +243,40 @@ bool parse_JPIPrequest( query_param_t query_param,
return false;
if( (query_param.fx > 0 && query_param.fy > 0) || query_param.box_type[0][0] != 0)
if( !gene_JPTstream( query_param, cursession, curchannel, msgqueue))
if( !gene_JPTstream( query_param, target, cursession, curchannel, msgqueue))
return false;
return true;
}
bool identify_target( query_param_t query_param, targetlist_param_t *targetlist, target_param_t **target)
{
if( query_param.tid[0] !='\0' && strcmp( query_param.tid, "0") != 0 ){
if( query_param.cid[0] != '\0'){
fprintf( FCGI_stdout, "Reason: Target can not be specified both through tid and cid\r\n");
fprintf( FCGI_stdout, "Status: 400\r\n");
return false;
}
if( ( *target = search_targetBytid( query_param.tid, targetlist)))
return true;
}
if( query_param.target[0] !='\0')
if( !( *target = search_target( query_param.target, targetlist)))
if(!( *target = gene_target( targetlist, query_param.target)))
return false;
if( *target){
fprintf( FCGI_stdout, "JPIP-tid: %s\r\n", (*target)->tid);
return true;
}
else{
fprintf( FCGI_stdout, "Reason: target not found\r\n");
fprintf( FCGI_stdout, "Status: 400\r\n");
return false;
}
}
bool associate_channel( query_param_t query_param,
sessionlist_param_t *sessionlist,
session_param_t **cursession,
@ -232,36 +296,24 @@ bool associate_channel( query_param_t query_param,
bool open_channel( query_param_t query_param,
sessionlist_param_t *sessionlist,
target_param_t *target,
session_param_t **cursession,
channel_param_t **curchannel)
{
target_param_t *target=NULL;
cachemodel_param_t *cachemodel = NULL;
if( query_param.target[0] !='\0'){ // target query specified
if( *cursession){
if( !( target = search_target( query_param.target, (*cursession)->targetlist))){
if((target = gene_target( query_param.target)))
insert_target_into_session( *cursession, target);
else
return false;
}
}
else{
if((target = gene_target( query_param.target))){
// new session
*cursession = gene_session( sessionlist);
insert_target_into_session( *cursession, target);
}
else
if( target){
if( !(*cursession))
*cursession = gene_session( sessionlist);
if( !( cachemodel = search_cachemodel( target, (*cursession)->cachemodellist)))
if( !(cachemodel = gene_cachemodel( (*cursession)->cachemodellist, target)))
return false;
}
}
else{
if( *cursession)
target = (*curchannel)->target;
}
*curchannel = gene_channel( query_param, target, (*cursession)->channellist);
else
if( *curchannel)
cachemodel = (*curchannel)->cachemodel;
*curchannel = gene_channel( query_param, cachemodel, (*cursession)->channellist);
if( *curchannel == NULL)
return false;
@ -335,22 +387,25 @@ void enqueue_metabins( query_param_t query_param, metadatalist_param_t *metadata
bool gene_JPTstream( query_param_t query_param,
target_param_t *target,
session_param_t *cursession,
channel_param_t *curchannel,
msgqueue_param_t **msgqueue)
{
target_param_t *target;
index_param_t *codeidx;
cachemodel_param_t *cachemodel;
if( !cursession || !curchannel){ // stateless
if((target = gene_target( query_param.target)))
*msgqueue = gene_msgqueue( true, target);
else
if( !target)
return false;
if( !(cachemodel = gene_cachemodel( NULL, target)))
return false;
*msgqueue = gene_msgqueue( true, cachemodel);
}
else{ // session
target = curchannel->target;
*msgqueue = gene_msgqueue( false, target);
cachemodel = curchannel->cachemodel;
target = cachemodel->target;
*msgqueue = gene_msgqueue( false, cachemodel);
}
codeidx = target->codeidx;
@ -359,13 +414,12 @@ bool gene_JPTstream( query_param_t query_param,
if( query_param.box_type[0][0] != 0)
enqueue_metabins( query_param, codeidx->metadatalist, *msgqueue);
// image code
// image codestream
if( query_param.fx > 0 && query_param.fy > 0){
if( !codeidx->mhead_model)
if( !cachemodel->mhead_model)
enqueue_mainheader( *msgqueue);
enqueue_tiles( query_param, codeidx, *msgqueue);
}
return true;
}

5
applications/jpip/opj_server/query_parser.c
View File

@ -99,6 +99,9 @@ void parse_query( char *query_string, query_param_t *query_param)
if( strcasecmp( fieldname, "target") == 0)
strcpy( query_param->target,fieldval);
else if( strcasecmp( fieldname, "tid") == 0)
strcpy( query_param->tid, fieldval);
else if( strcasecmp( fieldname, "fsiz") == 0)
sscanf( fieldval, "%d,%d", &query_param->fx, &query_param->fy);
@ -128,6 +131,7 @@ void init_queryparam( query_param_t *query_param)
int i;
query_param->target[0]='\0';
query_param->tid[0]='\0';
query_param->fx=-1;
query_param->fy=-1;
query_param->rx=-1;
@ -183,6 +187,7 @@ void print_queryparam( query_param_t query_param)
fprintf( logstream, "query parameters:\n");
fprintf( logstream, "\t target: %s\n", query_param.target);
fprintf( logstream, "\t tid: %s\n", query_param.tid);
fprintf( logstream, "\t fx,fy: %d, %d\n", query_param.fx, query_param.fy);
fprintf( logstream, "\t rx,ry: %d, %d \t rw,rh: %d, %d\n", query_param.rx, query_param.ry, query_param.rw, query_param.rh);
fprintf( logstream, "\t cnew: %d\n", query_param.cnew);

4
applications/jpip/opj_server/query_parser.h
View File

@ -35,6 +35,9 @@
//! maximum length of target name
#define MAX_LENOFTARGET 128
//! maximum length of target identifier
#define MAX_LENOFTID 30
//! maximum length of channel identifier
#define MAX_LENOFCID 30
@ -48,6 +51,7 @@
//! Query parameters
typedef struct query_param{
char target[MAX_LENOFTARGET]; //!< target name
char tid[MAX_LENOFTID]; //!< target identifier
int fx, fy; //!< frame size (fx,fy)
int rx, ry, rw, rh; //!< roi region
char cid[MAX_LENOFCID]; //!< channel identifier

28
applications/jpip/opj_server/session_manager.c
View File

@ -32,6 +32,7 @@
#include <string.h>
#include <stdio.h>
#include "session_manager.h"
#include "target_manager.h"
#ifdef SERVER
#include "fcgi_stdio.h"
@ -62,7 +63,7 @@ session_param_t * gene_session( sessionlist_param_t *sessionlist)
session = (session_param_t *)malloc( sizeof(session_param_t));
session->channellist = gene_channellist();
session->targetlist = gene_targetlist();
session->cachemodellist = gene_cachemodellist();
session->next = NULL;
@ -102,19 +103,19 @@ bool search_session_and_channel( char cid[],
return false;
}
void insert_target_into_session( session_param_t *session, target_param_t *target)
void insert_cachemodel_into_session( session_param_t *session, cachemodel_param_t *cachemodel)
{
if(!target)
if(!cachemodel)
return;
#ifndef SERVER
fprintf( logstream, "local log: insert target into session %p\n", (void *)session);
fprintf( logstream, "local log: insert cachemodel into session\n");
#endif
if( session->targetlist->first != NULL)
session->targetlist->last->next = target;
if( session->cachemodellist->first != NULL)
session->cachemodellist->last->next = cachemodel;
else
session->targetlist->first = target;
session->targetlist->last = target;
session->cachemodellist->first = cachemodel;
session->cachemodellist->last = cachemodel;
}
bool delete_session( session_param_t **session, sessionlist_param_t *sessionlist)
@ -138,7 +139,7 @@ bool delete_session( session_param_t **session, sessionlist_param_t *sessionlist
}
delete_channellist( &((*session)->channellist));
delete_targetlist ( &((*session)->targetlist));
delete_cachemodellist( &((*session)->cachemodellist));
#ifndef SERVER
fprintf( logstream, "local log: session: %p deleted!\n", (void *)(*session));
@ -157,7 +158,7 @@ void delete_sessionlist( sessionlist_param_t **sessionlist)
sessionNext=sessionPtr->next;
delete_channellist( &(sessionPtr->channellist));
delete_targetlist ( &(sessionPtr->targetlist));
delete_cachemodellist( &(sessionPtr->cachemodellist));
#ifndef SERVER
fprintf( logstream, "local log: session: %p deleted!\n", (void *)sessionPtr);
@ -176,6 +177,7 @@ void delete_sessionlist( sessionlist_param_t **sessionlist)
void print_allsession( sessionlist_param_t *sessionlist)
{
session_param_t *ptr;
cachemodel_param_t *cachemodel;
int i=0;
fprintf( logstream, "SESSIONS info:\n");
@ -184,7 +186,11 @@ void print_allsession( sessionlist_param_t *sessionlist)
while( ptr != NULL){
fprintf( logstream, "session No.%d\n", i++);
print_allchannel( ptr->channellist);
print_alltarget( ptr->targetlist);
cachemodel = ptr->cachemodellist->first;
while( cachemodel){
print_target( cachemodel->target);
cachemodel = cachemodel->next;
}
ptr=ptr->next;
}
}

16
applications/jpip/opj_server/session_manager.h
View File

@ -33,13 +33,13 @@
#include "bool.h"
#include "channel_manager.h"
#include "target_manager.h"
#include "cachemodel_manager.h"
//! Session parameters
typedef struct session_param{
channellist_param_t *channellist; //!< channel list pointer
targetlist_param_t *targetlist; //!< target list pointer
struct session_param *next; //!< pointer to the next session
channellist_param_t *channellist; //!< channel list pointer
cachemodellist_param_t *cachemodellist; //!< cache list pointer
struct session_param *next; //!< pointer to the next session
} session_param_t;
//! Session list parameters
@ -80,12 +80,12 @@ bool search_session_and_channel( char cid[],
channel_param_t **foundchannel);
/**
* insert a target into a session
* insert a cache model into a session
*
* @param[in] session session pointer
* @param[in] target target pointer
* @param[in] session session pointer
* @param[in] cachemodel cachemodel pointer
*/
void insert_target_into_session( session_param_t *session, target_param_t *target);
void insert_cachemodel_into_session( session_param_t *session, cachemodel_param_t *cachemodel);
/**

34
applications/jpip/tools/indexer/CMakeLists.txt
View File

@ -1,26 +1,32 @@
SET(INDEXER_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/bio.c
${CMAKE_CURRENT_SOURCE_DIR}/cio.c
${CMAKE_CURRENT_SOURCE_DIR}/index_create.c
${CMAKE_CURRENT_SOURCE_DIR}/int.c
${CMAKE_CURRENT_SOURCE_DIR}/jp2.c
${CMAKE_CURRENT_SOURCE_DIR}/jpip.c
${CMAKE_CURRENT_SOURCE_DIR}/pi.c
${CMAKE_CURRENT_SOURCE_DIR}/t2.c
${CMAKE_CURRENT_SOURCE_DIR}/tcd.c
${CMAKE_CURRENT_SOURCE_DIR}/tgt.c
${CMAKE_CURRENT_SOURCE_DIR}/j2k_to_idxjp2.c
${CMAKE_CURRENT_SOURCE_DIR}/cidx_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/cio_ext.c
${CMAKE_CURRENT_SOURCE_DIR}/event_mgr_handler.c
${CMAKE_CURRENT_SOURCE_DIR}/idxjp2_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/j2k_decoder.c
${CMAKE_CURRENT_SOURCE_DIR}/phix_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/ppix_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/thix_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/tpix_manager.c
)
# Headers file are located here:
INCLUDE_DIRECTORIES(
${OPENJPEG_SOURCE_DIR}/libopenjpeg
)
# Build executable
ADD_EXECUTABLE(index_create ${INDEXER_SRCS})
ADD_EXECUTABLE(j2k_to_idxjp2 ${INDEXER_SRCS})
TARGET_LINK_LIBRARIES(j2k_to_idxjp2 ${OPENJPEG_LIBRARY_NAME})
# On unix you need to link to the math library:
IF(UNIX)
TARGET_LINK_LIBRARIES(index_create m)
TARGET_LINK_LIBRARIES(j2k_to_idxjp2 m)
ENDIF(UNIX)
# Install exe
INSTALL(TARGETS index_create
INSTALL(TARGETS j2k_to_idxjp2
EXPORT OpenJPEGTargets
DESTINATION ${OPENJPEG_INSTALL_BIN_DIR} COMPONENT Applications
)
)

66
applications/jpip/tools/indexer/Makefile.am
View File

@ -1,34 +1,32 @@
MAINTAINERCLEANFILES = Makefile.in
bin_PROGRAMS = index_create
index_create_CPPFLAGS = \
-I. \
-I$(top_srcdir)/applications/libopenjpip/tools/indexer \
-I$(top_builddir)/applications/libopenjpip/tools/indexer
index_create_CFLAGS =
index_create_LDADD = -lm
index_create_SOURCES = \
bio.c \
bio.h \
cio.c \
cio.h \
index_create.c \
int.c \
int.h \
j2k.h \
jp2.c \
jp2.h \
jpip.c \
jpip.h \
pi.c \
pi.h \
t2.c \
t2.h \
tcd.c \
tcd.h \
tgt.c \
tgt.h
install-data-hook:
@echo -e " (B)\t$(bindir)/index_create$(EXEEXT)" >> $(top_builddir)/report.txt
MAINTAINERCLEANFILES = Makefile.in
bin_PROGRAMS = j2k_to_idxjp2
j2k_to_idxjp2_CPPFLAGS = \
-I. \
-I$(top_srcdir)/applications/libopenjpip/tools/indexer \
-I$(top_builddir)/applications/libopenjpip/tools/indexer \
-I$(top_srcdir)/libopenjpeg \
-I$(top_builddir)/libopenjpeg
j2k_to_idxjp2_CFLAGS =
j2k_to_idxjp2_LDADD = $(top_builddir)/libopenjpeg/libopenjpeg.la -lm
j2k_to_idxjp2_SOURCES = \
cidx_manager.c \
cidx_manager.h \
cio_ext.c \
cio_ext.h \
j2k_to_idxjp2.c \
j2k_to_idxjp2.h \
event_mgr_handler.c \
event_mgr_handler.h \
idxjp2_manager.c \
j2k_decoder.c \
indexbox_manager.h \
phix_manager.c \
ppix_manager.c \
thix_manager.c \
tpix_manager.c
install-data-hook:
@echo -e " (B)\t$(bindir)/j2k_to_idxjp2$(EXEEXT)" >> $(top_builddir)/report.txt

29
applications/jpip/tools/indexer/Makefile.nix
View File

@ -1,23 +1,14 @@
CC = gcc
INCDIR = ../../../../libopenjpeg
LIBDIR = $(INCDIR)/.libs
LIBFNAME = $(LIBDIR)/libopenjpeg.a
CFLAGS = -O3 -Wall -I$(INCDIR)
LDFLAGS = -L$(LIBDIR) -lm
LDFLAGS = -lm
CFLAGS = -Wall
ALL = j2k_to_idxjp2
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
all: $(ALL)
j2k_to_idxjp2: j2k_to_idxjp2.o event_mgr_handler.o idxjp2_manager.o j2k_decoder.o cidx_manager.o cio_ext.o tpix_manager.o thix_manager.o ppix_manager.o phix_manager.o $(LIBFNAME)
$(CC) $(CFLAGS) $< event_mgr_handler.o idxjp2_manager.o j2k_decoder.o cidx_manager.o cio_ext.o tpix_manager.o thix_manager.o ppix_manager.o phix_manager.o $(LDFLAGS) $(LIBFNAME) -o $@
clean:
rm -rf index_create *.o *.*~ *~ core.*
rm -f $(ALL) *.o *~

125
applications/jpip/tools/indexer/bio.c
View File

@ -1,125 +0,0 @@
/*
* 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 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;
}
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.
/// </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>
/// Read bit.
/// </summary>
int bio_getbit() {
if (bio_ct==0) {
bio_bytein();
}
bio_ct--;
return (bio_buf>>bio_ct)&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;
}

213
applications/jpip/tools/indexer/cidx_manager.c Normal file
View File

@ -0,0 +1,213 @@
/*
* $Id$
*
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2011, Professor Benoit Macq
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include "cidx_manager.h"
#include "indexbox_manager.h"
#include "cio_ext.h"
#include "cio.h"
/*
* Write CPTR Codestream finder box
*
* @param[in] coff offset of j2k codestream
* @param[in] clen length of j2k codestream
* @param[in] cio file output handle
*/
void write_cptr(int coff, int clen, opj_cio_t *cio);
/*
* Write main header index table (box)
*
* @param[in] cstr_info codestream information
* @param[in] cio file output handle
* @return length of mainmhix box
*/
int write_mainmhix( opj_codestream_info_t cstr_info, opj_cio_t *cio);
/*
* Check if EPH option is used
*
* @param[in] coff offset of j2k codestream
* @param[in] markers marker information
* @param[in] marknum number of markers
* @param[in] cio file output handle
* @return true if EPH is used
*/
opj_bool check_EPHuse( int coff, opj_marker_info_t *markers, int marknum, opj_cio_t *cio);
int write_cidx( int offset, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t cstr_info, int j2klen)
{
int len, i, lenp;
opj_jp2_box_t *box;
int num_box = 0;
opj_bool EPHused;
box = (opj_jp2_box_t *)calloc( 32, sizeof(opj_jp2_box_t));
for (i=0;i<2;i++){
if(i)
cio_seek( cio, lenp);
lenp = cio_tell( cio);
cio_skip( cio, 4); /* L [at the end] */
cio_write( cio, JPIP_CIDX, 4); /* CIDX */
write_cptr( offset, cstr_info.codestream_size, cio);
write_manf( i, num_box, box, cio);
num_box = 0;
box[num_box].length = write_mainmhix( cstr_info, cio);
box[num_box].type = JPIP_MHIX;
num_box++;
box[num_box].length = write_tpix( cstr_info, j2klen, cio);
box[num_box].type = JPIP_TPIX;
num_box++;
box[num_box].length = write_thix( offset, cstr_info, cio);
box[num_box].type = JPIP_THIX;
num_box++;
EPHused = check_EPHuse( offset, cstr_info.marker, cstr_info.marknum, cio);
box[num_box].length = write_ppix( cstr_info, EPHused, j2klen, cio);
box[num_box].type = JPIP_PPIX;
num_box++;
box[num_box].length = write_phix( cstr_info, EPHused, j2klen, cio);
box[num_box].type = JPIP_PHIX;
num_box++;
len = cio_tell( cio)-lenp;
cio_seek( cio, lenp);
cio_write( cio, len, 4); /* L */
cio_seek( cio, lenp+len);
}
free( box);
return len;
}
void write_cptr(int coff, int clen, opj_cio_t *cio)
{
int len, lenp;
lenp = cio_tell( cio);
cio_skip( cio, 4); /* L [at the end] */
cio_write( cio, JPIP_CPTR, 4); /* T */
cio_write( cio, 0, 2); /* DR A PRECISER !! */
cio_write( cio, 0, 2); /* CONT */
cio_ext_write( cio, coff, 8); /* COFF A PRECISER !! */
cio_ext_write( cio, clen, 8); /* CLEN */
len = cio_tell( cio) - lenp;
cio_seek( cio, lenp);
cio_write( cio, len, 4); /* L */
cio_seek( cio, lenp+len);
}
void write_manf(int second, int v, opj_jp2_box_t *box, opj_cio_t *cio)
{
int len, lenp, i;
lenp = cio_tell( cio);
cio_skip( cio, 4); /* L [at the end] */
cio_write( cio, JPIP_MANF,4); /* T */
if (second){ /* Write only during the second pass */
for( i=0; i<v; i++){
cio_write( cio, box[i].length, 4); /* Box length */
cio_write( cio, box[i].type, 4); /* Box type */
}
}
len = cio_tell( cio) - lenp;
cio_seek( cio, lenp);
cio_write( cio, len, 4); /* L */
cio_seek( cio, lenp+len);
}
int write_mainmhix( opj_codestream_info_t cstr_info, opj_cio_t *cio)
{
int i;
int len, lenp;
lenp = cio_tell( cio);
cio_skip( cio, 4); /* L [at the end] */
cio_write( cio, JPIP_MHIX, 4); /* MHIX */
cio_ext_write( cio, cstr_info.main_head_end-cstr_info.main_head_start+1, 8); /* TLEN */
for(i = 1; i < cstr_info.marknum; i++){ /* Marker restricted to 1 apparition, skip SOC marker */
cio_write( cio, cstr_info.marker[i].type, 2);
cio_write( cio, 0, 2);
cio_ext_write( cio, cstr_info.marker[i].pos, 8);
cio_write( cio, cstr_info.marker[i].len, 2);
}
len = cio_tell( cio) - lenp;
cio_seek( cio, lenp);
cio_write( cio, len, 4); /* L */
cio_seek( cio, lenp+len);
return len;
}
opj_bool check_EPHuse( int coff, opj_marker_info_t *markers, int marknum, opj_cio_t *cio)
{
opj_bool EPHused = OPJ_FALSE;
int i=0;
int org_pos;
unsigned int Scod;
for(i = 0; i < marknum; i++){
if( markers[i].type == J2K_MS_COD){
org_pos = cio_tell( cio);
cio_seek( cio, coff+markers[i].pos+2);
Scod = cio_read( cio, 1);
if( ((Scod >> 2) & 1))
EPHused = OPJ_TRUE;
cio_seek( cio, org_pos);
break;
}
}
return EPHused;
}

44
applications/jpip/tools/indexer/cio.h → applications/jpip/tools/indexer/cidx_manager.h
View File

@ -1,7 +1,10 @@
/*
* Copyright (c) 2001-2002, David Janssens
* $Id$
*
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2011, Professor Benoit Macq
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -26,19 +29,28 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __CIO_H
#define __CIO_H
/*! \file
* \brief Modification of jpip.h from 2KAN indexer
*/
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); */
long long cio_read(int n);
void cio_skip(int n);
#endif
#ifndef CIDX_MANAGER_H_
# define CIDX_MANAGER_H_
#include "openjpeg.h"
/*
* Write Codestream index box (superbox)
*
* @param[in] offset offset of j2k codestream
* @param[in] cio file output handle
* @param[in] image image data
* @param[in] cstr_info codestream information
* @param[in] j2klen length of j2k codestream
* @return length of cidx box
*/
int write_cidx( int offset, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t cstr_info, int j2klen);
#endif /* !CIDX_MANAGER_H_ */

129
applications/jpip/tools/indexer/cio.c
View File

@ -1,129 +0,0 @@
/*
* 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) { */
long long cio_read(int n) {
int i;
/*unsigned int v;*/
long long 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;
}

46
applications/jpip/tools/indexer/jpip.h → applications/jpip/tools/indexer/cio_ext.c
View File

@ -1,6 +1,13 @@
/*
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* $Id$
*
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2011, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -25,18 +32,31 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __JPIP_H
#define __JPIP_H
#include "cio_ext.h"
#include "event.h"
#include "j2k.h"
// Codestream index box (superbox)
int jpip_write_cidx(int offset, info_image_t img, j2k_cp_t *j2k_cp, int version);
/*
* Write a byte.
*/
opj_bool cio_ext_byteout(opj_cio_t *cio, unsigned char v);
// Index Finder Box
void jpip_write_iptr(int offset, int length);
unsigned int cio_ext_write( opj_cio_t *cio, unsigned long long int v, int n)
{
int i;
for (i = n - 1; i >= 0; i--) {
if( !cio_ext_byteout(cio, (unsigned char) ((v >> (i << 3)) & 0xff)) )
return 0;
}
return n;
}
// File Index Box
int jpip_write_fidx(int offset_jp2c, int length_jp2c, int offset_idx, int length_idx);
#endif
opj_bool cio_ext_byteout(opj_cio_t *cio, unsigned char v)
{
if (cio->bp >= cio->end) {
opj_event_msg(cio->cinfo, EVT_ERROR, "write error\n");
return OPJ_FALSE;
}
*cio->bp++ = v;
return OPJ_TRUE;
}

38
applications/jpip/tools/indexer/t2.h → applications/jpip/tools/indexer/cio_ext.h
View File

@ -1,7 +1,9 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* $Id$
*
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2011, Professor Benoit Macq
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -26,21 +28,25 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __T2_H
#define __T2_H
/*! \file
* \brief Additional functions to libopenjpeg/cio.h
*/
#ifndef CIO_EXT_H_
# define CIO_EXT_H_
#include "openjpeg.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
* Write byte codes with 5 bytes to 8 bytes length
* cio_write supports up to 4 bytes
*
* @param[in] cio file handler
* @param[in] v byte code
* @param[in] n byte length
* @return really writen byte length
*/
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 int cio_ext_write( opj_cio_t *cio, unsigned long long int v, int n);
#endif
#endif /* !CIO_EXT_H_ */

72
applications/jpip/tools/indexer/event_mgr_handler.c Normal file
View File

@ -0,0 +1,72 @@
/*
* $Id$
*
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2011, Professor Benoit Macq
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <string.h>
#include "event_mgr_handler.h"
void error_callback(const char *msg, void *client_data);
void warning_callback(const char *msg, void *client_data);
void info_callback(const char *msg, void *client_data);
opj_event_mgr_t set_default_event_mgr()
{
opj_event_mgr_t event_mgr;
/* configure the event callbacks (not required) */
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
event_mgr.error_handler = error_callback;
event_mgr.warning_handler = warning_callback;
event_mgr.info_handler = info_callback;
return event_mgr;
}
/**
sample error callback expecting a FILE* client object
*/
void error_callback(const char *msg, void *client_data) {
FILE *stream = (FILE*)client_data;
fprintf(stream, "[ERROR] %s", msg);
}
/**
sample warning callback expecting a FILE* client object
*/
void warning_callback(const char *msg, void *client_data) {
FILE *stream = (FILE*)client_data;
fprintf(stream, "[WARNING] %s", msg);
}
/**
sample debug callback expecting no client object
*/
void info_callback(const char *msg, void *client_data) {
(void)client_data;
// fprintf(stdout, "[INFO] %s", msg);
}

31
applications/jpip/tools/indexer/jp2.h → applications/jpip/tools/indexer/event_mgr_handler.h
View File

@ -1,6 +1,9 @@
/*
* Copyright (c) 2003, Yannick Verschueren
* Copyright (c) 2003, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* $Id$
*
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2011, Professor Benoit Macq
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -24,21 +27,17 @@
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __JP2_H
#define __JP2_H
#include "j2k.h"
#ifndef EVENT_MG_HANDLER_H_
# define EVENT_MG_HANDLER_H_
void jp2_write_url(char *Idx_file);
#include "openjpeg.h"
void jp2_write_dbtl(char *Idx_file);
/*
* Set default event message handler
*
* @return event message handler
*/
opj_event_mgr_t set_default_event_mgr();
void jp2_write_jp2h(j2k_image_t *j2k_img);
void jp2_write_ftyp();
int jp2_write_jp2c(char *J2K_file);
void jp2_write_jp();
#endif
#endif /* !EVENT_MG_HANDLER_H_ */

306
applications/jpip/tools/indexer/idxjp2_manager.c Normal file
View File

@ -0,0 +1,306 @@
/*
* $Id$
*
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2011, Professor Benoit Macq
* Copyright (c) 2001-2003, David Janssens
* Copyright (c) 2002-2003, Yannick Verschueren
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
* Copyright (c) 2005, Herve Drolon, FreeImage Team
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*! \file
* \brief Copy of some jp2.c functions, and modification of jpip.h from 2KAN indexer
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "event_mgr_handler.h"
#include "cio.h"
#include "cio_ext.h"
#include "j2k_to_idxjp2.h"
#include "cidx_manager.h"
#include "indexbox_manager.h"
/*
* Encode JP2 stream with index box
*
* @param[in] jp2 jp2 handle
* @param[in] cio file output handle
* @param[in] j2kstream j2k codestream
* @param[in] j2klen length of j2k codestream
* @param[in] cstr_info codestream information
* @param[in] image image data
* @return true if succeed
*/
opj_bool idxjp2_encode( opj_jp2_t *jp2, opj_cio_t *cio, unsigned char *j2kstream, int j2klen, opj_codestream_info_t cstr_info, opj_image_t *image);
void fwrite_idxjp2( char filename[], unsigned char *j2kstream, int j2klen, opj_image_t *image, opj_codestream_info_t cstr_info)
{
int codestream_length;
opj_cio_t *cio = NULL;
FILE *fp = NULL;
opj_cinfo_t *cinfo;
opj_cparameters_t parameters; /* compression parameters */
opj_event_mgr_t event_mgr;
opj_bool encSuccess;
/* set encoding parameters to default values */
opj_set_default_encoder_parameters(&parameters);
/* get a JP2 compressor handle */
cinfo = opj_create_compress(CODEC_JP2);
event_mgr = set_default_event_mgr();
/* catch events using our callbacks and give a local context */
opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
/* setup the encoder parameters using the current image and using user parameters */
opj_setup_encoder(cinfo, &parameters, image);
/* open a byte stream for writing */
/* allocate memory for all tiles */
cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
encSuccess = idxjp2_encode( (opj_jp2_t*)cinfo->jp2_handle, cio, j2kstream, j2klen, cstr_info, image);
if (!encSuccess){
opj_cio_close(cio);
fprintf(stderr, "failed to encode image\n");
return;
}
codestream_length = cio_tell(cio);
/* write the buffer to disk */
fp = fopen( filename, "wb");
if (!fp) {
fprintf(stderr, "failed to open %s for writing\n", filename);
return;
}
fwrite(cio->buffer, 1, codestream_length, fp);
fclose(fp);
fprintf(stderr,"Generated outfile %s\n", filename);
/* close and free the byte stream */
opj_cio_close(cio);
/* free remaining compression structures */
opj_destroy_compress(cinfo);
opj_destroy_cstr_info(&cstr_info);
}
/*
* Write JP box
* copy from jp2.c
*
* @param[in] cio file output handler
*/
void jp2_write_jp(opj_cio_t *cio);
/*
* Write FTYP box - File type box
* copy from jp2.c
*
* @param[in] jp2 JP2 handle
* @param[in] cio file output handle
*/
void jp2_write_ftyp(opj_jp2_t *jp2, opj_cio_t *cio);
/*
* Write file Index (superbox)
*
* @param[in] offset_jp2c offset of jp2c box
* @param[in] length_jp2c length of jp2c box
* @param[in] offset_idx offset of cidx box
* @param[in] length_idx length of cidx box
* @param[in] cio file output handle
* @return length of fidx box
*/
int write_fidx( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio);
/*
* Write index Finder box
*
* @param[in] offset offset of fidx box
* @param[in] length length of fidx box
* @param[in] cio file output handle
*/
void write_iptr( int offset, int length, opj_cio_t *cio);
opj_bool idxjp2_encode( opj_jp2_t *jp2, opj_cio_t *cio, unsigned char *j2kstream, int j2klen, opj_codestream_info_t cstr_info, opj_image_t *image)
{
int pos_iptr, pos_cidx, pos_jp2c, end_pos, pos_fidx, len_fidx;
int i;
/* JP2 encoding */
/* JPEG 2000 Signature box */
jp2_write_jp(cio);
/* File Type box */
jp2_write_ftyp(jp2, cio);
/* JP2 Header box */
jp2_write_jp2h(jp2, cio);
pos_iptr = cio_tell( cio);
cio_skip( cio, 24); /* IPTR further ! */
pos_jp2c = cio_tell( cio);
cio_write( cio, j2klen+8, 4); // L NOTICE: modify for the extended box
cio_write( cio, JP2_JP2C, 4); // JP2C
for( i=0; i<j2klen; i++)
cio_write( cio, j2kstream[i], 1);
pos_cidx = cio_tell( cio);
write_cidx( pos_jp2c+8, cio, image, cstr_info, j2klen);
pos_fidx = cio_tell( cio);
len_fidx = write_fidx( pos_jp2c, pos_cidx-pos_jp2c, pos_cidx, cio_tell(cio), cio);
end_pos = cio_tell( cio);
cio_seek( cio, pos_iptr);
write_iptr( pos_fidx, len_fidx, cio);
cio_seek( cio, end_pos);
return OPJ_TRUE;
}
void jp2_write_jp( opj_cio_t *cio)
{
opj_jp2_box_t box;
box.init_pos = cio_tell(cio);
cio_skip(cio, 4);
cio_write(cio, JP2_JP, 4); /* JP2 signature */
cio_write(cio, 0x0d0a870a, 4);
box.length = cio_tell(cio) - box.init_pos;
cio_seek(cio, box.init_pos);
cio_write(cio, box.length, 4); /* L */
cio_seek(cio, box.init_pos + box.length);
}
void jp2_write_ftyp(opj_jp2_t *jp2, opj_cio_t *cio)
{
unsigned int i;
opj_jp2_box_t box;
box.init_pos = cio_tell(cio);
cio_skip(cio, 4);
cio_write(cio, JP2_FTYP, 4); /* FTYP */
cio_write(cio, jp2->brand, 4); /* BR */
cio_write(cio, jp2->minversion, 4); /* MinV */
for (i = 0; i < jp2->numcl; i++) {
cio_write(cio, jp2->cl[i], 4); /* CL */
}
box.length = cio_tell(cio) - box.init_pos;
cio_seek(cio, box.init_pos);
cio_write(cio, box.length, 4); /* L */
cio_seek(cio, box.init_pos + box.length);
}
/*
* Write proxy box
*
* @param[in] offset_jp2c offset of jp2c box
* @param[in] length_jp2c length of jp2c box
* @param[in] offset_idx offset of cidx box
* @param[in] length_idx length of cidx box
* @param[in] cio file output handle
*/
void write_prxy( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio);
int write_fidx( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio)
{
int len, lenp;
lenp = cio_tell( cio);
cio_skip( cio, 4); /* L [at the end] */
cio_write( cio, JPIP_FIDX, 4); /* IPTR */
write_prxy( offset_jp2c, length_jp2c, offset_idx, offset_jp2c, cio);
len = cio_tell( cio)-lenp;
cio_seek( cio, lenp);
cio_write( cio, len, 4); /* L */
cio_seek( cio, lenp+len);
return len;
}
void write_prxy( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio)
{
int len, lenp;
lenp = cio_tell( cio);
cio_skip( cio, 4); /* L [at the end] */
cio_write( cio, JPIP_PRXY, 4); /* IPTR */
cio_ext_write( cio, offset_jp2c, 8); /* OOFF */
cio_write( cio, length_jp2c, 4); /* OBH part 1 */
cio_write( cio, JP2_JP2C, 4); /* OBH part 2 */
cio_write( cio, 1,1); /* NI */
cio_ext_write( cio, offset_idx, 8); /* IOFF */
cio_write( cio, length_idx, 4); /* IBH part 1 */
cio_write( cio, JPIP_CIDX, 4); /* IBH part 2 */
len = cio_tell( cio)-lenp;
cio_seek( cio, lenp);
cio_write( cio, len, 4); /* L */
cio_seek( cio, lenp+len);
}
void write_iptr( int offset, int length, opj_cio_t *cio)
{
int len, lenp;
lenp = cio_tell( cio);
cio_skip( cio, 4); /* L [at the end] */
cio_write( cio, JPIP_IPTR, 4); /* IPTR */
cio_ext_write( cio, offset, 8);
cio_ext_write( cio, length, 8);
len = cio_tell( cio)-lenp;
cio_seek( cio, lenp);
cio_write( cio, len, 4); /* L */
cio_seek( cio, lenp+len);
}

1227
applications/jpip/tools/indexer/index_create.c
View File

File diff suppressed because it is too large Load Diff

115
applications/jpip/tools/indexer/indexbox_manager.h Normal file
View File

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

89
applications/jpip/tools/indexer/int.c
View File

@ -1,89 +0,0 @@
/*
* 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
applications/jpip/tools/indexer/int.h
View File

@ -1,41 +0,0 @@
/*
* 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

288
applications/jpip/tools/indexer/j2k.h
View File

@ -1,288 +0,0 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#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 version;
int x0, y0; /* XOsiz, YOsiz */
int x1, y1; /* Xsiz, Ysiz */
int numcomps; /* number of components */
int index_on; /* 0 = no index || 1 = index */
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 first;
int csty; /* coding style */
int prg; /* progression order */
int numlayers; /* number of layers */
int mct; /* multi-component transform identifier */
int rates[100]; /* rates of layers */
int numpocs; /* number of progression order changes */
int POC; /* Precise if a POC marker has been used O:NO, 1:YES */
j2k_poc_t pocs[32]; /* progression order changes */
unsigned char *ppt_data; /* packet header store there for futur use in t2_decode_packet */
int ppt; /* If ppt == 1 --> there was a PPT marker for the present tile */
int ppt_store; /* Use in case of multiple marker PPT (number of info already store) */
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;
unsigned char *ppm_data; /* packet header store there for futur use in t2_decode_packet */
int ppm; /* If ppm == 1 --> there was a PPM marker for the present tile */
int ppm_store; /* Use in case of multiple marker PPM (number of info already store) */
int ppm_previous; /* Use in case of multiple marker PPM (case on non-finished previous info) */
j2k_tcp_t *tcps; /* tile coding parameters */
} j2k_cp_t;
/* Packet information : Layer level */
typedef struct {
int len; /* Length of the body of the packet */
int len_header; /* Length of the header of the packet */
int offset; /* Offset of the body of the packet */
int offset_header; /* Offset of the header of the packet */
} info_layer_t;
/* Access to packet information : precinct level */
typedef struct {
info_layer_t *layer;
} info_prec_t;
/* Access to packet information : resolution level */
typedef struct {
info_prec_t *prec;
} info_reso_t;
/* Access to packet information : component level */
typedef struct {
info_reso_t *reso;
} info_compo_t;
/* Information about the marker */
typedef struct {
int type; /* type of marker [SIZ, QCD, POC, PPM, CRG, COD] appearing only once */
int start_pos; /* Start position of the marker */
int len; /* Length of the marker */
} info_marker_t;
/* Multiple marker in tile header */
typedef struct{
info_marker_t *COC; /* COC markers */
int num_COC; /* Number of COC marker */
int CzCOC; /* Current size of the vector COC */
info_marker_t *RGN; /* RGN markers */
int num_RGN; /* Number of RGN marker */
int CzRGN; /* Current size of the vector RGN */
info_marker_t *QCC; /* QCC markers */
int num_QCC; /* Number of QCC marker */
int CzQCC; /* Current size of the vector QCC */
info_marker_t *PLT; /* PLT markers */
int num_PLT; /* Number of PLT marker */
int CzPLT; /* Current size of the vector PLT */
info_marker_t *PPT; /* PPT markers */
int num_PPT; /* Number of PPT marker */
int CzPPT; /* Current size of the vector PPT */
info_marker_t *COM; /* COM markers */
int num_COM; /* Number of COM marker */
int CzCOM; /* Current size of the vector COC */
} info_marker_mul_tile_t;
/* Information about each tile_part for a particulary tile */
typedef struct{
int start_pos; /* Start position of the tile_part */
int length; /* Length of the tile_part header + body */
int length_header; /* Length of the header */
int end_pos; /* End position of the tile part */
int end_header; /* End position of the tile part header */
int num_reso_AUX; /* Number of resolution level completed */
} info_tile_part_t;
/* Information about each tile */
typedef struct {
int num_tile; /* Number of Tile */
int pw, ph; /* number of precinct by tile */
int num_packet; /* number of packet in the tile */
info_compo_t *compo; /* component [packet] */
info_marker_t *marker; /* information concerning markers inside image [only one apparition] */
info_marker_mul_tile_t marker_mul; /* information concerning markers inside image [multiple apparition] */
int num_marker; /* number of marker */
int numparts; /* number of tile_part for this tile */
info_tile_part_t *tile_parts; /* Information about each tile_part */
int Cztile_parts; /* Current size of the tile_parts vector */
} info_tile_t; /* index struct */
/* Multiple marker in main header */
typedef struct{
info_marker_t *COC; /* COC markers */
int num_COC; /* Number of COC marker */
int CzCOC; /* Current size of the vector COC */
info_marker_t *RGN; /* RGN markers */
int num_RGN; /* Number of RGN marker */
int CzRGN; /* Current size of the vector RGN */
info_marker_t *QCC; /* QCC markers */
int num_QCC; /* Number of QCC marker */
int CzQCC; /* Current size of the vector QCC */
info_marker_t *TLM; /* TLM markers */
int num_TLM; /* Number of TLM marker */
int CzTLM; /* Current size of the vector TLM */
info_marker_t *PLM; /* PLM markers */
int num_PLM; /* Number of PLM marker */
int CzPLM; /* Current size of the vector PLM */
info_marker_t *PPM; /* PPM markers */
int num_PPM; /* Number of PPM marker */
int CzPPM; /* Current size of the vector PPM */
info_marker_t *COM; /* COM markers */
int num_COM; /* Number of COM marker */
int CzCOM; /* Current size of the vector COM */
} info_marker_mul_t; /* index struct */
/* Information about image */
typedef struct {
int Im_w, Im_h; /* Image width and Height */
int Tile_x, Tile_y; /* Number of Tile in X and Y */
int tw, th;
int pw, ph; /* nombre precinct in X and Y */
int pdx, pdy; /* size of precinct in X and Y */
int Prog; /* progression order */
int Comp; /* Component numbers */
int Layer; /* number of layer */
int Decomposition; /* number of decomposition */
int Main_head_end; /* Main header position */
int codestream_size; /* codestream's size */
info_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 */
int num_max_tile_parts; /* Maximum number of tile-part */
info_tile_t *tile; /* information concerning tiles inside image */
} info_image_t; /* index struct */
#endif

157
applications/jpip/tools/indexer/j2k_decoder.c Normal file
View File

@ -0,0 +1,157 @@
/*
* $Id$
*
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2011, Professor Benoit Macq
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include "j2k_to_idxjp2.h"
#include "event_mgr_handler.h"
#include "cio.h"
#include "j2k.h"
/*
* Decode and Add main header marker information
*
* @param[in] cio file input handle
* @param[in,out] cstr_info codestream information
*/
void add_mainheader_marker_info( opj_cio_t *cio, opj_codestream_info_t *cstr_info);
opj_image_t * decode_j2k( unsigned char *j2kstream, int j2klen, opj_codestream_info_t *cstr_info)
{
opj_image_t *image;
opj_dparameters_t parameters; /* decompression parameters */
opj_dinfo_t *dinfo; /* handle to a decompressor */
opj_cio_t *cio;
opj_event_mgr_t event_mgr; /* event manager */
/* set decoding parameters to default values */
opj_set_default_decoder_parameters(&parameters);
/* decode the code-stream */
/* ---------------------- */
/* JPEG-2000 codestream */
/* get a decoder handle */
dinfo = opj_create_decompress( CODEC_J2K);
event_mgr = set_default_event_mgr();
/* catch events using our callbacks and give a local context */
opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, stderr);
/* setup the decoder decoding parameters using user parameters */
opj_setup_decoder(dinfo, &parameters);
/* open a byte stream */
cio = opj_cio_open((opj_common_ptr)dinfo, j2kstream, j2klen);
/* decode the stream and fill the image structure */
image = opj_decode_with_info(dinfo, cio, cstr_info);
if(!image) {
fprintf(stderr, "ERROR -> jp2_to_image: failed to decode image!\n");
opj_destroy_decompress(dinfo);
opj_cio_close(cio);
return NULL;
}
if( cstr_info->marknum == 0)
add_mainheader_marker_info( cio, cstr_info);
/* close the byte stream */
opj_cio_close(cio);
/* free remaining structures */
if(dinfo) {
opj_destroy_decompress(dinfo);
}
return image;
}
/*
* Get main headr marker size
*
* @param[in] type marker type
* @param[in] cstr_info codestream information
* @param[in] cio file input handle
* @return marker size
*/
unsigned short get_mh_markersize( unsigned short type, opj_codestream_info_t cstr_info, opj_cio_t *cio);
void add_mainheader_marker_info( opj_cio_t *cio, opj_codestream_info_t *cstr_info)
{
opj_marker_info_t marker;
int pos;
cstr_info->marker = (opj_marker_info_t *)malloc( 100*sizeof(opj_marker_info_t)); // max 100
pos = cstr_info->main_head_start;
cio_seek( cio, pos);
while( pos <= cstr_info->main_head_end){
marker.type = cio_read( cio, 2);
marker.pos = cio_tell( cio);
marker.len = get_mh_markersize( marker.type, *cstr_info, cio);
cio_skip( cio, marker.len);
cstr_info->marker[ cstr_info->marknum] = marker;
cstr_info->marknum++;
pos = cio_tell( cio);
}
}
unsigned short get_mh_markersize( unsigned short type, opj_codestream_info_t cstr_info, opj_cio_t *cio)
{
unsigned short siz;
int pos;
siz = 0;
switch( type){
case J2K_MS_SOC:
siz = 0;
break;
case J2K_MS_SIZ:
siz = 38+3*cstr_info.numcomps;
break;
case J2K_MS_COD:
case J2K_MS_QCD:
case J2K_MS_COM:
pos = cio_tell( cio);
siz = cio_read( cio, 2);
cio_seek( cio, pos);
break;
default:
fprintf( stderr, "marker %x length not defined yet!\n", type);
}
return siz;
}

108
applications/jpip/tools/indexer/j2k_to_idxjp2.c Normal file
View File

@ -0,0 +1,108 @@
/*
* $Id$
*
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2011, Professor Benoit Macq
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*! \file
* \brief j2k_to_idxjp2 is a program to make jp2 file with index box from j2k file
*
* \section impinst Implementing instructions
* This program takes two arguments. \n
* -# Input J2K image file\n
* -# Output JP2 file name\n
* % ./j2k_to_idxjp2 image.j2k image.jp2\n
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "openjpeg.h"
#include "j2k_to_idxjp2.h"
/*
* Read a binary file
*
* @param[in] filename file name
* @param[out] lenoffile pointer to feed file length
* @return byte code
*/
unsigned char * read_binaryfile( char filename[], int *lenoffile);
int main(int argc, char **argv)
{
opj_image_t *image = NULL;
opj_codestream_info_t cstr_info; /* Codestream information structure */
unsigned char *j2kstream;
int j2klen;
if (argc < 3){
fprintf(stderr,"\nERROR in entry : j2k_to_idxjp2 J2K-file JP2-file\n");
return 1;
}
j2kstream = read_binaryfile( argv[1], &j2klen);
image = decode_j2k( j2kstream, j2klen, &cstr_info);
if( !image){
free(j2kstream);
return -1;
}
fwrite_idxjp2( argv[2], j2kstream, j2klen, image, cstr_info);
free(j2kstream);
/* free image data structure */
opj_image_destroy(image);
return 0;
}
unsigned char * read_binaryfile( char filename[], int *lenoffile)
{
FILE *fp;
unsigned char *bytecode;
fp = fopen( filename, "rb");
if (!fp) {
fprintf(stderr, "Failed to open %s for reading !!\n", filename);
exit (-1);
}
/* length of the codestream */
fseek( fp, 0, SEEK_END);
*lenoffile = ftell(fp);
fseek( fp, 0, SEEK_SET);
bytecode = (unsigned char*)malloc(*lenoffile);
fread( bytecode, *lenoffile, 1, fp);
fclose(fp);
return bytecode;
}

42
applications/jpip/tools/indexer/bio.h → applications/jpip/tools/indexer/j2k_to_idxjp2.h
View File

@ -1,7 +1,9 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* $Id$
*
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2011, Professor Benoit Macq
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -26,13 +28,31 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __BIO_H
#define __BIO_H
#ifndef J2K_TO_IDXJP2_H_
# define J2K_TO_IDXJP2_H_
int bio_numbytes();
void bio_init_dec(unsigned char *bp, int len);
int bio_read(int n);
int bio_flush();
int bio_inalign();
#include "openjpeg.h"
#endif
/*
* Decode j2k codestream
*
* @param[in] j2kstream j2k codestream
* @param[in] j2klen length of j2k codestream
* @param[out] cstr_info codestream information
* @return image data
*/
opj_image_t * decode_j2k( unsigned char *j2kstream, int j2klen, opj_codestream_info_t *cstr_info);
/*
* Write a JP2 file with index box
*
* @param[in] filename file name
* @param[in] j2kstream j2k codestream
* @param[in] j2klen length of j2k codestream
* @param[in] image image data
* @param[in] cstr_info codestream information
*/
void fwrite_idxjp2( char filename[], unsigned char *j2kstream, int j2klen, opj_image_t *image, opj_codestream_info_t cstr_info);
#endif /* !J2K_TO_IDXJP2S_H_ */

301
applications/jpip/tools/indexer/jp2.c
View File

@ -1,301 +0,0 @@
/*
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "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);
}
/*
* Write the JP2H box
*
* JP2 Header box
*
*/
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);
}
/*
* Write the FTYP box
*
* File type box
*
*/
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);
}
/*
* Read the FTYP box
*
* File type box
*
*/
void jp2_read_ftyp(int length)
{
int BR, MinV, type, i;
BR = cio_read(4); /* BR */
MinV = cio_read(4); /* MinV */
length-=8;
for (i=length/4;i>0;i--)
type = cio_read(4); /* CLi : JP2, JPIP */
}
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);
}
/*
* Read the JP box
*
* JPEG 2000 signature
*
* return 1 if error else 0
*/
int jp2_read_jp()
{
if (0x0d0a870a!=cio_read(4))
return 1;
else
return 0;
}

778
applications/jpip/tools/indexer/jpip.c
View File

@ -1,778 +0,0 @@
/*
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <setjmp.h>
#include <math.h>
#include <unistd.h>
#include "j2k.h"
#include "cio.h"
#include "tcd.h"
#include "int.h"
#define JPIP_CIDX 0x63696478 /* Codestream index */
#define JPIP_CPTR 0x63707472 /* Codestream Finder Box */
#define JPIP_MANF 0x6d616e66 /* Manifest Box */
#define JPIP_FAIX 0x66616978 /* Fragment array Index box */
#define JPIP_MHIX 0x6d686978 /* Main Header Index Table */
#define JPIP_TPIX 0x74706978 /* Tile-part Index Table box */
#define JPIP_THIX 0x74686978 /* Tile header Index Table box */
#define JPIP_PPIX 0x70706978 /* Precinct Packet Index Table box */
#define JPIP_PHIX 0x70686978 /* Packet Header index Table */
#define JPIP_FIDX 0x66696478 /* File Index */
#define JPIP_FPTR 0x66707472 /* File Finder */
#define JPIP_PRXY 0x70727879 /* Proxy boxes */
#define JPIP_IPTR 0x69707472 /* Index finder box */
#define JPIP_PHLD 0x70686c64 /* Place holder */
#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;
/*
* Write the CPTR box
*
* Codestream finder box (box)
*
*/
void jpip_write_cptr(int offset, info_image_t img)
{
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);
}
/*
* Read the CPTR box
*
* Codestream finder box (box)
*
*/
void jpip_read_cptr()
{
int DR, CONT;
long long Coff, codestream_size;
DR = cio_read(2); /* DR */
CONT = cio_read(2); /* CONT */
Coff = cio_read(8); /* COFF */
codestream_size = cio_read(8); /* CLEN */
}
/*
* Write the MANF box
*
* Manifest box (box)
*
*/
void jpip_write_manf(int second, int v, info_marker_t *marker)
{
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); /* Marker length */
cio_write(marker[i].type,4); /* Marker type */
}
}
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); /* L */
cio_seek(lenp+len);
}
/*
* Read the MANF box
*
* Manifest box (box)
*
*/
void jpip_read_manf(int len)
{
int i, v, marker_len, marker_type;
v = (len - 8)/ 8;
for(i=0;i<v;i++)
{
marker_len = cio_read(4); /* Marker length */
marker_type = cio_read(4); /* Marker type */
}
}
/*
* Write the MHIX box
*
* Main Header Index Table (box)
*
*/
int jpip_write_mhix(info_image_t img, int status, int tileno)
{
int len, lenp, i;
info_tile_t *tile;
lenp=cio_tell();
cio_skip(4); /* L [at the end] */
cio_write(JPIP_MHIX, 4); /* MHIX */
if (status==0) /* MAIN HEADER */
{
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_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_PPM - 1; i >= 0; i--) /* PPM */
{
cio_write(img.marker_mul.PPM[i].type, 2);
cio_write(i, 2);
cio_write(img.marker_mul.PPM[i].start_pos, 8);
cio_write(img.marker_mul.PPM[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);
}
}
else /* TILE HEADER */
{
tile = &img.tile[tileno];
cio_write(tile->tile_parts[0].length_header, 8); /* TLEN */
for(i = 0; i < tile->num_marker; i++) /* Marker restricted to 1 apparition */
{
cio_write(tile->marker[i].type, 2);
cio_write(0, 2);
cio_write(tile->marker[i].start_pos, 8);
cio_write(tile->marker[i].len, 2);
}
/* Marker NOT restricted to 1 apparition */
for(i = tile->marker_mul.num_COC - 1; i >= 0; i--) /* COC */
{
cio_write(tile->marker_mul.COC[i].type, 2);
cio_write(i, 2);
cio_write(tile->marker_mul.COC[i].start_pos, 8);
cio_write(tile->marker_mul.COC[i].len, 2);
}
for(i = tile->marker_mul.num_RGN - 1; i >= 0; i--) /* RGN */
{
cio_write(tile->marker_mul.RGN[i].type, 2);
cio_write(i, 2);
cio_write(tile->marker_mul.RGN[i].start_pos, 8);
cio_write(tile->marker_mul.RGN[i].len, 2);
}
for(i = tile->marker_mul.num_QCC - 1; i >= 0; i--) /* QCC */
{
cio_write(tile->marker_mul.QCC[i].type, 2);
cio_write(i, 2);
cio_write(tile->marker_mul.QCC[i].start_pos, 8);
cio_write(tile->marker_mul.QCC[i].len, 2);
}
for(i = tile->marker_mul.num_PLT - 1; i >= 0; i--) /* PLT */
{
cio_write(tile->marker_mul.PLT[i].type,2);
cio_write(i,2);
cio_write(tile->marker_mul.PLT[i].start_pos,8);
cio_write(tile->marker_mul.PLT[i].len,2);
}
for(i = tile->marker_mul.num_PPT - 1; i >= 0; i--) /* PPT */
{
cio_write(tile->marker_mul.PPT[i].type, 2);
cio_write(i, 2);
cio_write(tile->marker_mul.PPT[i].start_pos, 8);
cio_write(tile->marker_mul.PPT[i].len, 2);
}
for(i = tile->marker_mul.num_COM - 1; i >= 0; i--) /* COM */
{
cio_write(tile->marker_mul.COM[i].type, 2);
cio_write(i, 2);
cio_write(tile->marker_mul.COM[i].start_pos, 8);
cio_write(tile->marker_mul.COM[i].len, 2);
}
}
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); /* L */
cio_seek(lenp+len);
return len;
}
/*
* Read the MHIX box
*
* Main Header Index Table (box)
*
*/
void jpip_read_mhix(int len)
{
int i, v, marker_type, marker_start_pos, marker_len, marker_remains;
v = (len - 8) / 14;
for (i=0; i<v ; i++)
{
marker_type = cio_read(2); /* Type of the marker */
marker_remains = cio_read(2); /* Number of same markers following */
marker_start_pos = cio_read(2); /* Start position of the marker */
marker_len = cio_read(2); /* Length of the marker */
}
}
/*
* Write the FAIX box
*
* Fragment array Index box (box)
*
*/
int jpip_write_faix(int v, int compno, info_image_t img, j2k_cp_t *j2k_cp, int version)
{
int len, lenp, i, j;
int Aux;
int tileno, resno, precno, layno, num_packet=0;
lenp=cio_tell();
cio_skip(4); /* L [at the end] */
cio_write(JPIP_FAIX, 4); /* FAIX */
cio_write(version,1); /* Version 0 = 4 bytes */
switch(v)
{
case 0: /* TPIX */
cio_write(img.num_max_tile_parts,(version & 0x01)?8:4); /* NMAX */
cio_write(img.tw*img.th,(version & 0x01)?8:4); /* M */
for (i = 0; i < img.tw*img.th; i++)
{
for (j = 0; j < img.tile[i].numparts ; j++)
{
cio_write(img.tile[i].tile_parts[j].start_pos,(version & 0x01)?8:4); /* start position */
cio_write(img.tile[i].tile_parts[j].length,(version & 0x01)?8:4); /* length */
if (version & 0x02)
{
if (img.tile[i].numparts == 1 && img.Decomposition > 1)
Aux = img.Decomposition + 1;
else
Aux = j + 1;
cio_write(Aux,4);
//cio_write(img.tile[i].tile_parts[j].num_reso_AUX,4); /* Aux_i,j : Auxiliary value */
// fprintf(stderr,"AUX value %d\n",Aux);
}
//cio_write(0,4);
}
/* PADDING */
while (j < img.num_max_tile_parts)
{
cio_write(0,(version & 0x01)?8:4); /* start position */
cio_write(0,(version & 0x01)?8:4); /* length */
if (version & 0x02)
cio_write(0,4); /* Aux_i,j : Auxiliary value */
j++;
}
}
break;
/* case 1: */ /* THIX */
/* cio_write(1,(version & 0x01)?8:4); */ /* NMAX */
/* cio_write(img.tw*img.th,(version & 0x01)?8:4); */ /* M */
/* for (i=0;i<img.tw*img.th;i++) */
/* { */
/* cio_write(img.tile[i].start_pos,(version & 0x01)?8:4); */ /* start position */
/* cio_write(img.tile[i].end_header-img.tile[i].start_pos,(version & 0x01)?8:4); */ /* length */
/* if (version & 0x02)*/
/* cio_write(0,4); */ /* Aux_i,j : Auxiliary value */
/* } */
/* break; */
case 2: /* PPIX NOT FINISHED !! */
cio_write(img.num_packet_max,(version & 0x01)?8:4); /* NMAX */
cio_write(img.tw*img.th,(version & 0x01)?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;
num_packet=0;
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 & 0x01)?8:4); /* start position */
cio_write((layer_Idx->len_header-correction)?0:layer_Idx->len,(version & 0x01)?8:4); /* length */
if (version & 0x02)
cio_write(0,4); /* Aux_i,j : Auxiliary value */
num_packet++;
}
}
}
/* PADDING */
while (num_packet < img.num_packet_max)
{
cio_write(0,(version & 0x01)?8:4); /* start position */
cio_write(0,(version & 0x01)?8:4); /* length */
if (version & 0x02)
cio_write(0,4); /* Aux_i,j : Auxiliary value */
num_packet++;
}
}
break;
case 3: /* PHIX NOT FINISHED !! */
cio_write(img.num_packet_max,(version & 0x01)?8:4); /* NMAX */
cio_write(img.tw*img.th,(version & 0x01)?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;
num_packet = 0;
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_header,(version & 0x01)?8:4); /* start position */
cio_write((layer_Idx->len_header-correction)?0:layer_Idx->len_header,(version & 0x01)?8:4); /* length */
if (version & 0x02)
cio_write(0,4); /* Aux_i,j : Auxiliary value */
num_packet++;
}
}
}
/* PADDING */
while (num_packet<img.num_packet_max)
{
cio_write(0,(version & 0x01)?8:4); /* start position */
cio_write(0,(version & 0x01)?8:4); /* length */
if (version & 0x02)
cio_write(0,4); /* Aux_i,j : Auxiliary value */
num_packet++;
}
}
break;
}
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); /* L */
cio_seek(lenp+len);
return len;
}
/*
* Write the TPIX box
*
* Tile-part Index table box (superbox)
*
*/
int jpip_write_tpix(info_image_t img, j2k_cp_t *j2k_cp, int version)
{
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, version);
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); /* L */
cio_seek(lenp+len);
return len;
}
/*
* Write the THIX box
*
* Tile header Index table box (superbox)
*
*/
//int jpip_write_thix(info_image_t img, j2k_cp_t *j2k_cp)
// {
// 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_thix(info_image_t img, j2k_cp_t *j2k_cp)
{
int len, lenp, i;
int tileno;
info_marker_t *marker;
int num_marker_local_jpip;
marker = (info_marker_t*)calloc(sizeof(info_marker_t), j2k_cp->tw*j2k_cp->th);
for ( i = 0; i < 2 ; i++ )
{
if (i) cio_seek(lenp);
lenp = cio_tell();
cio_skip(4); /* L [at the end] */
cio_write(JPIP_THIX, 4); /* THIX */
jpip_write_manf(i, j2k_cp->tw*j2k_cp->th, marker);
num_marker_local_jpip=img.Comp;
for (tileno = 0; tileno < j2k_cp->tw*j2k_cp->th; tileno++)
{
marker[tileno].len = jpip_write_mhix(img, 1, tileno);
marker[tileno].type = JPIP_MHIX;
}
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); /* L */
cio_seek(lenp+len);
}
free(marker);
return len;
}
/*
* Write the PPIX box
*
* Precinct Packet Index table box (superbox)
*
*/
int jpip_write_ppix(info_image_t img,j2k_cp_t *j2k_cp)
{
int len, lenp, compno, i;
info_marker_t *marker;
int num_marker_local_jpip;
marker = (info_marker_t*)calloc(sizeof(info_marker_t), img.Comp);
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);
num_marker_local_jpip=img.Comp;
for (compno=0; compno<img.Comp; compno++)
{
marker[compno].len=jpip_write_faix(2,compno,img, j2k_cp, 0);
marker[compno].type=JPIP_FAIX;
}
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); /* L */
cio_seek(lenp+len);
}
free(marker);
return len;
}
/*
* Write the PHIX box
*
* Packet Header Index table box (superbox)
*
*/
int jpip_write_phix(info_image_t img, j2k_cp_t *j2k_cp)
{
int len, lenp=0, compno, i;
info_marker_t *marker;
marker = (info_marker_t*)calloc(sizeof(info_marker_t), img.Comp);
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);
for (compno=0; compno<img.Comp; compno++)
{
marker[compno].len=jpip_write_faix(3,compno,img, j2k_cp, 0);
marker[compno].type=JPIP_FAIX;
}
len=cio_tell()-lenp;
cio_seek(lenp);
cio_write(len, 4); /* L */
cio_seek(lenp+len);
}
free(marker);
return len;
}
/*
* Write the CIDX box
*
* Codestream Index box (superbox)
*
*/
int jpip_write_cidx(int offset, info_image_t img, j2k_cp_t *j2k_cp, int version)
{
int len, lenp = 0, i;
info_marker_t *marker_jpip;
int num_marker_jpip = 0;
marker_jpip = (info_marker_t*)calloc(sizeof(info_marker_t), 32);
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);
num_marker_jpip=0;
marker_jpip[num_marker_jpip].len=jpip_write_mhix(img, 0, 0);
marker_jpip[num_marker_jpip].type=JPIP_MHIX;
num_marker_jpip++;
marker_jpip[num_marker_jpip].len=jpip_write_tpix(img, j2k_cp, version);
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);
}
free(marker_jpip);
return len;
}
/*
* Write the IPTR box
*
* Index Finder box
*
*/
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);
}
/*
* Write the PRXY box
*
* proxy (box)
*
*/
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);
}
/*
* Write the FIDX box
*
* File Index (superbox)
*
*/
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;
}

142
applications/jpip/tools/indexer/phix_manager.c Normal file
View File

@ -0,0 +1,142 @@
/*
* $Id$
*
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2011, Professor Benoit Macq
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*! \file
* \brief Modification of jpip.c from 2KAN indexer
*/
#include <stdlib.h>
#include <math.h>
#include "indexbox_manager.h"
#include "cio_ext.h"
#include "cio.h"
/*
* Write faix box of phix
*
* @param[in] compno component number
* @param[in] cstr_info codestream information
* @param[in] EPHused true if if EPH option used
* @param[in] j2klen length of j2k codestream
* @param[in] cio file output handle
* @return length of faix box
*/
int write_phixfaix( int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio);
int write_phix( opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
{
int len, lenp=0, compno, i;
opj_jp2_box_t *box;
box = (opj_jp2_box_t *)calloc( cstr_info.numcomps, sizeof(opj_jp2_box_t));
for( i=0;i<2;i++){
if (i) cio_seek( cio, lenp);
lenp = cio_tell( cio);
cio_skip( cio, 4); /* L [at the end] */
cio_write( cio, JPIP_PHIX, 4); /* PHIX */
write_manf( i, cstr_info.numcomps, box, cio);
for( compno=0; compno<cstr_info.numcomps; compno++){
box[compno].length = write_phixfaix( compno, cstr_info, EPHused, j2klen, cio);
box[compno].type = JPIP_FAIX;
}
len = cio_tell( cio)-lenp;
cio_seek( cio, lenp);
cio_write( cio, len, 4); /* L */
cio_seek( cio, lenp+len);
}
free(box);
return len;
}
int write_phixfaix( int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
{
int len, lenp;
int size_of_coding; // 4 or 8
int version;
int tileno, resno, precno, layno, num_packet=0;
if( j2klen > pow( 2, 32)){
size_of_coding = 8;
version = 1;
}
else{
size_of_coding = 4;
version = 0;
}
lenp = cio_tell( cio);
cio_skip( cio, 4); /* L [at the end] */
cio_write( cio, JPIP_FAIX, 4); /* FAIX */
cio_write( cio, version,1); /* Version 0 = 4 bytes */
cio_ext_write( cio, cstr_info.packno, size_of_coding); /* NMAX */
cio_ext_write( cio, cstr_info.tw*cstr_info.th, size_of_coding); /* M */
for( tileno=0; tileno<cstr_info.tw*cstr_info.th; tileno++){
opj_tile_info_t *tile_Idx = &cstr_info.tile[ tileno];
// int correction = EPHused ? 3 : 1;
num_packet = 0;
for( resno=0; resno<cstr_info.numdecompos[compno]+1; resno++){
for( precno=0; precno<tile_Idx->pw[resno]*tile_Idx->ph[resno]; precno++){
for( layno=0; layno<cstr_info.numlayers; layno++){
opj_packet_info_t packet = tile_Idx->packet[num_packet];
cio_ext_write( cio, packet.start_pos, size_of_coding); /* start position */
cio_ext_write( cio, packet.end_ph_pos-packet.start_pos+1, size_of_coding); /* length */
num_packet++;
}
}
}
/* PADDING */
while( num_packet < cstr_info.packno){
cio_ext_write( cio, 0, size_of_coding); /* start position */
cio_ext_write( cio, 0, size_of_coding); /* length */
num_packet++;
}
}
len = cio_tell( cio)-lenp;
cio_seek( cio, lenp);
cio_write( cio, len, 4); /* L */
cio_seek( cio, lenp+len);
return len;
}

465
applications/jpip/tools/indexer/pi.c
View File

@ -1,465 +0,0 @@
/*
* Copyright (c) 2001-2002, David Janssens
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "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;
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;
}
}
tccp = &tcp->tccps[0];
pi[pino].step_p=1;
pi[pino].step_c=100*pi[pino].step_p;
pi[pino].step_r=img->numcomps*pi[pino].step_c;
pi[pino].step_l=maxres*pi[pino].step_r;
if (pino==0)
pi[pino].include=(short int*)calloc(img->numcomps*maxres*tcp->numlayers*100,sizeof(short int));
else
pi[pino].include=pi[pino-1].include;
/*if (pino == tcp->numpocs) {*/
if (tcp->POC == 0) {
pi[pino].first = 1;
pi[pino].poc.resno0 = 0;
pi[pino].poc.compno0 = 0;
pi[pino].poc.layno1 = tcp->numlayers;
pi[pino].poc.resno1 = maxres;
pi[pino].poc.compno1 = 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->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p]){
pi->include[pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p] = 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->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p]){
pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p] = 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->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p]){
pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p] = 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->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p]){
pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p] = 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->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p]){
pi->include[pi->layno*pi->step_l+pi->resno*pi->step_r+pi->compno*pi->step_c+pi->precno*pi->step_p] = 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;
}

72
applications/jpip/tools/indexer/pi.h
View File

@ -1,72 +0,0 @@
/*
* 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 {
short int *include;
int step_l, step_r, step_c, step_p;
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

147
applications/jpip/tools/indexer/ppix_manager.c Normal file
View File

@ -0,0 +1,147 @@
/*
* $Id$
*
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2011, Professor Benoit Macq
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*! \file
* \brief Modification of jpip.c from 2KAN indexer
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "indexbox_manager.h"
#include "cio_ext.h"
#include "cio.h"
/*
* Write faix box of ppix
*
* @param[in] compno component number
* @param[in] cstr_info codestream information
* @param[in] EPHused true if if EPH option used
* @param[in] j2klen length of j2k codestream
* @param[in] cio file output handle
* @return length of faix box
*/
int write_ppixfaix( int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio);
int write_ppix( opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
{
int len, lenp, compno, i;
opj_jp2_box_t *box;
printf("cstr_info.packno %d\n", cstr_info.packno); //NMAX?
box = (opj_jp2_box_t *)calloc( cstr_info.numcomps, sizeof(opj_jp2_box_t));
for (i=0;i<2;i++){
if (i) cio_seek( cio, lenp);
lenp = cio_tell( cio);
cio_skip( cio, 4); /* L [at the end] */
cio_write( cio, JPIP_PPIX, 4); /* PPIX */
write_manf( i, cstr_info.numcomps, box, cio);
for (compno=0; compno<cstr_info.numcomps; compno++){
box[compno].length = write_ppixfaix( compno, cstr_info, EPHused, j2klen, cio);
box[compno].type = JPIP_FAIX;
}
len = cio_tell( cio)-lenp;
cio_seek( cio, lenp);
cio_write( cio, len, 4); /* L */
cio_seek( cio, lenp+len);
}
free(box);
return len;
}
// NMAX might be wrong , phix too, do sth to correction
int write_ppixfaix( int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
{
int len, lenp;
int tileno, resno, precno, layno, num_packet=0;
int size_of_coding; // 4 or 8
int version;
if( j2klen > pow( 2, 32)){
size_of_coding = 8;
version = 1;
}
else{
size_of_coding = 4;
version = 0;
}
lenp = cio_tell( cio);
cio_skip( cio, 4); /* L [at the end] */
cio_write( cio, JPIP_FAIX, 4); /* FAIX */
cio_write( cio, version, 1); /* Version 0 = 4 bytes */
cio_ext_write( cio, cstr_info.packno, size_of_coding); /* NMAX */
cio_ext_write( cio, cstr_info.tw*cstr_info.th, size_of_coding); /* M */
for( tileno=0; tileno<cstr_info.tw*cstr_info.th; tileno++){
opj_tile_info_t *tile_Idx = &cstr_info.tile[ tileno];
// int correction = EPHused ? 3 : 1;
num_packet=0;
for( resno=0; resno< cstr_info.numdecompos[compno]+1; resno++){
for( precno=0; precno<tile_Idx->pw[resno]*tile_Idx->ph[resno]; precno++){
for( layno=0; layno<cstr_info.numlayers; layno++){
opj_packet_info_t packet = tile_Idx->packet[num_packet];
cio_ext_write( cio, packet.start_pos, size_of_coding); /* start position */
cio_ext_write( cio, packet.end_pos-packet.start_pos+1, size_of_coding); /* length */
num_packet++;
}
}
}
/* PADDING */
while( num_packet < cstr_info.packno){
cio_ext_write( cio, 0, size_of_coding); /* start position */
cio_ext_write( cio, 0, size_of_coding); /* length */
num_packet++;
}
}
len = cio_tell( cio)-lenp;
cio_seek( cio, lenp);
cio_write( cio, len, 4); /* L */
cio_seek( cio, lenp+len);
return len;
}

389
applications/jpip/tools/indexer/t2.c
View File

@ -1,389 +0,0 @@
/*
* 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_cp_t * cp, 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;
}
}
}
/* INDEX */
layer_Idx->len_header = 0;
/* When the marker PPT/PPM is used the packet header are store in PPT/PPM marker
This part deal with this caracteristic
step 1: Read packet header in the saved structure
step 2: (futher) return to codestream for decoding */
if (cp->ppm == 1) /* PPM */
{
c = cp->ppm_data;
d = c;
bio_init_dec(c, 1000);
} else
{
if (tcp->ppt == 1) /* PPT */
{
c = tcp->ppt_data;
d = c;
bio_init_dec(c, 1000);
} else /* Normal Case */
{
if (tcp->csty & J2K_CP_CSTY_SOP)
{
if ((*c) != 255 || (*(c+1) != 145)) {printf("Error : expected SOP marker [1]!!!\n");}
c += 6;
}
bio_init_dec(c, src + len - c);
layer_Idx->len_header = -6;
}
}
present = bio_read(1);
if (!present)
{
bio_inalign();
/* Normal case */
c += bio_numbytes();
if (tcp->csty & J2K_CP_CSTY_EPH)
{
if ((*c) != 255 || (*(c+1) != 146)) {printf("Error : expected EPH marker [1]!!!\n");}
c += 2;
}
/* INDEX */
layer_Idx->len_header += (c-d);
/* PPT and PPM dealing */
if (cp->ppm == 1) /* PPM */
{
cp->ppm_data = c;
return 0;
}
if (tcp->ppt == 1) /* PPT */
{
tcp->ppt_data = c;
return 0;
}
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) { /* EPH marker */
if ((*c) != 255 || (*(c+1) != 146)) {printf("Error : expected EPH marker [2]!!!\n"); }
c += 2;
}
/* INDEX */
layer_Idx->len_header += (c-d);
/* PPT Step 2 : see above for details */
if (cp->ppm == 1)
{
cp->ppm_data = c; /* Update pointer */
/* INDEX */
layer_Idx->len_header = c-d;
c = src;
d = c;
if (tcp->csty & J2K_CP_CSTY_SOP)
{
if ((*c) != 255 || (*(c+1) != 145)) {printf("Error : expected SOP marker [2] !!!\n"); }
c += 6;
}
bio_init_dec(c, src + len - c);
} else
{
if (tcp->ppt == 1)
{
tcp->ppt_data = c; /* Update pointer */
/* INDEX */
layer_Idx->len_header = c-d;
c = src;
d = c;
if (tcp->csty & J2K_CP_CSTY_SOP) /* SOP marker */
{
if ((*c) != 255 || (*(c+1) != 145)) {printf("Error : expected SOP marker [2] !!!\n"); }
c += 6;
}
bio_init_dec(c, src + len - c);
}
}
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;
}
void t2_init_info_packets(info_image_t *img, j2k_cp_t *cp)
{
int compno, tileno, resno, precno, layno;
for(compno = 0; compno < img->Comp; compno++)
{
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];
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];
layer_Idx->offset = 0; /* start position */
layer_Idx->len_header = 0; /* length */
}
}
}
}
}
}
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 partno;
info_tile_part_t *tile_part;
int position;
int length_read;
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;
t2_init_info_packets(imgg, cp); /* Initialize the packets information : LEN and OFFSET to 0 */
tile_Idx = &imgg->tile[tileno];
tile_Idx->num_packet = 0;
pi = pi_create(img, cp, tileno);
partno = 0;
tile_part = &tile_Idx->tile_parts[partno];
position = tile_part->end_header + 1;
length_read = 0;
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;
layer_Idx->offset_header = position;
e = t2_decode_packet(c, src+len-c, tile, cp, &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;
/* Update position in case of multiple tile-parts for a tile >> */
length_read += e;
if (length_read >= (tile_part->end_pos - tile_part->end_header))
{
partno++;
tile_part = &tile_Idx->tile_parts[partno];
position = tile_part->end_header + 1;
length_read = 0;
}
/* << end_update */
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[0].include);
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;
}
}

285
applications/jpip/tools/indexer/tcd.c
View File

@ -1,285 +0,0 @@
/*
* 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;
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;
tile = &tcd_image.tiles[tileno];
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
applications/jpip/tools/indexer/tcd.h
View File

@ -1,137 +0,0 @@
/*
* 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
applications/jpip/tools/indexer/tgt.c
View File

@ -1,170 +0,0 @@
/*
* 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
applications/jpip/tools/indexer/tgt.h
View File

@ -1,80 +0,0 @@
/*
* 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

208
applications/jpip/tools/indexer/thix_manager.c Normal file
View File

@ -0,0 +1,208 @@
/*
* $Id$
*
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
* Copyright (c) 2002-2011, Professor Benoit Macq
* Copyright (c) 2003-2004, Yannick Verschueren
* Copyright (c) 2010-2011, Kaori Hagihara
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*! \file
* \brief Modification of jpip.c from 2KAN indexer
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "indexbox_manager.h"
#include "cio_ext.h"
#include "cio.h"
/*
* Write tile-part headers mhix box
*
* @param[in] coff offset of j2k codestream
* @param[in] cstr_info codestream information
* @param[in] tileno tile number
* @param[in] cio file output handle
* @return length of mhix box
*/
int write_tilemhix( int coff, opj_codestream_info_t cstr_info, int tileno, opj_cio_t *cio);
int write_thix( int coff, opj_codestream_info_t cstr_info, opj_cio_t *cio)
{
int len, lenp, i;
int tileno;
opj_jp2_box_t *box;
lenp = 0;
box = (opj_jp2_box_t *)calloc( cstr_info.tw*cstr_info.th, sizeof(opj_jp2_box_t));
for ( i = 0; i < 2 ; i++ ){
if (i)
cio_seek( cio, lenp);
lenp = cio_tell( cio);
cio_skip( cio, 4); /* L [at the end] */
cio_write( cio, JPIP_THIX, 4); /* THIX */
write_manf( i, cstr_info.tw*cstr_info.th, box, cio);
for (tileno = 0; tileno < cstr_info.tw*cstr_info.th; tileno++){
box[tileno].length = write_tilemhix( coff, cstr_info, tileno, cio);
box[tileno].type = JPIP_MHIX;
}
len = cio_tell( cio)-lenp;
cio_seek( cio, lenp);
cio_write( cio, len, 4); /* L */
cio_seek( cio, lenp+len);
}
free(box);
return len;
}
/*
* Find tile markers
*
* @param[in] coff offset of j2k codestream
* @param[in] startpos tile start byte position
* @param[in] endpos tile end position
* @param[in] cio file output handle
* @param[out] marknum pointer to number of markers
* @return found marker information array
*/
opj_marker_info_t * find_tile_markers( int coff, int startpos, int endpos, opj_cio_t *cio, int *marknum);
int write_tilemhix( int coff, opj_codestream_info_t cstr_info, int tileno, opj_cio_t *cio)
{
int i;
opj_tile_info_t tile;
opj_tp_info_t tp;
int marknum;
int len, lenp;
opj_marker_info_t *marker;
lenp = cio_tell( cio);
cio_skip( cio, 4); /* L [at the end] */
cio_write( cio, JPIP_MHIX, 4); /* MHIX */
tile = cstr_info.tile[tileno];
tp = tile.tp[0];
cio_ext_write( cio, tp.tp_end_header-tp.tp_start_pos+1, 8); /* TLEN */
marker = find_tile_markers( coff, tile.start_pos, tile.end_header, cio, &marknum);
for( i=0; i<marknum; i++){ /* Marker restricted to 1 apparition */
cio_write( cio, marker[i].type, 2);
cio_write( cio, 0, 2);
cio_ext_write( cio, marker[i].pos, 8);
cio_write( cio, marker[i].len, 2);
}
free( marker);
len = cio_tell( cio) - lenp;
cio_seek( cio, lenp);
cio_write( cio, len, 4); /* L */
cio_seek( cio, lenp+len);
return len;
}
/*
* Get tile marker size
*
* @param[in] type marker type
* @param[in] cio file input handle
* @return marker size
*/
unsigned short get_tile_markersize( unsigned short type, opj_cio_t *cio);
opj_marker_info_t * find_tile_markers( int coff, int startpos, int endpos, opj_cio_t *cio, int *marknum)
{
int org_pos, pos;
opj_marker_info_t *marker, *tmp;
int max_num_of_markers = 100;
marker = (opj_marker_info_t *)malloc( max_num_of_markers*sizeof(opj_marker_info_t));
if( !marker){
fprintf( stderr, "malloc error for marker in find_tile_markers()\n");
exit(-1);
}
(*marknum) = 0;
org_pos = cio_tell( cio);
cio_seek( cio, coff+startpos);
pos = startpos;
while( pos < coff+endpos){
if( *marknum >= max_num_of_markers){
tmp = marker;
marker = (opj_marker_info_t *)malloc( (max_num_of_markers+100)*sizeof(opj_marker_info_t));
memcpy( marker, tmp, max_num_of_markers*sizeof(opj_marker_info_t));
free( tmp);
max_num_of_markers += 100;
}
marker[*marknum].type = cio_read( cio, 2);
marker[*marknum].pos = cio_tell( cio)-coff;
marker[*marknum].len = get_tile_markersize( marker[*marknum].type, cio);
cio_skip( cio, marker[*marknum].len);
(*marknum)++;
pos += 2+marker[*marknum].len;
}
cio_seek( cio, org_pos);
return marker;
}
unsigned short get_tile_markersize( unsigned short type, opj_cio_t *cio)
{
unsigned short siz;
int pos;
siz = 0;
switch( type){
case J2K_MS_SOD:
case J2K_MS_EOC:
case J2K_MS_EPH:
siz = 0;
break;
default:
pos = cio_tell( cio);
siz = cio_read( cio, 2);
cio_seek( cio, pos);
break;
}
return siz;
}

154
applications/jpip/tools/indexer/tpix_manager.c Normal file
View File

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

2
configure.ac
View File

@ -26,7 +26,7 @@ AC_CONFIG_HEADERS([opj_config.h])
AC_CANONICAL_SYSTEM
AC_CANONICAL_HOST
AM_INIT_AUTOMAKE(1[.11 foreign dist-bzip2])
AM_INIT_AUTOMAKE([1.11 foreign dist-bzip2])
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
MAJOR_NR=OPJ_MAJOR