diff --git a/libopenjpeg/jpwl/README.txt b/libopenjpeg/jpwl/README.txt index 66e9d5b1..e289e9e4 100644 --- a/libopenjpeg/jpwl/README.txt +++ b/libopenjpeg/jpwl/README.txt @@ -1,136 +1,136 @@ =============================================================================== JPEG2000 Part 11 (ISO/IEC 15444-11 JPWL) Software - - + + Version 20061213 =============================================================================== - - - -1. Scope -============= - -This document describes the installation and use of the JPWL module in the framework of OpenJPEG library. - -This implementation has been developed from OpenJPEG implementation of JPEG2000 standard, and for this reason it is written in C language. - + + + +1. Scope +============= + +This document describes the installation and use of the JPWL module in the framework of OpenJPEG library. + +This implementation has been developed from OpenJPEG implementation of JPEG2000 standard, and for this reason it is written in C language. + If you find some bugs or if you have problems using the encoder/decoder, please send an e-mail to jpwl@diei.unipg.it - - -2. Installing the code -========================== - -The JPWL code is integrated with the standard OpenJPEG library and codecs: it is activated by setting the macro USE_JPWL to defined in the preprocessor configuration options of your preferred C compiler. - -2.1. Compiling the source code in Windows -------------------------------------------- - -The "jpwl" directory is already populated with a couple of Visual C++ 6.0 workspaces - - * JPWL_image_to_j2k.dsw - Creates the encoder with JPWL functionalities - * JPWL_j2k_to_image.dsw - Creates the decoder with JPWL functionalities - -2.2. Compiling the source code in Unix-like systems ------------------------------------------------------ - -Under linux, enter the jpwl directory and type "make clean" and "make". - - -3. Running the JPWL software -========================= - -The options available at the command line are exactly the same of the base OpenJPEG codecs. In addition, there is a "-W" switch that activates JPWL functionalities. - -3.1. JPWL Encoder -------------------- - --W : adoption of JPWL (Part 11) capabilities (-W params) - The parameters can be written and repeated in any order: - [h<=type>,s<=method>,a=,z=,g=,... - ...,p<=type>] - - h selects the header error protection (EPB): 'type' can be - [0=none 1,absent=predefined 16=CRC-16 32=CRC-32 37-128=RS] - if 'tile' is absent, it applies to main and tile headers - if 'tile' is present, it applies from that tile - onwards, up to the next h spec, or to the last tile - in the codestream (max. 16 specs) - - p selects the packet error protection (EEP/UEP with EPBs) - to be applied to raw data: 'type' can be - [0=none 1,absent=predefined 16=CRC-16 32=CRC-32 37-128=RS] - if 'tile:pack' is absent, it starts from tile 0, packet 0 - if 'tile:pack' is present, it applies from that tile - and that packet onwards, up to the next packet spec - or to the last packet in the last tile in the codestream - (max. 16 specs) - - s enables sensitivity data insertion (ESD): 'method' can be - [-1=NO ESD 0=RELATIVE ERROR 1=MSE 2=MSE REDUCTION 3=PSNR - 4=PSNR INCREMENT 5=MAXERR 6=TSE 7=RESERVED] - if 'tile' is absent, it applies to main header only - if 'tile' is present, it applies from that tile - onwards, up to the next s spec, or to the last tile - in the codestream (max. 16 specs) - - g determines the addressing mode: can be - [0=PACKET 1=BYTE RANGE 2=PACKET RANGE] - - a determines the size of data addressing: can be - 2/4 bytes (small/large codestreams). If not set, auto-mode - - z determines the size of sensitivity values: can be - 1/2 bytes, for the transformed pseudo-floating point value - - ex.: - h,h0=64,h3=16,h5=32,p0=78,p0:24=56,p1,p3:0=0,p3:20=32,s=0,s0=6,s3=-1,a=0,g=1,z=1 - means - predefined EPB in MH, rs(64,32) from TPH 0 to TPH 2, - CRC-16 in TPH 3 and TPH 4, CRC-32 in remaining TPHs, - UEP rs(78,32) for packets 0 to 23 of tile 0, - UEP rs(56,32) for packets 24 to the last of tile 0, - UEP rs default for packets of tile 1, - no UEP for packets 0 to 19 of tile 3, - UEP CRC-32 for packets 20 of tile 3 to last tile, - relative sensitivity ESD for MH, - TSE ESD from TPH 0 to TPH 2, byte range with automatic - size of addresses and 1 byte for each sensitivity value - - ex.: - h,s,p - means - default protection to headers (MH and TPHs) as well as - data packets, one ESD in MH - - N.B.: use the following recommendations when specifying - the JPWL parameters list - - when you use UEP, always pair the 'p' option with 'h' - -3.2. JPWL Decoder -------------------- - - -W - Activates the JPWL correction capability, if the codestream complies. - Options can be a comma separated list of tokens: - c, c=numcomps - numcomps is the number of expected components in the codestream - (search of first EPB rely upon this, default is 3) - - -4. Known bugs and limitations -=============================== - -4.1. Bugs ------------ - -* It is not possible to save a JPWL encoded codestream using the wrapped file format (i.e. JP2): only raw file format (i.e. J2K) is working - -4.2. Limitations ------------------- - -* When specifying an UEP protection, you need to activate even TPH protection for those tiles where there is a protection of the packets -* RED insertion is not currently implemented at the decoder -* JPWL at entropy coding level is not implemented + + +2. Installing the code +========================== + +The JPWL code is integrated with the standard OpenJPEG library and codecs: it is activated by setting the macro USE_JPWL to defined in the preprocessor configuration options of your preferred C compiler. + +2.1. Compiling the source code in Windows +------------------------------------------- + +The "jpwl" directory is already populated with a couple of Visual C++ 6.0 workspaces + + * JPWL_image_to_j2k.dsw - Creates the encoder with JPWL functionalities + * JPWL_j2k_to_image.dsw - Creates the decoder with JPWL functionalities + +2.2. Compiling the source code in Unix-like systems +----------------------------------------------------- + +Under linux, enter the jpwl directory and type "make clean" and "make". + + +3. Running the JPWL software +========================= + +The options available at the command line are exactly the same of the base OpenJPEG codecs. In addition, there is a "-W" switch that activates JPWL functionalities. + +3.1. JPWL Encoder +------------------- + +-W : adoption of JPWL (Part 11) capabilities (-W params) + The parameters can be written and repeated in any order: + [h<=type>,s<=method>,a=,z=,g=,... + ...,p<=type>] + + h selects the header error protection (EPB): 'type' can be + [0=none 1,absent=predefined 16=CRC-16 32=CRC-32 37-128=RS] + if 'tile' is absent, it applies to main and tile headers + if 'tile' is present, it applies from that tile + onwards, up to the next h spec, or to the last tile + in the codestream (max. 16 specs) + + p selects the packet error protection (EEP/UEP with EPBs) + to be applied to raw data: 'type' can be + [0=none 1,absent=predefined 16=CRC-16 32=CRC-32 37-128=RS] + if 'tile:pack' is absent, it starts from tile 0, packet 0 + if 'tile:pack' is present, it applies from that tile + and that packet onwards, up to the next packet spec + or to the last packet in the last tile in the codestream + (max. 16 specs) + + s enables sensitivity data insertion (ESD): 'method' can be + [-1=NO ESD 0=RELATIVE ERROR 1=MSE 2=MSE REDUCTION 3=PSNR + 4=PSNR INCREMENT 5=MAXERR 6=TSE 7=RESERVED] + if 'tile' is absent, it applies to main header only + if 'tile' is present, it applies from that tile + onwards, up to the next s spec, or to the last tile + in the codestream (max. 16 specs) + + g determines the addressing mode: can be + [0=PACKET 1=BYTE RANGE 2=PACKET RANGE] + + a determines the size of data addressing: can be + 2/4 bytes (small/large codestreams). If not set, auto-mode + + z determines the size of sensitivity values: can be + 1/2 bytes, for the transformed pseudo-floating point value + + ex.: + h,h0=64,h3=16,h5=32,p0=78,p0:24=56,p1,p3:0=0,p3:20=32,s=0,s0=6,s3=-1,a=0,g=1,z=1 + means + predefined EPB in MH, rs(64,32) from TPH 0 to TPH 2, + CRC-16 in TPH 3 and TPH 4, CRC-32 in remaining TPHs, + UEP rs(78,32) for packets 0 to 23 of tile 0, + UEP rs(56,32) for packets 24 to the last of tile 0, + UEP rs default for packets of tile 1, + no UEP for packets 0 to 19 of tile 3, + UEP CRC-32 for packets 20 of tile 3 to last tile, + relative sensitivity ESD for MH, + TSE ESD from TPH 0 to TPH 2, byte range with automatic + size of addresses and 1 byte for each sensitivity value + + ex.: + h,s,p + means + default protection to headers (MH and TPHs) as well as + data packets, one ESD in MH + + N.B.: use the following recommendations when specifying + the JPWL parameters list + - when you use UEP, always pair the 'p' option with 'h' + +3.2. JPWL Decoder +------------------- + + -W + Activates the JPWL correction capability, if the codestream complies. + Options can be a comma separated list of tokens: + c, c=numcomps + numcomps is the number of expected components in the codestream + (search of first EPB rely upon this, default is 3) + + +4. Known bugs and limitations +=============================== + +4.1. Bugs +----------- + +* It is not possible to save a JPWL encoded codestream using the wrapped file format (i.e. JP2): only raw file format (i.e. J2K) is working + +4.2. Limitations +------------------ + +* When specifying an UEP protection, you need to activate even TPH protection for those tiles where there is a protection of the packets +* RED insertion is not currently implemented at the decoder +* JPWL at entropy coding level is not implemented diff --git a/libopenjpeg/jpwl/crc.c b/libopenjpeg/jpwl/crc.c index f65e4e1e..9cc57d7b 100644 --- a/libopenjpeg/jpwl/crc.c +++ b/libopenjpeg/jpwl/crc.c @@ -1,160 +1,160 @@ -/* - * Copyright (c) 2001-2003, David Janssens - * Copyright (c) 2002-2003, Yannick Verschueren - * Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe - * Copyright (c) 2005, Herve Drolon, FreeImage Team - * Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium - * Copyright (c) 2005-2006, Dept. of Electronic and Information Engineering, Universita' degli Studi di Perugia, Italy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#ifdef USE_JPWL - -#include "crc.h" - -/** -@file crc.c -@brief Functions used to compute the 16- and 32-bit CRC of byte arrays - -*/ - -/** file: CRC16.CPP - * - * CRC - Cyclic Redundancy Check (16-bit) - * - * A CRC-checksum is used to be sure, the data hasn't changed or is false. - * To create a CRC-checksum, initialise a check-variable (unsigned short), - * and set this to zero. Than call for every byte in the file (e.g.) the - * procedure updateCRC16 with this check-variable as the first parameter, - * and the byte as the second. At the end, the check-variable contains the - * CRC-checksum. - * - * implemented by Michael Neumann, 14.06.1998 - * - */ -const unsigned short CRC16_table[256] = { - 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, - 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef, - 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, - 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de, - 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485, - 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d, - 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4, - 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc, - 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823, - 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b, - 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, - 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a, - 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41, - 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49, - 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70, - 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78, - 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f, - 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067, - 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e, - 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256, - 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d, - 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, - 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c, - 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634, - 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab, - 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3, - 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, - 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92, - 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, - 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1, - 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, - 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0 -}; - -void updateCRC16(unsigned short *crc, unsigned char data) { - *crc = CRC16_table[(*crc >> 8) & 0xFF] ^ (*crc << 8) ^ data; -}; - - -/** file: CRC32.CPP - * - * CRC - Cyclic Redundancy Check (32-bit) - * - * A CRC-checksum is used to be sure, the data hasn't changed or is false. - * To create a CRC-checksum, initialise a check-variable (unsigned long), - * and set this to zero. Than call for every byte in the file (e.g.) the - * procedure updateCRC32 with this check-variable as the first parameter, - * and the byte as the second. At the end, the check-variable contains the - * CRC-checksum. - * - * implemented by Michael Neumann, 14.06.1998 - * - */ -const unsigned long CRC32_table[256] = { - 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, - 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, - 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, - 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, - 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, - 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, - 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, - 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, - 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, - 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, - 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, - 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, - 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, - 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, - 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, - 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, - 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, - 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, - 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, - 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, - 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, - 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, - 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, - 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, - 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, - 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, - 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, - 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, - 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, - 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, - 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, - 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, - 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, - 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, - 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, - 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, - 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, - 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, - 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, - 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, - 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, - 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, - 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d -}; - -void updateCRC32(unsigned long *crc, unsigned char data) { - *crc = CRC32_table[(unsigned char) *crc ^ data] ^ ((*crc >> 8) & 0x00FFFFFF); -}; - -#endif /* USE_JPWL */ +/* + * Copyright (c) 2001-2003, David Janssens + * Copyright (c) 2002-2003, Yannick Verschueren + * Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe + * Copyright (c) 2005, Herve Drolon, FreeImage Team + * Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium + * Copyright (c) 2005-2006, Dept. of Electronic and Information Engineering, Universita' degli Studi di Perugia, Italy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifdef USE_JPWL + +#include "crc.h" + +/** +@file crc.c +@brief Functions used to compute the 16- and 32-bit CRC of byte arrays + +*/ + +/** file: CRC16.CPP + * + * CRC - Cyclic Redundancy Check (16-bit) + * + * A CRC-checksum is used to be sure, the data hasn't changed or is false. + * To create a CRC-checksum, initialise a check-variable (unsigned short), + * and set this to zero. Than call for every byte in the file (e.g.) the + * procedure updateCRC16 with this check-variable as the first parameter, + * and the byte as the second. At the end, the check-variable contains the + * CRC-checksum. + * + * implemented by Michael Neumann, 14.06.1998 + * + */ +const unsigned short CRC16_table[256] = { + 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, + 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef, + 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, + 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de, + 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485, + 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d, + 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4, + 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc, + 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823, + 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b, + 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, + 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a, + 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41, + 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49, + 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70, + 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78, + 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f, + 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067, + 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e, + 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256, + 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d, + 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, + 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c, + 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634, + 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab, + 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3, + 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, + 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92, + 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, + 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1, + 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, + 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0 +}; + +void updateCRC16(unsigned short *crc, unsigned char data) { + *crc = CRC16_table[(*crc >> 8) & 0xFF] ^ (*crc << 8) ^ data; +}; + + +/** file: CRC32.CPP + * + * CRC - Cyclic Redundancy Check (32-bit) + * + * A CRC-checksum is used to be sure, the data hasn't changed or is false. + * To create a CRC-checksum, initialise a check-variable (unsigned long), + * and set this to zero. Than call for every byte in the file (e.g.) the + * procedure updateCRC32 with this check-variable as the first parameter, + * and the byte as the second. At the end, the check-variable contains the + * CRC-checksum. + * + * implemented by Michael Neumann, 14.06.1998 + * + */ +const unsigned long CRC32_table[256] = { + 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, + 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, + 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, + 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, + 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, + 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, + 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, + 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, + 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, + 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, + 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, + 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, + 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, + 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, + 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, + 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, + 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, + 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, + 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, + 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, + 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, + 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, + 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, + 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, + 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, + 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, + 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, + 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, + 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, + 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, + 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, + 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, + 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, + 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, + 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, + 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, + 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, + 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, + 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, + 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, + 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, + 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, + 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d +}; + +void updateCRC32(unsigned long *crc, unsigned char data) { + *crc = CRC32_table[(unsigned char) *crc ^ data] ^ ((*crc >> 8) & 0x00FFFFFF); +}; + +#endif /* USE_JPWL */ diff --git a/libopenjpeg/jpwl/jpwl.c b/libopenjpeg/jpwl/jpwl.c index 461b28a9..e379278f 100644 --- a/libopenjpeg/jpwl/jpwl.c +++ b/libopenjpeg/jpwl/jpwl.c @@ -1,1364 +1,1364 @@ -/* - * Copyright (c) 2001-2003, David Janssens - * Copyright (c) 2002-2003, Yannick Verschueren - * Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe - * Copyright (c) 2005, Herve Drolon, FreeImage Team - * Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium - * Copyright (c) 2005-2006, Dept. of Electronic and Information Engineering, Universita' degli Studi di Perugia, Italy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -#include "opj_includes.h" - -#ifdef USE_JPWL - -/** @defgroup JPWL JPWL - JPEG-2000 Part11 (JPWL) codestream manager */ -/*@{*/ - -/** @name Local static variables */ -/*@{*/ - -/** number of JPWL prepared markers */ -static int jwmarker_num; -/** properties of JPWL markers to insert */ -static jpwl_marker_t jwmarker[JPWL_MAX_NO_MARKERS]; - -/*@}*/ - -/*@}*/ - -/** @name Local static functions */ -/*@{*/ - -/** create an EPC marker segment -@param j2k J2K compressor handle -@param esd_on true if ESD is activated -@param red_on true if RED is activated -@param epb_on true if EPB is activated -@param info_on true if informative techniques are activated -@return returns the freshly created EPC -*/ -jpwl_epc_ms_t *jpwl_epc_create(opj_j2k_t *j2k, opj_bool esd_on, opj_bool red_on, opj_bool epb_on, opj_bool info_on); - -/*@}*/ - -/** create an EPC marker segment -@param j2k J2K compressor handle -@param comps considered component (-1=average, 0/1/2/...=component no.) -@param addrm addressing mode (0=packet, 1=byte range, 2=packet range, 3=reserved) -@param ad_size size of addresses (2/4 bytes) -@param senst sensitivity type -@param se_size sensitivity values size (1/2 bytes) -@param tileno tile where this ESD lies (-1 means MH) -@param svalnum number of sensitivity values (if 0, they will be automatically filled) -@param sensval pointer to an array of sensitivity values (if NULL, they will be automatically filled) -@return returns the freshly created ESD -*/ -jpwl_esd_ms_t *jpwl_esd_create(opj_j2k_t *j2k, int comps, - unsigned char addrm, unsigned char ad_size, - unsigned char senst, int se_size, int tileno, - unsigned long int svalnum, void *sensval); - -/** this function is used to compare two JPWL markers based on -their relevant wishlist position -@param arg1 pointer to first marker -@param arg2 pointer to second marker -@return 1 if arg1>arg2, 0 if arg1=arg2, -1 if arg1pos_correction = 0; - -} - -void j2k_add_marker(opj_codestream_info_t *cstr_info, unsigned short int type, int pos, int len) { - - if (!cstr_info) - return; - - /* expand the list? */ - if ((cstr_info->marknum + 1) > cstr_info->maxmarknum) { - cstr_info->maxmarknum += 100; - cstr_info->marker = (opj_marker_info_t*)opj_realloc(cstr_info->marker, cstr_info->maxmarknum * sizeof(opj_marker_info_t)); - } - - /* add the marker */ - cstr_info->marker[cstr_info->marknum].type = type; - cstr_info->marker[cstr_info->marknum].pos = pos; - cstr_info->marker[cstr_info->marknum].len = len; - cstr_info->marknum++; - -} - -void jpwl_prepare_marks(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image) { - - unsigned short int socsiz_len = 0; - int ciopos = cio_tell(cio), soc_pos = j2k->cstr_info->main_head_start; - unsigned char *socp = NULL; - - int tileno, acc_tpno, tpno, tilespec, hprot, sens, pprot, packspec, lastileno, packno; - - jpwl_epb_ms_t *epb_mark; - jpwl_epc_ms_t *epc_mark; - jpwl_esd_ms_t *esd_mark; - (void)image; - - /* find (SOC + SIZ) length */ - /* I assume SIZ is always the first marker after SOC */ - cio_seek(cio, soc_pos + 4); - socsiz_len = (unsigned short int) cio_read(cio, 2) + 4; /* add the 2 marks length itself */ - cio_seek(cio, soc_pos + 0); - socp = cio_getbp(cio); /* pointer to SOC */ - - /* - EPC MS for Main Header: if we are here it's required - */ - /* create the EPC */ - if ((epc_mark = jpwl_epc_create( - j2k, - j2k->cp->esd_on, /* is ESD present? */ - j2k->cp->red_on, /* is RED present? */ - j2k->cp->epb_on, /* is EPB present? */ - OPJ_FALSE /* are informative techniques present? */ - ))) { - - /* Add this marker to the 'insertanda' list */ - if (epc_mark) { - jwmarker[jwmarker_num].id = J2K_MS_EPC; /* its type */ - jwmarker[jwmarker_num].m.epcmark = epc_mark; /* the EPC */ - jwmarker[jwmarker_num].pos = soc_pos + socsiz_len; /* after SIZ */ - jwmarker[jwmarker_num].dpos = (double) jwmarker[jwmarker_num].pos + 0.1; /* not so first */ - jwmarker[jwmarker_num].len = epc_mark->Lepc; /* its length */ - jwmarker[jwmarker_num].len_ready = OPJ_TRUE; /* ready */ - jwmarker[jwmarker_num].pos_ready = OPJ_TRUE; /* ready */ - jwmarker[jwmarker_num].parms_ready = OPJ_FALSE; /* not ready */ - jwmarker[jwmarker_num].data_ready = OPJ_TRUE; /* ready */ - jwmarker_num++; - }; - - opj_event_msg(j2k->cinfo, EVT_INFO, - "MH EPC : setting %s%s%s\n", - j2k->cp->esd_on ? "ESD, " : "", - j2k->cp->red_on ? "RED, " : "", - j2k->cp->epb_on ? "EPB, " : "" - ); - - } else { - /* ooops, problems */ - opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not create MH EPC\n"); - }; - - /* - ESD MS for Main Header - */ - /* first of all, must MH have an ESD MS? */ - if (j2k->cp->esd_on && (j2k->cp->sens_MH >= 0)) { - - /* Create the ESD */ - if ((esd_mark = jpwl_esd_create( - j2k, /* this encoder handle */ - -1, /* we are averaging over all components */ - (unsigned char) j2k->cp->sens_range, /* range method */ - (unsigned char) j2k->cp->sens_addr, /* sensitivity addressing */ - (unsigned char) j2k->cp->sens_MH, /* sensitivity method */ - j2k->cp->sens_size, /* sensitivity size */ - -1, /* this ESD is in main header */ - 0 /*j2k->cstr_info->num*/, /* number of packets in codestream */ - NULL /*sensval*/ /* pointer to sensitivity data of packets */ - ))) { - - /* Add this marker to the 'insertanda' list */ - if (jwmarker_num < JPWL_MAX_NO_MARKERS) { - jwmarker[jwmarker_num].id = J2K_MS_ESD; /* its type */ - jwmarker[jwmarker_num].m.esdmark = esd_mark; /* the EPB */ - jwmarker[jwmarker_num].pos = soc_pos + socsiz_len; /* we choose to place it after SIZ */ - jwmarker[jwmarker_num].dpos = (double) jwmarker[jwmarker_num].pos + 0.2; /* not first at all! */ - jwmarker[jwmarker_num].len = esd_mark->Lesd; /* its length */ - jwmarker[jwmarker_num].len_ready = OPJ_TRUE; /* not ready, yet */ - jwmarker[jwmarker_num].pos_ready = OPJ_TRUE; /* ready */ - jwmarker[jwmarker_num].parms_ready = OPJ_TRUE; /* not ready */ - jwmarker[jwmarker_num].data_ready = OPJ_FALSE; /* not ready */ - jwmarker_num++; - } - - opj_event_msg(j2k->cinfo, EVT_INFO, - "MH ESDs: method %d\n", - j2k->cp->sens_MH - ); - - } else { - /* ooops, problems */ - opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not create MH ESD\n"); - }; - - } - - /* - ESD MSs for Tile Part Headers - */ - /* cycle through tiles */ - sens = -1; /* default spec: no ESD */ - tilespec = 0; /* first tile spec */ - acc_tpno = 0; - for (tileno = 0; tileno < j2k->cstr_info->tw * j2k->cstr_info->th; tileno++) { - - opj_event_msg(j2k->cinfo, EVT_INFO, - "Tile %d has %d tile part(s)\n", - tileno, j2k->cstr_info->tile[tileno].num_tps - ); - - /* for every tile part in the tile */ - for (tpno = 0; tpno < j2k->cstr_info->tile[tileno].num_tps; tpno++, acc_tpno++) { - - int sot_len, Psot, Psotp, mm; - unsigned long sot_pos, post_sod_pos; - - unsigned long int left_THmarks_len; - - /******* sot_pos = j2k->cstr_info->tile[tileno].start_pos; */ - sot_pos = j2k->cstr_info->tile[tileno].tp[tpno].tp_start_pos; - cio_seek(cio, sot_pos + 2); - sot_len = cio_read(cio, 2); /* SOT Len */ - cio_skip(cio, 2); - Psotp = cio_tell(cio); - Psot = cio_read(cio, 4); /* tile length */ - - /******* post_sod_pos = j2k->cstr_info->tile[tileno].end_header + 1; */ - post_sod_pos = j2k->cstr_info->tile[tileno].tp[tpno].tp_end_header + 1; - left_THmarks_len = post_sod_pos - sot_pos; - - /* add all the lengths of the markers which are len-ready and stay within SOT and SOD */ - for (mm = 0; mm < jwmarker_num; mm++) { - if ((jwmarker[mm].pos >= sot_pos) && (jwmarker[mm].pos < post_sod_pos)) { - if (jwmarker[mm].len_ready) - left_THmarks_len += jwmarker[mm].len + 2; - else { - opj_event_msg(j2k->cinfo, EVT_ERROR, "MS %x in %f is not len-ready: could not set up TH EPB\n", - jwmarker[mm].id, jwmarker[mm].dpos); - exit(1); - } - } - } - - /******* if ((tilespec < JPWL_MAX_NO_TILESPECS) && (j2k->cp->sens_TPH_tileno[tilespec] == tileno)) */ - if ((tilespec < JPWL_MAX_NO_TILESPECS) && (j2k->cp->sens_TPH_tileno[tilespec] == acc_tpno)) - /* we got a specification from this tile onwards */ - sens = j2k->cp->sens_TPH[tilespec++]; - - /* must this TPH have an ESD MS? */ - if (j2k->cp->esd_on && (sens >= 0)) { - - /* Create the ESD */ - if ((esd_mark = jpwl_esd_create( - j2k, /* this encoder handle */ - -1, /* we are averaging over all components */ - (unsigned char) j2k->cp->sens_range, /* range method */ - (unsigned char) j2k->cp->sens_addr, /* sensitivity addressing size */ - (unsigned char) sens, /* sensitivity method */ - j2k->cp->sens_size, /* sensitivity value size */ - tileno, /* this ESD is in a tile */ - 0, /* number of packets in codestream */ - NULL /* pointer to sensitivity data of packets */ - ))) { - - /* Add this marker to the 'insertanda' list */ - if (jwmarker_num < JPWL_MAX_NO_MARKERS) { - jwmarker[jwmarker_num].id = J2K_MS_ESD; /* its type */ - jwmarker[jwmarker_num].m.esdmark = esd_mark; /* the EPB */ - /****** jwmarker[jwmarker_num].pos = j2k->cstr_info->tile[tileno].start_pos + sot_len + 2; */ /* after SOT */ - jwmarker[jwmarker_num].pos = j2k->cstr_info->tile[tileno].tp[tpno].tp_start_pos + sot_len + 2; /* after SOT */ - jwmarker[jwmarker_num].dpos = (double) jwmarker[jwmarker_num].pos + 0.2; /* not first at all! */ - jwmarker[jwmarker_num].len = esd_mark->Lesd; /* its length */ - jwmarker[jwmarker_num].len_ready = OPJ_TRUE; /* ready, yet */ - jwmarker[jwmarker_num].pos_ready = OPJ_TRUE; /* ready */ - jwmarker[jwmarker_num].parms_ready = OPJ_TRUE; /* not ready */ - jwmarker[jwmarker_num].data_ready = OPJ_FALSE; /* ready */ - jwmarker_num++; - } - - /* update Psot of the tile */ - cio_seek(cio, Psotp); - cio_write(cio, Psot + esd_mark->Lesd + 2, 4); - - opj_event_msg(j2k->cinfo, EVT_INFO, - /******* "TPH ESDs: tile %02d, method %d\n", */ - "TPH ESDs: tile %02d, part %02d, method %d\n", - /******* tileno, */ - tileno, tpno, - sens - ); - - } else { - /* ooops, problems */ - /***** opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not create TPH ESD #%d\n", tileno); */ - opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not create TPH ESD #%d,%d\n", tileno, tpno); - }; - - } - - } - - }; - - /* - EPB MS for Main Header - */ - /* first of all, must MH have an EPB MS? */ - if (j2k->cp->epb_on && (j2k->cp->hprot_MH > 0)) { - - int mm; - - /* position of SOT */ - unsigned int sot_pos = j2k->cstr_info->main_head_end + 1; - - /* how much space is there between end of SIZ and beginning of SOT? */ - int left_MHmarks_len = sot_pos - socsiz_len; - - /* add all the lengths of the markers which are len-ready and stay within SOC and SOT */ - for (mm = 0; mm < jwmarker_num; mm++) { - if ( jwmarker[mm].pos < sot_pos) { /* jwmarker[mm].pos >=0 since ulong */ - if (jwmarker[mm].len_ready) - left_MHmarks_len += jwmarker[mm].len + 2; - else { - opj_event_msg(j2k->cinfo, EVT_ERROR, "MS %x in %f is not len-ready: could not set up MH EPB\n", - jwmarker[mm].id, jwmarker[mm].dpos); - exit(1); - } - } - } - - /* Create the EPB */ - if ((epb_mark = jpwl_epb_create( - j2k, /* this encoder handle */ - OPJ_TRUE, /* is it the latest? */ - OPJ_TRUE, /* is it packed? not for now */ - -1, /* we are in main header */ - 0, /* its index is 0 (first) */ - j2k->cp->hprot_MH, /* protection type parameters of data */ - socsiz_len, /* pre-data: only SOC+SIZ */ - left_MHmarks_len /* post-data: from SOC to SOT, and all JPWL markers within */ - ))) { - - /* Add this marker to the 'insertanda' list */ - if (jwmarker_num < JPWL_MAX_NO_MARKERS) { - jwmarker[jwmarker_num].id = J2K_MS_EPB; /* its type */ - jwmarker[jwmarker_num].m.epbmark = epb_mark; /* the EPB */ - jwmarker[jwmarker_num].pos = soc_pos + socsiz_len; /* after SIZ */ - jwmarker[jwmarker_num].dpos = (double) jwmarker[jwmarker_num].pos; /* first first first! */ - jwmarker[jwmarker_num].len = epb_mark->Lepb; /* its length */ - jwmarker[jwmarker_num].len_ready = OPJ_TRUE; /* ready */ - jwmarker[jwmarker_num].pos_ready = OPJ_TRUE; /* ready */ - jwmarker[jwmarker_num].parms_ready = OPJ_TRUE; /* ready */ - jwmarker[jwmarker_num].data_ready = OPJ_FALSE; /* not ready */ - jwmarker_num++; - } - - opj_event_msg(j2k->cinfo, EVT_INFO, - "MH EPB : prot. %d\n", - j2k->cp->hprot_MH - ); - - } else { - /* ooops, problems */ - opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not create MH EPB\n"); - }; - } - - /* - EPB MSs for Tile Parts - */ - /* cycle through TPHs */ - hprot = j2k->cp->hprot_MH; /* default spec */ - tilespec = 0; /* first tile spec */ - lastileno = 0; - packspec = 0; - pprot = -1; - acc_tpno = 0; - for (tileno = 0; tileno < j2k->cstr_info->tw * j2k->cstr_info->th; tileno++) { - - opj_event_msg(j2k->cinfo, EVT_INFO, - "Tile %d has %d tile part(s)\n", - tileno, j2k->cstr_info->tile[tileno].num_tps - ); - - /* for every tile part in the tile */ - for (tpno = 0; tpno < j2k->cstr_info->tile[tileno].num_tps; tpno++, acc_tpno++) { - - int sot_len, Psot, Psotp, mm, epb_index = 0, prot_len = 0; - unsigned long sot_pos, post_sod_pos; - unsigned long int left_THmarks_len/*, epbs_len = 0*/; - int startpack = 0, stoppack = j2k->cstr_info->packno; - int first_tp_pack, last_tp_pack; - jpwl_epb_ms_t *tph_epb = NULL; - - /****** sot_pos = j2k->cstr_info->tile[tileno].start_pos; */ - sot_pos = j2k->cstr_info->tile[tileno].tp[tpno].tp_start_pos; - cio_seek(cio, sot_pos + 2); - sot_len = cio_read(cio, 2); /* SOT Len */ - cio_skip(cio, 2); - Psotp = cio_tell(cio); - Psot = cio_read(cio, 4); /* tile length */ - - /* a-priori length of the data dwelling between SOT and SOD */ - /****** post_sod_pos = j2k->cstr_info->tile[tileno].end_header + 1; */ - post_sod_pos = j2k->cstr_info->tile[tileno].tp[tpno].tp_end_header + 1; - left_THmarks_len = post_sod_pos - (sot_pos + sot_len + 2); - - /* add all the lengths of the JPWL markers which are len-ready and stay within SOT and SOD */ - for (mm = 0; mm < jwmarker_num; mm++) { - if ((jwmarker[mm].pos >= sot_pos) && (jwmarker[mm].pos < post_sod_pos)) { - if (jwmarker[mm].len_ready) - left_THmarks_len += jwmarker[mm].len + 2; - else { - opj_event_msg(j2k->cinfo, EVT_ERROR, "MS %x in %f is not len-ready: could not set up TH EPB\n", - jwmarker[mm].id, jwmarker[mm].dpos); - exit(1); - } - } - } - - /****** if ((tilespec < JPWL_MAX_NO_TILESPECS) && (j2k->cp->hprot_TPH_tileno[tilespec] == tileno)) */ - if ((tilespec < JPWL_MAX_NO_TILESPECS) && (j2k->cp->hprot_TPH_tileno[tilespec] == acc_tpno)) - /* we got a specification from this tile part onwards */ - hprot = j2k->cp->hprot_TPH[tilespec++]; - - /* must this TPH have an EPB MS? */ - if (j2k->cp->epb_on && (hprot > 0)) { - - /* Create the EPB */ - if ((epb_mark = jpwl_epb_create( - j2k, /* this encoder handle */ - OPJ_FALSE, /* is it the latest? in TPH, no for now (if huge data size in TPH, we'd need more) */ - OPJ_TRUE, /* is it packed? yes for now */ - tileno, /* we are in TPH */ - epb_index++, /* its index is 0 (first) */ - hprot, /* protection type parameters of following data */ - sot_len + 2, /* pre-data length: only SOT */ - left_THmarks_len /* post-data length: from SOT end to SOD inclusive */ - ))) { - - /* Add this marker to the 'insertanda' list */ - if (jwmarker_num < JPWL_MAX_NO_MARKERS) { - jwmarker[jwmarker_num].id = J2K_MS_EPB; /* its type */ - jwmarker[jwmarker_num].m.epbmark = epb_mark; /* the EPB */ - /****** jwmarker[jwmarker_num].pos = j2k->cstr_info->tile[tileno].start_pos + sot_len + 2; */ /* after SOT */ - jwmarker[jwmarker_num].pos = j2k->cstr_info->tile[tileno].tp[tpno].tp_start_pos + sot_len + 2; /* after SOT */ - jwmarker[jwmarker_num].dpos = (double) jwmarker[jwmarker_num].pos; /* first first first! */ - jwmarker[jwmarker_num].len = epb_mark->Lepb; /* its length */ - jwmarker[jwmarker_num].len_ready = OPJ_TRUE; /* ready */ - jwmarker[jwmarker_num].pos_ready = OPJ_TRUE; /* ready */ - jwmarker[jwmarker_num].parms_ready = OPJ_TRUE; /* ready */ - jwmarker[jwmarker_num].data_ready = OPJ_FALSE; /* not ready */ - jwmarker_num++; - } - - /* update Psot of the tile */ - Psot += epb_mark->Lepb + 2; - - opj_event_msg(j2k->cinfo, EVT_INFO, - /***** "TPH EPB : tile %02d, prot. %d\n", */ - "TPH EPB : tile %02d, part %02d, prot. %d\n", - /***** tileno, */ - tileno, tpno, - hprot - ); - - /* save this TPH EPB address */ - tph_epb = epb_mark; - - } else { - /* ooops, problems */ - /****** opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not create TPH EPB #%d\n", tileno); */ - opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not create TPH EPB in #%d,d\n", tileno, tpno); - }; - - } - - startpack = 0; - /* EPB MSs for UEP packet data protection in Tile Parts */ - /****** for (packno = 0; packno < j2k->cstr_info->num; packno++) { */ - /*first_tp_pack = (tpno > 0) ? (first_tp_pack + j2k->cstr_info->tile[tileno].tp[tpno - 1].tp_numpacks) : 0;*/ - first_tp_pack = j2k->cstr_info->tile[tileno].tp[tpno].tp_start_pack; - last_tp_pack = first_tp_pack + j2k->cstr_info->tile[tileno].tp[tpno].tp_numpacks - 1; - for (packno = 0; packno < j2k->cstr_info->tile[tileno].tp[tpno].tp_numpacks; packno++) { - - /******** if ((packspec < JPWL_MAX_NO_PACKSPECS) && - (j2k->cp->pprot_tileno[packspec] == tileno) && (j2k->cp->pprot_packno[packspec] == packno)) { */ - if ((packspec < JPWL_MAX_NO_PACKSPECS) && - (j2k->cp->pprot_tileno[packspec] == acc_tpno) && (j2k->cp->pprot_packno[packspec] == packno)) { - - /* we got a specification from this tile and packet onwards */ - /* print the previous spec */ - if (packno > 0) { - stoppack = packno - 1; - opj_event_msg(j2k->cinfo, EVT_INFO, - /***** "UEP EPBs: tile %02d, packs. %02d-%02d (B %d-%d), prot. %d\n", */ - "UEP EPBs: tile %02d, part %02d, packs. %02d-%02d (B %d-%d), prot. %d\n", - /***** tileno, */ - tileno, tpno, - startpack, - stoppack, - /***** j2k->cstr_info->tile[tileno].packet[startpack].start_pos, */ - j2k->cstr_info->tile[tileno].packet[first_tp_pack + startpack].start_pos, - /***** j2k->cstr_info->tile[tileno].packet[stoppack].end_pos, */ - j2k->cstr_info->tile[tileno].packet[first_tp_pack + stoppack].end_pos, - pprot); - - /***** prot_len = j2k->cstr_info->tile[tileno].packet[stoppack].end_pos + 1 - - j2k->cstr_info->tile[tileno].packet[startpack].start_pos; */ - prot_len = j2k->cstr_info->tile[tileno].packet[first_tp_pack + stoppack].end_pos + 1 - - j2k->cstr_info->tile[tileno].packet[first_tp_pack + startpack].start_pos; - - /* - particular case: if this is the last header and the last packet, - then it is better to protect even the EOC marker - */ - /****** if ((tileno == ((j2k->cstr_info->tw * j2k->cstr_info->th) - 1)) && - (stoppack == (j2k->cstr_info->num - 1))) */ - if ((tileno == ((j2k->cstr_info->tw * j2k->cstr_info->th) - 1)) && - (tpno == (j2k->cstr_info->tile[tileno].num_tps - 1)) && - (stoppack == last_tp_pack)) - /* add the EOC len */ - prot_len += 2; - - /* let's add the EPBs */ - Psot += jpwl_epbs_add( - j2k, /* J2K handle */ - jwmarker, /* pointer to JPWL markers list */ - &jwmarker_num, /* pointer to the number of current markers */ - OPJ_FALSE, /* latest */ - OPJ_TRUE, /* packed */ - OPJ_FALSE, /* inside MH */ - &epb_index, /* pointer to EPB index */ - pprot, /* protection type */ - /****** (double) (j2k->cstr_info->tile[tileno].start_pos + sot_len + 2) + 0.0001, */ /* position */ - (double) (j2k->cstr_info->tile[tileno].tp[tpno].tp_start_pos + sot_len + 2) + 0.0001, /* position */ - tileno, /* number of tile */ - 0, /* length of pre-data */ - prot_len /*4000*/ /* length of post-data */ - ); - } - - startpack = packno; - pprot = j2k->cp->pprot[packspec++]; - } - - /*printf("Tile %02d, pack %02d ==> %d\n", tileno, packno, pprot);*/ - - } - - /* we are at the end: print the remaining spec */ - stoppack = packno - 1; - if (pprot >= 0) { - - opj_event_msg(j2k->cinfo, EVT_INFO, - /**** "UEP EPBs: tile %02d, packs. %02d-%02d (B %d-%d), prot. %d\n", */ - "UEP EPBs: tile %02d, part %02d, packs. %02d-%02d (B %d-%d), prot. %d\n", - /**** tileno, */ - tileno, tpno, - startpack, - stoppack, - /***** j2k->image_info->tile[tileno].packet[startpack].start_pos, - j2k->image_info->tile[tileno].packet[stoppack].end_pos, */ - j2k->cstr_info->tile[tileno].packet[first_tp_pack + startpack].start_pos, - j2k->cstr_info->tile[tileno].packet[first_tp_pack + stoppack].end_pos, - pprot); - - /***** prot_len = j2k->cstr_info->tile[tileno].packet[stoppack].end_pos + 1 - - j2k->cstr_info->tile[tileno].packet[startpack].start_pos; */ - prot_len = j2k->cstr_info->tile[tileno].packet[first_tp_pack + stoppack].end_pos + 1 - - j2k->cstr_info->tile[tileno].packet[first_tp_pack + startpack].start_pos; - - /* - particular case: if this is the last header and the last packet, - then it is better to protect even the EOC marker - */ - /***** if ((tileno == ((j2k->cstr_info->tw * j2k->cstr_info->th) - 1)) && - (stoppack == (j2k->cstr_info->num - 1))) */ - if ((tileno == ((j2k->cstr_info->tw * j2k->cstr_info->th) - 1)) && - (tpno == (j2k->cstr_info->tile[tileno].num_tps - 1)) && - (stoppack == last_tp_pack)) - /* add the EOC len */ - prot_len += 2; - - /* let's add the EPBs */ - Psot += jpwl_epbs_add( - j2k, /* J2K handle */ - jwmarker, /* pointer to JPWL markers list */ - &jwmarker_num, /* pointer to the number of current markers */ - OPJ_TRUE, /* latest */ - OPJ_TRUE, /* packed */ - OPJ_FALSE, /* inside MH */ - &epb_index, /* pointer to EPB index */ - pprot, /* protection type */ - /***** (double) (j2k->cstr_info->tile[tileno].start_pos + sot_len + 2) + 0.0001,*/ /* position */ - (double) (j2k->cstr_info->tile[tileno].tp[tpno].tp_start_pos + sot_len + 2) + 0.0001, /* position */ - tileno, /* number of tile */ - 0, /* length of pre-data */ - prot_len /*4000*/ /* length of post-data */ - ); - } - - /* we can now check if the TPH EPB was really the last one */ - if (tph_epb && (epb_index == 1)) { - /* set the TPH EPB to be the last one in current header */ - tph_epb->Depb |= (unsigned char) ((OPJ_TRUE & 0x0001) << 6); - tph_epb = NULL; - } - - /* write back Psot */ - cio_seek(cio, Psotp); - cio_write(cio, Psot, 4); - - } - - }; - - /* reset the position */ - cio_seek(cio, ciopos); - -} - -void jpwl_dump_marks(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image) { - - int mm; - unsigned long int old_size = j2k->cstr_info->codestream_size; - unsigned long int new_size = old_size; - int /*ciopos = cio_tell(cio),*/ soc_pos = j2k->cstr_info->main_head_start; - unsigned char *jpwl_buf, *orig_buf; - unsigned long int orig_pos; - double epbcoding_time = 0.0, esdcoding_time = 0.0; - (void)image; - - /* Order JPWL markers according to their wishlist position */ - qsort((void *) jwmarker, (size_t) jwmarker_num, sizeof (jpwl_marker_t), jpwl_markcomp); - - /* compute markers total size */ - for (mm = 0; mm < jwmarker_num; mm++) { - /*printf("%x, %d, %.10f, %d long\n", jwmarker[mm].id, jwmarker[mm].pos, - jwmarker[mm].dpos, jwmarker[mm].len);*/ - new_size += jwmarker[mm].len + 2; - } - - /* allocate a new buffer of proper size */ - if (!(jpwl_buf = (unsigned char *) opj_malloc((size_t) (new_size + soc_pos) * sizeof(unsigned char)))) { - opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not allocate room for JPWL codestream buffer\n"); - exit(1); - }; - - /* copy the jp2 part, if any */ - orig_buf = jpwl_buf; - memcpy(jpwl_buf, cio->buffer, soc_pos); - jpwl_buf += soc_pos; - - /* cycle through markers */ - orig_pos = soc_pos + 0; /* start from the beginning */ - cio_seek(cio, soc_pos + 0); /* rewind the original */ - for (mm = 0; mm < jwmarker_num; mm++) { - - /* - need to copy a piece of the original codestream - if there is such - */ - memcpy(jpwl_buf, cio_getbp(cio), jwmarker[mm].pos - orig_pos); - jpwl_buf += jwmarker[mm].pos - orig_pos; - orig_pos = jwmarker[mm].pos; - cio_seek(cio, orig_pos); - - /* - then write down the marker - */ - switch (jwmarker[mm].id) { - - case J2K_MS_EPB: - jpwl_epb_write(j2k, jwmarker[mm].m.epbmark, jpwl_buf); - break; - - case J2K_MS_EPC: - jpwl_epc_write(j2k, jwmarker[mm].m.epcmark, jpwl_buf); - break; - - case J2K_MS_ESD: - jpwl_esd_write(j2k, jwmarker[mm].m.esdmark, jpwl_buf); - break; - - case J2K_MS_RED: - memset(jpwl_buf, 0, jwmarker[mm].len + 2); /* placeholder */ - break; - - default: - break; - }; - - /* we update the markers struct */ - if (j2k->cstr_info) - j2k->cstr_info->marker[j2k->cstr_info->marknum - 1].pos = (jpwl_buf - orig_buf); - - /* we set the marker dpos to the new position in the JPWL codestream */ - jwmarker[mm].dpos = (double) (jpwl_buf - orig_buf); - - /* advance JPWL buffer position */ - jpwl_buf += jwmarker[mm].len + 2; - - } - - /* finish remaining original codestream */ - memcpy(jpwl_buf, cio_getbp(cio), old_size - (orig_pos - soc_pos)); - jpwl_buf += old_size - (orig_pos - soc_pos); - cio_seek(cio, soc_pos + old_size); - - /* - update info file based on added markers - */ - if (!jpwl_update_info(j2k, jwmarker, jwmarker_num)) - opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not update OPJ cstr_info structure\n"); - - /* now we need to repass some markers and fill their data fields */ - - /* first of all, DL and Pcrc in EPCs */ - for (mm = 0; mm < jwmarker_num; mm++) { - - /* find the EPCs */ - if (jwmarker[mm].id == J2K_MS_EPC) { - - int epc_pos = (int) jwmarker[mm].dpos, pp; - unsigned short int mycrc = 0x0000; - - /* fix and fill the DL field */ - jwmarker[mm].m.epcmark->DL = new_size; - orig_buf[epc_pos + 6] = (unsigned char) (jwmarker[mm].m.epcmark->DL >> 24); - orig_buf[epc_pos + 7] = (unsigned char) (jwmarker[mm].m.epcmark->DL >> 16); - orig_buf[epc_pos + 8] = (unsigned char) (jwmarker[mm].m.epcmark->DL >> 8); - orig_buf[epc_pos + 9] = (unsigned char) (jwmarker[mm].m.epcmark->DL >> 0); - - /* compute the CRC field (excluding itself) */ - for (pp = 0; pp < 4; pp++) - jpwl_updateCRC16(&mycrc, orig_buf[epc_pos + pp]); - for (pp = 6; pp < (jwmarker[mm].len + 2); pp++) - jpwl_updateCRC16(&mycrc, orig_buf[epc_pos + pp]); - - /* fix and fill the CRC */ - jwmarker[mm].m.epcmark->Pcrc = mycrc; - orig_buf[epc_pos + 4] = (unsigned char) (jwmarker[mm].m.epcmark->Pcrc >> 8); - orig_buf[epc_pos + 5] = (unsigned char) (jwmarker[mm].m.epcmark->Pcrc >> 0); - - } - } - - /* then, sensitivity data in ESDs */ - esdcoding_time = opj_clock(); - for (mm = 0; mm < jwmarker_num; mm++) { - - /* find the ESDs */ - if (jwmarker[mm].id == J2K_MS_ESD) { - - /* remember that they are now in a new position (dpos) */ - int esd_pos = (int) jwmarker[mm].dpos; - - jpwl_esd_fill(j2k, jwmarker[mm].m.esdmark, &orig_buf[esd_pos]); - - } - - } - esdcoding_time = opj_clock() - esdcoding_time; - if (j2k->cp->esd_on) - opj_event_msg(j2k->cinfo, EVT_INFO, "ESDs sensitivities computed in %f s\n", esdcoding_time); - - /* finally, RS or CRC parity in EPBs */ - epbcoding_time = opj_clock(); - for (mm = 0; mm < jwmarker_num; mm++) { - - /* find the EPBs */ - if (jwmarker[mm].id == J2K_MS_EPB) { - - /* remember that they are now in a new position (dpos) */ - int nn, accum_len; - - /* let's see how many EPBs are following this one, included itself */ - /* for this to work, we suppose that the markers are correctly ordered */ - /* and, overall, that they are in packed mode inside headers */ - accum_len = 0; - for (nn = mm; (nn < jwmarker_num) && (jwmarker[nn].id == J2K_MS_EPB) && - (jwmarker[nn].pos == jwmarker[mm].pos); nn++) - accum_len += jwmarker[nn].m.epbmark->Lepb + 2; - - /* fill the current (first) EPB with post-data starting from the computed position */ - jpwl_epb_fill(j2k, jwmarker[mm].m.epbmark, &orig_buf[(int) jwmarker[mm].dpos], - &orig_buf[(int) jwmarker[mm].dpos + accum_len]); - - /* fill the remaining EPBs in the header with post-data starting from the last position */ - for (nn = mm + 1; (nn < jwmarker_num) && (jwmarker[nn].id == J2K_MS_EPB) && - (jwmarker[nn].pos == jwmarker[mm].pos); nn++) - jpwl_epb_fill(j2k, jwmarker[nn].m.epbmark, &orig_buf[(int) jwmarker[nn].dpos], NULL); - - /* skip all the processed EPBs */ - mm = nn - 1; - } - - } - epbcoding_time = opj_clock() - epbcoding_time; - if (j2k->cp->epb_on) - opj_event_msg(j2k->cinfo, EVT_INFO, "EPBs redundancy computed in %f s\n", epbcoding_time); - - /* free original cio buffer and set it to the JPWL one */ - opj_free(cio->buffer); - cio->cinfo = cio->cinfo; /* no change */ - cio->openmode = cio->openmode; /* no change */ - cio->buffer = orig_buf; - cio->length = new_size + soc_pos; - cio->start = cio->buffer; - cio->end = cio->buffer + cio->length; - cio->bp = cio->buffer; - cio_seek(cio, soc_pos + new_size); - -} - - -void j2k_read_epc(opj_j2k_t *j2k) { - unsigned long int DL, Lepcp, Pcrcp, l; - unsigned short int Lepc, Pcrc = 0x0000; - unsigned char Pepc; - opj_cio_t *cio = j2k->cio; - const char *ans1; - - /* Simply read the EPC parameters */ - Lepcp = cio_tell(cio); - Lepc = cio_read(cio, 2); - Pcrcp = cio_tell(cio); - cio_skip(cio, 2); /* Pcrc */ - DL = cio_read(cio, 4); - Pepc = cio_read(cio, 1); - - /* compute Pcrc */ - cio_seek(cio, Lepcp - 2); - - /* Marker */ - jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); - jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); - - /* Length */ - jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); - jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); - - /* skip Pcrc */ - cio_skip(cio, 2); - - /* read all remaining */ - for (l = 4; l < Lepc; l++) - jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); - - /* check Pcrc with the result */ - cio_seek(cio, Pcrcp); - ans1 = (Pcrc == (unsigned short int) cio_read(cio, 2)) ? "crc-ok" : "crc-ko"; - - /* now we write them to screen */ - opj_event_msg(j2k->cinfo, EVT_INFO, - "EPC(%u,%d): %s, DL=%d%s %s %s\n", - Lepcp - 2, - Lepc, - ans1, - DL, /* data length this EPC is referring to */ - (Pepc & 0x10) ? ", esd" : "", /* ESD is present */ - (Pepc & 0x20) ? ", red" : "", /* RED is present */ - (Pepc & 0x40) ? ", epb" : ""); /* EPB is present */ - - cio_seek(cio, Lepcp + Lepc); -} - -void j2k_write_epc(opj_j2k_t *j2k) { - - unsigned long int DL, Lepcp, Pcrcp, l; - unsigned short int Lepc, Pcrc; - unsigned char Pepc; - - opj_cio_t *cio = j2k->cio; - - cio_write(cio, J2K_MS_EPC, 2); /* EPC */ - Lepcp = cio_tell(cio); - cio_skip(cio, 2); - - /* CRC-16 word of the EPC */ - Pcrc = 0x0000; /* initialize */ - Pcrcp = cio_tell(cio); - cio_write(cio, Pcrc, 2); /* Pcrc placeholder*/ - - /* data length of the EPC protection domain */ - DL = 0x00000000; /* we leave this set to 0, as if the information is not available */ - cio_write(cio, DL, 4); /* DL */ - - /* jpwl capabilities */ - Pepc = 0x00; - cio_write(cio, Pepc, 1); /* Pepc */ - - /* ID section */ - /* no ID's, as of now */ - - Lepc = (unsigned short) (cio_tell(cio) - Lepcp); - cio_seek(cio, Lepcp); - cio_write(cio, Lepc, 2); /* Lepc */ - - /* compute Pcrc */ - cio_seek(cio, Lepcp - 2); - - /* Marker */ - jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); - jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); - - /* Length */ - jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); - jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); - - /* skip Pcrc */ - cio_skip(cio, 2); - - /* read all remaining */ - for (l = 4; l < Lepc; l++) - jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); - - /* fill Pcrc with the result */ - cio_seek(cio, Pcrcp); - cio_write(cio, Pcrc, 2); - - cio_seek(cio, Lepcp + Lepc); - - /* marker struct update */ - j2k_add_marker(j2k->cstr_info, J2K_MS_EPC, Lepcp - 2, Lepc + 2); - -} - -void j2k_read_epb(opj_j2k_t *j2k) { - unsigned long int LDPepb, Pepb; - unsigned short int Lepb; - unsigned char Depb; - char str1[25] = ""; - opj_bool status; - static opj_bool first_in_tph = OPJ_TRUE; - int type, pre_len, post_len; - static unsigned char *redund = NULL; - - opj_cio_t *cio = j2k->cio; - - /* B/W = 45, RGB = 51 */ - /* SIZ SIZ_FIELDS SIZ_COMPS FOLLOWING_MARKER */ - int skipnum = 2 + 38 + 3 * j2k->cp->exp_comps + 2; - - if (j2k->cp->correct) { - - /* go back to EPB marker value */ - cio_seek(cio, cio_tell(cio) - 2); - - /* we need to understand where we are */ - if (j2k->state == J2K_STATE_MH) { - /* we are in MH */ - type = 0; /* MH */ - pre_len = skipnum; /* SOC+SIZ */ - post_len = -1; /* auto */ - - } else if ((j2k->state == J2K_STATE_TPH) && first_in_tph) { - /* we are in TPH */ - type = 1; /* TPH */ - pre_len = 12; /* SOC+SIZ */ - first_in_tph = OPJ_FALSE; - post_len = -1; /* auto */ - - } else { - /* we are elsewhere */ - type = 2; /* other */ - pre_len = 0; /* nada */ - post_len = -1; /* auto */ - - } - - /* call EPB corrector */ - /*printf("before %x, ", redund);*/ - status = jpwl_epb_correct(j2k, /* J2K decompressor handle */ - cio->bp, /* pointer to EPB in codestream buffer */ - type, /* EPB type: MH */ - pre_len, /* length of pre-data */ - post_len, /* length of post-data: -1 means auto */ - NULL, /* do everything auto */ - &redund - ); - /*printf("after %x\n", redund);*/ - - /* Read the (possibly corrected) EPB parameters */ - cio_skip(cio, 2); - Lepb = cio_read(cio, 2); - Depb = cio_read(cio, 1); - LDPepb = cio_read(cio, 4); - Pepb = cio_read(cio, 4); - - if (!status) { - - opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL correction could not be performed\n"); - - /* advance to EPB endpoint */ - cio_skip(cio, Lepb + 2); - - return; - } - - /* last in current header? */ - if (Depb & 0x40) { - redund = NULL; /* reset the pointer to L4 buffer */ - first_in_tph = OPJ_TRUE; - } - - /* advance to EPB endpoint */ - cio_skip(cio, Lepb - 11); - - } else { - - /* Simply read the EPB parameters */ - Lepb = cio_read(cio, 2); - Depb = cio_read(cio, 1); - LDPepb = cio_read(cio, 4); - Pepb = cio_read(cio, 4); - - /* What does Pepb tells us about the protection method? */ - if (((Pepb & 0xF0000000) >> 28) == 0) - sprintf(str1, "pred"); /* predefined */ - else if (((Pepb & 0xF0000000) >> 28) == 1) - sprintf(str1, "crc-%lu", 16 * ((Pepb & 0x00000001) + 1)); /* CRC mode */ - else if (((Pepb & 0xF0000000) >> 28) == 2) - sprintf(str1, "rs(%lu,32)", (Pepb & 0x0000FF00) >> 8); /* RS mode */ - else if (Pepb == 0xFFFFFFFF) - sprintf(str1, "nometh"); /* RS mode */ - else - sprintf(str1, "unknown"); /* unknown */ - - /* Now we write them to screen */ - opj_event_msg(j2k->cinfo, EVT_INFO, - "EPB(%d): (%sl, %sp, %u), %lu, %s\n", - cio_tell(cio) - 13, - (Depb & 0x40) ? "" : "n", /* latest EPB or not? */ - (Depb & 0x80) ? "" : "n", /* packed or unpacked EPB? */ - (Depb & 0x3F), /* EPB index value */ - LDPepb, /*length of the data protected by the EPB */ - str1); /* protection method */ - - cio_skip(cio, Lepb - 11); - } -} - -void j2k_write_epb(opj_j2k_t *j2k) { - unsigned long int LDPepb, Pepb, Lepbp; - unsigned short int Lepb; - unsigned char Depb; - - opj_cio_t *cio = j2k->cio; - - cio_write(cio, J2K_MS_EPB, 2); /* EPB */ - Lepbp = cio_tell(cio); - cio_skip(cio, 2); - - /* EPB style */ - Depb = 0x00; /* test */ - cio_write(cio, Depb, 1); /* Depb */ - - /* length of the data to be protected by this EPB */ - LDPepb = 0x00000000; /* test */ - cio_write(cio, LDPepb, 4); /* LDPepb */ - - /* next error correction tool */ - Pepb = 0x00000000; /* test */ - cio_write(cio, Pepb, 4); /* Pepb */ - - /* EPB data */ - /* no data, as of now */ - - Lepb = (unsigned short) (cio_tell(cio) - Lepbp); - cio_seek(cio, Lepbp); - cio_write(cio, Lepb, 2); /* Lepb */ - - cio_seek(cio, Lepbp + Lepb); - - /* marker struct update */ - j2k_add_marker(j2k->cstr_info, J2K_MS_EPB, Lepbp - 2, Lepb + 2); -} - -void j2k_read_esd(opj_j2k_t *j2k) { - unsigned short int Lesd, Cesd; - unsigned char Pesd; - - int cesdsize = (j2k->image->numcomps >= 257) ? 2 : 1; - - char str1[4][4] = {"p", "br", "pr", "res"}; - char str2[8][8] = {"res", "mse", "mse-r", "psnr", "psnr-i", "maxerr", "tse", "res"}; - - opj_cio_t *cio = j2k->cio; - - /* Simply read the ESD parameters */ - Lesd = cio_read(cio, 2); - Cesd = cio_read(cio, cesdsize); - Pesd = cio_read(cio, 1); - - /* Now we write them to screen */ - opj_event_msg(j2k->cinfo, EVT_INFO, - "ESD(%d): c%d, %s, %s, %s, %s, %s\n", - cio_tell(cio) - (5 + cesdsize), - Cesd, /* component number for this ESD */ - str1[(Pesd & (unsigned char) 0xC0) >> 6], /* addressing mode */ - str2[(Pesd & (unsigned char) 0x38) >> 3], /* sensitivity type */ - ((Pesd & (unsigned char) 0x04) >> 2) ? "2Bs" : "1Bs", - ((Pesd & (unsigned char) 0x02) >> 1) ? "4Ba" : "2Ba", - (Pesd & (unsigned char) 0x01) ? "avgc" : ""); - - cio_skip(cio, Lesd - (3 + cesdsize)); -} - -void j2k_read_red(opj_j2k_t *j2k) { - unsigned short int Lred; - unsigned char Pred; - char str1[4][4] = {"p", "br", "pr", "res"}; - - opj_cio_t *cio = j2k->cio; - - /* Simply read the RED parameters */ - Lred = cio_read(cio, 2); - Pred = cio_read(cio, 1); - - /* Now we write them to screen */ - opj_event_msg(j2k->cinfo, EVT_INFO, - "RED(%d): %s, %dc, %s, %s\n", - cio_tell(cio) - 5, - str1[(Pred & (unsigned char) 0xC0) >> 6], /* addressing mode */ - (Pred & (unsigned char) 0x38) >> 3, /* corruption level */ - ((Pred & (unsigned char) 0x02) >> 1) ? "4Ba" : "2Ba", /* address range */ - (Pred & (unsigned char) 0x01) ? "errs" : "free"); /* error free? */ - - cio_skip(cio, Lred - 3); -} - -opj_bool jpwl_check_tile(opj_j2k_t *j2k, opj_tcd_t *tcd, int tileno) { - -#ifdef oerhgierhgvhreit4u - /* - we navigate through the tile and find possible invalid parameters: - this saves a lot of crashes!!!!! - */ - int compno, resno, precno, /*layno,*/ bandno, blockno; - int numprecincts, numblocks; - - /* this is the selected tile */ - opj_tcd_tile_t *tile = &(tcd->tcd_image->tiles[tileno]); - - /* will keep the component */ - opj_tcd_tilecomp_t *comp = NULL; - - /* will keep the resolution */ - opj_tcd_resolution_t *res; - - /* will keep the subband */ - opj_tcd_band_t *band; - - /* will keep the precinct */ - opj_tcd_precinct_t *prec; - - /* will keep the codeblock */ - opj_tcd_cblk_t *block; - - /* check all tile components */ - for (compno = 0; compno < tile->numcomps; compno++) { - comp = &(tile->comps[compno]); - - /* check all component resolutions */ - for (resno = 0; resno < comp->numresolutions; resno++) { - res = &(comp->resolutions[resno]); - numprecincts = res->pw * res->ph; - - /* check all the subbands */ - for (bandno = 0; bandno < res->numbands; bandno++) { - band = &(res->bands[bandno]); - - /* check all the precincts */ - for (precno = 0; precno < numprecincts; precno++) { - prec = &(band->precincts[precno]); - numblocks = prec->ch * prec->cw; - - /* check all the codeblocks */ - for (blockno = 0; blockno < numblocks; blockno++) { - block = &(prec->cblks[blockno]); - - /* x-origin is invalid */ - if ((block->x0 < prec->x0) || (block->x0 > prec->x1)) { - opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR, - "JPWL: wrong x-cord of block origin %d => x-prec is (%d, %d)\n", - block->x0, prec->x0, prec->x1); - if (!JPWL_ASSUME || JPWL_ASSUME) - return OPJ_FALSE; - }; - } - } - } - } - } - -#else - (void)j2k; - (void)tcd; - (void)tileno; -#endif - - return OPJ_TRUE; -} - -/*@}*/ - -#endif /* USE_JPWL */ - - -#ifdef USE_JPSEC - -/** @defgroup JPSEC JPSEC - JPEG-2000 Part 8 (JPSEC) codestream manager */ -/*@{*/ - - -/** @name Local static functions */ -/*@{*/ - -void j2k_read_sec(opj_j2k_t *j2k) { - unsigned short int Lsec; - - opj_cio_t *cio = j2k->cio; - - /* Simply read the SEC length */ - Lsec = cio_read(cio, 2); - - /* Now we write them to screen */ - opj_event_msg(j2k->cinfo, EVT_INFO, - "SEC(%d)\n", - cio_tell(cio) - 2 - ); - - cio_skip(cio, Lsec - 2); -} - -void j2k_write_sec(opj_j2k_t *j2k) { - unsigned short int Lsec = 24; - int i; - - opj_cio_t *cio = j2k->cio; - - cio_write(cio, J2K_MS_SEC, 2); /* SEC */ - cio_write(cio, Lsec, 2); - - /* write dummy data */ - for (i = 0; i < Lsec - 2; i++) - cio_write(cio, 0, 1); -} - -void j2k_read_insec(opj_j2k_t *j2k) { - unsigned short int Linsec; - - opj_cio_t *cio = j2k->cio; - - /* Simply read the INSEC length */ - Linsec = cio_read(cio, 2); - - /* Now we write them to screen */ - opj_event_msg(j2k->cinfo, EVT_INFO, - "INSEC(%d)\n", - cio_tell(cio) - 2 - ); - - cio_skip(cio, Linsec - 2); -} - - -/*@}*/ - -/*@}*/ - -#endif /* USE_JPSEC */ - +/* + * Copyright (c) 2001-2003, David Janssens + * Copyright (c) 2002-2003, Yannick Verschueren + * Copyright (c) 2003-2005, Francois Devaux and Antonin Descampe + * Copyright (c) 2005, Herve Drolon, FreeImage Team + * Copyright (c) 2002-2005, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium + * Copyright (c) 2005-2006, Dept. of Electronic and Information Engineering, Universita' degli Studi di Perugia, Italy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "opj_includes.h" + +#ifdef USE_JPWL + +/** @defgroup JPWL JPWL - JPEG-2000 Part11 (JPWL) codestream manager */ +/*@{*/ + +/** @name Local static variables */ +/*@{*/ + +/** number of JPWL prepared markers */ +static int jwmarker_num; +/** properties of JPWL markers to insert */ +static jpwl_marker_t jwmarker[JPWL_MAX_NO_MARKERS]; + +/*@}*/ + +/*@}*/ + +/** @name Local static functions */ +/*@{*/ + +/** create an EPC marker segment +@param j2k J2K compressor handle +@param esd_on true if ESD is activated +@param red_on true if RED is activated +@param epb_on true if EPB is activated +@param info_on true if informative techniques are activated +@return returns the freshly created EPC +*/ +jpwl_epc_ms_t *jpwl_epc_create(opj_j2k_t *j2k, opj_bool esd_on, opj_bool red_on, opj_bool epb_on, opj_bool info_on); + +/*@}*/ + +/** create an EPC marker segment +@param j2k J2K compressor handle +@param comps considered component (-1=average, 0/1/2/...=component no.) +@param addrm addressing mode (0=packet, 1=byte range, 2=packet range, 3=reserved) +@param ad_size size of addresses (2/4 bytes) +@param senst sensitivity type +@param se_size sensitivity values size (1/2 bytes) +@param tileno tile where this ESD lies (-1 means MH) +@param svalnum number of sensitivity values (if 0, they will be automatically filled) +@param sensval pointer to an array of sensitivity values (if NULL, they will be automatically filled) +@return returns the freshly created ESD +*/ +jpwl_esd_ms_t *jpwl_esd_create(opj_j2k_t *j2k, int comps, + unsigned char addrm, unsigned char ad_size, + unsigned char senst, int se_size, int tileno, + unsigned long int svalnum, void *sensval); + +/** this function is used to compare two JPWL markers based on +their relevant wishlist position +@param arg1 pointer to first marker +@param arg2 pointer to second marker +@return 1 if arg1>arg2, 0 if arg1=arg2, -1 if arg1pos_correction = 0; + +} + +void j2k_add_marker(opj_codestream_info_t *cstr_info, unsigned short int type, int pos, int len) { + + if (!cstr_info) + return; + + /* expand the list? */ + if ((cstr_info->marknum + 1) > cstr_info->maxmarknum) { + cstr_info->maxmarknum += 100; + cstr_info->marker = (opj_marker_info_t*)opj_realloc(cstr_info->marker, cstr_info->maxmarknum * sizeof(opj_marker_info_t)); + } + + /* add the marker */ + cstr_info->marker[cstr_info->marknum].type = type; + cstr_info->marker[cstr_info->marknum].pos = pos; + cstr_info->marker[cstr_info->marknum].len = len; + cstr_info->marknum++; + +} + +void jpwl_prepare_marks(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image) { + + unsigned short int socsiz_len = 0; + int ciopos = cio_tell(cio), soc_pos = j2k->cstr_info->main_head_start; + unsigned char *socp = NULL; + + int tileno, acc_tpno, tpno, tilespec, hprot, sens, pprot, packspec, lastileno, packno; + + jpwl_epb_ms_t *epb_mark; + jpwl_epc_ms_t *epc_mark; + jpwl_esd_ms_t *esd_mark; + (void)image; + + /* find (SOC + SIZ) length */ + /* I assume SIZ is always the first marker after SOC */ + cio_seek(cio, soc_pos + 4); + socsiz_len = (unsigned short int) cio_read(cio, 2) + 4; /* add the 2 marks length itself */ + cio_seek(cio, soc_pos + 0); + socp = cio_getbp(cio); /* pointer to SOC */ + + /* + EPC MS for Main Header: if we are here it's required + */ + /* create the EPC */ + if ((epc_mark = jpwl_epc_create( + j2k, + j2k->cp->esd_on, /* is ESD present? */ + j2k->cp->red_on, /* is RED present? */ + j2k->cp->epb_on, /* is EPB present? */ + OPJ_FALSE /* are informative techniques present? */ + ))) { + + /* Add this marker to the 'insertanda' list */ + if (epc_mark) { + jwmarker[jwmarker_num].id = J2K_MS_EPC; /* its type */ + jwmarker[jwmarker_num].m.epcmark = epc_mark; /* the EPC */ + jwmarker[jwmarker_num].pos = soc_pos + socsiz_len; /* after SIZ */ + jwmarker[jwmarker_num].dpos = (double) jwmarker[jwmarker_num].pos + 0.1; /* not so first */ + jwmarker[jwmarker_num].len = epc_mark->Lepc; /* its length */ + jwmarker[jwmarker_num].len_ready = OPJ_TRUE; /* ready */ + jwmarker[jwmarker_num].pos_ready = OPJ_TRUE; /* ready */ + jwmarker[jwmarker_num].parms_ready = OPJ_FALSE; /* not ready */ + jwmarker[jwmarker_num].data_ready = OPJ_TRUE; /* ready */ + jwmarker_num++; + }; + + opj_event_msg(j2k->cinfo, EVT_INFO, + "MH EPC : setting %s%s%s\n", + j2k->cp->esd_on ? "ESD, " : "", + j2k->cp->red_on ? "RED, " : "", + j2k->cp->epb_on ? "EPB, " : "" + ); + + } else { + /* ooops, problems */ + opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not create MH EPC\n"); + }; + + /* + ESD MS for Main Header + */ + /* first of all, must MH have an ESD MS? */ + if (j2k->cp->esd_on && (j2k->cp->sens_MH >= 0)) { + + /* Create the ESD */ + if ((esd_mark = jpwl_esd_create( + j2k, /* this encoder handle */ + -1, /* we are averaging over all components */ + (unsigned char) j2k->cp->sens_range, /* range method */ + (unsigned char) j2k->cp->sens_addr, /* sensitivity addressing */ + (unsigned char) j2k->cp->sens_MH, /* sensitivity method */ + j2k->cp->sens_size, /* sensitivity size */ + -1, /* this ESD is in main header */ + 0 /*j2k->cstr_info->num*/, /* number of packets in codestream */ + NULL /*sensval*/ /* pointer to sensitivity data of packets */ + ))) { + + /* Add this marker to the 'insertanda' list */ + if (jwmarker_num < JPWL_MAX_NO_MARKERS) { + jwmarker[jwmarker_num].id = J2K_MS_ESD; /* its type */ + jwmarker[jwmarker_num].m.esdmark = esd_mark; /* the EPB */ + jwmarker[jwmarker_num].pos = soc_pos + socsiz_len; /* we choose to place it after SIZ */ + jwmarker[jwmarker_num].dpos = (double) jwmarker[jwmarker_num].pos + 0.2; /* not first at all! */ + jwmarker[jwmarker_num].len = esd_mark->Lesd; /* its length */ + jwmarker[jwmarker_num].len_ready = OPJ_TRUE; /* not ready, yet */ + jwmarker[jwmarker_num].pos_ready = OPJ_TRUE; /* ready */ + jwmarker[jwmarker_num].parms_ready = OPJ_TRUE; /* not ready */ + jwmarker[jwmarker_num].data_ready = OPJ_FALSE; /* not ready */ + jwmarker_num++; + } + + opj_event_msg(j2k->cinfo, EVT_INFO, + "MH ESDs: method %d\n", + j2k->cp->sens_MH + ); + + } else { + /* ooops, problems */ + opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not create MH ESD\n"); + }; + + } + + /* + ESD MSs for Tile Part Headers + */ + /* cycle through tiles */ + sens = -1; /* default spec: no ESD */ + tilespec = 0; /* first tile spec */ + acc_tpno = 0; + for (tileno = 0; tileno < j2k->cstr_info->tw * j2k->cstr_info->th; tileno++) { + + opj_event_msg(j2k->cinfo, EVT_INFO, + "Tile %d has %d tile part(s)\n", + tileno, j2k->cstr_info->tile[tileno].num_tps + ); + + /* for every tile part in the tile */ + for (tpno = 0; tpno < j2k->cstr_info->tile[tileno].num_tps; tpno++, acc_tpno++) { + + int sot_len, Psot, Psotp, mm; + unsigned long sot_pos, post_sod_pos; + + unsigned long int left_THmarks_len; + + /******* sot_pos = j2k->cstr_info->tile[tileno].start_pos; */ + sot_pos = j2k->cstr_info->tile[tileno].tp[tpno].tp_start_pos; + cio_seek(cio, sot_pos + 2); + sot_len = cio_read(cio, 2); /* SOT Len */ + cio_skip(cio, 2); + Psotp = cio_tell(cio); + Psot = cio_read(cio, 4); /* tile length */ + + /******* post_sod_pos = j2k->cstr_info->tile[tileno].end_header + 1; */ + post_sod_pos = j2k->cstr_info->tile[tileno].tp[tpno].tp_end_header + 1; + left_THmarks_len = post_sod_pos - sot_pos; + + /* add all the lengths of the markers which are len-ready and stay within SOT and SOD */ + for (mm = 0; mm < jwmarker_num; mm++) { + if ((jwmarker[mm].pos >= sot_pos) && (jwmarker[mm].pos < post_sod_pos)) { + if (jwmarker[mm].len_ready) + left_THmarks_len += jwmarker[mm].len + 2; + else { + opj_event_msg(j2k->cinfo, EVT_ERROR, "MS %x in %f is not len-ready: could not set up TH EPB\n", + jwmarker[mm].id, jwmarker[mm].dpos); + exit(1); + } + } + } + + /******* if ((tilespec < JPWL_MAX_NO_TILESPECS) && (j2k->cp->sens_TPH_tileno[tilespec] == tileno)) */ + if ((tilespec < JPWL_MAX_NO_TILESPECS) && (j2k->cp->sens_TPH_tileno[tilespec] == acc_tpno)) + /* we got a specification from this tile onwards */ + sens = j2k->cp->sens_TPH[tilespec++]; + + /* must this TPH have an ESD MS? */ + if (j2k->cp->esd_on && (sens >= 0)) { + + /* Create the ESD */ + if ((esd_mark = jpwl_esd_create( + j2k, /* this encoder handle */ + -1, /* we are averaging over all components */ + (unsigned char) j2k->cp->sens_range, /* range method */ + (unsigned char) j2k->cp->sens_addr, /* sensitivity addressing size */ + (unsigned char) sens, /* sensitivity method */ + j2k->cp->sens_size, /* sensitivity value size */ + tileno, /* this ESD is in a tile */ + 0, /* number of packets in codestream */ + NULL /* pointer to sensitivity data of packets */ + ))) { + + /* Add this marker to the 'insertanda' list */ + if (jwmarker_num < JPWL_MAX_NO_MARKERS) { + jwmarker[jwmarker_num].id = J2K_MS_ESD; /* its type */ + jwmarker[jwmarker_num].m.esdmark = esd_mark; /* the EPB */ + /****** jwmarker[jwmarker_num].pos = j2k->cstr_info->tile[tileno].start_pos + sot_len + 2; */ /* after SOT */ + jwmarker[jwmarker_num].pos = j2k->cstr_info->tile[tileno].tp[tpno].tp_start_pos + sot_len + 2; /* after SOT */ + jwmarker[jwmarker_num].dpos = (double) jwmarker[jwmarker_num].pos + 0.2; /* not first at all! */ + jwmarker[jwmarker_num].len = esd_mark->Lesd; /* its length */ + jwmarker[jwmarker_num].len_ready = OPJ_TRUE; /* ready, yet */ + jwmarker[jwmarker_num].pos_ready = OPJ_TRUE; /* ready */ + jwmarker[jwmarker_num].parms_ready = OPJ_TRUE; /* not ready */ + jwmarker[jwmarker_num].data_ready = OPJ_FALSE; /* ready */ + jwmarker_num++; + } + + /* update Psot of the tile */ + cio_seek(cio, Psotp); + cio_write(cio, Psot + esd_mark->Lesd + 2, 4); + + opj_event_msg(j2k->cinfo, EVT_INFO, + /******* "TPH ESDs: tile %02d, method %d\n", */ + "TPH ESDs: tile %02d, part %02d, method %d\n", + /******* tileno, */ + tileno, tpno, + sens + ); + + } else { + /* ooops, problems */ + /***** opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not create TPH ESD #%d\n", tileno); */ + opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not create TPH ESD #%d,%d\n", tileno, tpno); + }; + + } + + } + + }; + + /* + EPB MS for Main Header + */ + /* first of all, must MH have an EPB MS? */ + if (j2k->cp->epb_on && (j2k->cp->hprot_MH > 0)) { + + int mm; + + /* position of SOT */ + unsigned int sot_pos = j2k->cstr_info->main_head_end + 1; + + /* how much space is there between end of SIZ and beginning of SOT? */ + int left_MHmarks_len = sot_pos - socsiz_len; + + /* add all the lengths of the markers which are len-ready and stay within SOC and SOT */ + for (mm = 0; mm < jwmarker_num; mm++) { + if ( jwmarker[mm].pos < sot_pos) { /* jwmarker[mm].pos >=0 since ulong */ + if (jwmarker[mm].len_ready) + left_MHmarks_len += jwmarker[mm].len + 2; + else { + opj_event_msg(j2k->cinfo, EVT_ERROR, "MS %x in %f is not len-ready: could not set up MH EPB\n", + jwmarker[mm].id, jwmarker[mm].dpos); + exit(1); + } + } + } + + /* Create the EPB */ + if ((epb_mark = jpwl_epb_create( + j2k, /* this encoder handle */ + OPJ_TRUE, /* is it the latest? */ + OPJ_TRUE, /* is it packed? not for now */ + -1, /* we are in main header */ + 0, /* its index is 0 (first) */ + j2k->cp->hprot_MH, /* protection type parameters of data */ + socsiz_len, /* pre-data: only SOC+SIZ */ + left_MHmarks_len /* post-data: from SOC to SOT, and all JPWL markers within */ + ))) { + + /* Add this marker to the 'insertanda' list */ + if (jwmarker_num < JPWL_MAX_NO_MARKERS) { + jwmarker[jwmarker_num].id = J2K_MS_EPB; /* its type */ + jwmarker[jwmarker_num].m.epbmark = epb_mark; /* the EPB */ + jwmarker[jwmarker_num].pos = soc_pos + socsiz_len; /* after SIZ */ + jwmarker[jwmarker_num].dpos = (double) jwmarker[jwmarker_num].pos; /* first first first! */ + jwmarker[jwmarker_num].len = epb_mark->Lepb; /* its length */ + jwmarker[jwmarker_num].len_ready = OPJ_TRUE; /* ready */ + jwmarker[jwmarker_num].pos_ready = OPJ_TRUE; /* ready */ + jwmarker[jwmarker_num].parms_ready = OPJ_TRUE; /* ready */ + jwmarker[jwmarker_num].data_ready = OPJ_FALSE; /* not ready */ + jwmarker_num++; + } + + opj_event_msg(j2k->cinfo, EVT_INFO, + "MH EPB : prot. %d\n", + j2k->cp->hprot_MH + ); + + } else { + /* ooops, problems */ + opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not create MH EPB\n"); + }; + } + + /* + EPB MSs for Tile Parts + */ + /* cycle through TPHs */ + hprot = j2k->cp->hprot_MH; /* default spec */ + tilespec = 0; /* first tile spec */ + lastileno = 0; + packspec = 0; + pprot = -1; + acc_tpno = 0; + for (tileno = 0; tileno < j2k->cstr_info->tw * j2k->cstr_info->th; tileno++) { + + opj_event_msg(j2k->cinfo, EVT_INFO, + "Tile %d has %d tile part(s)\n", + tileno, j2k->cstr_info->tile[tileno].num_tps + ); + + /* for every tile part in the tile */ + for (tpno = 0; tpno < j2k->cstr_info->tile[tileno].num_tps; tpno++, acc_tpno++) { + + int sot_len, Psot, Psotp, mm, epb_index = 0, prot_len = 0; + unsigned long sot_pos, post_sod_pos; + unsigned long int left_THmarks_len/*, epbs_len = 0*/; + int startpack = 0, stoppack = j2k->cstr_info->packno; + int first_tp_pack, last_tp_pack; + jpwl_epb_ms_t *tph_epb = NULL; + + /****** sot_pos = j2k->cstr_info->tile[tileno].start_pos; */ + sot_pos = j2k->cstr_info->tile[tileno].tp[tpno].tp_start_pos; + cio_seek(cio, sot_pos + 2); + sot_len = cio_read(cio, 2); /* SOT Len */ + cio_skip(cio, 2); + Psotp = cio_tell(cio); + Psot = cio_read(cio, 4); /* tile length */ + + /* a-priori length of the data dwelling between SOT and SOD */ + /****** post_sod_pos = j2k->cstr_info->tile[tileno].end_header + 1; */ + post_sod_pos = j2k->cstr_info->tile[tileno].tp[tpno].tp_end_header + 1; + left_THmarks_len = post_sod_pos - (sot_pos + sot_len + 2); + + /* add all the lengths of the JPWL markers which are len-ready and stay within SOT and SOD */ + for (mm = 0; mm < jwmarker_num; mm++) { + if ((jwmarker[mm].pos >= sot_pos) && (jwmarker[mm].pos < post_sod_pos)) { + if (jwmarker[mm].len_ready) + left_THmarks_len += jwmarker[mm].len + 2; + else { + opj_event_msg(j2k->cinfo, EVT_ERROR, "MS %x in %f is not len-ready: could not set up TH EPB\n", + jwmarker[mm].id, jwmarker[mm].dpos); + exit(1); + } + } + } + + /****** if ((tilespec < JPWL_MAX_NO_TILESPECS) && (j2k->cp->hprot_TPH_tileno[tilespec] == tileno)) */ + if ((tilespec < JPWL_MAX_NO_TILESPECS) && (j2k->cp->hprot_TPH_tileno[tilespec] == acc_tpno)) + /* we got a specification from this tile part onwards */ + hprot = j2k->cp->hprot_TPH[tilespec++]; + + /* must this TPH have an EPB MS? */ + if (j2k->cp->epb_on && (hprot > 0)) { + + /* Create the EPB */ + if ((epb_mark = jpwl_epb_create( + j2k, /* this encoder handle */ + OPJ_FALSE, /* is it the latest? in TPH, no for now (if huge data size in TPH, we'd need more) */ + OPJ_TRUE, /* is it packed? yes for now */ + tileno, /* we are in TPH */ + epb_index++, /* its index is 0 (first) */ + hprot, /* protection type parameters of following data */ + sot_len + 2, /* pre-data length: only SOT */ + left_THmarks_len /* post-data length: from SOT end to SOD inclusive */ + ))) { + + /* Add this marker to the 'insertanda' list */ + if (jwmarker_num < JPWL_MAX_NO_MARKERS) { + jwmarker[jwmarker_num].id = J2K_MS_EPB; /* its type */ + jwmarker[jwmarker_num].m.epbmark = epb_mark; /* the EPB */ + /****** jwmarker[jwmarker_num].pos = j2k->cstr_info->tile[tileno].start_pos + sot_len + 2; */ /* after SOT */ + jwmarker[jwmarker_num].pos = j2k->cstr_info->tile[tileno].tp[tpno].tp_start_pos + sot_len + 2; /* after SOT */ + jwmarker[jwmarker_num].dpos = (double) jwmarker[jwmarker_num].pos; /* first first first! */ + jwmarker[jwmarker_num].len = epb_mark->Lepb; /* its length */ + jwmarker[jwmarker_num].len_ready = OPJ_TRUE; /* ready */ + jwmarker[jwmarker_num].pos_ready = OPJ_TRUE; /* ready */ + jwmarker[jwmarker_num].parms_ready = OPJ_TRUE; /* ready */ + jwmarker[jwmarker_num].data_ready = OPJ_FALSE; /* not ready */ + jwmarker_num++; + } + + /* update Psot of the tile */ + Psot += epb_mark->Lepb + 2; + + opj_event_msg(j2k->cinfo, EVT_INFO, + /***** "TPH EPB : tile %02d, prot. %d\n", */ + "TPH EPB : tile %02d, part %02d, prot. %d\n", + /***** tileno, */ + tileno, tpno, + hprot + ); + + /* save this TPH EPB address */ + tph_epb = epb_mark; + + } else { + /* ooops, problems */ + /****** opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not create TPH EPB #%d\n", tileno); */ + opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not create TPH EPB in #%d,d\n", tileno, tpno); + }; + + } + + startpack = 0; + /* EPB MSs for UEP packet data protection in Tile Parts */ + /****** for (packno = 0; packno < j2k->cstr_info->num; packno++) { */ + /*first_tp_pack = (tpno > 0) ? (first_tp_pack + j2k->cstr_info->tile[tileno].tp[tpno - 1].tp_numpacks) : 0;*/ + first_tp_pack = j2k->cstr_info->tile[tileno].tp[tpno].tp_start_pack; + last_tp_pack = first_tp_pack + j2k->cstr_info->tile[tileno].tp[tpno].tp_numpacks - 1; + for (packno = 0; packno < j2k->cstr_info->tile[tileno].tp[tpno].tp_numpacks; packno++) { + + /******** if ((packspec < JPWL_MAX_NO_PACKSPECS) && + (j2k->cp->pprot_tileno[packspec] == tileno) && (j2k->cp->pprot_packno[packspec] == packno)) { */ + if ((packspec < JPWL_MAX_NO_PACKSPECS) && + (j2k->cp->pprot_tileno[packspec] == acc_tpno) && (j2k->cp->pprot_packno[packspec] == packno)) { + + /* we got a specification from this tile and packet onwards */ + /* print the previous spec */ + if (packno > 0) { + stoppack = packno - 1; + opj_event_msg(j2k->cinfo, EVT_INFO, + /***** "UEP EPBs: tile %02d, packs. %02d-%02d (B %d-%d), prot. %d\n", */ + "UEP EPBs: tile %02d, part %02d, packs. %02d-%02d (B %d-%d), prot. %d\n", + /***** tileno, */ + tileno, tpno, + startpack, + stoppack, + /***** j2k->cstr_info->tile[tileno].packet[startpack].start_pos, */ + j2k->cstr_info->tile[tileno].packet[first_tp_pack + startpack].start_pos, + /***** j2k->cstr_info->tile[tileno].packet[stoppack].end_pos, */ + j2k->cstr_info->tile[tileno].packet[first_tp_pack + stoppack].end_pos, + pprot); + + /***** prot_len = j2k->cstr_info->tile[tileno].packet[stoppack].end_pos + 1 - + j2k->cstr_info->tile[tileno].packet[startpack].start_pos; */ + prot_len = j2k->cstr_info->tile[tileno].packet[first_tp_pack + stoppack].end_pos + 1 - + j2k->cstr_info->tile[tileno].packet[first_tp_pack + startpack].start_pos; + + /* + particular case: if this is the last header and the last packet, + then it is better to protect even the EOC marker + */ + /****** if ((tileno == ((j2k->cstr_info->tw * j2k->cstr_info->th) - 1)) && + (stoppack == (j2k->cstr_info->num - 1))) */ + if ((tileno == ((j2k->cstr_info->tw * j2k->cstr_info->th) - 1)) && + (tpno == (j2k->cstr_info->tile[tileno].num_tps - 1)) && + (stoppack == last_tp_pack)) + /* add the EOC len */ + prot_len += 2; + + /* let's add the EPBs */ + Psot += jpwl_epbs_add( + j2k, /* J2K handle */ + jwmarker, /* pointer to JPWL markers list */ + &jwmarker_num, /* pointer to the number of current markers */ + OPJ_FALSE, /* latest */ + OPJ_TRUE, /* packed */ + OPJ_FALSE, /* inside MH */ + &epb_index, /* pointer to EPB index */ + pprot, /* protection type */ + /****** (double) (j2k->cstr_info->tile[tileno].start_pos + sot_len + 2) + 0.0001, */ /* position */ + (double) (j2k->cstr_info->tile[tileno].tp[tpno].tp_start_pos + sot_len + 2) + 0.0001, /* position */ + tileno, /* number of tile */ + 0, /* length of pre-data */ + prot_len /*4000*/ /* length of post-data */ + ); + } + + startpack = packno; + pprot = j2k->cp->pprot[packspec++]; + } + + /*printf("Tile %02d, pack %02d ==> %d\n", tileno, packno, pprot);*/ + + } + + /* we are at the end: print the remaining spec */ + stoppack = packno - 1; + if (pprot >= 0) { + + opj_event_msg(j2k->cinfo, EVT_INFO, + /**** "UEP EPBs: tile %02d, packs. %02d-%02d (B %d-%d), prot. %d\n", */ + "UEP EPBs: tile %02d, part %02d, packs. %02d-%02d (B %d-%d), prot. %d\n", + /**** tileno, */ + tileno, tpno, + startpack, + stoppack, + /***** j2k->image_info->tile[tileno].packet[startpack].start_pos, + j2k->image_info->tile[tileno].packet[stoppack].end_pos, */ + j2k->cstr_info->tile[tileno].packet[first_tp_pack + startpack].start_pos, + j2k->cstr_info->tile[tileno].packet[first_tp_pack + stoppack].end_pos, + pprot); + + /***** prot_len = j2k->cstr_info->tile[tileno].packet[stoppack].end_pos + 1 - + j2k->cstr_info->tile[tileno].packet[startpack].start_pos; */ + prot_len = j2k->cstr_info->tile[tileno].packet[first_tp_pack + stoppack].end_pos + 1 - + j2k->cstr_info->tile[tileno].packet[first_tp_pack + startpack].start_pos; + + /* + particular case: if this is the last header and the last packet, + then it is better to protect even the EOC marker + */ + /***** if ((tileno == ((j2k->cstr_info->tw * j2k->cstr_info->th) - 1)) && + (stoppack == (j2k->cstr_info->num - 1))) */ + if ((tileno == ((j2k->cstr_info->tw * j2k->cstr_info->th) - 1)) && + (tpno == (j2k->cstr_info->tile[tileno].num_tps - 1)) && + (stoppack == last_tp_pack)) + /* add the EOC len */ + prot_len += 2; + + /* let's add the EPBs */ + Psot += jpwl_epbs_add( + j2k, /* J2K handle */ + jwmarker, /* pointer to JPWL markers list */ + &jwmarker_num, /* pointer to the number of current markers */ + OPJ_TRUE, /* latest */ + OPJ_TRUE, /* packed */ + OPJ_FALSE, /* inside MH */ + &epb_index, /* pointer to EPB index */ + pprot, /* protection type */ + /***** (double) (j2k->cstr_info->tile[tileno].start_pos + sot_len + 2) + 0.0001,*/ /* position */ + (double) (j2k->cstr_info->tile[tileno].tp[tpno].tp_start_pos + sot_len + 2) + 0.0001, /* position */ + tileno, /* number of tile */ + 0, /* length of pre-data */ + prot_len /*4000*/ /* length of post-data */ + ); + } + + /* we can now check if the TPH EPB was really the last one */ + if (tph_epb && (epb_index == 1)) { + /* set the TPH EPB to be the last one in current header */ + tph_epb->Depb |= (unsigned char) ((OPJ_TRUE & 0x0001) << 6); + tph_epb = NULL; + } + + /* write back Psot */ + cio_seek(cio, Psotp); + cio_write(cio, Psot, 4); + + } + + }; + + /* reset the position */ + cio_seek(cio, ciopos); + +} + +void jpwl_dump_marks(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image) { + + int mm; + unsigned long int old_size = j2k->cstr_info->codestream_size; + unsigned long int new_size = old_size; + int /*ciopos = cio_tell(cio),*/ soc_pos = j2k->cstr_info->main_head_start; + unsigned char *jpwl_buf, *orig_buf; + unsigned long int orig_pos; + double epbcoding_time = 0.0, esdcoding_time = 0.0; + (void)image; + + /* Order JPWL markers according to their wishlist position */ + qsort((void *) jwmarker, (size_t) jwmarker_num, sizeof (jpwl_marker_t), jpwl_markcomp); + + /* compute markers total size */ + for (mm = 0; mm < jwmarker_num; mm++) { + /*printf("%x, %d, %.10f, %d long\n", jwmarker[mm].id, jwmarker[mm].pos, + jwmarker[mm].dpos, jwmarker[mm].len);*/ + new_size += jwmarker[mm].len + 2; + } + + /* allocate a new buffer of proper size */ + if (!(jpwl_buf = (unsigned char *) opj_malloc((size_t) (new_size + soc_pos) * sizeof(unsigned char)))) { + opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not allocate room for JPWL codestream buffer\n"); + exit(1); + }; + + /* copy the jp2 part, if any */ + orig_buf = jpwl_buf; + memcpy(jpwl_buf, cio->buffer, soc_pos); + jpwl_buf += soc_pos; + + /* cycle through markers */ + orig_pos = soc_pos + 0; /* start from the beginning */ + cio_seek(cio, soc_pos + 0); /* rewind the original */ + for (mm = 0; mm < jwmarker_num; mm++) { + + /* + need to copy a piece of the original codestream + if there is such + */ + memcpy(jpwl_buf, cio_getbp(cio), jwmarker[mm].pos - orig_pos); + jpwl_buf += jwmarker[mm].pos - orig_pos; + orig_pos = jwmarker[mm].pos; + cio_seek(cio, orig_pos); + + /* + then write down the marker + */ + switch (jwmarker[mm].id) { + + case J2K_MS_EPB: + jpwl_epb_write(j2k, jwmarker[mm].m.epbmark, jpwl_buf); + break; + + case J2K_MS_EPC: + jpwl_epc_write(j2k, jwmarker[mm].m.epcmark, jpwl_buf); + break; + + case J2K_MS_ESD: + jpwl_esd_write(j2k, jwmarker[mm].m.esdmark, jpwl_buf); + break; + + case J2K_MS_RED: + memset(jpwl_buf, 0, jwmarker[mm].len + 2); /* placeholder */ + break; + + default: + break; + }; + + /* we update the markers struct */ + if (j2k->cstr_info) + j2k->cstr_info->marker[j2k->cstr_info->marknum - 1].pos = (jpwl_buf - orig_buf); + + /* we set the marker dpos to the new position in the JPWL codestream */ + jwmarker[mm].dpos = (double) (jpwl_buf - orig_buf); + + /* advance JPWL buffer position */ + jpwl_buf += jwmarker[mm].len + 2; + + } + + /* finish remaining original codestream */ + memcpy(jpwl_buf, cio_getbp(cio), old_size - (orig_pos - soc_pos)); + jpwl_buf += old_size - (orig_pos - soc_pos); + cio_seek(cio, soc_pos + old_size); + + /* + update info file based on added markers + */ + if (!jpwl_update_info(j2k, jwmarker, jwmarker_num)) + opj_event_msg(j2k->cinfo, EVT_ERROR, "Could not update OPJ cstr_info structure\n"); + + /* now we need to repass some markers and fill their data fields */ + + /* first of all, DL and Pcrc in EPCs */ + for (mm = 0; mm < jwmarker_num; mm++) { + + /* find the EPCs */ + if (jwmarker[mm].id == J2K_MS_EPC) { + + int epc_pos = (int) jwmarker[mm].dpos, pp; + unsigned short int mycrc = 0x0000; + + /* fix and fill the DL field */ + jwmarker[mm].m.epcmark->DL = new_size; + orig_buf[epc_pos + 6] = (unsigned char) (jwmarker[mm].m.epcmark->DL >> 24); + orig_buf[epc_pos + 7] = (unsigned char) (jwmarker[mm].m.epcmark->DL >> 16); + orig_buf[epc_pos + 8] = (unsigned char) (jwmarker[mm].m.epcmark->DL >> 8); + orig_buf[epc_pos + 9] = (unsigned char) (jwmarker[mm].m.epcmark->DL >> 0); + + /* compute the CRC field (excluding itself) */ + for (pp = 0; pp < 4; pp++) + jpwl_updateCRC16(&mycrc, orig_buf[epc_pos + pp]); + for (pp = 6; pp < (jwmarker[mm].len + 2); pp++) + jpwl_updateCRC16(&mycrc, orig_buf[epc_pos + pp]); + + /* fix and fill the CRC */ + jwmarker[mm].m.epcmark->Pcrc = mycrc; + orig_buf[epc_pos + 4] = (unsigned char) (jwmarker[mm].m.epcmark->Pcrc >> 8); + orig_buf[epc_pos + 5] = (unsigned char) (jwmarker[mm].m.epcmark->Pcrc >> 0); + + } + } + + /* then, sensitivity data in ESDs */ + esdcoding_time = opj_clock(); + for (mm = 0; mm < jwmarker_num; mm++) { + + /* find the ESDs */ + if (jwmarker[mm].id == J2K_MS_ESD) { + + /* remember that they are now in a new position (dpos) */ + int esd_pos = (int) jwmarker[mm].dpos; + + jpwl_esd_fill(j2k, jwmarker[mm].m.esdmark, &orig_buf[esd_pos]); + + } + + } + esdcoding_time = opj_clock() - esdcoding_time; + if (j2k->cp->esd_on) + opj_event_msg(j2k->cinfo, EVT_INFO, "ESDs sensitivities computed in %f s\n", esdcoding_time); + + /* finally, RS or CRC parity in EPBs */ + epbcoding_time = opj_clock(); + for (mm = 0; mm < jwmarker_num; mm++) { + + /* find the EPBs */ + if (jwmarker[mm].id == J2K_MS_EPB) { + + /* remember that they are now in a new position (dpos) */ + int nn, accum_len; + + /* let's see how many EPBs are following this one, included itself */ + /* for this to work, we suppose that the markers are correctly ordered */ + /* and, overall, that they are in packed mode inside headers */ + accum_len = 0; + for (nn = mm; (nn < jwmarker_num) && (jwmarker[nn].id == J2K_MS_EPB) && + (jwmarker[nn].pos == jwmarker[mm].pos); nn++) + accum_len += jwmarker[nn].m.epbmark->Lepb + 2; + + /* fill the current (first) EPB with post-data starting from the computed position */ + jpwl_epb_fill(j2k, jwmarker[mm].m.epbmark, &orig_buf[(int) jwmarker[mm].dpos], + &orig_buf[(int) jwmarker[mm].dpos + accum_len]); + + /* fill the remaining EPBs in the header with post-data starting from the last position */ + for (nn = mm + 1; (nn < jwmarker_num) && (jwmarker[nn].id == J2K_MS_EPB) && + (jwmarker[nn].pos == jwmarker[mm].pos); nn++) + jpwl_epb_fill(j2k, jwmarker[nn].m.epbmark, &orig_buf[(int) jwmarker[nn].dpos], NULL); + + /* skip all the processed EPBs */ + mm = nn - 1; + } + + } + epbcoding_time = opj_clock() - epbcoding_time; + if (j2k->cp->epb_on) + opj_event_msg(j2k->cinfo, EVT_INFO, "EPBs redundancy computed in %f s\n", epbcoding_time); + + /* free original cio buffer and set it to the JPWL one */ + opj_free(cio->buffer); + cio->cinfo = cio->cinfo; /* no change */ + cio->openmode = cio->openmode; /* no change */ + cio->buffer = orig_buf; + cio->length = new_size + soc_pos; + cio->start = cio->buffer; + cio->end = cio->buffer + cio->length; + cio->bp = cio->buffer; + cio_seek(cio, soc_pos + new_size); + +} + + +void j2k_read_epc(opj_j2k_t *j2k) { + unsigned long int DL, Lepcp, Pcrcp, l; + unsigned short int Lepc, Pcrc = 0x0000; + unsigned char Pepc; + opj_cio_t *cio = j2k->cio; + const char *ans1; + + /* Simply read the EPC parameters */ + Lepcp = cio_tell(cio); + Lepc = cio_read(cio, 2); + Pcrcp = cio_tell(cio); + cio_skip(cio, 2); /* Pcrc */ + DL = cio_read(cio, 4); + Pepc = cio_read(cio, 1); + + /* compute Pcrc */ + cio_seek(cio, Lepcp - 2); + + /* Marker */ + jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); + jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); + + /* Length */ + jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); + jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); + + /* skip Pcrc */ + cio_skip(cio, 2); + + /* read all remaining */ + for (l = 4; l < Lepc; l++) + jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); + + /* check Pcrc with the result */ + cio_seek(cio, Pcrcp); + ans1 = (Pcrc == (unsigned short int) cio_read(cio, 2)) ? "crc-ok" : "crc-ko"; + + /* now we write them to screen */ + opj_event_msg(j2k->cinfo, EVT_INFO, + "EPC(%u,%d): %s, DL=%d%s %s %s\n", + Lepcp - 2, + Lepc, + ans1, + DL, /* data length this EPC is referring to */ + (Pepc & 0x10) ? ", esd" : "", /* ESD is present */ + (Pepc & 0x20) ? ", red" : "", /* RED is present */ + (Pepc & 0x40) ? ", epb" : ""); /* EPB is present */ + + cio_seek(cio, Lepcp + Lepc); +} + +void j2k_write_epc(opj_j2k_t *j2k) { + + unsigned long int DL, Lepcp, Pcrcp, l; + unsigned short int Lepc, Pcrc; + unsigned char Pepc; + + opj_cio_t *cio = j2k->cio; + + cio_write(cio, J2K_MS_EPC, 2); /* EPC */ + Lepcp = cio_tell(cio); + cio_skip(cio, 2); + + /* CRC-16 word of the EPC */ + Pcrc = 0x0000; /* initialize */ + Pcrcp = cio_tell(cio); + cio_write(cio, Pcrc, 2); /* Pcrc placeholder*/ + + /* data length of the EPC protection domain */ + DL = 0x00000000; /* we leave this set to 0, as if the information is not available */ + cio_write(cio, DL, 4); /* DL */ + + /* jpwl capabilities */ + Pepc = 0x00; + cio_write(cio, Pepc, 1); /* Pepc */ + + /* ID section */ + /* no ID's, as of now */ + + Lepc = (unsigned short) (cio_tell(cio) - Lepcp); + cio_seek(cio, Lepcp); + cio_write(cio, Lepc, 2); /* Lepc */ + + /* compute Pcrc */ + cio_seek(cio, Lepcp - 2); + + /* Marker */ + jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); + jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); + + /* Length */ + jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); + jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); + + /* skip Pcrc */ + cio_skip(cio, 2); + + /* read all remaining */ + for (l = 4; l < Lepc; l++) + jpwl_updateCRC16(&Pcrc, (unsigned char) cio_read(cio, 1)); + + /* fill Pcrc with the result */ + cio_seek(cio, Pcrcp); + cio_write(cio, Pcrc, 2); + + cio_seek(cio, Lepcp + Lepc); + + /* marker struct update */ + j2k_add_marker(j2k->cstr_info, J2K_MS_EPC, Lepcp - 2, Lepc + 2); + +} + +void j2k_read_epb(opj_j2k_t *j2k) { + unsigned long int LDPepb, Pepb; + unsigned short int Lepb; + unsigned char Depb; + char str1[25] = ""; + opj_bool status; + static opj_bool first_in_tph = OPJ_TRUE; + int type, pre_len, post_len; + static unsigned char *redund = NULL; + + opj_cio_t *cio = j2k->cio; + + /* B/W = 45, RGB = 51 */ + /* SIZ SIZ_FIELDS SIZ_COMPS FOLLOWING_MARKER */ + int skipnum = 2 + 38 + 3 * j2k->cp->exp_comps + 2; + + if (j2k->cp->correct) { + + /* go back to EPB marker value */ + cio_seek(cio, cio_tell(cio) - 2); + + /* we need to understand where we are */ + if (j2k->state == J2K_STATE_MH) { + /* we are in MH */ + type = 0; /* MH */ + pre_len = skipnum; /* SOC+SIZ */ + post_len = -1; /* auto */ + + } else if ((j2k->state == J2K_STATE_TPH) && first_in_tph) { + /* we are in TPH */ + type = 1; /* TPH */ + pre_len = 12; /* SOC+SIZ */ + first_in_tph = OPJ_FALSE; + post_len = -1; /* auto */ + + } else { + /* we are elsewhere */ + type = 2; /* other */ + pre_len = 0; /* nada */ + post_len = -1; /* auto */ + + } + + /* call EPB corrector */ + /*printf("before %x, ", redund);*/ + status = jpwl_epb_correct(j2k, /* J2K decompressor handle */ + cio->bp, /* pointer to EPB in codestream buffer */ + type, /* EPB type: MH */ + pre_len, /* length of pre-data */ + post_len, /* length of post-data: -1 means auto */ + NULL, /* do everything auto */ + &redund + ); + /*printf("after %x\n", redund);*/ + + /* Read the (possibly corrected) EPB parameters */ + cio_skip(cio, 2); + Lepb = cio_read(cio, 2); + Depb = cio_read(cio, 1); + LDPepb = cio_read(cio, 4); + Pepb = cio_read(cio, 4); + + if (!status) { + + opj_event_msg(j2k->cinfo, EVT_ERROR, "JPWL correction could not be performed\n"); + + /* advance to EPB endpoint */ + cio_skip(cio, Lepb + 2); + + return; + } + + /* last in current header? */ + if (Depb & 0x40) { + redund = NULL; /* reset the pointer to L4 buffer */ + first_in_tph = OPJ_TRUE; + } + + /* advance to EPB endpoint */ + cio_skip(cio, Lepb - 11); + + } else { + + /* Simply read the EPB parameters */ + Lepb = cio_read(cio, 2); + Depb = cio_read(cio, 1); + LDPepb = cio_read(cio, 4); + Pepb = cio_read(cio, 4); + + /* What does Pepb tells us about the protection method? */ + if (((Pepb & 0xF0000000) >> 28) == 0) + sprintf(str1, "pred"); /* predefined */ + else if (((Pepb & 0xF0000000) >> 28) == 1) + sprintf(str1, "crc-%lu", 16 * ((Pepb & 0x00000001) + 1)); /* CRC mode */ + else if (((Pepb & 0xF0000000) >> 28) == 2) + sprintf(str1, "rs(%lu,32)", (Pepb & 0x0000FF00) >> 8); /* RS mode */ + else if (Pepb == 0xFFFFFFFF) + sprintf(str1, "nometh"); /* RS mode */ + else + sprintf(str1, "unknown"); /* unknown */ + + /* Now we write them to screen */ + opj_event_msg(j2k->cinfo, EVT_INFO, + "EPB(%d): (%sl, %sp, %u), %lu, %s\n", + cio_tell(cio) - 13, + (Depb & 0x40) ? "" : "n", /* latest EPB or not? */ + (Depb & 0x80) ? "" : "n", /* packed or unpacked EPB? */ + (Depb & 0x3F), /* EPB index value */ + LDPepb, /*length of the data protected by the EPB */ + str1); /* protection method */ + + cio_skip(cio, Lepb - 11); + } +} + +void j2k_write_epb(opj_j2k_t *j2k) { + unsigned long int LDPepb, Pepb, Lepbp; + unsigned short int Lepb; + unsigned char Depb; + + opj_cio_t *cio = j2k->cio; + + cio_write(cio, J2K_MS_EPB, 2); /* EPB */ + Lepbp = cio_tell(cio); + cio_skip(cio, 2); + + /* EPB style */ + Depb = 0x00; /* test */ + cio_write(cio, Depb, 1); /* Depb */ + + /* length of the data to be protected by this EPB */ + LDPepb = 0x00000000; /* test */ + cio_write(cio, LDPepb, 4); /* LDPepb */ + + /* next error correction tool */ + Pepb = 0x00000000; /* test */ + cio_write(cio, Pepb, 4); /* Pepb */ + + /* EPB data */ + /* no data, as of now */ + + Lepb = (unsigned short) (cio_tell(cio) - Lepbp); + cio_seek(cio, Lepbp); + cio_write(cio, Lepb, 2); /* Lepb */ + + cio_seek(cio, Lepbp + Lepb); + + /* marker struct update */ + j2k_add_marker(j2k->cstr_info, J2K_MS_EPB, Lepbp - 2, Lepb + 2); +} + +void j2k_read_esd(opj_j2k_t *j2k) { + unsigned short int Lesd, Cesd; + unsigned char Pesd; + + int cesdsize = (j2k->image->numcomps >= 257) ? 2 : 1; + + char str1[4][4] = {"p", "br", "pr", "res"}; + char str2[8][8] = {"res", "mse", "mse-r", "psnr", "psnr-i", "maxerr", "tse", "res"}; + + opj_cio_t *cio = j2k->cio; + + /* Simply read the ESD parameters */ + Lesd = cio_read(cio, 2); + Cesd = cio_read(cio, cesdsize); + Pesd = cio_read(cio, 1); + + /* Now we write them to screen */ + opj_event_msg(j2k->cinfo, EVT_INFO, + "ESD(%d): c%d, %s, %s, %s, %s, %s\n", + cio_tell(cio) - (5 + cesdsize), + Cesd, /* component number for this ESD */ + str1[(Pesd & (unsigned char) 0xC0) >> 6], /* addressing mode */ + str2[(Pesd & (unsigned char) 0x38) >> 3], /* sensitivity type */ + ((Pesd & (unsigned char) 0x04) >> 2) ? "2Bs" : "1Bs", + ((Pesd & (unsigned char) 0x02) >> 1) ? "4Ba" : "2Ba", + (Pesd & (unsigned char) 0x01) ? "avgc" : ""); + + cio_skip(cio, Lesd - (3 + cesdsize)); +} + +void j2k_read_red(opj_j2k_t *j2k) { + unsigned short int Lred; + unsigned char Pred; + char str1[4][4] = {"p", "br", "pr", "res"}; + + opj_cio_t *cio = j2k->cio; + + /* Simply read the RED parameters */ + Lred = cio_read(cio, 2); + Pred = cio_read(cio, 1); + + /* Now we write them to screen */ + opj_event_msg(j2k->cinfo, EVT_INFO, + "RED(%d): %s, %dc, %s, %s\n", + cio_tell(cio) - 5, + str1[(Pred & (unsigned char) 0xC0) >> 6], /* addressing mode */ + (Pred & (unsigned char) 0x38) >> 3, /* corruption level */ + ((Pred & (unsigned char) 0x02) >> 1) ? "4Ba" : "2Ba", /* address range */ + (Pred & (unsigned char) 0x01) ? "errs" : "free"); /* error free? */ + + cio_skip(cio, Lred - 3); +} + +opj_bool jpwl_check_tile(opj_j2k_t *j2k, opj_tcd_t *tcd, int tileno) { + +#ifdef oerhgierhgvhreit4u + /* + we navigate through the tile and find possible invalid parameters: + this saves a lot of crashes!!!!! + */ + int compno, resno, precno, /*layno,*/ bandno, blockno; + int numprecincts, numblocks; + + /* this is the selected tile */ + opj_tcd_tile_t *tile = &(tcd->tcd_image->tiles[tileno]); + + /* will keep the component */ + opj_tcd_tilecomp_t *comp = NULL; + + /* will keep the resolution */ + opj_tcd_resolution_t *res; + + /* will keep the subband */ + opj_tcd_band_t *band; + + /* will keep the precinct */ + opj_tcd_precinct_t *prec; + + /* will keep the codeblock */ + opj_tcd_cblk_t *block; + + /* check all tile components */ + for (compno = 0; compno < tile->numcomps; compno++) { + comp = &(tile->comps[compno]); + + /* check all component resolutions */ + for (resno = 0; resno < comp->numresolutions; resno++) { + res = &(comp->resolutions[resno]); + numprecincts = res->pw * res->ph; + + /* check all the subbands */ + for (bandno = 0; bandno < res->numbands; bandno++) { + band = &(res->bands[bandno]); + + /* check all the precincts */ + for (precno = 0; precno < numprecincts; precno++) { + prec = &(band->precincts[precno]); + numblocks = prec->ch * prec->cw; + + /* check all the codeblocks */ + for (blockno = 0; blockno < numblocks; blockno++) { + block = &(prec->cblks[blockno]); + + /* x-origin is invalid */ + if ((block->x0 < prec->x0) || (block->x0 > prec->x1)) { + opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR, + "JPWL: wrong x-cord of block origin %d => x-prec is (%d, %d)\n", + block->x0, prec->x0, prec->x1); + if (!JPWL_ASSUME || JPWL_ASSUME) + return OPJ_FALSE; + }; + } + } + } + } + } + +#else + (void)j2k; + (void)tcd; + (void)tileno; +#endif + + return OPJ_TRUE; +} + +/*@}*/ + +#endif /* USE_JPWL */ + + +#ifdef USE_JPSEC + +/** @defgroup JPSEC JPSEC - JPEG-2000 Part 8 (JPSEC) codestream manager */ +/*@{*/ + + +/** @name Local static functions */ +/*@{*/ + +void j2k_read_sec(opj_j2k_t *j2k) { + unsigned short int Lsec; + + opj_cio_t *cio = j2k->cio; + + /* Simply read the SEC length */ + Lsec = cio_read(cio, 2); + + /* Now we write them to screen */ + opj_event_msg(j2k->cinfo, EVT_INFO, + "SEC(%d)\n", + cio_tell(cio) - 2 + ); + + cio_skip(cio, Lsec - 2); +} + +void j2k_write_sec(opj_j2k_t *j2k) { + unsigned short int Lsec = 24; + int i; + + opj_cio_t *cio = j2k->cio; + + cio_write(cio, J2K_MS_SEC, 2); /* SEC */ + cio_write(cio, Lsec, 2); + + /* write dummy data */ + for (i = 0; i < Lsec - 2; i++) + cio_write(cio, 0, 1); +} + +void j2k_read_insec(opj_j2k_t *j2k) { + unsigned short int Linsec; + + opj_cio_t *cio = j2k->cio; + + /* Simply read the INSEC length */ + Linsec = cio_read(cio, 2); + + /* Now we write them to screen */ + opj_event_msg(j2k->cinfo, EVT_INFO, + "INSEC(%d)\n", + cio_tell(cio) - 2 + ); + + cio_skip(cio, Linsec - 2); +} + + +/*@}*/ + +/*@}*/ + +#endif /* USE_JPSEC */ +