2004-07-07 10:24:36 +02:00
/*
2007-01-15 10:55:40 +01:00
* Copyright ( c ) 2002 - 2007 , Communications and Remote Sensing Laboratory , Universite catholique de Louvain ( UCL ) , Belgium
* Copyright ( c ) 2002 - 2007 , Professor Benoit Macq
* Copyright ( c ) 2001 - 2003 , David Janssens
* Copyright ( c ) 2002 - 2003 , Yannick Verschueren
* Copyright ( c ) 2003 - 2007 , Francois - Olivier Devaux and Antonin Descampe
* Copyright ( c ) 2005 , Herve Drolon , FreeImage Team
2011-09-09 16:49:08 +02:00
* Copyright ( c ) 2010 - 2011 , Kaori Hagihara
2005-12-02 14:34:15 +01:00
* 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"
2005-12-08 10:38:47 +01:00
/** @defgroup JP2 JP2 - JPEG-2000 file format reader/writer */
/*@{*/
2011-09-19 15:36:07 +02:00
# define BOX_SIZE 1024
2005-12-08 10:38:47 +01:00
/** @name Local static functions */
/*@{*/
2012-08-10 12:57:51 +02:00
2006-01-20 17:53:05 +01:00
/*static void jp2_write_url(opj_cio_t *cio, char *Idx_file);*/
2011-09-19 15:36:07 +02:00
/**
* Reads a IHDR box - Image Header box
*
* @ param p_image_header_data pointer to actual data ( already read from file )
* @ param jp2 the jpeg2000 file codec .
* @ param p_image_header_size the size of the image header
* @ param p_manager the user event manager .
*
2012-08-09 15:22:25 +02:00
* @ return true if the image header is valid , false else .
2011-09-19 15:36:07 +02:00
*/
2012-08-10 11:47:56 +02:00
static opj_bool opj_jp2_read_ihdr ( opj_jp2_v2_t * jp2 ,
2012-08-09 15:22:25 +02:00
OPJ_BYTE * p_image_header_data ,
2012-08-10 12:34:40 +02:00
OPJ_UINT32 p_image_header_size ,
2012-08-09 15:22:25 +02:00
opj_event_mgr_t * p_manager ) ;
2011-09-19 15:36:07 +02:00
2012-05-14 11:37:36 +02:00
/**
* Writes the Image Header box - Image Header box .
*
* @ param jp2 jpeg2000 file codec .
* @ param p_nb_bytes_written pointer to store the nb of bytes written by the function .
*
* @ return the data being copied .
*/
2012-08-13 11:27:58 +02:00
static OPJ_BYTE * opj_jp2_write_ihdr ( opj_jp2_v2_t * jp2 ,
OPJ_UINT32 * p_nb_bytes_written ) ;
2012-05-14 11:37:36 +02:00
/**
* Writes the Bit per Component box .
*
* @ param jp2 jpeg2000 file codec .
* @ param p_nb_bytes_written pointer to store the nb of bytes written by the function .
*
* @ return the data being copied .
*/
2012-08-13 11:31:24 +02:00
static OPJ_BYTE * opj_jp2_write_bpcc ( opj_jp2_v2_t * jp2 ,
OPJ_UINT32 * p_nb_bytes_written ) ;
2012-05-14 11:37:36 +02:00
2011-09-19 15:36:07 +02:00
/**
* Reads a Bit per Component box .
*
* @ param p_bpc_header_data pointer to actual data ( already read from file )
* @ param jp2 the jpeg2000 file codec .
* @ param p_bpc_header_size the size of the bpc header
* @ param p_manager the user event manager .
*
* @ return true if the bpc header is valid , fale else .
*/
2012-08-10 11:53:28 +02:00
static opj_bool opj_jp2_read_bpcc ( opj_jp2_v2_t * jp2 ,
OPJ_BYTE * p_bpc_header_data ,
2012-08-10 12:34:40 +02:00
OPJ_UINT32 p_bpc_header_size ,
2012-08-10 11:53:28 +02:00
opj_event_mgr_t * p_manager ) ;
2011-09-19 15:36:07 +02:00
2012-08-10 12:19:11 +02:00
static opj_bool opj_jp2_read_cdef ( opj_jp2_v2_t * jp2 ,
OPJ_BYTE * p_cdef_header_data ,
2011-09-19 15:36:07 +02:00
OPJ_UINT32 p_cdef_header_size ,
2012-08-10 12:19:11 +02:00
opj_event_mgr_t * p_manager ) ;
2012-08-13 12:10:25 +02:00
static void opj_jp2_apply_cdef ( opj_image_t * image , opj_jp2_color_t * color ) ;
2012-05-14 11:37:36 +02:00
/**
* Writes the Colour Specification box .
*
* @ param jp2 jpeg2000 file codec .
* @ param p_nb_bytes_written pointer to store the nb of bytes written by the function .
*
* @ return the data being copied .
*/
2012-08-13 11:35:16 +02:00
static OPJ_BYTE * opj_jp2_write_colr ( opj_jp2_v2_t * jp2 ,
OPJ_UINT32 * p_nb_bytes_written ) ;
2012-05-14 11:37:36 +02:00
/**
* Writes a FTYP box - File type box
*
* @ param cio the stream to write data to .
* @ param jp2 the jpeg2000 file codec .
* @ param p_manager the user event manager .
*
* @ return true if writting was successful .
*/
2012-08-13 11:39:51 +02:00
static opj_bool opj_jp2_write_ftyp ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * cio ,
opj_event_mgr_t * p_manager ) ;
2012-05-14 11:37:36 +02:00
2011-09-19 15:36:07 +02:00
/**
* Reads a a FTYP box - File type box
*
* @ param p_header_data the data contained in the FTYP box .
* @ param jp2 the jpeg2000 file codec .
* @ param p_header_size the size of the data contained in the FTYP box .
* @ param p_manager the user event manager .
*
* @ return true if the FTYP box is valid .
*/
2012-08-10 12:24:09 +02:00
static opj_bool opj_jp2_read_ftyp ( opj_jp2_v2_t * jp2 ,
2012-08-10 12:22:51 +02:00
OPJ_BYTE * p_header_data ,
2012-05-14 11:37:36 +02:00
OPJ_UINT32 p_header_size ,
2012-08-10 12:22:51 +02:00
opj_event_mgr_t * p_manager ) ;
2011-09-19 15:36:07 +02:00
2012-03-15 11:23:20 +01:00
/**
* Skips the Jpeg2000 Codestream Header box - JP2C Header box .
*
* @ param cio the stream to write data to .
* @ param jp2 the jpeg2000 file codec .
* @ param p_manager user event manager .
*
* @ return true if writting was successful .
*/
2012-08-13 11:44:40 +02:00
opj_bool opj_jp2_skip_jp2c ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * cio ,
opj_event_mgr_t * p_manager ) ;
2012-03-15 11:23:20 +01:00
2011-09-19 15:36:07 +02:00
/**
* Reads the Jpeg2000 file Header box - JP2 Header box ( warning , this is a super box ) .
*
* @ param p_header_data the data contained in the file header box .
* @ param jp2 the jpeg2000 file codec .
* @ param p_header_size the size of the data contained in the file header box .
* @ param p_manager the user event manager .
*
* @ return true if the JP2 Header box was successfully reconized .
*/
2012-08-10 11:43:28 +02:00
static opj_bool opj_jp2_read_jp2h ( opj_jp2_v2_t * jp2 ,
OPJ_BYTE * p_header_data ,
OPJ_UINT32 p_header_size ,
opj_event_mgr_t * p_manager ) ;
2011-09-19 15:36:07 +02:00
2012-05-14 19:17:53 +02:00
/**
* Writes the Jpeg2000 codestream Header box - JP2C Header box . This function must be called AFTER the coding has been done .
*
* @ param cio the stream to write data to .
* @ param jp2 the jpeg2000 file codec .
* @ param p_manager user event manager .
*
* @ return true if writting was successful .
*/
2012-08-13 11:57:09 +02:00
static opj_bool opj_jp2_write_jp2c ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * cio ,
opj_event_mgr_t * p_manager ) ;
2012-05-14 19:17:53 +02:00
2011-09-19 15:36:07 +02:00
/**
* Reads a jpeg2000 file signature box .
*
* @ param p_header_data the data contained in the signature box .
* @ param jp2 the jpeg2000 file codec .
* @ param p_header_size the size of the data contained in the signature box .
* @ param p_manager the user event manager .
*
* @ return true if the file signature box is valid .
*/
2012-08-10 12:34:40 +02:00
static opj_bool opj_jp2_read_jp ( opj_jp2_v2_t * jp2 ,
OPJ_BYTE * p_header_data ,
OPJ_UINT32 p_header_size ,
opj_event_mgr_t * p_manager ) ;
2012-08-10 12:27:17 +02:00
2012-08-13 12:03:57 +02:00
/**
* Writes a jpeg2000 file signature box .
*
* @ param cio the stream to write data to .
* @ param jp2 the jpeg2000 file codec .
* @ param p_manager the user event manager .
*
* @ return true if writting was successful .
*/
static opj_bool opj_jp2_write_jp ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * cio ,
opj_event_mgr_t * p_manager ) ;
2010-10-24 22:28:22 +02:00
/**
Apply collected palette data
2010-12-08 12:06:41 +01:00
@ param color Collector for profile , cdef and pclr data
2010-10-24 22:28:22 +02:00
@ param image
*/
2012-08-13 12:10:25 +02:00
static void opj_jp2_apply_pclr ( opj_image_t * image , opj_jp2_color_t * color ) ;
static void opj_jp2_free_pclr ( opj_jp2_color_t * color ) ;
2010-10-24 22:28:22 +02:00
/**
Collect palette data
@ param jp2 JP2 handle
@ param cio Input buffer stream
@ param box
2010-12-08 12:06:41 +01:00
@ param color Collector for profile , cdef and pclr data
2010-10-24 22:28:22 +02:00
@ return Returns true if successful , returns false otherwise
*/
2012-08-10 12:19:11 +02:00
static opj_bool opj_jp2_read_pclr ( opj_jp2_v2_t * jp2 ,
OPJ_BYTE * p_pclr_header_data ,
OPJ_UINT32 p_pclr_header_size ,
opj_event_mgr_t * p_manager ) ;
2011-09-19 15:36:07 +02:00
2010-10-24 22:28:22 +02:00
/**
Collect component mapping data
@ param jp2 JP2 handle
@ param cio Input buffer stream
@ param box
2010-12-08 12:06:41 +01:00
@ param color Collector for profile , cdef and pclr data
2010-10-24 22:28:22 +02:00
@ return Returns true if successful , returns false otherwise
*/
2011-09-19 15:36:07 +02:00
2012-08-10 12:19:11 +02:00
static opj_bool opj_jp2_read_cmap ( opj_jp2_v2_t * jp2 ,
OPJ_BYTE * p_cmap_header_data ,
OPJ_UINT32 p_cmap_header_size ,
opj_event_mgr_t * p_manager ) ;
2011-09-19 15:36:07 +02:00
/**
* Reads the Color Specification box .
*
* @ param p_colr_header_data pointer to actual data ( already read from file )
* @ param jp2 the jpeg2000 file codec .
* @ param p_colr_header_size the size of the color header
* @ param p_manager the user event manager .
*
* @ return true if the bpc header is valid , fale else .
*/
2012-08-10 12:19:11 +02:00
static opj_bool opj_jp2_read_colr ( opj_jp2_v2_t * jp2 ,
OPJ_BYTE * p_colr_header_data ,
OPJ_UINT32 p_colr_header_size ,
opj_event_mgr_t * p_manager ) ;
2011-09-19 15:36:07 +02:00
2005-12-08 10:38:47 +01:00
/*@}*/
/*@}*/
2005-12-02 14:34:15 +01:00
2012-03-15 11:23:20 +01:00
/**
* Sets up the procedures to do on writting header after the codestream .
* Developpers wanting to extend the library can add their own writting procedures .
*/
2012-08-13 11:44:40 +02:00
static void opj_jp2_setup_end_header_writting ( opj_jp2_v2_t * jp2 ) ;
2012-03-15 11:23:20 +01:00
2011-09-19 15:36:07 +02:00
/**
* Sets up the procedures to do on reading header after the codestream .
* Developpers wanting to extend the library can add their own writting procedures .
*/
2012-08-10 12:55:10 +02:00
static void opj_jp2_setup_end_header_reading ( opj_jp2_v2_t * jp2 ) ;
2011-09-19 15:36:07 +02:00
/**
* Reads a jpeg2000 file header structure .
*
* @ param cio the stream to read data from .
* @ param jp2 the jpeg2000 file header structure .
* @ param p_manager the user event manager .
*
* @ return true if the box is valid .
*/
2012-08-10 12:55:10 +02:00
static opj_bool opj_jp2_read_header_procedure ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * stream ,
opj_event_mgr_t * p_manager ) ;
2011-09-19 15:36:07 +02:00
/**
* Excutes the given procedures on the given codec .
*
* @ param p_procedure_list the list of procedures to execute
* @ param jp2 the jpeg2000 file codec to execute the procedures on .
2012-08-10 12:55:10 +02:00
* @ param stream the stream to execute the procedures on .
2011-09-19 15:36:07 +02:00
* @ param p_manager the user manager .
*
* @ return true if all the procedures were successfully executed .
*/
2012-08-10 12:55:10 +02:00
static opj_bool opj_jp2_exec ( opj_jp2_v2_t * jp2 ,
opj_procedure_list_t * p_procedure_list ,
opj_stream_private_t * stream ,
opj_event_mgr_t * p_manager ) ;
2011-09-19 15:36:07 +02:00
/**
* Reads a box header . The box is the way data is packed inside a jpeg2000 file structure .
*
* @ param cio the input stream to read data from .
* @ param box the box structure to fill .
* @ param p_number_bytes_read pointer to an int that will store the number of bytes read from the stream ( shoul usually be 2 ) .
* @ param p_manager user event manager .
*
* @ return true if the box is reconized , false otherwise
*/
2012-08-10 13:00:40 +02:00
static opj_bool opj_jp2_read_boxhdr ( opj_jp2_box_t * box ,
OPJ_UINT32 * p_number_bytes_read ,
opj_stream_private_t * cio ,
opj_event_mgr_t * p_manager ) ;
2011-09-19 15:36:07 +02:00
2012-03-15 11:23:20 +01:00
/**
* Sets up the validation , i . e . adds the procedures to lauch to make sure the codec parameters
* are valid . Developpers wanting to extend the library can add their own validation procedures .
*/
2012-08-13 11:44:40 +02:00
static void opj_jp2_setup_encoding_validation ( opj_jp2_v2_t * jp2 ) ;
2012-03-15 11:23:20 +01:00
/**
* Sets up the procedures to do on writting header . Developpers wanting to extend the library can add their own writting procedures .
*/
2012-08-13 11:44:40 +02:00
static void opj_jp2_setup_header_writting ( opj_jp2_v2_t * jp2 ) ;
2012-03-15 11:23:20 +01:00
/**
* The default validation procedure without any extension .
*
* @ param jp2 the jpeg2000 codec to validate .
* @ param cio the input stream to validate .
* @ param p_manager the user event manager .
*
* @ return true if the parameters are correct .
*/
2012-08-10 12:55:10 +02:00
opj_bool opj_jp2_default_validation ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * cio ,
opj_event_mgr_t * p_manager ) ;
2012-03-15 11:23:20 +01:00
2011-09-19 15:36:07 +02:00
/**
* Finds the image execution function related to the given box id .
*
* @ param p_id the id of the handler to fetch .
*
* @ return the given handler or NULL if it could not be found .
*/
2012-08-10 12:55:10 +02:00
static const opj_jp2_header_handler_t * opj_jp2_img_find_handler ( OPJ_UINT32 p_id ) ;
/**
* Finds the execution function related to the given box id .
*
* @ param p_id the id of the handler to fetch .
*
* @ return the given handler or NULL if it could not be found .
*/
static const opj_jp2_header_handler_t * opj_jp2_find_handler ( OPJ_UINT32 p_id ) ;
2011-09-19 15:36:07 +02:00
const opj_jp2_header_handler_t jp2_header [ ] =
{
2012-08-10 12:34:40 +02:00
{ JP2_JP , opj_jp2_read_jp } ,
2012-08-10 12:24:09 +02:00
{ JP2_FTYP , opj_jp2_read_ftyp } ,
2012-08-10 11:43:28 +02:00
{ JP2_JP2H , opj_jp2_read_jp2h }
2011-09-19 15:36:07 +02:00
} ;
const opj_jp2_header_handler_t jp2_img_header [ ] =
{
2012-08-10 11:47:56 +02:00
{ JP2_IHDR , opj_jp2_read_ihdr } ,
2012-08-10 12:19:11 +02:00
{ JP2_COLR , opj_jp2_read_colr } ,
2012-08-10 11:53:28 +02:00
{ JP2_BPCC , opj_jp2_read_bpcc } ,
2012-08-10 12:19:11 +02:00
{ JP2_PCLR , opj_jp2_read_pclr } ,
{ JP2_CMAP , opj_jp2_read_cmap } ,
{ JP2_CDEF , opj_jp2_read_cdef }
2011-09-19 15:36:07 +02:00
} ;
/**
* Reads a box header . The box is the way data is packed inside a jpeg2000 file structure . Data is read from a character string
*
* @ param p_data the character string to read data from .
* @ param box the box structure to fill .
* @ param p_number_bytes_read pointer to an int that will store the number of bytes read from the stream ( shoul usually be 2 ) .
* @ param p_box_max_size the maximum number of bytes in the box .
*
* @ return true if the box is reconized , false otherwise
*/
2012-08-10 12:55:10 +02:00
static opj_bool opj_jp2_read_boxhdr_char ( opj_jp2_box_t * box ,
OPJ_BYTE * p_data ,
OPJ_UINT32 * p_number_bytes_read ,
OPJ_UINT32 p_box_max_size ,
opj_event_mgr_t * p_manager ) ;
2011-09-19 15:36:07 +02:00
/**
* Sets up the validation , i . e . adds the procedures to lauch to make sure the codec parameters
* are valid . Developpers wanting to extend the library can add their own validation procedures .
*/
2012-08-10 12:55:10 +02:00
static void opj_jp2_setup_decoding_validation ( opj_jp2_v2_t * jp2 ) ;
2011-09-19 15:36:07 +02:00
/**
* Sets up the procedures to do on reading header .
* Developpers wanting to extend the library can add their own writting procedures .
*/
2012-08-10 12:55:10 +02:00
static void opj_jp2_setup_header_reading ( opj_jp2_v2_t * jp2 ) ;
2011-09-19 15:36:07 +02:00
2005-12-02 14:34:15 +01:00
/* ----------------------------------------------------------------------- */
2011-09-19 15:36:07 +02:00
/**
* Reads a box header . The box is the way data is packed inside a jpeg2000 file structure .
*
* @ param cio the input stream to read data from .
* @ param box the box structure to fill .
* @ param p_number_bytes_read pointer to an int that will store the number of bytes read from the stream ( should usually be 8 ) .
* @ param p_manager user event manager .
*
* @ return true if the box is reconized , false otherwise
*/
2012-08-10 13:00:40 +02:00
opj_bool opj_jp2_read_boxhdr ( opj_jp2_box_t * box ,
OPJ_UINT32 * p_number_bytes_read ,
opj_stream_private_t * cio ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
/* read header from file */
unsigned char l_data_header [ 8 ] ;
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( cio ! = 00 ) ;
assert ( box ! = 00 ) ;
assert ( p_number_bytes_read ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
* p_number_bytes_read = opj_stream_read_data ( cio , l_data_header , 8 , p_manager ) ;
if ( * p_number_bytes_read ! = 8 ) {
return OPJ_FALSE ;
}
/* process read data */
opj_read_bytes ( l_data_header , & ( box - > length ) , 4 ) ;
opj_read_bytes ( l_data_header + 4 , & ( box - > type ) , 4 ) ;
2012-03-02 16:53:14 +01:00
/* do we have a "special very large box ?" */
/* read then the XLBox */
2011-09-19 15:36:07 +02:00
if ( box - > length = = 1 ) {
OPJ_UINT32 l_xl_part_size ;
OPJ_UINT32 l_nb_bytes_read = opj_stream_read_data ( cio , l_data_header , 8 , p_manager ) ;
if ( l_nb_bytes_read ! = 8 ) {
if ( l_nb_bytes_read > 0 ) {
* p_number_bytes_read + = l_nb_bytes_read ;
}
return OPJ_FALSE ;
}
opj_read_bytes ( l_data_header , & l_xl_part_size , 4 ) ;
if ( l_xl_part_size ! = 0 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Cannot handle box sizes higher than 2^32 \n " ) ;
return OPJ_FALSE ;
}
opj_read_bytes ( l_data_header , & ( box - > length ) , 4 ) ;
}
return OPJ_TRUE ;
}
2006-01-20 17:53:05 +01:00
#if 0
2005-12-02 14:34:15 +01:00
static void jp2_write_url ( opj_cio_t * cio , char * Idx_file ) {
2005-12-08 10:38:47 +01:00
unsigned int i ;
opj_jp2_box_t box ;
box . init_pos = cio_tell ( cio ) ;
cio_skip ( cio , 4 ) ;
cio_write ( cio , JP2_URL , 4 ) ; /* DBTL */
cio_write ( cio , 0 , 1 ) ; /* VERS */
cio_write ( cio , 0 , 3 ) ; /* FLAG */
if ( Idx_file ) {
for ( i = 0 ; i < strlen ( Idx_file ) ; i + + ) {
cio_write ( cio , Idx_file [ i ] , 1 ) ;
}
}
box . length = cio_tell ( cio ) - box . init_pos ;
cio_seek ( cio , box . init_pos ) ;
cio_write ( cio , box . length , 4 ) ; /* L */
cio_seek ( cio , box . init_pos + box . length ) ;
2004-07-07 10:24:36 +02:00
}
2006-01-20 17:53:05 +01:00
# endif
2004-07-07 10:24:36 +02:00
2011-09-19 15:36:07 +02:00
/**
* Reads a IHDR box - Image Header box
*
* @ param jp2 the jpeg2000 file codec .
2011-12-03 18:26:59 +01:00
* @ param p_image_header_data pointer to actual data ( already read from file )
2011-09-19 15:36:07 +02:00
* @ param p_image_header_size the size of the image header
* @ param p_manager the user event manager .
*
* @ return true if the image header is valid , fale else .
*/
2012-08-10 11:47:56 +02:00
opj_bool opj_jp2_read_ihdr ( opj_jp2_v2_t * jp2 ,
2012-08-09 15:22:25 +02:00
OPJ_BYTE * p_image_header_data ,
2012-08-10 12:34:40 +02:00
OPJ_UINT32 p_image_header_size ,
2012-08-10 11:47:56 +02:00
opj_event_mgr_t * p_manager )
2011-09-19 15:36:07 +02:00
{
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( p_image_header_data ! = 00 ) ;
assert ( jp2 ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
if ( p_image_header_size ! = 14 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Bad image header box (bad size) \n " ) ;
return OPJ_FALSE ;
}
opj_read_bytes ( p_image_header_data , & ( jp2 - > h ) , 4 ) ; /* HEIGHT */
p_image_header_data + = 4 ;
opj_read_bytes ( p_image_header_data , & ( jp2 - > w ) , 4 ) ; /* WIDTH */
p_image_header_data + = 4 ;
2012-08-09 15:22:25 +02:00
opj_read_bytes ( p_image_header_data , & ( jp2 - > numcomps ) , 2 ) ; /* NC */
2011-09-19 15:36:07 +02:00
p_image_header_data + = 2 ;
/* allocate memory for components */
jp2 - > comps = ( opj_jp2_comps_t * ) opj_malloc ( jp2 - > numcomps * sizeof ( opj_jp2_comps_t ) ) ;
if ( jp2 - > comps = = 0 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Not enough memory to handle image header (ihdr) \n " ) ;
return OPJ_FALSE ;
}
memset ( jp2 - > comps , 0 , jp2 - > numcomps * sizeof ( opj_jp2_comps_t ) ) ;
opj_read_bytes ( p_image_header_data , & ( jp2 - > bpc ) , 1 ) ; /* BPC */
+ + p_image_header_data ;
2012-03-02 16:53:14 +01:00
/* if equal to 0 then need a BPC box (cf. chapter about image header box of the norm) */
2011-09-19 15:36:07 +02:00
/*if (jp2->bpc == 0){
2012-03-02 16:53:14 +01:00
indicate with a flag that we will wait a BPC box
2011-09-19 15:36:07 +02:00
} */
opj_read_bytes ( p_image_header_data , & ( jp2 - > C ) , 1 ) ; /* C */
+ + p_image_header_data ;
2012-03-02 16:53:14 +01:00
/* Should be equal to 7 cf. chapter about image header box of the norm */
2011-09-19 15:36:07 +02:00
if ( jp2 - > C ! = 7 ) {
opj_event_msg_v2 ( p_manager , EVT_INFO , " JP2 IHDR box: compression type indicate that the file is not a conforming JP2 file (%d) \n " , jp2 - > C ) ;
}
opj_read_bytes ( p_image_header_data , & ( jp2 - > UnkC ) , 1 ) ; /* UnkC */
+ + p_image_header_data ;
opj_read_bytes ( p_image_header_data , & ( jp2 - > IPR ) , 1 ) ; /* IPR */
+ + p_image_header_data ;
return OPJ_TRUE ;
}
2012-05-14 11:37:36 +02:00
/**
* Writes the Image Header box - Image Header box .
*
* @ param jp2 jpeg2000 file codec .
* @ param p_nb_bytes_written pointer to store the nb of bytes written by the function .
*
* @ return the data being copied .
*/
2012-08-13 11:27:58 +02:00
OPJ_BYTE * opj_jp2_write_ihdr ( opj_jp2_v2_t * jp2 ,
OPJ_UINT32 * p_nb_bytes_written
)
2012-05-14 11:37:36 +02:00
{
unsigned char * l_ihdr_data , * l_current_ihdr_ptr ;
// preconditions
assert ( jp2 ! = 00 ) ;
assert ( p_nb_bytes_written ! = 00 ) ;
/* default image header is 22 bytes wide */
l_ihdr_data = ( unsigned char * ) opj_malloc ( 22 ) ;
if ( l_ihdr_data = = 00 ) {
return 00 ;
}
memset ( l_ihdr_data , 0 , 22 ) ;
l_current_ihdr_ptr = l_ihdr_data ;
opj_write_bytes ( l_current_ihdr_ptr , 22 , 4 ) ; /* write box size */
l_current_ihdr_ptr + = 4 ;
opj_write_bytes ( l_current_ihdr_ptr , JP2_IHDR , 4 ) ; /* IHDR */
l_current_ihdr_ptr + = 4 ;
opj_write_bytes ( l_current_ihdr_ptr , jp2 - > h , 4 ) ; /* HEIGHT */
l_current_ihdr_ptr + = 4 ;
opj_write_bytes ( l_current_ihdr_ptr , jp2 - > w , 4 ) ; /* WIDTH */
l_current_ihdr_ptr + = 4 ;
opj_write_bytes ( l_current_ihdr_ptr , jp2 - > numcomps , 2 ) ; /* NC */
l_current_ihdr_ptr + = 2 ;
opj_write_bytes ( l_current_ihdr_ptr , jp2 - > bpc , 1 ) ; /* BPC */
+ + l_current_ihdr_ptr ;
opj_write_bytes ( l_current_ihdr_ptr , jp2 - > C , 1 ) ; /* C : Always 7 */
+ + l_current_ihdr_ptr ;
opj_write_bytes ( l_current_ihdr_ptr , jp2 - > UnkC , 1 ) ; /* UnkC, colorspace unknown */
+ + l_current_ihdr_ptr ;
opj_write_bytes ( l_current_ihdr_ptr , jp2 - > IPR , 1 ) ; /* IPR, no intellectual property */
+ + l_current_ihdr_ptr ;
* p_nb_bytes_written = 22 ;
return l_ihdr_data ;
}
/**
* Writes the Bit per Component box .
*
* @ param jp2 jpeg2000 file codec .
* @ param p_nb_bytes_written pointer to store the nb of bytes written by the function .
*
* @ return the data being copied .
*/
2012-08-13 11:31:24 +02:00
OPJ_BYTE * opj_jp2_write_bpcc ( opj_jp2_v2_t * jp2 ,
2012-08-13 11:33:00 +02:00
OPJ_UINT32 * p_nb_bytes_written
)
2012-05-14 11:37:36 +02:00
{
unsigned int i ;
/* room for 8 bytes for box and 1 byte for each component */
int l_bpcc_size = 8 + jp2 - > numcomps ;
unsigned char * l_bpcc_data , * l_current_bpcc_ptr ;
// preconditions
assert ( jp2 ! = 00 ) ;
assert ( p_nb_bytes_written ! = 00 ) ;
l_bpcc_data = ( unsigned char * ) opj_malloc ( l_bpcc_size ) ;
if ( l_bpcc_data = = 00 ) {
return 00 ;
}
memset ( l_bpcc_data , 0 , l_bpcc_size ) ;
l_current_bpcc_ptr = l_bpcc_data ;
opj_write_bytes ( l_current_bpcc_ptr , l_bpcc_size , 4 ) ; /* write box size */
l_current_bpcc_ptr + = 4 ;
opj_write_bytes ( l_current_bpcc_ptr , JP2_BPCC , 4 ) ; /* BPCC */
l_current_bpcc_ptr + = 4 ;
for ( i = 0 ; i < jp2 - > numcomps ; + + i ) {
opj_write_bytes ( l_current_bpcc_ptr , jp2 - > comps [ i ] . bpcc , 1 ) ; /* write each component information */
+ + l_current_bpcc_ptr ;
}
* p_nb_bytes_written = l_bpcc_size ;
return l_bpcc_data ;
}
2011-09-19 15:36:07 +02:00
/**
* Reads a Bit per Component box .
*
* @ param jp2 the jpeg2000 file codec .
2011-12-03 18:26:59 +01:00
* @ param p_bpc_header_data pointer to actual data ( already read from file )
2011-09-19 15:36:07 +02:00
* @ param p_bpc_header_size pointer that will hold the size of the bpc header
* @ param p_manager the user event manager .
*
2011-12-03 18:26:59 +01:00
* @ return true if the bpc header is valid , false otherwise .
2011-09-19 15:36:07 +02:00
*/
2012-08-10 12:55:10 +02:00
opj_bool opj_jp2_read_bpcc ( opj_jp2_v2_t * jp2 ,
OPJ_BYTE * p_bpc_header_data ,
OPJ_UINT32 p_bpc_header_size ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
OPJ_UINT32 i ;
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( p_bpc_header_data ! = 00 ) ;
assert ( jp2 ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
2012-03-02 16:53:14 +01:00
/* TODO MSD */
2011-09-19 15:36:07 +02:00
/*if (jp2->bpc != 0 ){
opj_event_msg_v2 ( p_manager , EVT_WARNING , " A BPCC header box is available although BPC is different to zero (%d) \n " , jp2 - > bpc ) ;
} */
2012-03-02 16:53:14 +01:00
/* and length is relevant */
2011-09-19 15:36:07 +02:00
if ( p_bpc_header_size ! = jp2 - > numcomps ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Bad BPCC header box (bad size) \n " ) ;
return OPJ_FALSE ;
}
2012-03-02 16:53:14 +01:00
/* read info for each component */
2011-09-19 15:36:07 +02:00
for ( i = 0 ; i < jp2 - > numcomps ; + + i ) {
opj_read_bytes ( p_bpc_header_data , & jp2 - > comps [ i ] . bpcc , 1 ) ; /* read each BPCC component */
+ + p_bpc_header_data ;
}
return OPJ_TRUE ;
}
2012-05-14 11:37:36 +02:00
/**
* Writes the Colour Specification box .
*
* @ param jp2 jpeg2000 file codec .
* @ param p_nb_bytes_written pointer to store the nb of bytes written by the function .
*
* @ return the data being copied .
*/
2012-08-13 11:35:16 +02:00
OPJ_BYTE * opj_jp2_write_colr ( opj_jp2_v2_t * jp2 ,
OPJ_UINT32 * p_nb_bytes_written
)
2012-05-14 11:37:36 +02:00
{
/* room for 8 bytes for box 3 for common data and variable upon profile*/
unsigned int l_colr_size = 11 ;
unsigned char * l_colr_data , * l_current_colr_ptr ;
// preconditions
assert ( jp2 ! = 00 ) ;
assert ( p_nb_bytes_written ! = 00 ) ;
switch ( jp2 - > meth ) {
case 1 :
l_colr_size + = 4 ;
break ;
case 2 :
+ + l_colr_size ;
break ;
default :
return 00 ;
}
l_colr_data = ( unsigned char * ) opj_malloc ( l_colr_size ) ;
if ( l_colr_data = = 00 ) {
return 00 ;
}
memset ( l_colr_data , 0 , l_colr_size ) ;
l_current_colr_ptr = l_colr_data ;
opj_write_bytes ( l_current_colr_ptr , l_colr_size , 4 ) ; /* write box size */
l_current_colr_ptr + = 4 ;
opj_write_bytes ( l_current_colr_ptr , JP2_COLR , 4 ) ; /* BPCC */
l_current_colr_ptr + = 4 ;
opj_write_bytes ( l_current_colr_ptr , jp2 - > meth , 1 ) ; /* METH */
+ + l_current_colr_ptr ;
opj_write_bytes ( l_current_colr_ptr , jp2 - > precedence , 1 ) ; /* PRECEDENCE */
+ + l_current_colr_ptr ;
opj_write_bytes ( l_current_colr_ptr , jp2 - > approx , 1 ) ; /* APPROX */
+ + l_current_colr_ptr ;
if ( jp2 - > meth = = 1 ) {
opj_write_bytes ( l_current_colr_ptr , jp2 - > enumcs , 4 ) ; /* EnumCS */
}
else {
opj_write_bytes ( l_current_colr_ptr , 0 , 1 ) ; /* PROFILE (??) */
}
* p_nb_bytes_written = l_colr_size ;
return l_colr_data ;
}
2012-08-13 12:10:25 +02:00
void opj_jp2_free_pclr ( opj_jp2_color_t * color )
2010-10-05 12:33:15 +02:00
{
2010-12-08 12:06:41 +01:00
opj_free ( color - > jp2_pclr - > channel_sign ) ;
opj_free ( color - > jp2_pclr - > channel_size ) ;
opj_free ( color - > jp2_pclr - > entries ) ;
2010-10-05 12:33:15 +02:00
2010-12-08 12:06:41 +01:00
if ( color - > jp2_pclr - > cmap ) opj_free ( color - > jp2_pclr - > cmap ) ;
2010-10-05 12:33:15 +02:00
2010-12-08 12:06:41 +01:00
opj_free ( color - > jp2_pclr ) ; color - > jp2_pclr = NULL ;
2010-10-05 12:33:15 +02:00
}
2012-03-02 15:29:08 +01:00
2012-08-13 12:10:25 +02:00
void opj_jp2_apply_pclr ( opj_image_t * image , opj_jp2_color_t * color )
2010-10-05 12:33:15 +02:00
{
opj_image_comp_t * old_comps , * new_comps ;
2011-10-05 18:27:16 +02:00
OPJ_BYTE * channel_size , * channel_sign ;
OPJ_UINT32 * entries ;
2010-10-05 12:33:15 +02:00
opj_jp2_cmap_comp_t * cmap ;
2011-10-05 18:27:16 +02:00
OPJ_INT32 * src , * dst ;
OPJ_UINT32 j , max ;
OPJ_UINT16 i , nr_channels , cmp , pcol ;
OPJ_INT32 k , top_k ;
2010-10-05 12:33:15 +02:00
2010-12-08 12:06:41 +01:00
channel_size = color - > jp2_pclr - > channel_size ;
channel_sign = color - > jp2_pclr - > channel_sign ;
entries = color - > jp2_pclr - > entries ;
cmap = color - > jp2_pclr - > cmap ;
nr_channels = color - > jp2_pclr - > nr_channels ;
2010-10-05 12:33:15 +02:00
old_comps = image - > comps ;
new_comps = ( opj_image_comp_t * )
2011-10-05 18:27:16 +02:00
opj_malloc ( nr_channels * sizeof ( opj_image_comp_t ) ) ;
2010-10-05 12:33:15 +02:00
2011-10-05 18:27:16 +02:00
for ( i = 0 ; i < nr_channels ; + + i ) {
pcol = cmap [ i ] . pcol ; cmp = cmap [ i ] . cmp ;
2010-10-05 12:33:15 +02:00
2012-03-02 15:29:08 +01:00
new_comps [ pcol ] = old_comps [ cmp ] ;
2011-10-05 18:27:16 +02:00
/* Direct use */
if ( cmap [ i ] . mtyp = = 0 ) {
old_comps [ cmp ] . data = NULL ; continue ;
}
/* Palette mapping: */
new_comps [ pcol ] . data = ( int * )
opj_malloc ( old_comps [ cmp ] . w * old_comps [ cmp ] . h * sizeof ( int ) ) ;
new_comps [ pcol ] . prec = channel_size [ i ] ;
new_comps [ pcol ] . sgnd = channel_sign [ i ] ;
}
2010-10-05 12:33:15 +02:00
2010-12-08 12:06:41 +01:00
top_k = color - > jp2_pclr - > nr_entries - 1 ;
2010-10-05 12:33:15 +02:00
2011-10-05 18:27:16 +02:00
for ( i = 0 ; i < nr_channels ; + + i ) {
/* Direct use: */
if ( cmap [ i ] . mtyp = = 0 ) continue ;
2010-10-05 12:33:15 +02:00
2011-10-05 18:27:16 +02:00
/* Palette mapping: */
cmp = cmap [ i ] . cmp ; pcol = cmap [ i ] . pcol ;
src = old_comps [ cmp ] . data ;
dst = new_comps [ pcol ] . data ;
max = new_comps [ pcol ] . w * new_comps [ pcol ] . h ;
for ( j = 0 ; j < max ; + + j )
{
/* The index */
if ( ( k = src [ j ] ) < 0 ) k = 0 ; else if ( k > top_k ) k = top_k ;
/* The colour */
dst [ j ] = entries [ k * nr_channels + pcol ] ;
}
}
2010-10-05 12:33:15 +02:00
max = image - > numcomps ;
2011-10-05 18:27:16 +02:00
for ( i = 0 ; i < max ; + + i ) {
if ( old_comps [ i ] . data ) opj_free ( old_comps [ i ] . data ) ;
}
2010-10-05 12:33:15 +02:00
opj_free ( old_comps ) ;
image - > comps = new_comps ;
image - > numcomps = nr_channels ;
2012-08-13 12:10:25 +02:00
opj_jp2_free_pclr ( color ) ;
2010-10-05 12:33:15 +02:00
} /* apply_pclr() */
2011-09-19 15:36:07 +02:00
/**
* Reads a palette box .
*
* @ param jp2 the jpeg2000 file codec .
2011-12-03 18:26:59 +01:00
* @ param p_pclr_header_data pointer to actual data ( already read from file )
* @ param p_pclr_header_size pointer that will hold the size of the PCLR header
2011-09-19 15:36:07 +02:00
* @ param p_manager the user event manager .
*
* @ return true if the bpc header is valid , fale else .
*/
2012-08-10 12:55:10 +02:00
opj_bool opj_jp2_read_pclr ( opj_jp2_v2_t * jp2 ,
OPJ_BYTE * p_pclr_header_data ,
OPJ_UINT32 p_pclr_header_size ,
opj_event_mgr_t * p_manager
)
2012-08-10 12:19:11 +02:00
{
2011-09-19 15:36:07 +02:00
opj_jp2_pclr_t * jp2_pclr ;
OPJ_BYTE * channel_size , * channel_sign ;
OPJ_UINT32 * entries ;
OPJ_UINT16 nr_entries , nr_channels ;
OPJ_UINT16 i , j ;
OPJ_UINT32 l_value ;
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( p_pclr_header_data ! = 00 ) ;
assert ( jp2 ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
2012-05-14 17:20:20 +02:00
( void ) p_pclr_header_size ;
2011-09-19 15:36:07 +02:00
if ( jp2 - > color . jp2_pclr )
return OPJ_FALSE ;
opj_read_bytes ( p_pclr_header_data , & l_value , 2 ) ; /* NE */
p_pclr_header_data + = 2 ;
nr_entries = ( OPJ_UINT16 ) l_value ;
opj_read_bytes ( p_pclr_header_data , & l_value , 1 ) ; /* NPC */
+ + p_pclr_header_data ;
nr_channels = ( OPJ_UINT16 ) l_value ;
entries = ( OPJ_UINT32 * ) opj_malloc ( nr_channels * nr_entries * sizeof ( OPJ_UINT32 ) ) ;
channel_size = ( OPJ_BYTE * ) opj_malloc ( nr_channels ) ;
channel_sign = ( OPJ_BYTE * ) opj_malloc ( nr_channels ) ;
jp2_pclr = ( opj_jp2_pclr_t * ) opj_malloc ( sizeof ( opj_jp2_pclr_t ) ) ;
jp2_pclr - > channel_sign = channel_sign ;
jp2_pclr - > channel_size = channel_size ;
jp2_pclr - > entries = entries ;
jp2_pclr - > nr_entries = nr_entries ;
2012-08-10 13:21:48 +02:00
jp2_pclr - > nr_channels = ( OPJ_BYTE ) l_value ;
2011-09-19 15:36:07 +02:00
jp2_pclr - > cmap = NULL ;
jp2 - > color . jp2_pclr = jp2_pclr ;
for ( i = 0 ; i < nr_channels ; + + i ) {
opj_read_bytes ( p_pclr_header_data , & l_value , 1 ) ; /* Bi */
+ + p_pclr_header_data ;
channel_size [ i ] = ( l_value & 0x7f ) + 1 ;
channel_sign [ i ] = ( l_value & 0x80 ) ? 1 : 0 ;
}
for ( j = 0 ; j < nr_entries ; + + j ) {
for ( i = 0 ; i < nr_channels ; + + i ) {
2012-05-29 15:55:49 +02:00
int bytes_to_read = ( channel_size [ i ] + 7 ) > > 3 ;
opj_read_bytes ( p_pclr_header_data , & l_value , bytes_to_read ) ; /* Cji */
p_pclr_header_data + = bytes_to_read ;
2011-09-19 15:36:07 +02:00
* entries = ( OPJ_UINT32 ) l_value ;
entries + + ;
}
}
return OPJ_TRUE ;
}
/**
* Reads the Component Mapping box .
*
* @ param p_cmap_header_data pointer to actual data ( already read from file )
* @ param jp2 the jpeg2000 file codec .
* @ param p_cmap_header_size pointer that will hold the size of the color header
* @ param p_manager the user event manager .
*
* @ return true if the cdef header is valid , false else .
*/
2012-08-10 12:55:10 +02:00
opj_bool opj_jp2_read_cmap ( opj_jp2_v2_t * jp2 ,
OPJ_BYTE * p_cmap_header_data ,
OPJ_UINT32 p_cmap_header_size ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
opj_jp2_cmap_comp_t * cmap ;
OPJ_BYTE i , nr_channels ;
OPJ_UINT32 l_value ;
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( jp2 ! = 00 ) ;
assert ( p_cmap_header_data ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
2012-05-14 17:20:20 +02:00
( void ) p_cmap_header_size ;
2011-09-19 15:36:07 +02:00
/* Need nr_channels: */
if ( jp2 - > color . jp2_pclr = = NULL ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Need to read a PCLR box before the CMAP box. \n " ) ;
return OPJ_FALSE ;
}
/* Part 1, I.5.3.5: 'There shall be at most one Component Mapping box
* inside a JP2 Header box ' :
*/
if ( jp2 - > color . jp2_pclr - > cmap ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Only one CMAP box is allowed. \n " ) ;
return OPJ_FALSE ;
}
nr_channels = jp2 - > color . jp2_pclr - > nr_channels ;
cmap = ( opj_jp2_cmap_comp_t * ) opj_malloc ( nr_channels * sizeof ( opj_jp2_cmap_comp_t ) ) ;
for ( i = 0 ; i < nr_channels ; + + i ) {
opj_read_bytes ( p_cmap_header_data , & l_value , 2 ) ; /* CMP^i */
p_cmap_header_data + = 2 ;
cmap [ i ] . cmp = ( OPJ_UINT16 ) l_value ;
opj_read_bytes ( p_cmap_header_data , & l_value , 1 ) ; /* MTYP^i */
+ + p_cmap_header_data ;
cmap [ i ] . mtyp = ( OPJ_BYTE ) l_value ;
opj_read_bytes ( p_cmap_header_data , & l_value , 1 ) ; /* PCOL^i */
+ + p_cmap_header_data ;
cmap [ i ] . pcol = ( OPJ_BYTE ) l_value ;
}
jp2 - > color . jp2_pclr - > cmap = cmap ;
return OPJ_TRUE ;
}
2012-08-13 12:10:25 +02:00
void opj_jp2_apply_cdef ( opj_image_t * image , opj_jp2_color_t * color )
2010-10-05 12:33:15 +02:00
{
opj_jp2_cdef_info_t * info ;
2011-10-05 18:27:16 +02:00
OPJ_INT32 color_space ;
OPJ_UINT16 i , n , cn , typ , asoc , acn ;
2010-10-05 12:33:15 +02:00
color_space = image - > color_space ;
2010-12-08 12:06:41 +01:00
info = color - > jp2_cdef - > info ;
n = color - > jp2_cdef - > n ;
2010-10-05 12:33:15 +02:00
for ( i = 0 ; i < n ; + + i )
2011-10-05 18:27:16 +02:00
{
/* WATCH: acn = asoc - 1 ! */
if ( ( asoc = info [ i ] . asoc ) = = 0 ) continue ;
2010-10-05 12:33:15 +02:00
2011-10-05 18:27:16 +02:00
cn = info [ i ] . cn ; typ = info [ i ] . typ ; acn = asoc - 1 ;
2010-10-05 12:33:15 +02:00
2011-10-05 18:27:16 +02:00
if ( cn ! = acn )
{
opj_image_comp_t saved ;
2010-10-05 12:33:15 +02:00
2011-10-05 18:27:16 +02:00
memcpy ( & saved , & image - > comps [ cn ] , sizeof ( opj_image_comp_t ) ) ;
memcpy ( & image - > comps [ cn ] , & image - > comps [ acn ] , sizeof ( opj_image_comp_t ) ) ;
memcpy ( & image - > comps [ acn ] , & saved , sizeof ( opj_image_comp_t ) ) ;
info [ i ] . asoc = cn + 1 ;
info [ acn ] . asoc = info [ acn ] . cn + 1 ;
}
}
2010-10-05 12:33:15 +02:00
2010-12-08 12:06:41 +01:00
if ( color - > jp2_cdef - > info ) opj_free ( color - > jp2_cdef - > info ) ;
2010-10-05 12:33:15 +02:00
2010-12-08 12:06:41 +01:00
opj_free ( color - > jp2_cdef ) ; color - > jp2_cdef = NULL ;
2010-10-05 12:33:15 +02:00
} /* jp2_apply_cdef() */
2011-09-19 15:36:07 +02:00
/**
* Reads the Component Definition box .
*
* @ param p_cdef_header_data pointer to actual data ( already read from file )
* @ param jp2 the jpeg2000 file codec .
* @ param p_cdef_header_size pointer that will hold the size of the color header
* @ param p_manager the user event manager .
*
* @ return true if the cdef header is valid , false else .
*/
2012-08-10 12:55:10 +02:00
opj_bool opj_jp2_read_cdef ( opj_jp2_v2_t * jp2 ,
OPJ_BYTE * p_cdef_header_data ,
OPJ_UINT32 p_cdef_header_size ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
opj_jp2_cdef_info_t * cdef_info ;
unsigned short i ;
OPJ_UINT32 l_value ;
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( jp2 ! = 00 ) ;
assert ( p_cdef_header_data ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
2012-05-14 17:20:20 +02:00
( void ) p_cdef_header_size ;
2011-09-19 15:36:07 +02:00
/* Part 1, I.5.3.6: 'The shall be at most one Channel Definition box
* inside a JP2 Header box . ' */
if ( jp2 - > color . jp2_cdef ) return OPJ_FALSE ;
2011-09-19 15:47:35 +02:00
opj_read_bytes ( p_cdef_header_data , & l_value , 2 ) ; /* N */
p_cdef_header_data + = 2 ;
2011-09-19 15:36:07 +02:00
if ( ( OPJ_UINT16 ) l_value = = 0 ) { /* szukw000: FIXME */
2011-09-19 15:47:35 +02:00
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Number of channel description is equal to zero in CDEF box. \n " ) ;
2011-09-19 15:36:07 +02:00
return OPJ_FALSE ;
}
cdef_info = ( opj_jp2_cdef_info_t * ) opj_malloc ( l_value * sizeof ( opj_jp2_cdef_info_t ) ) ;
jp2 - > color . jp2_cdef = ( opj_jp2_cdef_t * ) opj_malloc ( sizeof ( opj_jp2_cdef_t ) ) ;
jp2 - > color . jp2_cdef - > info = cdef_info ;
jp2 - > color . jp2_cdef - > n = ( OPJ_UINT16 ) l_value ;
for ( i = 0 ; i < jp2 - > color . jp2_cdef - > n ; + + i ) {
opj_read_bytes ( p_cdef_header_data , & l_value , 2 ) ; /* Cn^i */
p_cdef_header_data + = 2 ;
cdef_info [ i ] . cn = ( OPJ_UINT16 ) l_value ;
opj_read_bytes ( p_cdef_header_data , & l_value , 2 ) ; /* Typ^i */
p_cdef_header_data + = 2 ;
cdef_info [ i ] . typ = ( OPJ_UINT16 ) l_value ;
opj_read_bytes ( p_cdef_header_data , & l_value , 2 ) ; /* Asoc^i */
p_cdef_header_data + = 2 ;
cdef_info [ i ] . asoc = ( OPJ_UINT16 ) l_value ;
}
return OPJ_TRUE ;
}
/**
* Reads the Colour Specification box .
*
* @ param p_colr_header_data pointer to actual data ( already read from file )
* @ param jp2 the jpeg2000 file codec .
* @ param p_colr_header_size pointer that will hold the size of the color header
* @ param p_colr_header_max_size maximum size of the header , any size bigger than this value should result the function to output false .
* @ param p_manager the user event manager .
*
* @ return true if the bpc header is valid , fale else .
*/
2012-08-10 12:55:10 +02:00
opj_bool opj_jp2_read_colr ( opj_jp2_v2_t * jp2 ,
OPJ_BYTE * p_colr_header_data ,
OPJ_UINT32 p_colr_header_size ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
OPJ_UINT32 l_value ;
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( jp2 ! = 00 ) ;
assert ( p_colr_header_data ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
if ( p_colr_header_size < 3 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Bad COLR header box (bad size) \n " ) ;
return OPJ_FALSE ;
}
/* Part 1, I.5.3.3 : 'A conforming JP2 reader shall ignore all Colour
* Specification boxes after the first . '
*/
if ( jp2 - > color . jp2_has_colr ) {
opj_event_msg_v2 ( p_manager , EVT_INFO , " A conforming JP2 reader shall ignore all Colour Specification boxes after the first, so we ignore this one. \n " ) ;
p_colr_header_data + = p_colr_header_size ;
return OPJ_TRUE ;
}
opj_read_bytes ( p_colr_header_data , & jp2 - > meth , 1 ) ; /* METH */
+ + p_colr_header_data ;
opj_read_bytes ( p_colr_header_data , & jp2 - > precedence , 1 ) ; /* PRECEDENCE */
+ + p_colr_header_data ;
opj_read_bytes ( p_colr_header_data , & jp2 - > approx , 1 ) ; /* APPROX */
+ + p_colr_header_data ;
if ( jp2 - > meth = = 1 ) {
if ( p_colr_header_size ! = 7 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Bad BPCC header box (bad size) \n " ) ;
return OPJ_FALSE ;
}
opj_read_bytes ( p_colr_header_data , & jp2 - > enumcs , 4 ) ; /* EnumCS */
}
else if ( jp2 - > meth = = 2 ) {
2012-03-02 16:53:14 +01:00
/* ICC profile */
2011-09-19 15:36:07 +02:00
int it_icc_value = 0 ;
int icc_len = p_colr_header_size - 3 ;
jp2 - > color . icc_profile_len = icc_len ;
jp2 - > color . icc_profile_buf = ( unsigned char * ) opj_malloc ( icc_len ) ;
memset ( jp2 - > color . icc_profile_buf , 0 , icc_len * sizeof ( unsigned char ) ) ;
for ( it_icc_value = 0 ; it_icc_value < icc_len ; + + it_icc_value )
{
opj_read_bytes ( p_colr_header_data , & l_value , 1 ) ; /* icc values */
+ + p_colr_header_data ;
jp2 - > color . icc_profile_buf [ it_icc_value ] = ( OPJ_BYTE ) l_value ;
}
}
2012-03-02 16:53:14 +01:00
else /* TODO MSD */
2011-09-19 15:55:06 +02:00
opj_event_msg_v2 ( p_manager , EVT_INFO , " COLR BOX meth value is not a regular value (%d), so we will skip the fields following the approx field. \n " , jp2 - > meth ) ;
2011-09-19 15:36:07 +02:00
jp2 - > color . jp2_has_colr = 1 ;
return OPJ_TRUE ;
}
2010-10-05 12:33:15 +02:00
2012-08-09 16:46:11 +02:00
opj_bool opj_jp2_decode ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * p_stream ,
opj_image_t * p_image ,
opj_event_mgr_t * p_manager )
2011-10-05 18:27:16 +02:00
{
2011-10-12 16:42:21 +02:00
if ( ! p_image )
return OPJ_FALSE ;
2011-10-05 18:27:16 +02:00
/* J2K decoding */
2012-08-09 17:16:33 +02:00
if ( ! opj_j2k_decode ( jp2 - > j2k , p_stream , p_image , p_manager ) ) {
2011-10-11 09:49:16 +02:00
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Failed to decode the codestream in the JP2 file \n " ) ;
2011-10-05 18:27:16 +02:00
return OPJ_FALSE ;
}
2012-08-09 16:28:35 +02:00
if ( ! jp2 - > ignore_pclr_cmap_cdef ) {
2011-10-05 18:27:16 +02:00
2012-08-09 16:28:35 +02:00
/* Set Image Color Space */
if ( jp2 - > enumcs = = 16 )
p_image - > color_space = CLRSPC_SRGB ;
else if ( jp2 - > enumcs = = 17 )
p_image - > color_space = CLRSPC_GRAY ;
else if ( jp2 - > enumcs = = 18 )
p_image - > color_space = CLRSPC_SYCC ;
else
p_image - > color_space = CLRSPC_UNKNOWN ;
/* Apply the color space if needed */
if ( jp2 - > color . jp2_cdef ) {
2012-08-13 12:10:25 +02:00
opj_jp2_apply_cdef ( p_image , & ( jp2 - > color ) ) ;
2012-08-09 16:28:35 +02:00
}
if ( jp2 - > color . jp2_pclr ) {
/* Part 1, I.5.3.4: Either both or none : */
if ( ! jp2 - > color . jp2_pclr - > cmap )
2012-08-13 12:10:25 +02:00
opj_jp2_free_pclr ( & ( jp2 - > color ) ) ;
2012-08-09 16:28:35 +02:00
else
2012-08-13 12:10:25 +02:00
opj_jp2_apply_pclr ( p_image , & ( jp2 - > color ) ) ;
2012-08-09 16:28:35 +02:00
}
if ( jp2 - > color . icc_profile_buf ) {
p_image - > icc_profile_buf = jp2 - > color . icc_profile_buf ;
p_image - > icc_profile_len = jp2 - > color . icc_profile_len ;
jp2 - > color . icc_profile_buf = NULL ;
}
}
2011-10-05 18:27:16 +02:00
return OPJ_TRUE ;
}
2004-07-07 10:24:36 +02:00
2012-05-14 11:37:36 +02:00
/**
* Writes the Jpeg2000 file Header box - JP2 Header box ( warning , this is a super box ) .
*
* @ param cio the stream to write data to .
* @ param jp2 the jpeg2000 file codec .
* @ param p_manager user event manager .
*
* @ return true if writting was successful .
*/
2012-08-13 11:24:15 +02:00
opj_bool opj_jp2_write_jp2h ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * stream ,
opj_event_mgr_t * p_manager
)
2012-05-14 11:37:36 +02:00
{
opj_jp2_img_header_writer_handler_t l_writers [ 3 ] ;
opj_jp2_img_header_writer_handler_t * l_current_writer ;
int i , l_nb_pass ;
/* size of data for super box*/
int l_jp2h_size = 8 ;
opj_bool l_result = OPJ_TRUE ;
/* to store the data of the super box */
unsigned char l_jp2h_data [ 8 ] ;
// preconditions
2012-08-13 11:24:15 +02:00
assert ( stream ! = 00 ) ;
2012-05-14 11:37:36 +02:00
assert ( jp2 ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
memset ( l_writers , 0 , sizeof ( l_writers ) ) ;
if ( jp2 - > bpc = = 255 ) {
l_nb_pass = 3 ;
2012-08-13 11:27:58 +02:00
l_writers [ 0 ] . handler = opj_jp2_write_ihdr ;
2012-08-13 11:31:24 +02:00
l_writers [ 1 ] . handler = opj_jp2_write_bpcc ;
2012-08-13 11:35:16 +02:00
l_writers [ 2 ] . handler = opj_jp2_write_colr ;
2012-05-14 11:37:36 +02:00
}
else {
l_nb_pass = 2 ;
2012-08-13 11:27:58 +02:00
l_writers [ 0 ] . handler = opj_jp2_write_ihdr ;
2012-08-13 11:35:16 +02:00
l_writers [ 1 ] . handler = opj_jp2_write_colr ;
2012-05-14 11:37:36 +02:00
}
/* write box header */
/* write JP2H type */
opj_write_bytes ( l_jp2h_data + 4 , JP2_JP2H , 4 ) ;
l_current_writer = l_writers ;
for ( i = 0 ; i < l_nb_pass ; + + i ) {
l_current_writer - > m_data = l_current_writer - > handler ( jp2 , & ( l_current_writer - > m_size ) ) ;
if ( l_current_writer - > m_data = = 00 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Not enough memory to hold JP2 Header data \n " ) ;
l_result = OPJ_FALSE ;
break ;
}
l_jp2h_size + = l_current_writer - > m_size ;
+ + l_current_writer ;
}
if ( ! l_result ) {
l_current_writer = l_writers ;
for ( i = 0 ; i < l_nb_pass ; + + i ) {
if ( l_current_writer - > m_data ! = 00 ) {
opj_free ( l_current_writer - > m_data ) ;
}
+ + l_current_writer ;
}
return OPJ_FALSE ;
}
/* write super box size */
opj_write_bytes ( l_jp2h_data , l_jp2h_size , 4 ) ;
/* write super box data on stream */
2012-08-13 11:24:15 +02:00
if ( opj_stream_write_data ( stream , l_jp2h_data , 8 , p_manager ) ! = 8 ) {
2012-05-14 17:20:20 +02:00
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Stream error while writing JP2 Header box \n " ) ;
2012-05-14 11:37:36 +02:00
l_result = OPJ_FALSE ;
}
if ( l_result ) {
l_current_writer = l_writers ;
for ( i = 0 ; i < l_nb_pass ; + + i ) {
2012-08-13 11:24:15 +02:00
if ( opj_stream_write_data ( stream , l_current_writer - > m_data , l_current_writer - > m_size , p_manager ) ! = l_current_writer - > m_size ) {
2012-05-14 17:20:20 +02:00
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Stream error while writting JP2 Header box \n " ) ;
2012-05-14 11:37:36 +02:00
l_result = OPJ_FALSE ;
break ;
}
+ + l_current_writer ;
}
}
l_current_writer = l_writers ;
/* cleanup */
for ( i = 0 ; i < l_nb_pass ; + + i ) {
if ( l_current_writer - > m_data ! = 00 ) {
opj_free ( l_current_writer - > m_data ) ;
}
+ + l_current_writer ;
}
return l_result ;
}
/**
* Writes a FTYP box - File type box
*
* @ param cio the stream to write data to .
* @ param jp2 the jpeg2000 file codec .
* @ param p_manager the user event manager .
*
* @ return true if writting was successful .
*/
2012-08-13 11:39:51 +02:00
opj_bool opj_jp2_write_ftyp ( opj_jp2_v2_t * jp2 ,
2012-05-14 11:37:36 +02:00
opj_stream_private_t * cio ,
opj_event_mgr_t * p_manager )
{
unsigned int i ;
unsigned int l_ftyp_size = 16 + 4 * jp2 - > numcl ;
unsigned char * l_ftyp_data , * l_current_data_ptr ;
opj_bool l_result ;
// preconditions
assert ( cio ! = 00 ) ;
assert ( jp2 ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
l_ftyp_data = ( unsigned char * ) opj_malloc ( l_ftyp_size ) ;
if ( l_ftyp_data = = 00 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Not enough memory to handle ftyp data \n " ) ;
return OPJ_FALSE ;
}
memset ( l_ftyp_data , 0 , l_ftyp_size ) ;
l_current_data_ptr = l_ftyp_data ;
opj_write_bytes ( l_current_data_ptr , l_ftyp_size , 4 ) ; /* box size */
l_current_data_ptr + = 4 ;
opj_write_bytes ( l_current_data_ptr , JP2_FTYP , 4 ) ; /* FTYP */
l_current_data_ptr + = 4 ;
opj_write_bytes ( l_current_data_ptr , jp2 - > brand , 4 ) ; /* BR */
l_current_data_ptr + = 4 ;
opj_write_bytes ( l_current_data_ptr , jp2 - > minversion , 4 ) ; /* MinV */
l_current_data_ptr + = 4 ;
for ( i = 0 ; i < jp2 - > numcl ; i + + ) {
opj_write_bytes ( l_current_data_ptr , jp2 - > cl [ i ] , 4 ) ; /* CL */
}
l_result = ( opj_stream_write_data ( cio , l_ftyp_data , l_ftyp_size , p_manager ) = = l_ftyp_size ) ;
if ( ! l_result )
{
2012-05-14 17:20:20 +02:00
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Error while writting ftyp data to stream \n " ) ;
2012-05-14 11:37:36 +02:00
}
opj_free ( l_ftyp_data ) ;
return l_result ;
}
2012-05-14 19:17:53 +02:00
/**
* Writes the Jpeg2000 codestream Header box - JP2C Header box .
*
* @ param cio the stream to write data to .
* @ param jp2 the jpeg2000 file codec .
* @ param p_manager user event manager .
*
* @ return true if writting was successful .
*/
2012-08-13 11:57:09 +02:00
opj_bool opj_jp2_write_jp2c ( opj_jp2_v2_t * jp2 ,
2012-05-14 19:17:53 +02:00
opj_stream_private_t * cio ,
opj_event_mgr_t * p_manager )
{
2012-08-10 13:21:48 +02:00
OPJ_OFF_T j2k_codestream_exit ;
OPJ_BYTE l_data_header [ 8 ] ;
2012-05-14 19:17:53 +02:00
// preconditions
assert ( jp2 ! = 00 ) ;
assert ( cio ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
assert ( opj_stream_has_seek ( cio ) ) ;
j2k_codestream_exit = opj_stream_tell ( cio ) ;
2012-08-10 13:21:48 +02:00
opj_write_bytes ( l_data_header ,
( OPJ_UINT32 ) ( j2k_codestream_exit - jp2 - > j2k_codestream_offset ) ,
4 ) ; /* size of codestream */
2012-05-14 19:17:53 +02:00
opj_write_bytes ( l_data_header + 4 , JP2_JP2C , 4 ) ; /* JP2C */
if ( ! opj_stream_seek ( cio , jp2 - > j2k_codestream_offset , p_manager ) ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Failed to seek in the stream. \n " ) ;
return OPJ_FALSE ;
}
if ( opj_stream_write_data ( cio , l_data_header , 8 , p_manager ) ! = 8 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Failed to seek in the stream. \n " ) ;
return OPJ_FALSE ;
}
if ( ! opj_stream_seek ( cio , j2k_codestream_exit , p_manager ) ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Failed to seek in the stream. \n " ) ;
return OPJ_FALSE ;
}
return OPJ_TRUE ;
}
2012-05-14 11:37:36 +02:00
/**
* Writes a jpeg2000 file signature box .
*
* @ param cio the stream to write data to .
* @ param jp2 the jpeg2000 file codec .
* @ param p_manager the user event manager .
*
* @ return true if writting was successful .
*/
2012-08-13 12:03:57 +02:00
opj_bool opj_jp2_write_jp ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * cio ,
opj_event_mgr_t * p_manager )
2012-05-14 11:37:36 +02:00
{
/* 12 bytes will be read */
unsigned char l_signature_data [ 12 ] ;
// preconditions
assert ( cio ! = 00 ) ;
assert ( jp2 ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
/* write box length */
opj_write_bytes ( l_signature_data , 12 , 4 ) ;
/* writes box type */
opj_write_bytes ( l_signature_data + 4 , JP2_JP , 4 ) ;
/* writes magic number*/
opj_write_bytes ( l_signature_data + 8 , 0x0d0a870a , 4 ) ;
if ( opj_stream_write_data ( cio , l_signature_data , 12 , p_manager ) ! = 12 ) {
return OPJ_FALSE ;
}
return OPJ_TRUE ;
}
2011-09-09 16:49:08 +02:00
2005-12-02 14:34:15 +01:00
/* ----------------------------------------------------------------------- */
/* JP2 decoder interface */
/* ----------------------------------------------------------------------- */
2012-08-09 16:38:55 +02:00
void opj_jp2_setup_decoder ( opj_jp2_v2_t * jp2 , opj_dparameters_t * parameters )
2011-09-21 18:37:45 +02:00
{
2011-09-19 15:36:07 +02:00
/* setup the J2K codec */
2012-08-09 17:08:33 +02:00
opj_j2k_setup_decoder ( jp2 - > j2k , parameters ) ;
2011-09-19 15:36:07 +02:00
2011-09-21 18:37:45 +02:00
/* further JP2 initializations go here */
2011-09-19 15:36:07 +02:00
jp2 - > color . jp2_has_colr = 0 ;
2012-08-09 16:28:35 +02:00
jp2 - > ignore_pclr_cmap_cdef = parameters - > flags & OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG ;
2011-09-19 15:36:07 +02:00
}
/* ----------------------------------------------------------------------- */
2005-12-02 14:34:15 +01:00
/* JP2 encoder interface */
/* ----------------------------------------------------------------------- */
2012-08-13 11:24:15 +02:00
void opj_jp2_setup_encoder ( opj_jp2_v2_t * jp2 ,
opj_cparameters_t * parameters ,
opj_image_t * image ,
opj_event_mgr_t * p_manager )
2012-08-10 13:21:48 +02:00
{
OPJ_UINT32 i ;
2005-12-08 10:38:47 +01:00
int depth_0 , sign ;
if ( ! jp2 | | ! parameters | | ! image )
return ;
/* setup the J2K codec */
/* ------------------- */
2007-01-03 16:41:50 +01:00
/* Check if number of components respects standard */
if ( image - > numcomps < 1 | | image - > numcomps > 16384 ) {
2012-05-14 11:37:36 +02:00
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Invalid number of components specified while setting up JP2 encoder \n " ) ;
2007-01-03 16:41:50 +01:00
return ;
}
2012-05-14 11:37:36 +02:00
j2k_setup_encoder_v2 ( jp2 - > j2k , parameters , image , p_manager ) ;
2005-12-08 10:38:47 +01:00
/* setup the JP2 codec */
/* ------------------- */
/* Profile box */
jp2 - > brand = JP2_JP2 ; /* BR */
jp2 - > minversion = 0 ; /* MinV */
jp2 - > numcl = 1 ;
jp2 - > cl = ( unsigned int * ) opj_malloc ( jp2 - > numcl * sizeof ( unsigned int ) ) ;
jp2 - > cl [ 0 ] = JP2_JP2 ; /* CL0 : JP2 */
/* Image Header box */
jp2 - > numcomps = image - > numcomps ; /* NC */
jp2 - > comps = ( opj_jp2_comps_t * ) opj_malloc ( jp2 - > numcomps * sizeof ( opj_jp2_comps_t ) ) ;
jp2 - > h = image - > y1 - image - > y0 ; /* HEIGHT */
jp2 - > w = image - > x1 - image - > x0 ; /* WIDTH */
/* BPC */
depth_0 = image - > comps [ 0 ] . prec - 1 ;
sign = image - > comps [ 0 ] . sgnd ;
jp2 - > bpc = depth_0 + ( sign < < 7 ) ;
for ( i = 1 ; i < image - > numcomps ; i + + ) {
int depth = image - > comps [ i ] . prec - 1 ;
sign = image - > comps [ i ] . sgnd ;
if ( depth_0 ! = depth )
jp2 - > bpc = 255 ;
}
jp2 - > C = 7 ; /* C : Always 7 */
jp2 - > UnkC = 0 ; /* UnkC, colorspace specified in colr box */
jp2 - > IPR = 0 ; /* IPR, no intellectual property */
/* BitsPerComponent box */
for ( i = 0 ; i < image - > numcomps ; i + + ) {
jp2 - > comps [ i ] . bpcc = image - > comps [ i ] . prec - 1 + ( image - > comps [ i ] . sgnd < < 7 ) ;
}
2012-05-14 11:37:36 +02:00
/* Colour Specification box */
if ( ( image - > numcomps = = 1 | | image - > numcomps = = 3 ) & & ( jp2 - > bpc ! = 255 ) ) {
jp2 - > meth = 1 ; /* METH: Enumerated colourspace */
} else {
jp2 - > meth = 2 ; /* METH: Restricted ICC profile */
}
if ( jp2 - > meth = = 1 ) {
if ( image - > color_space = = 1 )
jp2 - > enumcs = 16 ; /* sRGB as defined by IEC 61966<36> 2<EFBFBD> 1 */
else if ( image - > color_space = = 2 )
jp2 - > enumcs = 17 ; /* greyscale */
else if ( image - > color_space = = 3 )
jp2 - > enumcs = 18 ; /* YUV */
} else {
jp2 - > enumcs = 0 ; /* PROFILE (??) */
}
2005-12-08 10:38:47 +01:00
jp2 - > precedence = 0 ; /* PRECEDENCE */
jp2 - > approx = 0 ; /* APPROX */
2011-09-09 16:49:08 +02:00
2012-05-14 11:37:36 +02:00
// jp2->jpip_on = parameters->jpip_on;
2005-12-02 14:34:15 +01:00
}
2012-05-14 13:04:59 +02:00
2012-08-13 11:24:15 +02:00
opj_bool opj_jp2_encode ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * stream ,
opj_event_mgr_t * p_manager )
2012-05-14 13:04:59 +02:00
{
return j2k_encode_v2 ( jp2 - > j2k , stream , p_manager ) ;
}
2011-09-19 15:36:07 +02:00
/**
* Ends the decompression procedures and possibiliy add data to be read after the
* codestream .
*/
2012-08-13 11:24:15 +02:00
opj_bool opj_jp2_end_decompress ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * cio ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( jp2 ! = 00 ) ;
assert ( cio ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
/* customization of the end encoding */
2012-08-10 12:55:10 +02:00
opj_jp2_setup_end_header_reading ( jp2 ) ;
2011-09-19 15:36:07 +02:00
/* write header */
2012-08-10 12:55:10 +02:00
if ( ! opj_jp2_exec ( jp2 , jp2 - > m_procedure_list , cio , p_manager ) ) {
2011-09-19 15:36:07 +02:00
return OPJ_FALSE ;
}
return j2k_end_decompress ( jp2 - > j2k , cio , p_manager ) ;
}
2012-03-15 11:23:20 +01:00
/**
* Ends the compression procedures and possibility add data to be read after the
* codestream .
*/
2012-08-13 11:24:15 +02:00
opj_bool opj_jp2_end_compress ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * cio ,
opj_event_mgr_t * p_manager
)
2012-03-15 11:23:20 +01:00
{
/* preconditions */
assert ( jp2 ! = 00 ) ;
assert ( cio ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
/* customization of the end encoding */
2012-08-13 11:44:40 +02:00
opj_jp2_setup_end_header_writting ( jp2 ) ;
2012-03-15 11:23:20 +01:00
if ( ! j2k_end_compress ( jp2 - > j2k , cio , p_manager ) ) {
return OPJ_FALSE ;
}
/* write header */
2012-08-10 12:55:10 +02:00
return opj_jp2_exec ( jp2 , jp2 - > m_procedure_list , cio , p_manager ) ;
2012-03-15 11:23:20 +01:00
}
/**
* Sets up the procedures to do on writing header after the codestream .
* Developers wanting to extend the library can add their own writing procedures .
*/
2012-08-13 11:44:40 +02:00
void opj_jp2_setup_end_header_writting ( opj_jp2_v2_t * jp2 )
2012-03-15 11:23:20 +01:00
{
/* preconditions */
assert ( jp2 ! = 00 ) ;
2012-08-13 11:57:09 +02:00
opj_procedure_list_add_procedure ( jp2 - > m_procedure_list , ( opj_procedure ) opj_jp2_write_jp2c ) ;
2012-03-15 11:23:20 +01:00
/* DEVELOPER CORNER, add your custom procedures */
}
2011-09-19 15:36:07 +02:00
/**
* Sets up the procedures to do on reading header after the codestream .
2012-03-15 11:23:20 +01:00
* Developers wanting to extend the library can add their own writing procedures .
2011-09-19 15:36:07 +02:00
*/
2012-08-10 12:55:10 +02:00
void opj_jp2_setup_end_header_reading ( opj_jp2_v2_t * jp2 )
2011-09-19 15:36:07 +02:00
{
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( jp2 ! = 00 ) ;
2012-08-10 12:55:10 +02:00
opj_procedure_list_add_procedure ( jp2 - > m_procedure_list , ( opj_procedure ) opj_jp2_read_header_procedure ) ;
2011-09-19 15:36:07 +02:00
/* DEVELOPER CORNER, add your custom procedures */
}
2012-03-15 11:23:20 +01:00
/**
* The default validation procedure without any extension .
*
* @ param jp2 the jpeg2000 codec to validate .
* @ param cio the input stream to validate .
* @ param p_manager the user event manager .
*
* @ return true if the parameters are correct .
*/
2012-08-10 12:55:10 +02:00
opj_bool opj_jp2_default_validation ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * cio ,
opj_event_mgr_t * p_manager
)
2012-03-15 11:23:20 +01:00
{
opj_bool l_is_valid = OPJ_TRUE ;
unsigned int i ;
/* preconditions */
assert ( jp2 ! = 00 ) ;
assert ( cio ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
/* JPEG2000 codec validation */
/*TODO*/
/* STATE checking */
/* make sure the state is at 0 */
l_is_valid & = ( jp2 - > jp2_state = = JP2_STATE_NONE ) ;
/* make sure not reading a jp2h ???? WEIRD */
l_is_valid & = ( jp2 - > jp2_img_state = = JP2_IMG_STATE_NONE ) ;
/* POINTER validation */
/* make sure a j2k codec is present */
l_is_valid & = ( jp2 - > j2k ! = 00 ) ;
/* make sure a procedure list is present */
l_is_valid & = ( jp2 - > m_procedure_list ! = 00 ) ;
/* make sure a validation list is present */
l_is_valid & = ( jp2 - > m_validation_list ! = 00 ) ;
/* PARAMETER VALIDATION */
/* number of components */
l_is_valid & = ( jp2 - > numcl > 0 ) ;
/* width */
l_is_valid & = ( jp2 - > h > 0 ) ;
/* height */
l_is_valid & = ( jp2 - > w > 0 ) ;
/* precision */
for ( i = 0 ; i < jp2 - > numcomps ; + + i ) {
l_is_valid & = ( jp2 - > comps [ i ] . bpcc > 0 ) ;
}
/* METH */
l_is_valid & = ( ( jp2 - > meth > 0 ) & & ( jp2 - > meth < 3 ) ) ;
/* stream validation */
/* back and forth is needed */
l_is_valid & = opj_stream_has_seek ( cio ) ;
return l_is_valid ;
}
2011-09-19 15:36:07 +02:00
/**
* Reads a jpeg2000 file header structure .
*
2012-08-10 12:55:10 +02:00
* @ param stream the stream to read data from .
2011-09-19 15:36:07 +02:00
* @ param jp2 the jpeg2000 file header structure .
* @ param p_manager the user event manager .
*
* @ return true if the box is valid .
*/
2012-08-10 12:55:10 +02:00
static opj_bool opj_jp2_read_header_procedure ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * stream ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
opj_jp2_box_t box ;
OPJ_UINT32 l_nb_bytes_read ;
const opj_jp2_header_handler_t * l_current_handler ;
OPJ_UINT32 l_last_data_size = BOX_SIZE ;
OPJ_UINT32 l_current_data_size ;
unsigned char * l_current_data = 00 ;
2012-03-02 16:53:14 +01:00
/* preconditions */
2012-08-10 12:55:10 +02:00
assert ( stream ! = 00 ) ;
2011-09-19 15:36:07 +02:00
assert ( jp2 ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
l_current_data = ( unsigned char * ) opj_malloc ( l_last_data_size ) ;
if ( l_current_data = = 00 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Not enough memory to handle jpeg2000 file header \n " ) ;
return OPJ_FALSE ;
}
memset ( l_current_data , 0 , l_last_data_size ) ;
2012-08-10 13:00:40 +02:00
while ( opj_jp2_read_boxhdr ( & box , & l_nb_bytes_read , stream , p_manager ) ) {
2012-03-02 16:53:14 +01:00
/* is it the codestream box ? */
2011-09-19 15:36:07 +02:00
if ( box . type = = JP2_JP2C ) {
if ( jp2 - > jp2_state & JP2_STATE_HEADER ) {
jp2 - > jp2_state | = JP2_STATE_CODESTREAM ;
opj_free ( l_current_data ) ;
return OPJ_TRUE ;
}
else {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " bad placed jpeg codestream \n " ) ;
opj_free ( l_current_data ) ;
return OPJ_FALSE ;
}
}
else if ( box . length = = 0 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Cannot handle box of undefined sizes \n " ) ;
opj_free ( l_current_data ) ;
return OPJ_FALSE ;
}
2012-08-10 12:55:10 +02:00
l_current_handler = opj_jp2_find_handler ( box . type ) ;
2011-09-19 15:36:07 +02:00
l_current_data_size = box . length - l_nb_bytes_read ;
if ( l_current_handler ! = 00 ) {
if ( l_current_data_size > l_last_data_size ) {
l_current_data = ( unsigned char * ) opj_realloc ( l_current_data , l_current_data_size ) ;
2011-12-07 10:53:46 +01:00
if ( ! l_current_data ) {
opj_free ( l_current_data ) ;
return OPJ_FALSE ;
}
2011-09-19 15:36:07 +02:00
l_last_data_size = l_current_data_size ;
}
2012-08-10 12:55:10 +02:00
l_nb_bytes_read = opj_stream_read_data ( stream , l_current_data , l_current_data_size , p_manager ) ;
2011-09-19 15:36:07 +02:00
if ( l_nb_bytes_read ! = l_current_data_size ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Problem with reading JPEG2000 box, stream error \n " ) ;
return OPJ_FALSE ;
}
if ( ! l_current_handler - > handler ( jp2 , l_current_data , l_current_data_size , p_manager ) ) {
opj_free ( l_current_data ) ;
return OPJ_FALSE ;
}
}
else {
jp2 - > jp2_state | = JP2_STATE_UNKNOWN ;
2012-08-10 12:55:10 +02:00
if ( opj_stream_skip ( stream , l_current_data_size , p_manager ) ! = l_current_data_size ) {
2011-09-19 15:36:07 +02:00
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Problem with skipping JPEG2000 box, stream error \n " ) ;
opj_free ( l_current_data ) ;
return OPJ_FALSE ;
}
}
2005-12-08 10:38:47 +01:00
}
2005-12-02 14:34:15 +01:00
2011-09-19 15:36:07 +02:00
opj_free ( l_current_data ) ;
2011-05-18 13:02:27 +02:00
return OPJ_TRUE ;
2004-07-07 10:24:36 +02:00
}
2011-09-19 15:36:07 +02:00
/**
* Excutes the given procedures on the given codec .
*
* @ param p_procedure_list the list of procedures to execute
* @ param jp2 the jpeg2000 file codec to execute the procedures on .
2012-08-10 12:55:10 +02:00
* @ param stream the stream to execute the procedures on .
2011-09-19 15:36:07 +02:00
* @ param p_manager the user manager .
*
* @ return true if all the procedures were successfully executed .
*/
2012-08-10 12:55:10 +02:00
static opj_bool opj_jp2_exec ( opj_jp2_v2_t * jp2 ,
opj_procedure_list_t * p_procedure_list ,
opj_stream_private_t * stream ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
opj_bool ( * * l_procedure ) ( opj_jp2_v2_t * jp2 , opj_stream_private_t * , opj_event_mgr_t * ) = 00 ;
opj_bool l_result = OPJ_TRUE ;
OPJ_UINT32 l_nb_proc , i ;
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( p_procedure_list ! = 00 ) ;
assert ( jp2 ! = 00 ) ;
2012-08-10 12:55:10 +02:00
assert ( stream ! = 00 ) ;
2011-09-19 15:36:07 +02:00
assert ( p_manager ! = 00 ) ;
l_nb_proc = opj_procedure_list_get_nb_procedures ( p_procedure_list ) ;
l_procedure = ( opj_bool ( * * ) ( opj_jp2_v2_t * jp2 , opj_stream_private_t * , opj_event_mgr_t * ) ) opj_procedure_list_get_first_procedure ( p_procedure_list ) ;
for ( i = 0 ; i < l_nb_proc ; + + i ) {
2012-08-10 12:55:10 +02:00
l_result = l_result & & ( * l_procedure ) ( jp2 , stream , p_manager ) ;
2011-09-19 15:36:07 +02:00
+ + l_procedure ;
}
2012-03-02 16:53:14 +01:00
/* and clear the procedure list at the end. */
2011-09-19 15:36:07 +02:00
opj_procedure_list_clear ( p_procedure_list ) ;
return l_result ;
}
2012-03-15 11:23:20 +01:00
/**
* Starts a compression scheme , i . e . validates the codec parameters , writes the header .
*
* @ param jp2 the jpeg2000 file codec .
* @ param cio the stream object .
*
* @ return true if the codec is valid .
*/
2012-08-13 11:24:15 +02:00
opj_bool opj_jp2_start_compress ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * stream ,
opj_image_t * p_image ,
opj_event_mgr_t * p_manager
)
2012-03-15 11:23:20 +01:00
{
/* preconditions */
assert ( jp2 ! = 00 ) ;
2012-08-13 11:24:15 +02:00
assert ( stream ! = 00 ) ;
2012-03-15 11:23:20 +01:00
assert ( p_manager ! = 00 ) ;
/* customization of the validation */
2012-08-13 11:44:40 +02:00
opj_jp2_setup_encoding_validation ( jp2 ) ;
2012-03-15 11:23:20 +01:00
/* validation of the parameters codec */
2012-08-13 11:24:15 +02:00
if ( ! opj_jp2_exec ( jp2 , jp2 - > m_validation_list , stream , p_manager ) ) {
2012-03-15 11:23:20 +01:00
return OPJ_FALSE ;
}
/* customization of the encoding */
2012-08-13 11:44:40 +02:00
opj_jp2_setup_header_writting ( jp2 ) ;
2012-03-15 11:23:20 +01:00
/* write header */
2012-08-13 11:24:15 +02:00
if ( ! opj_jp2_exec ( jp2 , jp2 - > m_procedure_list , stream , p_manager ) ) {
2012-03-15 11:23:20 +01:00
return OPJ_FALSE ;
}
2012-08-13 11:24:15 +02:00
return j2k_start_compress ( jp2 - > j2k , stream , p_image , p_manager ) ;
2012-03-15 11:23:20 +01:00
}
2011-09-19 15:36:07 +02:00
/**
* Finds the execution function related to the given box id .
*
* @ param p_id the id of the handler to fetch .
*
* @ return the given handler or 00 if it could not be found .
*/
2012-08-10 12:55:10 +02:00
const opj_jp2_header_handler_t * opj_jp2_find_handler ( OPJ_UINT32 p_id )
2011-09-19 15:36:07 +02:00
{
OPJ_UINT32 i , l_handler_size = sizeof ( jp2_header ) / sizeof ( opj_jp2_header_handler_t ) ;
for ( i = 0 ; i < l_handler_size ; + + i ) {
if ( jp2_header [ i ] . id = = p_id ) {
return & jp2_header [ i ] ;
}
}
return NULL ;
}
/**
* Finds the image execution function related to the given box id .
*
* @ param p_id the id of the handler to fetch .
*
* @ return the given handler or 00 if it could not be found .
*/
2012-08-10 12:55:10 +02:00
static const opj_jp2_header_handler_t * opj_jp2_img_find_handler ( OPJ_UINT32 p_id )
2011-09-19 15:36:07 +02:00
{
OPJ_UINT32 i , l_handler_size = sizeof ( jp2_img_header ) / sizeof ( opj_jp2_header_handler_t ) ;
for ( i = 0 ; i < l_handler_size ; + + i )
{
if ( jp2_img_header [ i ] . id = = p_id ) {
return & jp2_img_header [ i ] ;
}
}
return NULL ;
}
/**
* Reads a jpeg2000 file signature box .
*
* @ param p_header_data the data contained in the signature box .
* @ param jp2 the jpeg2000 file codec .
* @ param p_header_size the size of the data contained in the signature box .
* @ param p_manager the user event manager .
*
* @ return true if the file signature box is valid .
*/
2012-08-10 12:34:40 +02:00
static opj_bool opj_jp2_read_jp ( opj_jp2_v2_t * jp2 ,
OPJ_BYTE * p_header_data ,
OPJ_UINT32 p_header_size ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
unsigned int l_magic_number ;
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( p_header_data ! = 00 ) ;
assert ( jp2 ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
if ( jp2 - > jp2_state ! = JP2_STATE_NONE ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " The signature box must be the first box in the file. \n " ) ;
return OPJ_FALSE ;
}
/* assure length of data is correct (4 -> magic number) */
if ( p_header_size ! = 4 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Error with JP signature Box size \n " ) ;
return OPJ_FALSE ;
}
2012-03-02 16:53:14 +01:00
/* rearrange data */
2011-09-19 15:36:07 +02:00
opj_read_bytes ( p_header_data , & l_magic_number , 4 ) ;
if ( l_magic_number ! = 0x0d0a870a ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Error with JP Signature : bad magic number \n " ) ;
return OPJ_FALSE ;
}
jp2 - > jp2_state | = JP2_STATE_SIGNATURE ;
return OPJ_TRUE ;
}
/**
* Reads a a FTYP box - File type box
*
* @ param p_header_data the data contained in the FTYP box .
* @ param jp2 the jpeg2000 file codec .
* @ param p_header_size the size of the data contained in the FTYP box .
* @ param p_manager the user event manager .
*
* @ return true if the FTYP box is valid .
*/
2012-08-10 12:24:09 +02:00
static opj_bool opj_jp2_read_ftyp ( opj_jp2_v2_t * jp2 ,
OPJ_BYTE * p_header_data ,
OPJ_UINT32 p_header_size ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
OPJ_UINT32 i , l_remaining_bytes ;
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( p_header_data ! = 00 ) ;
assert ( jp2 ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
if ( jp2 - > jp2_state ! = JP2_STATE_SIGNATURE ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " The ftyp box must be the second box in the file. \n " ) ;
return OPJ_FALSE ;
}
/* assure length of data is correct */
if ( p_header_size < 8 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Error with FTYP signature Box size \n " ) ;
return OPJ_FALSE ;
}
opj_read_bytes ( p_header_data , & jp2 - > brand , 4 ) ; /* BR */
p_header_data + = 4 ;
opj_read_bytes ( p_header_data , & jp2 - > minversion , 4 ) ; /* MinV */
p_header_data + = 4 ;
l_remaining_bytes = p_header_size - 8 ;
/* the number of remaining bytes should be a multiple of 4 */
if ( ( l_remaining_bytes & 0x3 ) ! = 0 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Error with FTYP signature Box size \n " ) ;
return OPJ_FALSE ;
}
/* div by 4 */
jp2 - > numcl = l_remaining_bytes > > 2 ;
if ( jp2 - > numcl ) {
jp2 - > cl = ( unsigned int * ) opj_malloc ( jp2 - > numcl * sizeof ( unsigned int ) ) ;
if ( jp2 - > cl = = 00 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Not enough memory with FTYP Box \n " ) ;
return OPJ_FALSE ;
}
memset ( jp2 - > cl , 0 , jp2 - > numcl * sizeof ( unsigned int ) ) ;
}
for ( i = 0 ; i < jp2 - > numcl ; + + i )
{
opj_read_bytes ( p_header_data , & jp2 - > cl [ i ] , 4 ) ; /* CLi */
p_header_data + = 4 ;
}
jp2 - > jp2_state | = JP2_STATE_FILE_TYPE ;
return OPJ_TRUE ;
}
2012-03-15 11:23:20 +01:00
/**
* Skips the Jpeg2000 Codestream Header box - JP2C Header box .
*
* @ param cio the stream to write data to .
* @ param jp2 the jpeg2000 file codec .
* @ param p_manager user event manager .
*
* @ return true if writting was successful .
*/
2012-08-13 11:44:40 +02:00
opj_bool opj_jp2_skip_jp2c ( opj_jp2_v2_t * jp2 ,
opj_stream_private_t * stream ,
opj_event_mgr_t * p_manager )
2012-03-15 11:23:20 +01:00
{
/* preconditions */
assert ( jp2 ! = 00 ) ;
2012-05-14 12:02:59 +02:00
assert ( stream ! = 00 ) ;
2012-03-15 11:23:20 +01:00
assert ( p_manager ! = 00 ) ;
2012-05-14 12:02:59 +02:00
jp2 - > j2k_codestream_offset = opj_stream_tell ( stream ) ;
2012-03-15 11:23:20 +01:00
2012-05-14 12:02:59 +02:00
if ( opj_stream_skip ( stream , 8 , p_manager ) ! = 8 ) {
2012-03-15 11:23:20 +01:00
return OPJ_FALSE ;
}
return OPJ_TRUE ;
}
2011-09-19 15:36:07 +02:00
/**
* Reads the Jpeg2000 file Header box - JP2 Header box ( warning , this is a super box ) .
*
* @ param p_header_data the data contained in the file header box .
* @ param jp2 the jpeg2000 file codec .
* @ param p_header_size the size of the data contained in the file header box .
* @ param p_manager the user event manager .
*
* @ return true if the JP2 Header box was successfully reconized .
*/
2012-08-10 11:43:28 +02:00
static opj_bool opj_jp2_read_jp2h ( opj_jp2_v2_t * jp2 ,
OPJ_BYTE * p_header_data ,
OPJ_UINT32 p_header_size ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
OPJ_UINT32 l_box_size = 0 , l_current_data_size = 0 ;
opj_jp2_box_t box ;
const opj_jp2_header_handler_t * l_current_handler ;
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( p_header_data ! = 00 ) ;
assert ( jp2 ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
/* make sure the box is well placed */
if ( ( jp2 - > jp2_state & JP2_STATE_FILE_TYPE ) ! = JP2_STATE_FILE_TYPE ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " The box must be the first box in the file. \n " ) ;
return OPJ_FALSE ;
}
jp2 - > jp2_img_state = JP2_IMG_STATE_NONE ;
/* iterate while remaining data */
while ( p_header_size > 0 ) {
2012-08-10 12:55:10 +02:00
if ( ! opj_jp2_read_boxhdr_char ( & box , p_header_data , & l_box_size , p_header_size , p_manager ) ) {
2011-09-19 15:36:07 +02:00
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Stream error while reading JP2 Header box \n " ) ;
return OPJ_FALSE ;
}
if ( box . length > p_header_size ) {
2011-09-19 15:47:35 +02:00
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Stream error while reading JP2 Header box: box length is inconsistent. \n " ) ;
2011-09-19 15:36:07 +02:00
return OPJ_FALSE ;
}
2012-08-10 12:55:10 +02:00
l_current_handler = opj_jp2_img_find_handler ( box . type ) ;
2011-09-19 15:36:07 +02:00
l_current_data_size = box . length - l_box_size ;
p_header_data + = l_box_size ;
if ( l_current_handler ! = 00 ) {
if ( ! l_current_handler - > handler ( jp2 , p_header_data , l_current_data_size , p_manager ) ) {
return OPJ_FALSE ;
}
}
else {
jp2 - > jp2_img_state | = JP2_IMG_STATE_UNKNOWN ;
}
p_header_data + = l_current_data_size ;
p_header_size - = box . length ;
}
jp2 - > jp2_state | = JP2_STATE_HEADER ;
return OPJ_TRUE ;
}
/**
* Reads a box header . The box is the way data is packed inside a jpeg2000 file structure . Data is read from a character string
*
* @ param p_data the character string to read data from .
* @ param box the box structure to fill .
* @ param p_number_bytes_read pointer to an int that will store the number of bytes read from the stream ( shoul usually be 2 ) .
* @ param p_box_max_size the maximum number of bytes in the box .
*
* @ return true if the box is reconized , false otherwise
*/
2012-08-10 12:55:10 +02:00
opj_bool opj_jp2_read_boxhdr_char ( opj_jp2_box_t * box ,
OPJ_BYTE * p_data ,
OPJ_UINT32 * p_number_bytes_read ,
OPJ_UINT32 p_box_max_size ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
OPJ_UINT32 l_value ;
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( p_data ! = 00 ) ;
assert ( box ! = 00 ) ;
assert ( p_number_bytes_read ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
if ( p_box_max_size < 8 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Cannot handle box of less than 8 bytes \n " ) ;
return OPJ_FALSE ;
}
/* process read data */
opj_read_bytes ( p_data , & l_value , 4 ) ;
p_data + = 4 ;
box - > length = ( OPJ_INT32 ) ( l_value ) ;
opj_read_bytes ( p_data , & l_value , 4 ) ;
p_data + = 4 ;
box - > type = ( OPJ_INT32 ) ( l_value ) ;
* p_number_bytes_read = 8 ;
2012-03-02 16:53:14 +01:00
/* do we have a "special very large box ?" */
/* read then the XLBox */
2011-09-19 15:36:07 +02:00
if ( box - > length = = 1 ) {
unsigned int l_xl_part_size ;
if ( p_box_max_size < 16 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Cannot handle XL box of less than 16 bytes \n " ) ;
return OPJ_FALSE ;
}
opj_read_bytes ( p_data , & l_xl_part_size , 4 ) ;
p_data + = 4 ;
* p_number_bytes_read + = 4 ;
if ( l_xl_part_size ! = 0 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Cannot handle box sizes higher than 2^32 \n " ) ;
return OPJ_FALSE ;
}
opj_read_bytes ( p_data , & l_value , 4 ) ;
* p_number_bytes_read + = 4 ;
box - > length = ( OPJ_INT32 ) ( l_value ) ;
if ( box - > length = = 0 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Cannot handle box of undefined sizes \n " ) ;
return OPJ_FALSE ;
}
}
else if ( box - > length = = 0 ) {
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Cannot handle box of undefined sizes \n " ) ;
return OPJ_FALSE ;
}
return OPJ_TRUE ;
}
/**
* Reads a jpeg2000 file header structure .
*
* @ param cio the stream to read data from .
* @ param jp2 the jpeg2000 file header structure .
* @ param p_manager the user event manager .
*
* @ return true if the box is valid .
*/
2012-08-13 11:24:15 +02:00
opj_bool opj_jp2_read_header ( opj_stream_private_t * p_stream ,
opj_jp2_v2_t * jp2 ,
opj_image_t * * p_image ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
2011-10-07 19:31:35 +02:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( jp2 ! = 00 ) ;
assert ( p_stream ! = 00 ) ;
assert ( p_manager ! = 00 ) ;
/* customization of the validation */
2012-08-10 12:55:10 +02:00
opj_jp2_setup_decoding_validation ( jp2 ) ;
2011-09-19 15:36:07 +02:00
/* customization of the encoding */
2012-08-10 12:55:10 +02:00
opj_jp2_setup_header_reading ( jp2 ) ;
2011-09-19 15:36:07 +02:00
/* validation of the parameters codec */
2012-08-10 12:55:10 +02:00
if ( ! opj_jp2_exec ( jp2 , jp2 - > m_validation_list , p_stream , p_manager ) ) {
2011-09-19 15:36:07 +02:00
return OPJ_FALSE ;
}
/* read header */
2012-08-10 12:55:10 +02:00
if ( ! opj_jp2_exec ( jp2 , jp2 - > m_procedure_list , p_stream , p_manager ) ) {
2011-09-19 15:36:07 +02:00
return OPJ_FALSE ;
}
return j2k_read_header ( p_stream ,
jp2 - > j2k ,
2011-10-05 18:27:16 +02:00
p_image ,
2011-09-19 15:36:07 +02:00
p_manager ) ;
}
2012-03-15 11:23:20 +01:00
/**
* Sets up the validation , i . e . adds the procedures to launch to make sure the codec parameters
* are valid . Developers wanting to extend the library can add their own validation procedures .
*/
2012-08-13 11:44:40 +02:00
void opj_jp2_setup_encoding_validation ( opj_jp2_v2_t * jp2 )
2012-03-15 11:23:20 +01:00
{
/* preconditions */
assert ( jp2 ! = 00 ) ;
2012-08-10 12:55:10 +02:00
opj_procedure_list_add_procedure ( jp2 - > m_validation_list , ( opj_procedure ) opj_jp2_default_validation ) ;
2012-03-15 11:23:20 +01:00
/* DEVELOPER CORNER, add your custom validation procedure */
}
2011-09-19 15:36:07 +02:00
/**
* Sets up the validation , i . e . adds the procedures to lauch to make sure the codec parameters
* are valid . Developpers wanting to extend the library can add their own validation procedures .
*/
2012-08-10 12:55:10 +02:00
void opj_jp2_setup_decoding_validation ( opj_jp2_v2_t * jp2 )
2011-09-19 15:36:07 +02:00
{
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( jp2 ! = 00 ) ;
/* DEVELOPER CORNER, add your custom validation procedure */
}
2012-03-15 11:23:20 +01:00
/**
* Sets up the procedures to do on writting header .
* Developers wanting to extend the library can add their own writing procedures .
*/
2012-08-13 11:44:40 +02:00
void opj_jp2_setup_header_writting ( opj_jp2_v2_t * jp2 )
2012-03-15 11:23:20 +01:00
{
/* preconditions */
assert ( jp2 ! = 00 ) ;
2012-08-13 12:03:57 +02:00
opj_procedure_list_add_procedure ( jp2 - > m_procedure_list , ( opj_procedure ) opj_jp2_write_jp ) ;
2012-08-13 11:39:51 +02:00
opj_procedure_list_add_procedure ( jp2 - > m_procedure_list , ( opj_procedure ) opj_jp2_write_ftyp ) ;
2012-08-13 11:24:15 +02:00
opj_procedure_list_add_procedure ( jp2 - > m_procedure_list , ( opj_procedure ) opj_jp2_write_jp2h ) ;
2012-08-13 11:44:40 +02:00
opj_procedure_list_add_procedure ( jp2 - > m_procedure_list , ( opj_procedure ) opj_jp2_skip_jp2c ) ;
2012-03-15 11:23:20 +01:00
/* DEVELOPER CORNER, insert your custom procedures */
}
2011-09-19 15:36:07 +02:00
/**
* Sets up the procedures to do on reading header .
* Developpers wanting to extend the library can add their own writting procedures .
*/
2012-08-10 12:55:10 +02:00
void opj_jp2_setup_header_reading ( opj_jp2_v2_t * jp2 )
2011-09-19 15:36:07 +02:00
{
2012-03-02 16:53:14 +01:00
/* preconditions */
2011-09-19 15:36:07 +02:00
assert ( jp2 ! = 00 ) ;
2012-08-10 12:55:10 +02:00
opj_procedure_list_add_procedure ( jp2 - > m_procedure_list , ( opj_procedure ) opj_jp2_read_header_procedure ) ;
2011-09-19 15:36:07 +02:00
/* DEVELOPER CORNER, add your custom procedures */
}
/**
* Reads a tile header .
* @ param p_j2k the jpeg2000 codec .
* @ param p_stream the stream to write data to .
* @ param p_manager the user event manager .
*/
2012-08-13 11:24:15 +02:00
opj_bool opj_jp2_read_tile_header ( opj_jp2_v2_t * p_jp2 ,
OPJ_UINT32 * p_tile_index ,
OPJ_UINT32 * p_data_size ,
OPJ_INT32 * p_tile_x0 ,
OPJ_INT32 * p_tile_y0 ,
OPJ_INT32 * p_tile_x1 ,
OPJ_INT32 * p_tile_y1 ,
OPJ_UINT32 * p_nb_comps ,
opj_bool * p_go_on ,
opj_stream_private_t * p_stream ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
2011-09-19 18:05:43 +02:00
return j2k_read_tile_header ( p_jp2 - > j2k ,
2011-09-19 15:36:07 +02:00
p_tile_index ,
p_data_size ,
2011-09-19 18:05:43 +02:00
p_tile_x0 , p_tile_y0 ,
p_tile_x1 , p_tile_y1 ,
2011-09-19 15:36:07 +02:00
p_nb_comps ,
p_go_on ,
p_stream ,
p_manager ) ;
}
2012-03-15 11:23:20 +01:00
/**
* Writes a tile .
* @ param p_j2k the jpeg2000 codec .
* @ param p_stream the stream to write data to .
* @ param p_manager the user event manager .
*/
2012-08-13 11:24:15 +02:00
opj_bool opj_jp2_write_tile ( opj_jp2_v2_t * p_jp2 ,
OPJ_UINT32 p_tile_index ,
OPJ_BYTE * p_data ,
OPJ_UINT32 p_data_size ,
opj_stream_private_t * p_stream ,
opj_event_mgr_t * p_manager
)
2012-03-15 11:23:20 +01:00
{
return j2k_write_tile ( p_jp2 - > j2k , p_tile_index , p_data , p_data_size , p_stream , p_manager ) ;
}
2011-09-19 15:36:07 +02:00
/**
* Decode tile data .
* @ param p_j2k the jpeg2000 codec .
* @ param p_stream the stream to write data to .
* @ param p_manager the user event manager .
*/
2012-08-13 11:24:15 +02:00
opj_bool opj_jp2_decode_tile ( opj_jp2_v2_t * p_jp2 ,
OPJ_UINT32 p_tile_index ,
OPJ_BYTE * p_data ,
OPJ_UINT32 p_data_size ,
opj_stream_private_t * p_stream ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
return j2k_decode_tile ( p_jp2 - > j2k , p_tile_index , p_data , p_data_size , p_stream , p_manager ) ;
}
/**
* Destroys a jpeg2000 file decompressor .
*
* @ param jp2 a jpeg2000 file decompressor .
*/
2012-08-13 11:24:15 +02:00
void opj_jp2_destroy ( opj_jp2_v2_t * jp2 )
2011-09-19 15:36:07 +02:00
{
if ( jp2 ) {
/* destroy the J2K codec */
j2k_destroy ( jp2 - > j2k ) ;
jp2 - > j2k = 00 ;
if ( jp2 - > comps ) {
opj_free ( jp2 - > comps ) ;
jp2 - > comps = 00 ;
}
if ( jp2 - > cl ) {
opj_free ( jp2 - > cl ) ;
jp2 - > cl = 00 ;
}
if ( jp2 - > color . icc_profile_buf ) {
opj_free ( jp2 - > color . icc_profile_buf ) ;
jp2 - > color . icc_profile_buf = 00 ;
}
if ( jp2 - > color . jp2_cdef ) {
2011-10-20 15:18:52 +02:00
if ( jp2 - > color . jp2_cdef - > info ) {
opj_free ( jp2 - > color . jp2_cdef - > info ) ;
jp2 - > color . jp2_cdef - > info = NULL ;
}
2011-09-19 15:36:07 +02:00
opj_free ( jp2 - > color . jp2_cdef ) ;
jp2 - > color . jp2_cdef = 00 ;
}
if ( jp2 - > color . jp2_pclr ) {
2011-10-20 15:18:52 +02:00
if ( jp2 - > color . jp2_pclr - > cmap ) {
opj_free ( jp2 - > color . jp2_pclr - > cmap ) ;
jp2 - > color . jp2_pclr - > cmap = NULL ;
}
if ( jp2 - > color . jp2_pclr - > channel_sign ) {
opj_free ( jp2 - > color . jp2_pclr - > channel_sign ) ;
jp2 - > color . jp2_pclr - > channel_sign = NULL ;
}
if ( jp2 - > color . jp2_pclr - > channel_size ) {
opj_free ( jp2 - > color . jp2_pclr - > channel_size ) ;
jp2 - > color . jp2_pclr - > channel_size = NULL ;
}
if ( jp2 - > color . jp2_pclr - > entries ) {
opj_free ( jp2 - > color . jp2_pclr - > entries ) ;
jp2 - > color . jp2_pclr - > entries = NULL ;
}
2011-09-19 15:36:07 +02:00
opj_free ( jp2 - > color . jp2_pclr ) ;
jp2 - > color . jp2_pclr = 00 ;
}
if ( jp2 - > m_validation_list ) {
opj_procedure_list_destroy ( jp2 - > m_validation_list ) ;
jp2 - > m_validation_list = 00 ;
}
if ( jp2 - > m_procedure_list ) {
opj_procedure_list_destroy ( jp2 - > m_procedure_list ) ;
jp2 - > m_procedure_list = 00 ;
}
opj_free ( jp2 ) ;
}
}
/**
* Sets the given area to be decoded . This function should be called right after opj_read_header and before any tile header reading .
*
* @ param p_jp2 the jpeg2000 codec .
* @ param p_end_x the right position of the rectangle to decode ( in image coordinates ) .
* @ param p_start_y the up position of the rectangle to decode ( in image coordinates ) .
* @ param p_end_y the bottom position of the rectangle to decode ( in image coordinates ) .
* @ param p_manager the user event manager
*
* @ return true if the area could be set .
*/
2012-08-13 11:24:15 +02:00
opj_bool opj_jp2_set_decode_area ( opj_jp2_v2_t * p_jp2 ,
opj_image_t * p_image ,
OPJ_INT32 p_start_x , OPJ_INT32 p_start_y ,
OPJ_INT32 p_end_x , OPJ_INT32 p_end_y ,
opj_event_mgr_t * p_manager
)
2011-09-19 15:36:07 +02:00
{
2011-10-21 18:38:08 +02:00
return j2k_set_decode_area ( p_jp2 - > j2k , p_image , p_start_x , p_start_y , p_end_x , p_end_y , p_manager ) ;
2011-09-19 15:36:07 +02:00
}
2011-11-08 14:21:17 +01:00
/**
* Get the decoded tile .
*
2011-12-03 18:26:59 +01:00
* @ param jp2 the jpeg2000 codec .
2011-11-08 14:21:17 +01:00
* @ param p_stream input_stream
* @ param p_image output image . .
* @ param p_manager the user event manager
* @ param tile_index index of the tile we want decode
*
* @ return true if succeed .
*/
2012-08-13 11:24:15 +02:00
opj_bool opj_jp2_get_tile ( opj_jp2_v2_t * p_jp2 ,
opj_stream_private_t * p_stream ,
opj_image_t * p_image ,
opj_event_mgr_t * p_manager ,
OPJ_UINT32 tile_index
)
2011-11-08 14:21:17 +01:00
{
if ( ! p_image )
return OPJ_FALSE ;
opj_event_msg_v2 ( p_manager , EVT_WARNING , " JP2 box which are after the codestream will not be read by this function. \n " ) ;
2012-08-13 11:24:15 +02:00
if ( ! j2k_get_tile ( p_jp2 - > j2k , p_stream , p_image , p_manager , tile_index ) ) {
2011-11-08 14:21:17 +01:00
opj_event_msg_v2 ( p_manager , EVT_ERROR , " Failed to decode the codestream in the JP2 file \n " ) ;
return OPJ_FALSE ;
}
/* Set Image Color Space */
2012-08-13 11:24:15 +02:00
if ( p_jp2 - > enumcs = = 16 )
2011-11-08 14:21:17 +01:00
p_image - > color_space = CLRSPC_SRGB ;
2012-08-13 11:24:15 +02:00
else if ( p_jp2 - > enumcs = = 17 )
2011-11-08 14:21:17 +01:00
p_image - > color_space = CLRSPC_GRAY ;
2012-08-13 11:24:15 +02:00
else if ( p_jp2 - > enumcs = = 18 )
2011-11-08 14:21:17 +01:00
p_image - > color_space = CLRSPC_SYCC ;
else
p_image - > color_space = CLRSPC_UNKNOWN ;
/* Apply the color space if needed */
2012-08-13 11:24:15 +02:00
if ( p_jp2 - > color . jp2_cdef ) {
2012-08-13 12:10:25 +02:00
opj_jp2_apply_cdef ( p_image , & ( p_jp2 - > color ) ) ;
2011-11-08 14:21:17 +01:00
}
2012-08-13 11:24:15 +02:00
if ( p_jp2 - > color . jp2_pclr ) {
2011-11-08 14:21:17 +01:00
/* Part 1, I.5.3.4: Either both or none : */
2012-08-13 11:24:15 +02:00
if ( ! p_jp2 - > color . jp2_pclr - > cmap )
2012-08-13 12:10:25 +02:00
opj_jp2_free_pclr ( & ( p_jp2 - > color ) ) ;
2011-11-08 14:21:17 +01:00
else
2012-08-13 12:10:25 +02:00
opj_jp2_apply_pclr ( p_image , & ( p_jp2 - > color ) ) ;
2011-11-08 14:21:17 +01:00
}
2012-08-13 11:24:15 +02:00
if ( p_jp2 - > color . icc_profile_buf ) {
p_image - > icc_profile_buf = p_jp2 - > color . icc_profile_buf ;
p_image - > icc_profile_len = p_jp2 - > color . icc_profile_len ;
p_jp2 - > color . icc_profile_buf = NULL ;
2011-11-08 14:21:17 +01:00
}
return OPJ_TRUE ;
}
2011-09-19 15:36:07 +02:00
/* ----------------------------------------------------------------------- */
/* JP2 encoder interface */
/* ----------------------------------------------------------------------- */
2012-08-13 11:24:15 +02:00
opj_jp2_v2_t * opj_jp2_create ( opj_bool p_is_decoder )
2011-09-19 15:36:07 +02:00
{
opj_jp2_v2_t * jp2 = ( opj_jp2_v2_t * ) opj_malloc ( sizeof ( opj_jp2_v2_t ) ) ;
if ( jp2 ) {
2012-05-14 16:51:26 +02:00
memset ( jp2 , 0 , sizeof ( opj_jp2_v2_t ) ) ;
2011-09-19 15:36:07 +02:00
/* create the J2K codec */
if ( ! p_is_decoder ) {
jp2 - > j2k = j2k_create_compress_v2 ( ) ;
}
else {
2012-08-09 17:00:50 +02:00
jp2 - > j2k = opj_j2k_create_decompress ( ) ;
2011-09-19 15:36:07 +02:00
}
if ( jp2 - > j2k = = 00 ) {
2012-08-13 11:24:15 +02:00
opj_jp2_destroy ( jp2 ) ;
2011-09-19 15:36:07 +02:00
return 00 ;
}
2011-10-11 12:09:02 +02:00
/* Color structure */
jp2 - > color . icc_profile_buf = NULL ;
jp2 - > color . icc_profile_len = 0 ;
jp2 - > color . jp2_cdef = NULL ;
jp2 - > color . jp2_pclr = NULL ;
jp2 - > color . jp2_has_colr = 0 ;
2012-03-02 16:53:14 +01:00
/* validation list creation */
2011-09-19 15:36:07 +02:00
jp2 - > m_validation_list = opj_procedure_list_create ( ) ;
if ( ! jp2 - > m_validation_list ) {
2012-08-13 11:24:15 +02:00
opj_jp2_destroy ( jp2 ) ;
2011-09-19 15:36:07 +02:00
return 00 ;
}
2012-03-02 16:53:14 +01:00
/* execution list creation */
2011-09-19 15:36:07 +02:00
jp2 - > m_procedure_list = opj_procedure_list_create ( ) ;
if ( ! jp2 - > m_procedure_list ) {
2012-08-13 11:24:15 +02:00
opj_jp2_destroy ( jp2 ) ;
2011-09-19 15:36:07 +02:00
return 00 ;
}
}
return jp2 ;
}
2011-10-07 19:31:35 +02:00
void jp2_dump ( opj_jp2_v2_t * p_jp2 , OPJ_INT32 flag , FILE * out_stream )
{
/* preconditions */
assert ( p_jp2 ! = 00 ) ;
j2k_dump ( p_jp2 - > j2k ,
flag ,
out_stream ) ;
}
opj_codestream_index_t * jp2_get_cstr_index ( opj_jp2_v2_t * p_jp2 )
{
return j2k_get_cstr_index ( p_jp2 - > j2k ) ;
}
opj_codestream_info_v2_t * jp2_get_cstr_info ( opj_jp2_v2_t * p_jp2 )
{
return j2k_get_cstr_info ( p_jp2 - > j2k ) ;
}
2012-08-13 11:24:15 +02:00
opj_bool opj_jp2_set_decoded_resolution_factor ( opj_jp2_v2_t * p_jp2 ,
OPJ_UINT32 res_factor ,
opj_event_mgr_t * p_manager )
2011-11-17 15:21:11 +01:00
{
return j2k_set_decoded_resolution_factor ( p_jp2 - > j2k , res_factor , p_manager ) ;
}