X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fopenjp2%2Fj2k.c;h=f30b3a369b0543ca18bb54d42e9b189e369b6184;hb=7f8f284ee5ee05200f62266dfff0284551407a83;hp=82bc0627f7b3ab1cdd17640b53a1f072bf497a3e;hpb=76947f007466ea68cddabd915633d9670dabdb98;p=openjpeg.git diff --git a/src/lib/openjp2/j2k.c b/src/lib/openjp2/j2k.c index 82bc0627..f30b3a36 100644 --- a/src/lib/openjp2/j2k.c +++ b/src/lib/openjp2/j2k.c @@ -1,14 +1,21 @@ /* - * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium - * Copyright (c) 2002-2007, Professor Benoit Macq + * The copyright in this software is being made available under the 2-clauses + * BSD License, included below. This software may be subject to other third + * party and contributor rights, including patent rights, and no such rights + * are granted under this license. + * + * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium + * Copyright (c) 2002-2014, Professor Benoit Macq * Copyright (c) 2001-2003, David Janssens * Copyright (c) 2002-2003, Yannick Verschueren - * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe + * Copyright (c) 2003-2007, Francois-Olivier Devaux + * Copyright (c) 2003-2014, Antonin Descampe * Copyright (c) 2005, Herve Drolon, FreeImage Team * Copyright (c) 2008, Jerome Fimes, Communications & Systemes * Copyright (c) 2006-2007, Parvatha Elangovan * Copyright (c) 2010-2011, Kaori Hagihara - * Copyright (c) 2011-2012, Mickael Savinaud, Communications & Systemes + * Copyright (c) 2011-2012, Centre National d'Etudes Spatiales (CNES), France + * Copyright (c) 2012, CS Systemes d'Information, France * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -44,12 +51,12 @@ /** * Sets up the procedures to do on reading header. Developpers wanting to extend the library can add their own reading procedures. */ -static void opj_j2k_setup_header_reading (opj_j2k_v2_t *p_j2k); +static void opj_j2k_setup_header_reading (opj_j2k_t *p_j2k); /** * The read header procedure. */ -static opj_bool opj_j2k_read_header_procedure( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_header_procedure( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager); @@ -62,7 +69,7 @@ static opj_bool opj_j2k_read_header_procedure( opj_j2k_v2_t *p_j2k, * * @return true if the parameters are correct. */ -static opj_bool opj_j2k_encoding_validation ( opj_j2k_v2_t * p_j2k, +static OPJ_BOOL opj_j2k_encoding_validation ( opj_j2k_t * p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -75,7 +82,7 @@ static opj_bool opj_j2k_encoding_validation ( opj_j2k_v2_t * p_j2k, * * @return true if the parameters are correct. */ -static opj_bool opj_j2k_decoding_validation ( opj_j2k_v2_t * p_j2k, +static OPJ_BOOL opj_j2k_decoding_validation ( opj_j2k_t * p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -83,19 +90,19 @@ static opj_bool opj_j2k_decoding_validation ( opj_j2k_v2_t * p_j2k, * 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. */ -static void opj_j2k_setup_encoding_validation (opj_j2k_v2_t *p_j2k); +static void opj_j2k_setup_encoding_validation (opj_j2k_t *p_j2k); /** * 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. */ -static void opj_j2k_setup_decoding_validation (opj_j2k_v2_t *p_j2k); +static void opj_j2k_setup_decoding_validation (opj_j2k_t *p_j2k); /** * 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. */ -static void opj_j2k_setup_end_compress (opj_j2k_v2_t *p_j2k); +static void opj_j2k_setup_end_compress (opj_j2k_t *p_j2k); /** * The mct encoding validation procedure. @@ -106,20 +113,20 @@ static void opj_j2k_setup_end_compress (opj_j2k_v2_t *p_j2k); * * @return true if the parameters are correct. */ -static opj_bool opj_j2k_mct_validation (opj_j2k_v2_t * p_j2k, +static OPJ_BOOL opj_j2k_mct_validation (opj_j2k_t * p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); /** * Builds the tcd decoder to use to decode tile. */ -static opj_bool opj_j2k_build_decoder ( opj_j2k_v2_t * p_j2k, +static OPJ_BOOL opj_j2k_build_decoder ( opj_j2k_t * p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); /** * Builds the tcd encoder to use to encode tile. */ -static opj_bool opj_j2k_build_encoder ( opj_j2k_v2_t * p_j2k, +static OPJ_BOOL opj_j2k_build_encoder ( opj_j2k_t * p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -130,7 +137,7 @@ static opj_bool opj_j2k_build_encoder ( opj_j2k_v2_t * p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_create_tcd( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_create_tcd( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -144,7 +151,7 @@ static opj_bool opj_j2k_create_tcd( opj_j2k_v2_t *p_j2k, * * @return true if all the procedures were successfully executed. */ -static opj_bool opj_j2k_exec ( opj_j2k_v2_t * p_j2k, +static OPJ_BOOL opj_j2k_exec ( opj_j2k_t * p_j2k, opj_procedure_list_t * p_procedure_list, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager); @@ -156,7 +163,7 @@ static opj_bool opj_j2k_exec ( opj_j2k_v2_t * p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_update_rates( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_update_rates( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -164,14 +171,14 @@ static opj_bool opj_j2k_update_rates( opj_j2k_v2_t *p_j2k, * Copies the decoding tile parameters onto all the tile parameters. * Creates also the tile decoder. */ -static opj_bool opj_j2k_copy_default_tcp_and_create_tcd ( opj_j2k_v2_t * p_j2k, +static OPJ_BOOL opj_j2k_copy_default_tcp_and_create_tcd ( opj_j2k_t * p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); /** * Destroys the memory associated with the decoding of headers. */ -static opj_bool opj_j2k_destroy_header_memory ( opj_j2k_v2_t * p_j2k, +static OPJ_BOOL opj_j2k_destroy_header_memory ( opj_j2k_t * p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -189,21 +196,21 @@ static const struct opj_dec_memory_marker_handler * opj_j2k_get_marker_handler ( * * @param p_tcp the tile coding parameter to destroy. */ -static void opj_j2k_tcp_destroy (opj_tcp_v2_t *p_tcp); +static void opj_j2k_tcp_destroy (opj_tcp_t *p_tcp); /** * Destroys the data inside a tile coding parameter structure. * * @param p_tcp the tile coding parameter which contain data to destroy. */ -static void opj_j2k_tcp_data_destroy (opj_tcp_v2_t *p_tcp); +static void opj_j2k_tcp_data_destroy (opj_tcp_t *p_tcp); /** * Destroys a coding parameter structure. * * @param p_cp the coding parameter to destroy. */ -static void opj_j2k_cp_destroy (opj_cp_v2_t *p_cp); +static void opj_j2k_cp_destroy (opj_cp_t *p_cp); /** * Writes a SPCod or SPCoc element, i.e. the coding style of a given component of a tile. @@ -217,7 +224,7 @@ static void opj_j2k_cp_destroy (opj_cp_v2_t *p_cp); * * @return FIXME DOC */ -static opj_bool opj_j2k_write_SPCod_SPCoc( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_SPCod_SPCoc( opj_j2k_t *p_j2k, OPJ_UINT32 p_tile_no, OPJ_UINT32 p_comp_no, OPJ_BYTE * p_data, @@ -233,7 +240,7 @@ static opj_bool opj_j2k_write_SPCod_SPCoc( opj_j2k_v2_t *p_j2k, * * @return the number of bytes taken by the SPCod element. */ -static OPJ_UINT32 opj_j2k_get_SPCod_SPCoc_size (opj_j2k_v2_t *p_j2k, +static OPJ_UINT32 opj_j2k_get_SPCod_SPCoc_size (opj_j2k_t *p_j2k, OPJ_UINT32 p_tile_no, OPJ_UINT32 p_comp_no ); @@ -245,7 +252,7 @@ static OPJ_UINT32 opj_j2k_get_SPCod_SPCoc_size (opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the COM marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_SPCod_SPCoc( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_SPCod_SPCoc( opj_j2k_t *p_j2k, OPJ_UINT32 compno, OPJ_BYTE * p_header_data, OPJ_UINT32 * p_header_size, @@ -260,7 +267,7 @@ static opj_bool opj_j2k_read_SPCod_SPCoc( opj_j2k_v2_t *p_j2k, * * @return the number of bytes taken by the SPCod element. */ -static OPJ_UINT32 opj_j2k_get_SQcd_SQcc_size ( opj_j2k_v2_t *p_j2k, +static OPJ_UINT32 opj_j2k_get_SQcd_SQcc_size ( opj_j2k_t *p_j2k, OPJ_UINT32 p_tile_no, OPJ_UINT32 p_comp_no ); @@ -275,7 +282,7 @@ static OPJ_UINT32 opj_j2k_get_SQcd_SQcc_size ( opj_j2k_v2_t *p_j2k, * @param p_manager the user event manager. * */ -static opj_bool opj_j2k_write_SQcd_SQcc(opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_SQcd_SQcc(opj_j2k_t *p_j2k, OPJ_UINT32 p_tile_no, OPJ_UINT32 p_comp_no, OPJ_BYTE * p_data, @@ -285,7 +292,7 @@ static opj_bool opj_j2k_write_SQcd_SQcc(opj_j2k_v2_t *p_j2k, /** * Updates the Tile Length Marker. */ -static void opj_j2k_update_tlm ( opj_j2k_v2_t * p_j2k, OPJ_UINT32 p_tile_part_size); +static void opj_j2k_update_tlm ( opj_j2k_t * p_j2k, OPJ_UINT32 p_tile_part_size); /** * Reads a SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC. @@ -297,7 +304,7 @@ static void opj_j2k_update_tlm ( opj_j2k_v2_t * p_j2k, OPJ_UINT32 p_tile_part_si * @param p_manager the user event manager. * */ -static opj_bool opj_j2k_read_SQcd_SQcc( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_SQcd_SQcc( opj_j2k_t *p_j2k, OPJ_UINT32 compno, OPJ_BYTE * p_header_data, OPJ_UINT32 * p_header_size, @@ -308,32 +315,32 @@ static opj_bool opj_j2k_read_SQcd_SQcc( opj_j2k_v2_t *p_j2k, * * @param p_j2k the J2k codec. */ -static void opj_j2k_copy_tile_component_parameters( opj_j2k_v2_t *p_j2k ); +static void opj_j2k_copy_tile_component_parameters( opj_j2k_t *p_j2k ); /** * Copies the tile quantization parameters of all the component from the first tile component. * * @param p_j2k the J2k codec. */ -static void opj_j2k_copy_tile_quantization_parameters( opj_j2k_v2_t *p_j2k ); +static void opj_j2k_copy_tile_quantization_parameters( opj_j2k_t *p_j2k ); /** * Reads the tiles. */ -static opj_bool opj_j2k_decode_tiles ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_decode_tiles ( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager); -static opj_bool opj_j2k_pre_write_tile ( opj_j2k_v2_t * p_j2k, +static OPJ_BOOL opj_j2k_pre_write_tile ( opj_j2k_t * p_j2k, OPJ_UINT32 p_tile_index, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); -static opj_bool opj_j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data, opj_image_t* p_output_image); +static OPJ_BOOL opj_j2k_update_image_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data, opj_image_t* p_output_image); -static void opj_j2k_get_tile_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data); +static void opj_j2k_get_tile_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data); -static opj_bool opj_j2k_post_write_tile (opj_j2k_v2_t * p_j2k, +static OPJ_BOOL opj_j2k_post_write_tile (opj_j2k_t * p_j2k, OPJ_BYTE * p_data, OPJ_UINT32 p_data_size, opj_stream_private_t *p_stream, @@ -343,16 +350,16 @@ static opj_bool opj_j2k_post_write_tile (opj_j2k_v2_t * p_j2k, * Sets up the procedures to do on writing header. * Developers wanting to extend the library can add their own writing procedures. */ -static void opj_j2k_setup_header_writing (opj_j2k_v2_t *p_j2k); +static void opj_j2k_setup_header_writing (opj_j2k_t *p_j2k); -static opj_bool opj_j2k_write_first_tile_part( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_first_tile_part( opj_j2k_t *p_j2k, OPJ_BYTE * p_data, OPJ_UINT32 * p_data_written, OPJ_UINT32 p_total_data_size, opj_stream_private_t *p_stream, struct opj_event_mgr * p_manager ); -static opj_bool opj_j2k_write_all_tile_parts( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_all_tile_parts( opj_j2k_t *p_j2k, OPJ_BYTE * p_data, OPJ_UINT32 * p_data_written, OPJ_UINT32 p_total_data_size, @@ -366,11 +373,11 @@ static opj_bool opj_j2k_write_all_tile_parts( opj_j2k_v2_t *p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_get_end_header( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_get_end_header( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); -static opj_bool opj_j2k_allocate_tile_element_cstr_index(opj_j2k_v2_t *p_j2k); +static OPJ_BOOL opj_j2k_allocate_tile_element_cstr_index(opj_j2k_t *p_j2k); /* * ----------------------------------------------------------------------- @@ -385,7 +392,7 @@ static opj_bool opj_j2k_allocate_tile_element_cstr_index(opj_j2k_v2_t *p_j2k); * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_soc( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_soc( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -395,7 +402,7 @@ static opj_bool opj_j2k_write_soc( opj_j2k_v2_t *p_j2k, * @param p_stream XXX needs data * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_soc( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_soc( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -406,7 +413,7 @@ static opj_bool opj_j2k_read_soc( opj_j2k_v2_t *p_j2k, * @param p_stream the stream to write data to. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_siz( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_siz( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -417,7 +424,7 @@ static opj_bool opj_j2k_write_siz( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the SIZ marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_siz(opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_siz(opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager); @@ -429,7 +436,7 @@ static opj_bool opj_j2k_read_siz(opj_j2k_v2_t *p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_com( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_com( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -440,7 +447,7 @@ static opj_bool opj_j2k_write_com( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the COM marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_com ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_com ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ); @@ -451,7 +458,7 @@ static opj_bool opj_j2k_read_com ( opj_j2k_v2_t *p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_cod( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_cod( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -462,11 +469,12 @@ static opj_bool opj_j2k_write_cod( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the COD marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_cod ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_cod ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager); +#if 0 /** * Writes the COC marker (Coding style component) * @@ -475,10 +483,13 @@ static opj_bool opj_j2k_read_cod ( opj_j2k_v2_t *p_j2k, * @param p_stream the stream to write data to. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_coc( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_coc( opj_j2k_t *p_j2k, OPJ_UINT32 p_comp_no, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); +#endif + +#if 0 /** * Writes the COC marker (Coding style component) * @@ -488,18 +499,19 @@ static opj_bool opj_j2k_write_coc( opj_j2k_v2_t *p_j2k, * @param p_data_written FIXME DOC * @param p_manager the user event manager. */ -static void opj_j2k_write_coc_in_memory(opj_j2k_v2_t *p_j2k, +static void opj_j2k_write_coc_in_memory(opj_j2k_t *p_j2k, OPJ_UINT32 p_comp_no, OPJ_BYTE * p_data, OPJ_UINT32 * p_data_written, opj_event_mgr_t * p_manager ); +#endif /** * Gets the maximum size taken by a coc. * * @param p_j2k the jpeg2000 codec to use. */ -static OPJ_UINT32 opj_j2k_get_max_coc_size(opj_j2k_v2_t *p_j2k); +static OPJ_UINT32 opj_j2k_get_max_coc_size(opj_j2k_t *p_j2k); /** * Reads a COC marker (Coding Style Component) @@ -508,7 +520,7 @@ static OPJ_UINT32 opj_j2k_get_max_coc_size(opj_j2k_v2_t *p_j2k); * @param p_header_size the size of the data contained in the COC marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_coc ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_coc ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ); @@ -520,7 +532,7 @@ static opj_bool opj_j2k_read_coc ( opj_j2k_v2_t *p_j2k, * @param p_stream the stream to write data to. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_qcd( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_qcd( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -531,10 +543,11 @@ static opj_bool opj_j2k_write_qcd( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the QCD marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_qcd ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_qcd ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ); +#if 0 /** * Writes the QCC marker (quantization component) * @@ -543,11 +556,13 @@ static opj_bool opj_j2k_read_qcd ( opj_j2k_v2_t *p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_qcc( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_qcc( opj_j2k_t *p_j2k, OPJ_UINT32 p_comp_no, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); +#endif +#if 0 /** * Writes the QCC marker (quantization component) * @@ -557,16 +572,17 @@ static opj_bool opj_j2k_write_qcc( opj_j2k_v2_t *p_j2k, * @param p_data_written the stream to write data to. * @param p_manager the user event manager. */ -static void opj_j2k_write_qcc_in_memory(opj_j2k_v2_t *p_j2k, +static void opj_j2k_write_qcc_in_memory(opj_j2k_t *p_j2k, OPJ_UINT32 p_comp_no, OPJ_BYTE * p_data, OPJ_UINT32 * p_data_written, opj_event_mgr_t * p_manager ); +#endif /** * Gets the maximum size taken by a qcc. */ -static OPJ_UINT32 opj_j2k_get_max_qcc_size (opj_j2k_v2_t *p_j2k); +static OPJ_UINT32 opj_j2k_get_max_qcc_size (opj_j2k_t *p_j2k); /** * Reads a QCC marker (Quantization component) @@ -575,7 +591,7 @@ static OPJ_UINT32 opj_j2k_get_max_qcc_size (opj_j2k_v2_t *p_j2k); * @param p_header_size the size of the data contained in the QCC marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_qcc( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_qcc( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager); @@ -586,7 +602,7 @@ static opj_bool opj_j2k_read_qcc( opj_j2k_v2_t *p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_poc( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_poc( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); /** @@ -597,14 +613,14 @@ static opj_bool opj_j2k_write_poc( opj_j2k_v2_t *p_j2k, * @param p_data_written the stream to write data to. * @param p_manager the user event manager. */ -static void opj_j2k_write_poc_in_memory(opj_j2k_v2_t *p_j2k, +static void opj_j2k_write_poc_in_memory(opj_j2k_t *p_j2k, OPJ_BYTE * p_data, OPJ_UINT32 * p_data_written, opj_event_mgr_t * p_manager ); /** * Gets the maximum size taken by the writing of a POC. */ -static OPJ_UINT32 opj_j2k_get_max_poc_size(opj_j2k_v2_t *p_j2k); +static OPJ_UINT32 opj_j2k_get_max_poc_size(opj_j2k_t *p_j2k); /** * Reads a POC marker (Progression Order Change) @@ -614,7 +630,7 @@ static OPJ_UINT32 opj_j2k_get_max_poc_size(opj_j2k_v2_t *p_j2k); * @param p_header_size the size of the data contained in the POC marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_poc ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_poc ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ); @@ -622,14 +638,14 @@ static opj_bool opj_j2k_read_poc ( opj_j2k_v2_t *p_j2k, /** * Gets the maximum size taken by the toc headers of all the tile parts of any given tile. */ -static OPJ_UINT32 opj_j2k_get_max_toc_size (opj_j2k_v2_t *p_j2k); +static OPJ_UINT32 opj_j2k_get_max_toc_size (opj_j2k_t *p_j2k); /** * Gets the maximum size taken by the headers of the SOT. * * @param p_j2k the jpeg2000 codec to use. */ -static OPJ_UINT32 opj_j2k_get_specific_header_sizes(opj_j2k_v2_t *p_j2k); +static OPJ_UINT32 opj_j2k_get_specific_header_sizes(opj_j2k_t *p_j2k); /** * Reads a CRG marker (Component registration) @@ -639,7 +655,7 @@ static OPJ_UINT32 opj_j2k_get_specific_header_sizes(opj_j2k_v2_t *p_j2k); * @param p_header_size the size of the data contained in the TLM marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_crg ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_crg ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ); @@ -651,7 +667,7 @@ static opj_bool opj_j2k_read_crg ( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the TLM marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_tlm ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_tlm ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager); @@ -663,7 +679,7 @@ static opj_bool opj_j2k_read_tlm ( opj_j2k_v2_t *p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_updated_tlm( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_updated_tlm( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -675,7 +691,7 @@ static opj_bool opj_j2k_write_updated_tlm( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the TLM marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_plm ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_plm ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager); @@ -687,7 +703,7 @@ static opj_bool opj_j2k_read_plm ( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the PLT marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_plt ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_plt ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ); @@ -701,16 +717,16 @@ static opj_bool opj_j2k_read_plt ( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the POC marker. * @param p_manager the user event manager. */ -static opj_bool j2k_read_ppm_v2 ( - opj_j2k_v2_t *p_j2k, +static OPJ_BOOL j2k_read_ppm_v2 ( + opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, struct opj_event_mgr * p_manager ); #endif -static opj_bool j2k_read_ppm_v3 ( - opj_j2k_v2_t *p_j2k, +static OPJ_BOOL j2k_read_ppm_v3 ( + opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ); @@ -723,7 +739,7 @@ static opj_bool j2k_read_ppm_v3 ( * @param p_header_size the size of the data contained in the PPT marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_ppt ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_ppt ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ); @@ -734,7 +750,7 @@ static opj_bool opj_j2k_read_ppt ( opj_j2k_v2_t *p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_tlm( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_tlm( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -747,7 +763,7 @@ static opj_bool opj_j2k_write_tlm( opj_j2k_v2_t *p_j2k, * @param p_stream the stream to write data to. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_sot( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_sot( opj_j2k_t *p_j2k, OPJ_BYTE * p_data, OPJ_UINT32 * p_data_written, const opj_stream_private_t *p_stream, @@ -761,7 +777,7 @@ static opj_bool opj_j2k_write_sot( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the PPT marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_sot ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ); @@ -776,8 +792,8 @@ static opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k, * @param p_stream the stream to write data to. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_sod( opj_j2k_v2_t *p_j2k, - opj_tcd_v2_t * p_tile_coder, +static OPJ_BOOL opj_j2k_write_sod( opj_j2k_t *p_j2k, + opj_tcd_t * p_tile_coder, OPJ_BYTE * p_data, OPJ_UINT32 * p_data_written, OPJ_UINT32 p_total_data_size, @@ -791,11 +807,11 @@ static opj_bool opj_j2k_write_sod( opj_j2k_v2_t *p_j2k, * @param p_stream FIXME DOC * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_sod( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_sod( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); -void opj_j2k_update_tlm (opj_j2k_v2_t * p_j2k, OPJ_UINT32 p_tile_part_size ) +void opj_j2k_update_tlm (opj_j2k_t * p_j2k, OPJ_UINT32 p_tile_part_size ) { opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,p_j2k->m_current_tile_number,1); /* PSOT */ ++p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current; @@ -809,15 +825,17 @@ void opj_j2k_update_tlm (opj_j2k_v2_t * p_j2k, OPJ_UINT32 p_tile_part_size ) * * @param p_tile_no the tile to output * @param p_comp_no the component to output - * @param p_stream the stream to write data to. - * @param p_j2k J2K codec. + * @param nb_comps the number of components + * @param p_stream the stream to write data to. + * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_rgn( opj_j2k_v2_t *p_j2k, - OPJ_UINT32 p_tile_no, - OPJ_UINT32 p_comp_no, - opj_stream_private_t *p_stream, - opj_event_mgr_t * p_manager ); +static OPJ_BOOL opj_j2k_write_rgn( opj_j2k_t *p_j2k, + OPJ_UINT32 p_tile_no, + OPJ_UINT32 p_comp_no, + OPJ_UINT32 nb_comps, + opj_stream_private_t *p_stream, + opj_event_mgr_t * p_manager ); /** * Reads a RGN marker (Region Of Interest) @@ -827,7 +845,7 @@ static opj_bool opj_j2k_write_rgn( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the POC marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_rgn (opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_rgn (opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ); @@ -839,10 +857,11 @@ static opj_bool opj_j2k_read_rgn (opj_j2k_v2_t *p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_eoc( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_eoc( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); +#if 0 /** * Reads a EOC marker (End Of Codestream) * @@ -850,9 +869,10 @@ static opj_bool opj_j2k_write_eoc( opj_j2k_v2_t *p_j2k, * @param p_stream FIXME DOC * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_eoc ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_eoc ( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); +#endif /** * Writes the CBD-MCT-MCC-MCO markers (Multi components transform) @@ -861,7 +881,7 @@ static opj_bool opj_j2k_read_eoc ( opj_j2k_v2_t *p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_mct_data_group( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_mct_data_group( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -872,7 +892,7 @@ static opj_bool opj_j2k_write_mct_data_group( opj_j2k_v2_t *p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_init_info( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_init_info( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -883,7 +903,7 @@ Add main header marker information @param pos byte offset of marker segment @param len length of marker segment */ -static opj_bool opj_j2k_add_mhmarker(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len) ; +static OPJ_BOOL opj_j2k_add_mhmarker(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len) ; /** Add tile header marker information @param tileno tile index number @@ -892,7 +912,7 @@ Add tile header marker information @param pos byte offset of marker segment @param len length of marker segment */ -static opj_bool opj_j2k_add_tlmarker(OPJ_UINT32 tileno, opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len); +static OPJ_BOOL opj_j2k_add_tlmarker(OPJ_UINT32 tileno, opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len); /** * Reads an unknown marker @@ -904,7 +924,7 @@ static opj_bool opj_j2k_add_tlmarker(OPJ_UINT32 tileno, opj_codestream_index_t * * * @return true if the marker could be deduced. */ -static opj_bool opj_j2k_read_unk( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_unk( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, OPJ_UINT32 *output_marker, opj_event_mgr_t * p_manager ); @@ -917,7 +937,7 @@ static opj_bool opj_j2k_read_unk( opj_j2k_v2_t *p_j2k, * @param p_stream the stream to write data to. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_mct_record( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_mct_record( opj_j2k_t *p_j2k, opj_mct_data_t * p_mct_record, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -930,7 +950,7 @@ static opj_bool opj_j2k_write_mct_record( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the MCT marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_mct ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_mct ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ); @@ -943,7 +963,7 @@ static opj_bool opj_j2k_read_mct ( opj_j2k_v2_t *p_j2k, * @param p_stream the stream to write data to. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_mcc_record( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_mcc_record( opj_j2k_t *p_j2k, opj_simple_mcc_decorrelation_data_t * p_mcc_record, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -956,7 +976,7 @@ static opj_bool opj_j2k_write_mcc_record( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the MCC marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_mcc ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ); @@ -968,7 +988,7 @@ static opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_mco( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_mco( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -980,12 +1000,12 @@ static opj_bool opj_j2k_write_mco( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the MCO marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_mco ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_mco ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ); -static opj_bool opj_j2k_add_mct(opj_tcp_v2_t * p_tcp, opj_image_t * p_image, OPJ_UINT32 p_index); +static OPJ_BOOL opj_j2k_add_mct(opj_tcp_t * p_tcp, opj_image_t * p_image, OPJ_UINT32 p_index); static void opj_j2k_read_int16_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem); static void opj_j2k_read_int32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem); @@ -1009,7 +1029,7 @@ static void opj_j2k_write_float_to_float64 (const void * p_src_data, void * p_d * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_end_encoding( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_end_encoding( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -1020,7 +1040,7 @@ static opj_bool opj_j2k_end_encoding( opj_j2k_v2_t *p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_cbd( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_cbd( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -1031,21 +1051,36 @@ static opj_bool opj_j2k_write_cbd( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the CBD marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_cbd ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_cbd ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager); +#if 0 /** - * Writes the image components. + * Writes COC marker for each component. * * @param p_stream the stream to write data to. * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_image_components( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_all_coc( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); +#endif + +#if 0 +/** + * Writes QCC marker for each component. + * + * @param p_stream the stream to write data to. + * @param p_j2k J2K codec. + * @param p_manager the user event manager. +*/ +static OPJ_BOOL opj_j2k_write_all_qcc( opj_j2k_t *p_j2k, + opj_stream_private_t *p_stream, + opj_event_mgr_t * p_manager ); +#endif /** * Writes regions of interests. @@ -1054,7 +1089,7 @@ static opj_bool opj_j2k_write_image_components( opj_j2k_v2_t *p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_regions( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_regions( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -1065,7 +1100,7 @@ static opj_bool opj_j2k_write_regions( opj_j2k_v2_t *p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_write_epc( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_write_epc( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ); @@ -1082,7 +1117,7 @@ static opj_bool opj_j2k_write_epc( opj_j2k_v2_t *p_j2k, * * @return true if the pocs are valid. */ -static opj_bool opj_j2k_check_poc_val( const opj_poc_t *p_pocs, +static OPJ_BOOL opj_j2k_check_poc_val( const opj_poc_t *p_pocs, OPJ_UINT32 p_nb_pocs, OPJ_UINT32 p_nb_resolutions, OPJ_UINT32 numcomps, @@ -1098,7 +1133,7 @@ static opj_bool opj_j2k_check_poc_val( const opj_poc_t *p_pocs, * * @return the number of tile parts. */ -static OPJ_UINT32 opj_j2k_get_num_tp( opj_cp_v2_t *cp, OPJ_UINT32 pino, OPJ_UINT32 tileno); +static OPJ_UINT32 opj_j2k_get_num_tp( opj_cp_t *cp, OPJ_UINT32 pino, OPJ_UINT32 tileno); /** * Calculates the total number of tile parts needed by the encoder to @@ -1112,21 +1147,27 @@ static OPJ_UINT32 opj_j2k_get_num_tp( opj_cp_v2_t *cp, OPJ_UINT32 pino, OPJ_UINT * * @return true if the function was successful, false else. */ -static opj_bool opj_j2k_calculate_tp( opj_j2k_v2_t *p_j2k, - opj_cp_v2_t *cp, +static OPJ_BOOL opj_j2k_calculate_tp( opj_j2k_t *p_j2k, + opj_cp_t *cp, OPJ_UINT32 * p_nb_tiles, opj_image_t *image, opj_event_mgr_t * p_manager); -static void opj_j2k_dump_MH_info(opj_j2k_v2_t* p_j2k, FILE* out_stream); +static void opj_j2k_dump_MH_info(opj_j2k_t* p_j2k, FILE* out_stream); -static void opj_j2k_dump_MH_index(opj_j2k_v2_t* p_j2k, FILE* out_stream); +static void opj_j2k_dump_MH_index(opj_j2k_t* p_j2k, FILE* out_stream); static opj_codestream_index_t* opj_j2k_create_cstr_index(void); -static OPJ_FLOAT32 opj_j2k_get_tp_stride (opj_tcp_v2_t * p_tcp); +static OPJ_FLOAT32 opj_j2k_get_tp_stride (opj_tcp_t * p_tcp); + +static OPJ_FLOAT32 opj_j2k_get_default_stride (opj_tcp_t * p_tcp); + +static int opj_j2k_initialise_4K_poc(opj_poc_t *POC, int numres); -static OPJ_FLOAT32 opj_j2k_get_default_stride (opj_tcp_v2_t * p_tcp); +static void opj_j2k_set_cinema_parameters(opj_cparameters_t *parameters, opj_image_t *image, opj_event_mgr_t *p_manager); + +static OPJ_BOOL opj_j2k_is_cinema_compliant(opj_image_t *image, OPJ_UINT16 rsiz, opj_event_mgr_t *p_manager); /*@}*/ @@ -1139,11 +1180,11 @@ typedef struct j2k_prog_order{ }j2k_prog_order_t; j2k_prog_order_t j2k_prog_order_list[] = { - {CPRL, "CPRL"}, - {LRCP, "LRCP"}, - {PCRL, "PCRL"}, - {RLCP, "RLCP"}, - {RPCL, "RPCL"}, + {OPJ_CPRL, "CPRL"}, + {OPJ_LRCP, "LRCP"}, + {OPJ_PCRL, "PCRL"}, + {OPJ_RLCP, "RLCP"}, + {OPJ_RPCL, "RPCL"}, {(OPJ_PROG_ORDER)-1, ""} }; @@ -1191,7 +1232,7 @@ typedef struct opj_dec_memory_marker_handler /** value of the state when the marker can appear */ OPJ_UINT32 states; /** action linked to the marker */ - opj_bool (*handler) ( opj_j2k_v2_t *p_j2k, + OPJ_BOOL (*handler) ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ); @@ -1437,7 +1478,7 @@ char *opj_j2k_convert_progression_order(OPJ_PROG_ORDER prg_order){ return po->str_prog; } -opj_bool opj_j2k_check_poc_val( const opj_poc_t *p_pocs, +OPJ_BOOL opj_j2k_check_poc_val( const opj_poc_t *p_pocs, OPJ_UINT32 p_nb_pocs, OPJ_UINT32 p_nb_resolutions, OPJ_UINT32 p_num_comps, @@ -1450,17 +1491,17 @@ opj_bool opj_j2k_check_poc_val( const opj_poc_t *p_pocs, OPJ_UINT32 step_c = 1; OPJ_UINT32 step_r = p_num_comps * step_c; OPJ_UINT32 step_l = p_nb_resolutions * step_r; - opj_bool loss = OPJ_FALSE; + OPJ_BOOL loss = OPJ_FALSE; OPJ_UINT32 layno0 = 0; packet_array = (OPJ_UINT32*) opj_calloc(step_l * p_num_layers, sizeof(OPJ_UINT32)); if (packet_array == 00) { - opj_event_msg_v2(p_manager , EVT_ERROR, "Not enough memory for checking the poc values.\n"); + opj_event_msg(p_manager , EVT_ERROR, "Not enough memory for checking the poc values.\n"); return OPJ_FALSE; } - memset(packet_array,0,step_l * p_num_layers* sizeof(OPJ_UINT32)); if (p_nb_pocs == 0) { + opj_free(packet_array); return OPJ_TRUE; } @@ -1531,7 +1572,7 @@ opj_bool opj_j2k_check_poc_val( const opj_poc_t *p_pocs, } if (loss) { - opj_event_msg_v2(p_manager , EVT_ERROR, "Missing packets possible loss of data\n"); + opj_event_msg(p_manager , EVT_ERROR, "Missing packets possible loss of data\n"); } opj_free(packet_array); @@ -1541,12 +1582,12 @@ opj_bool opj_j2k_check_poc_val( const opj_poc_t *p_pocs, /* ----------------------------------------------------------------------- */ -OPJ_UINT32 opj_j2k_get_num_tp(opj_cp_v2_t *cp, OPJ_UINT32 pino, OPJ_UINT32 tileno) +OPJ_UINT32 opj_j2k_get_num_tp(opj_cp_t *cp, OPJ_UINT32 pino, OPJ_UINT32 tileno) { const OPJ_CHAR *prog = 00; - OPJ_UINT32 i; + OPJ_INT32 i; OPJ_UINT32 tpnum = 1; - opj_tcp_v2_t *tcp = 00; + opj_tcp_t *tcp = 00; opj_poc_t * l_current_poc = 00; /* preconditions */ @@ -1599,8 +1640,8 @@ OPJ_UINT32 opj_j2k_get_num_tp(opj_cp_v2_t *cp, OPJ_UINT32 pino, OPJ_UINT32 tilen return tpnum; } -opj_bool opj_j2k_calculate_tp( opj_j2k_v2_t *p_j2k, - opj_cp_v2_t *cp, +OPJ_BOOL opj_j2k_calculate_tp( opj_j2k_t *p_j2k, + opj_cp_t *cp, OPJ_UINT32 * p_nb_tiles, opj_image_t *image, opj_event_mgr_t * p_manager @@ -1608,7 +1649,7 @@ opj_bool opj_j2k_calculate_tp( opj_j2k_v2_t *p_j2k, { OPJ_UINT32 pino,tileno; OPJ_UINT32 l_nb_tiles; - opj_tcp_v2_t *tcp; + opj_tcp_t *tcp; /* preconditions */ assert(p_nb_tiles != 00); @@ -1677,7 +1718,7 @@ opj_bool opj_j2k_calculate_tp( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_soc( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_soc( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) { @@ -1702,7 +1743,7 @@ opj_bool opj_j2k_write_soc( opj_j2k_v2_t *p_j2k, #ifdef USE_JPWL /* update markers struct */ /* - opj_bool res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOC, p_stream_tell(p_stream) - 2, 2); + OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOC, p_stream_tell(p_stream) - 2, 2); */ assert( 0 && "TODO" ); #endif /* USE_JPWL */ @@ -1717,7 +1758,7 @@ opj_bool opj_j2k_write_soc( opj_j2k_v2_t *p_j2k, * @param p_stream FIXME DOC * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_soc( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_soc( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) @@ -1745,17 +1786,17 @@ static opj_bool opj_j2k_read_soc( opj_j2k_v2_t *p_j2k, /* FIXME move it in a index structure included in p_j2k*/ p_j2k->cstr_index->main_head_start = opj_stream_tell(p_stream) - 2; - opj_event_msg_v2(p_manager, EVT_INFO, "Start to read j2k main header (%d).\n", p_j2k->cstr_index->main_head_start); + opj_event_msg(p_manager, EVT_INFO, "Start to read j2k main header (%d).\n", p_j2k->cstr_index->main_head_start); /* Add the marker to the codestream index*/ if (OPJ_FALSE == opj_j2k_add_mhmarker(p_j2k->cstr_index, J2K_MS_SOC, p_j2k->cstr_index->main_head_start, 2)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n"); return OPJ_FALSE; } return OPJ_TRUE; } -opj_bool opj_j2k_write_siz( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_siz( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) { @@ -1763,7 +1804,7 @@ opj_bool opj_j2k_write_siz( opj_j2k_v2_t *p_j2k, OPJ_UINT32 l_size_len; OPJ_BYTE * l_current_ptr; opj_image_t * l_image = 00; - opj_cp_v2_t *cp = 00; + opj_cp_t *cp = 00; opj_image_comp_t * l_img_comp = 00; /* preconditions */ @@ -1783,7 +1824,7 @@ opj_bool opj_j2k_write_siz( opj_j2k_v2_t *p_j2k, opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data); p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL; p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory for the SIZ marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory for the SIZ marker\n"); return OPJ_FALSE; } p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data; @@ -1857,22 +1898,22 @@ opj_bool opj_j2k_write_siz( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the SIZ marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_siz(opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_siz(opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ) { - OPJ_UINT32 l_size, i; + OPJ_UINT32 i; OPJ_UINT32 l_nb_comp; OPJ_UINT32 l_nb_comp_remain; OPJ_UINT32 l_remaining_size; OPJ_UINT32 l_nb_tiles; OPJ_UINT32 l_tmp; opj_image_t *l_image = 00; - opj_cp_v2_t *l_cp = 00; + opj_cp_t *l_cp = 00; opj_image_comp_t * l_img_comp = 00; - opj_tcp_v2_t * l_current_tile_param = 00; + opj_tcp_t * l_current_tile_param = 00; /* preconditions */ assert(p_j2k != 00); @@ -1884,7 +1925,7 @@ static opj_bool opj_j2k_read_siz(opj_j2k_v2_t *p_j2k, /* minimum size == 39 - 3 (= minimum component parameter) */ if (p_header_size < 36) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error with SIZ marker size\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n"); return OPJ_FALSE; } @@ -1892,15 +1933,13 @@ static opj_bool opj_j2k_read_siz(opj_j2k_v2_t *p_j2k, l_nb_comp = l_remaining_size / 3; l_nb_comp_remain = l_remaining_size % 3; if (l_nb_comp_remain != 0){ - opj_event_msg_v2(p_manager, EVT_ERROR, "Error with SIZ marker size\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n"); return OPJ_FALSE; } - l_size = p_header_size + 2; /* Lsiz */ - opj_read_bytes(p_header_data,&l_tmp ,2); /* Rsiz (capabilities) */ p_header_data+=2; - l_cp->rsiz = (OPJ_RSIZ_CAPABILITIES) l_tmp; + l_cp->rsiz = (OPJ_UINT16) l_tmp; opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->x1, 4); /* Xsiz */ p_header_data+=4; opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->y1, 4); /* Ysiz */ @@ -1922,12 +1961,29 @@ static opj_bool opj_j2k_read_siz(opj_j2k_v2_t *p_j2k, if (l_tmp < 16385) l_image->numcomps = (OPJ_UINT16) l_tmp; else { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error with SIZ marker: number of component is illegal -> %d\n", l_tmp); + opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker: number of component is illegal -> %d\n", l_tmp); return OPJ_FALSE; } if (l_image->numcomps != l_nb_comp) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error with SIZ marker: number of component is not compatible with the remaining number of parameters ( %d vs %d)\n", l_image->numcomps, l_nb_comp); + opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker: number of component is not compatible with the remaining number of parameters ( %d vs %d)\n", l_image->numcomps, l_nb_comp); + return OPJ_FALSE; + } + + /* testcase 4035.pdf.SIGSEGV.d8b.3375 */ + if (l_image->x0 > l_image->x1 || l_image->y0 > l_image->y1) { + opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker: negative image size (%d x %d)\n", l_image->x1 - l_image->x0, l_image->y1 - l_image->y0); + return OPJ_FALSE; + } + /* testcase 2539.pdf.SIGFPE.706.1712 (also 3622.pdf.SIGFPE.706.2916 and 4008.pdf.SIGFPE.706.3345 and maybe more) */ + if (!(l_cp->tdx * l_cp->tdy)) { + opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker: invalid tile size (tdx: %d, tdy: %d)\n", l_cp->tdx, l_cp->tdy); + return OPJ_FALSE; + } + + /* testcase 1610.pdf.SIGSEGV.59c.681 */ + if (((OPJ_UINT64)l_image->x1) * ((OPJ_UINT64)l_image->y1) != (l_image->x1 * l_image->y1)) { + opj_event_msg(p_manager, EVT_ERROR, "Prevent buffer overflow (x1: %d, y1: %d)\n", l_image->x1, l_image->y1); return OPJ_FALSE; } @@ -1936,33 +1992,33 @@ static opj_bool opj_j2k_read_siz(opj_j2k_v2_t *p_j2k, /* if JPWL is on, we check whether TX errors have damaged too much the SIZ parameters */ if (!(l_image->x1 * l_image->y1)) { - opj_event_msg_v2(p_manager, EVT_ERROR, + opj_event_msg(p_manager, EVT_ERROR, "JPWL: bad image size (%d x %d)\n", l_image->x1, l_image->y1); if (!JPWL_ASSUME || JPWL_ASSUME) { - opj_event_msg_v2(p_manager, EVT_ERROR, "JPWL: giving up\n"); + opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n"); return OPJ_FALSE; } } /* FIXME check previously in the function so why keep this piece of code ? Need by the norm ? if (l_image->numcomps != ((len - 38) / 3)) { - opj_event_msg_v2(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR, + opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR, "JPWL: Csiz is %d => space in SIZ only for %d comps.!!!\n", l_image->numcomps, ((len - 38) / 3)); if (!JPWL_ASSUME) { - opj_event_msg_v2(p_manager, EVT_ERROR, "JPWL: giving up\n"); + opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n"); return OPJ_FALSE; } */ /* we try to correct */ - /* opj_event_msg_v2(p_manager, EVT_WARNING, "- trying to adjust this\n"); + /* opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n"); if (l_image->numcomps < ((len - 38) / 3)) { len = 38 + 3 * l_image->numcomps; - opj_event_msg_v2(p_manager, EVT_WARNING, "- setting Lsiz to %d => HYPOTHESIS!!!\n", + opj_event_msg(p_manager, EVT_WARNING, "- setting Lsiz to %d => HYPOTHESIS!!!\n", len); } else { l_image->numcomps = ((len - 38) / 3); - opj_event_msg_v2(p_manager, EVT_WARNING, "- setting Csiz to %d => HYPOTHESIS!!!\n", + opj_event_msg(p_manager, EVT_WARNING, "- setting Csiz to %d => HYPOTHESIS!!!\n", l_image->numcomps); } } @@ -1977,11 +2033,10 @@ static opj_bool opj_j2k_read_siz(opj_j2k_v2_t *p_j2k, l_image->comps = (opj_image_comp_t*) opj_calloc(l_image->numcomps, sizeof(opj_image_comp_t)); if (l_image->comps == 00){ l_image->numcomps = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); return OPJ_FALSE; } - memset(l_image->comps,0,l_image->numcomps * sizeof(opj_image_comp_t)); l_img_comp = l_image->comps; /* Read the component information */ @@ -1993,33 +2048,40 @@ static opj_bool opj_j2k_read_siz(opj_j2k_v2_t *p_j2k, l_img_comp->sgnd = tmp >> 7; opj_read_bytes(p_header_data,&tmp,1); /* XRsiz_i */ ++p_header_data; - l_img_comp->dx = (OPJ_INT32)tmp; /* should be between 1 and 255 */ + l_img_comp->dx = (OPJ_UINT32)tmp; /* should be between 1 and 255 */ opj_read_bytes(p_header_data,&tmp,1); /* YRsiz_i */ ++p_header_data; - l_img_comp->dy = (OPJ_INT32)tmp; /* should be between 1 and 255 */ + l_img_comp->dy = (OPJ_UINT32)tmp; /* should be between 1 and 255 */ + if( l_img_comp->dx < 1 || l_img_comp->dx > 255 || + l_img_comp->dy < 1 || l_img_comp->dy > 255 ) { + opj_event_msg(p_manager, EVT_ERROR, + "Invalid values for comp = %d : dx=%u dy=%u\n (should be between 1 and 255 according the JPEG2000 norm)", + i, l_img_comp->dx, l_img_comp->dy); + return OPJ_FALSE; + } #ifdef USE_JPWL if (l_cp->correct) { /* if JPWL is on, we check whether TX errors have damaged too much the SIZ parameters, again */ if (!(l_image->comps[i].dx * l_image->comps[i].dy)) { - opj_event_msg_v2(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR, + opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR, "JPWL: bad XRsiz_%d/YRsiz_%d (%d x %d)\n", i, i, l_image->comps[i].dx, l_image->comps[i].dy); if (!JPWL_ASSUME) { - opj_event_msg_v2(p_manager, EVT_ERROR, "JPWL: giving up\n"); + opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n"); return OPJ_FALSE; } /* we try to correct */ - opj_event_msg_v2(p_manager, EVT_WARNING, "- trying to adjust them\n"); + opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust them\n"); if (!l_image->comps[i].dx) { l_image->comps[i].dx = 1; - opj_event_msg_v2(p_manager, EVT_WARNING, "- setting XRsiz_%d to %d => HYPOTHESIS!!!\n", + opj_event_msg(p_manager, EVT_WARNING, "- setting XRsiz_%d to %d => HYPOTHESIS!!!\n", i, l_image->comps[i].dx); } if (!l_image->comps[i].dy) { l_image->comps[i].dy = 1; - opj_event_msg_v2(p_manager, EVT_WARNING, "- setting YRsiz_%d to %d => HYPOTHESIS!!!\n", + opj_event_msg(p_manager, EVT_WARNING, "- setting YRsiz_%d to %d => HYPOTHESIS!!!\n", i, l_image->comps[i].dy); } } @@ -2031,16 +2093,24 @@ static opj_bool opj_j2k_read_siz(opj_j2k_v2_t *p_j2k, } /* Compute the number of tiles */ - l_cp->tw = opj_int_ceildiv(l_image->x1 - l_cp->tx0, l_cp->tdx); - l_cp->th = opj_int_ceildiv(l_image->y1 - l_cp->ty0, l_cp->tdy); + l_cp->tw = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(l_image->x1 - l_cp->tx0), (OPJ_INT32)l_cp->tdx); + l_cp->th = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(l_image->y1 - l_cp->ty0), (OPJ_INT32)l_cp->tdy); + + /* Check that the number of tiles is valid */ + if (l_cp->tw == 0 || l_cp->th == 0 || l_cp->tw > 65535 / l_cp->th) { + opj_event_msg( p_manager, EVT_ERROR, + "Invalid number of tiles : %u x %u (maximum fixed by jpeg2000 norm is 65535 tiles)\n", + l_cp->tw, l_cp->th); + return OPJ_FALSE; + } l_nb_tiles = l_cp->tw * l_cp->th; /* Define the tiles which will be decoded */ if (p_j2k->m_specific_param.m_decoder.m_discard_tiles) { p_j2k->m_specific_param.m_decoder.m_start_tile_x = (p_j2k->m_specific_param.m_decoder.m_start_tile_x - l_cp->tx0) / l_cp->tdx; p_j2k->m_specific_param.m_decoder.m_start_tile_y = (p_j2k->m_specific_param.m_decoder.m_start_tile_y - l_cp->ty0) / l_cp->tdy; - p_j2k->m_specific_param.m_decoder.m_end_tile_x = opj_int_ceildiv((p_j2k->m_specific_param.m_decoder.m_end_tile_x - l_cp->tx0), l_cp->tdx); - p_j2k->m_specific_param.m_decoder.m_end_tile_y = opj_int_ceildiv((p_j2k->m_specific_param.m_decoder.m_end_tile_y - l_cp->ty0), l_cp->tdy); + p_j2k->m_specific_param.m_decoder.m_end_tile_x = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(p_j2k->m_specific_param.m_decoder.m_end_tile_x - l_cp->tx0), (OPJ_INT32)l_cp->tdx); + p_j2k->m_specific_param.m_decoder.m_end_tile_y = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(p_j2k->m_specific_param.m_decoder.m_end_tile_y - l_cp->ty0), (OPJ_INT32)l_cp->tdy); } else { p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0; @@ -2054,34 +2124,34 @@ static opj_bool opj_j2k_read_siz(opj_j2k_v2_t *p_j2k, /* if JPWL is on, we check whether TX errors have damaged too much the SIZ parameters */ if ((l_cp->tw < 1) || (l_cp->th < 1) || (l_cp->tw > l_cp->max_tiles) || (l_cp->th > l_cp->max_tiles)) { - opj_event_msg_v2(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR, + opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR, "JPWL: bad number of tiles (%d x %d)\n", l_cp->tw, l_cp->th); if (!JPWL_ASSUME) { - opj_event_msg_v2(p_manager, EVT_ERROR, "JPWL: giving up\n"); + opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n"); return OPJ_FALSE; } /* we try to correct */ - opj_event_msg_v2(p_manager, EVT_WARNING, "- trying to adjust them\n"); + opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust them\n"); if (l_cp->tw < 1) { l_cp->tw= 1; - opj_event_msg_v2(p_manager, EVT_WARNING, "- setting %d tiles in x => HYPOTHESIS!!!\n", + opj_event_msg(p_manager, EVT_WARNING, "- setting %d tiles in x => HYPOTHESIS!!!\n", l_cp->tw); } if (l_cp->tw > l_cp->max_tiles) { l_cp->tw= 1; - opj_event_msg_v2(p_manager, EVT_WARNING, "- too large x, increase expectance of %d\n" + opj_event_msg(p_manager, EVT_WARNING, "- too large x, increase expectance of %d\n" "- setting %d tiles in x => HYPOTHESIS!!!\n", l_cp->max_tiles, l_cp->tw); } if (l_cp->th < 1) { l_cp->th= 1; - opj_event_msg_v2(p_manager, EVT_WARNING, "- setting %d tiles in y => HYPOTHESIS!!!\n", + opj_event_msg(p_manager, EVT_WARNING, "- setting %d tiles in y => HYPOTHESIS!!!\n", l_cp->th); } if (l_cp->th > l_cp->max_tiles) { l_cp->th= 1; - opj_event_msg_v2(p_manager, EVT_WARNING, "- too large y, increase expectance of %d to continue\n", + opj_event_msg(p_manager, EVT_WARNING, "- too large y, increase expectance of %d to continue\n", "- setting %d tiles in y => HYPOTHESIS!!!\n", l_cp->max_tiles, l_cp->th); } @@ -2090,20 +2160,19 @@ static opj_bool opj_j2k_read_siz(opj_j2k_v2_t *p_j2k, #endif /* USE_JPWL */ /* memory allocations */ - l_cp->tcps = (opj_tcp_v2_t*) opj_calloc(l_nb_tiles, sizeof(opj_tcp_v2_t)); + l_cp->tcps = (opj_tcp_t*) opj_calloc(l_nb_tiles, sizeof(opj_tcp_t)); if (l_cp->tcps == 00) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); return OPJ_FALSE; } - memset(l_cp->tcps,0,l_nb_tiles*sizeof(opj_tcp_t)); #ifdef USE_JPWL if (l_cp->correct) { if (!l_cp->tcps) { - opj_event_msg_v2(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR, + opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR, "JPWL: could not alloc tcps field of cp\n"); if (!JPWL_ASSUME || JPWL_ASSUME) { - opj_event_msg_v2(p_manager, EVT_ERROR, "JPWL: giving up\n"); + opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n"); return OPJ_FALSE; } } @@ -2113,31 +2182,28 @@ static opj_bool opj_j2k_read_siz(opj_j2k_v2_t *p_j2k, p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps = (opj_tccp_t*) opj_calloc(l_image->numcomps, sizeof(opj_tccp_t)); if(p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps == 00) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); return OPJ_FALSE; } - memset(p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps ,0,l_image->numcomps*sizeof(opj_tccp_t)); p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records = - (opj_mct_data_t*)opj_malloc(J2K_MCT_DEFAULT_NB_RECORDS * sizeof(opj_mct_data_t)); + (opj_mct_data_t*)opj_calloc(OPJ_J2K_MCT_DEFAULT_NB_RECORDS ,sizeof(opj_mct_data_t)); if (! p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); return OPJ_FALSE; } - memset(p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records,0,J2K_MCT_DEFAULT_NB_RECORDS * sizeof(opj_mct_data_t)); - p_j2k->m_specific_param.m_decoder.m_default_tcp->m_nb_max_mct_records = J2K_MCT_DEFAULT_NB_RECORDS; + p_j2k->m_specific_param.m_decoder.m_default_tcp->m_nb_max_mct_records = OPJ_J2K_MCT_DEFAULT_NB_RECORDS; p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records = (opj_simple_mcc_decorrelation_data_t*) - opj_malloc(J2K_MCC_DEFAULT_NB_RECORDS * sizeof(opj_simple_mcc_decorrelation_data_t)); + opj_calloc(OPJ_J2K_MCC_DEFAULT_NB_RECORDS, sizeof(opj_simple_mcc_decorrelation_data_t)); if (! p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); return OPJ_FALSE; } - memset(p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mcc_records,0,J2K_MCC_DEFAULT_NB_RECORDS * sizeof(opj_simple_mcc_decorrelation_data_t)); - p_j2k->m_specific_param.m_decoder.m_default_tcp->m_nb_max_mcc_records = J2K_MCC_DEFAULT_NB_RECORDS; + p_j2k->m_specific_param.m_decoder.m_default_tcp->m_nb_max_mcc_records = OPJ_J2K_MCC_DEFAULT_NB_RECORDS; /* set up default dc level shift */ for (i=0;inumcomps;++i) { @@ -2148,12 +2214,11 @@ static opj_bool opj_j2k_read_siz(opj_j2k_v2_t *p_j2k, l_current_tile_param = l_cp->tcps; for (i = 0; i < l_nb_tiles; ++i) { - l_current_tile_param->tccps = (opj_tccp_t*) opj_malloc(l_image->numcomps * sizeof(opj_tccp_t)); + l_current_tile_param->tccps = (opj_tccp_t*) opj_calloc(l_image->numcomps, sizeof(opj_tccp_t)); if (l_current_tile_param->tccps == 00) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); return OPJ_FALSE; } - memset(l_current_tile_param->tccps,0,l_image->numcomps * sizeof(opj_tccp_t)); ++l_current_tile_param; } @@ -2164,7 +2229,7 @@ static opj_bool opj_j2k_read_siz(opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_com( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_com( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) @@ -2180,7 +2245,7 @@ opj_bool opj_j2k_write_com( opj_j2k_v2_t *p_j2k, assert(p_manager != 00); l_comment = p_j2k->m_cp.comment; - l_comment_size = strlen(l_comment); + l_comment_size = (OPJ_UINT32)strlen(l_comment); l_total_com_size = l_comment_size + 6; if (l_total_com_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) { @@ -2189,7 +2254,7 @@ opj_bool opj_j2k_write_com( opj_j2k_v2_t *p_j2k, opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data); p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL; p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to write the COM marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write the COM marker\n"); return OPJ_FALSE; } p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data; @@ -2223,7 +2288,7 @@ opj_bool opj_j2k_write_com( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the COM marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_com ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_com ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager @@ -2238,12 +2303,12 @@ static opj_bool opj_j2k_read_com ( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_cod( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_cod( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) { - opj_cp_v2_t *l_cp = 00; - opj_tcp_v2_t *l_tcp = 00; + opj_cp_t *l_cp = 00; + opj_tcp_t *l_tcp = 00; OPJ_UINT32 l_code_size,l_remaining_size; OPJ_BYTE * l_current_data = 00; @@ -2263,7 +2328,7 @@ opj_bool opj_j2k_write_cod( opj_j2k_v2_t *p_j2k, opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data); p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL; p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to write COD marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write COD marker\n"); return OPJ_FALSE; } p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data; @@ -2293,12 +2358,12 @@ opj_bool opj_j2k_write_cod( opj_j2k_v2_t *p_j2k, l_remaining_size -= 9; if (! opj_j2k_write_SPCod_SPCoc(p_j2k,p_j2k->m_current_tile_number,0,l_current_data,&l_remaining_size,p_manager)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error writing COD marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error writing COD marker\n"); return OPJ_FALSE; } if (l_remaining_size != 0) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error writing COD marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error writing COD marker\n"); return OPJ_FALSE; } @@ -2316,7 +2381,7 @@ opj_bool opj_j2k_write_cod( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the COD marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_cod ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_cod ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager @@ -2325,8 +2390,8 @@ static opj_bool opj_j2k_read_cod ( opj_j2k_v2_t *p_j2k, /* loop */ OPJ_UINT32 i; OPJ_UINT32 l_tmp; - opj_cp_v2_t *l_cp = 00; - opj_tcp_v2_t *l_tcp = 00; + opj_cp_t *l_cp = 00; + opj_tcp_t *l_tcp = 00; opj_image_t *l_image = 00; /* preconditions */ @@ -2344,15 +2409,25 @@ static opj_bool opj_j2k_read_cod ( opj_j2k_v2_t *p_j2k, /* Make sure room is sufficient */ if (p_header_size < 5) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading COD marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n"); return OPJ_FALSE; } opj_read_bytes(p_header_data,&l_tcp->csty,1); /* Scod */ ++p_header_data; + /* Make sure we know how to decode this */ + if ((l_tcp->csty & ~(OPJ_UINT32)(J2K_CP_CSTY_PRT | J2K_CP_CSTY_SOP | J2K_CP_CSTY_EPH)) != 0U) { + opj_event_msg(p_manager, EVT_ERROR, "Unknown Scod value in COD marker\n"); + return OPJ_FALSE; + } opj_read_bytes(p_header_data,&l_tmp,1); /* SGcod (A) */ ++p_header_data; l_tcp->prg = (OPJ_PROG_ORDER) l_tmp; + /* Make sure progression order is valid */ + if (l_tcp->prg > OPJ_CPRL ) { + opj_event_msg(p_manager, EVT_ERROR, "Unknown progression order in COD marker\n"); + l_tcp->prg = OPJ_PROG_UNKNOWN; + } opj_read_bytes(p_header_data,&l_tcp->numlayers,2); /* SGcod (B) */ p_header_data+=2; @@ -2373,12 +2448,12 @@ static opj_bool opj_j2k_read_cod ( opj_j2k_v2_t *p_j2k, } if (! opj_j2k_read_SPCod_SPCoc(p_j2k,0,p_header_data,&p_header_size,p_manager)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading COD marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n"); return OPJ_FALSE; } if (p_header_size != 0) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading COD marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n"); return OPJ_FALSE; } @@ -2401,7 +2476,8 @@ static opj_bool opj_j2k_read_cod ( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_coc( opj_j2k_v2_t *p_j2k, +#if 0 +OPJ_BOOL opj_j2k_write_coc( opj_j2k_t *p_j2k, OPJ_UINT32 p_comp_no, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) @@ -2420,17 +2496,17 @@ opj_bool opj_j2k_write_coc( opj_j2k_v2_t *p_j2k, if (l_coc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) { OPJ_BYTE *new_header_tile_data; - p_j2k->m_specific_param.m_encoder.m_header_tile_data + /*p_j2k->m_specific_param.m_encoder.m_header_tile_data = (OPJ_BYTE*)opj_realloc( p_j2k->m_specific_param.m_encoder.m_header_tile_data, - l_coc_size); + l_coc_size);*/ new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_coc_size); if (! new_header_tile_data) { opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data); p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL; p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to write COC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write COC marker\n"); return OPJ_FALSE; } p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data; @@ -2445,16 +2521,18 @@ opj_bool opj_j2k_write_coc( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } +#endif -void opj_j2k_write_coc_in_memory( opj_j2k_v2_t *p_j2k, +#if 0 +void opj_j2k_write_coc_in_memory( opj_j2k_t *p_j2k, OPJ_UINT32 p_comp_no, OPJ_BYTE * p_data, OPJ_UINT32 * p_data_written, opj_event_mgr_t * p_manager ) { - opj_cp_v2_t *l_cp = 00; - opj_tcp_v2_t *l_tcp = 00; + opj_cp_t *l_cp = 00; + opj_tcp_t *l_tcp = 00; OPJ_UINT32 l_coc_size,l_remaining_size; OPJ_BYTE * l_current_data = 00; opj_image_t *l_image = 00; @@ -2490,8 +2568,9 @@ void opj_j2k_write_coc_in_memory( opj_j2k_v2_t *p_j2k, opj_j2k_write_SPCod_SPCoc(p_j2k,p_j2k->m_current_tile_number,0,l_current_data,&l_remaining_size,p_manager); * p_data_written = l_coc_size; } +#endif -OPJ_UINT32 opj_j2k_get_max_coc_size(opj_j2k_v2_t *p_j2k) +OPJ_UINT32 opj_j2k_get_max_coc_size(opj_j2k_t *p_j2k) { OPJ_UINT32 i,j; OPJ_UINT32 l_nb_comp; @@ -2519,14 +2598,14 @@ OPJ_UINT32 opj_j2k_get_max_coc_size(opj_j2k_v2_t *p_j2k) * @param p_header_size the size of the data contained in the COC marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_coc ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_coc ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ) { - opj_cp_v2_t *l_cp = NULL; - opj_tcp_v2_t *l_tcp = NULL; + opj_cp_t *l_cp = NULL; + opj_tcp_t *l_tcp = NULL; opj_image_t *l_image = NULL; OPJ_UINT32 l_comp_room; OPJ_UINT32 l_comp_no; @@ -2546,7 +2625,7 @@ static opj_bool opj_j2k_read_coc ( opj_j2k_v2_t *p_j2k, /* make sure room is sufficient*/ if (p_header_size < l_comp_room + 1) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading COC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n"); return OPJ_FALSE; } p_header_size -= l_comp_room + 1; @@ -2554,7 +2633,7 @@ static opj_bool opj_j2k_read_coc ( opj_j2k_v2_t *p_j2k, opj_read_bytes(p_header_data,&l_comp_no,l_comp_room); /* Ccoc */ p_header_data += l_comp_room; if (l_comp_no >= l_image->numcomps) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading COC marker (bad number of components)\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker (bad number of components)\n"); return OPJ_FALSE; } @@ -2562,24 +2641,22 @@ static opj_bool opj_j2k_read_coc ( opj_j2k_v2_t *p_j2k, ++p_header_data ; if (! opj_j2k_read_SPCod_SPCoc(p_j2k,l_comp_no,p_header_data,&p_header_size,p_manager)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading COC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n"); return OPJ_FALSE; } if (p_header_size != 0) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading COC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n"); return OPJ_FALSE; } return OPJ_TRUE; } -opj_bool opj_j2k_write_qcd( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_qcd( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) { - opj_cp_v2_t *l_cp = 00; - opj_tcp_v2_t *l_tcp = 00; OPJ_UINT32 l_qcd_size,l_remaining_size; OPJ_BYTE * l_current_data = 00; @@ -2588,8 +2665,6 @@ opj_bool opj_j2k_write_qcd( opj_j2k_v2_t *p_j2k, assert(p_manager != 00); assert(p_stream != 00); - l_cp = &(p_j2k->m_cp); - l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number]; l_qcd_size = 4 + opj_j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,0); l_remaining_size = l_qcd_size; @@ -2599,7 +2674,7 @@ opj_bool opj_j2k_write_qcd( opj_j2k_v2_t *p_j2k, opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data); p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL; p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to write QCD marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write QCD marker\n"); return OPJ_FALSE; } p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data; @@ -2617,12 +2692,12 @@ opj_bool opj_j2k_write_qcd( opj_j2k_v2_t *p_j2k, l_remaining_size -= 4; if (! opj_j2k_write_SQcd_SQcc(p_j2k,p_j2k->m_current_tile_number,0,l_current_data,&l_remaining_size,p_manager)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error writing QCD marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error writing QCD marker\n"); return OPJ_FALSE; } if (l_remaining_size != 0) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error writing QCD marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error writing QCD marker\n"); return OPJ_FALSE; } @@ -2640,7 +2715,7 @@ opj_bool opj_j2k_write_qcd( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the QCD marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_qcd ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_qcd ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager @@ -2652,12 +2727,12 @@ static opj_bool opj_j2k_read_qcd ( opj_j2k_v2_t *p_j2k, assert(p_manager != 00); if (! opj_j2k_read_SQcd_SQcc(p_j2k,0,p_header_data,&p_header_size,p_manager)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading QCD marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading QCD marker\n"); return OPJ_FALSE; } if (p_header_size != 0) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading QCD marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading QCD marker\n"); return OPJ_FALSE; } @@ -2667,7 +2742,8 @@ static opj_bool opj_j2k_read_qcd ( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_qcc( opj_j2k_v2_t *p_j2k, +#if 0 +OPJ_BOOL opj_j2k_write_qcc( opj_j2k_t *p_j2k, OPJ_UINT32 p_comp_no, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager @@ -2680,7 +2756,8 @@ opj_bool opj_j2k_write_qcc( opj_j2k_v2_t *p_j2k, assert(p_manager != 00); assert(p_stream != 00); - l_qcc_size = 6 + opj_j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no); + l_qcc_size = 5 + opj_j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no); + l_qcc_size += p_j2k->m_private_image->numcomps <= 256 ? 0:1; l_remaining_size = l_qcc_size; if (l_qcc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) { @@ -2689,7 +2766,7 @@ opj_bool opj_j2k_write_qcc( opj_j2k_v2_t *p_j2k, opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data); p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL; p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to write QCC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write QCC marker\n"); return OPJ_FALSE; } p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data; @@ -2704,8 +2781,10 @@ opj_bool opj_j2k_write_qcc( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } +#endif -void opj_j2k_write_qcc_in_memory( opj_j2k_v2_t *p_j2k, +#if 0 +void opj_j2k_write_qcc_in_memory( opj_j2k_t *p_j2k, OPJ_UINT32 p_comp_no, OPJ_BYTE * p_data, OPJ_UINT32 * p_data_written, @@ -2753,8 +2832,9 @@ void opj_j2k_write_qcc_in_memory( opj_j2k_v2_t *p_j2k, *p_data_written = l_qcc_size; } +#endif -OPJ_UINT32 opj_j2k_get_max_qcc_size (opj_j2k_v2_t *p_j2k) +OPJ_UINT32 opj_j2k_get_max_qcc_size (opj_j2k_t *p_j2k) { return opj_j2k_get_max_coc_size(p_j2k); } @@ -2766,7 +2846,7 @@ OPJ_UINT32 opj_j2k_get_max_qcc_size (opj_j2k_v2_t *p_j2k) * @param p_header_size the size of the data contained in the QCC marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_qcc( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_qcc( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager @@ -2783,7 +2863,7 @@ static opj_bool opj_j2k_read_qcc( opj_j2k_v2_t *p_j2k, if (l_num_comp <= 256) { if (p_header_size < 1) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading QCC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n"); return OPJ_FALSE; } opj_read_bytes(p_header_data,&l_comp_no,1); @@ -2792,7 +2872,7 @@ static opj_bool opj_j2k_read_qcc( opj_j2k_v2_t *p_j2k, } else { if (p_header_size < 2) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading QCC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n"); return OPJ_FALSE; } opj_read_bytes(p_header_data,&l_comp_no,2); @@ -2807,16 +2887,16 @@ static opj_bool opj_j2k_read_qcc( opj_j2k_v2_t *p_j2k, /* compno is negative or larger than the number of components!!! */ if (/*(l_comp_no < 0) ||*/ (l_comp_no >= l_num_comp)) { - opj_event_msg_v2(p_manager, EVT_ERROR, + opj_event_msg(p_manager, EVT_ERROR, "JPWL: bad component number in QCC (%d out of a maximum of %d)\n", l_comp_no, l_num_comp); if (!JPWL_ASSUME) { - opj_event_msg_v2(p_manager, EVT_ERROR, "JPWL: giving up\n"); + opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n"); return OPJ_FALSE; } /* we try to correct */ l_comp_no = backup_compno % l_num_comp; - opj_event_msg_v2(p_manager, EVT_WARNING, "- trying to adjust this\n" + opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n" "- setting component number to %d\n", l_comp_no); } @@ -2826,20 +2906,27 @@ static opj_bool opj_j2k_read_qcc( opj_j2k_v2_t *p_j2k, }; #endif /* USE_JPWL */ + if (l_comp_no >= p_j2k->m_private_image->numcomps) { + opj_event_msg(p_manager, EVT_ERROR, + "Invalid component number: %d, regarding the number of components %d\n", + l_comp_no, p_j2k->m_private_image->numcomps); + return OPJ_FALSE; + } + if (! opj_j2k_read_SQcd_SQcc(p_j2k,l_comp_no,p_header_data,&p_header_size,p_manager)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading QCC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n"); return OPJ_FALSE; } if (p_header_size != 0) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading QCC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading QCC marker\n"); return OPJ_FALSE; } return OPJ_TRUE; } -opj_bool opj_j2k_write_poc( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_poc( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) @@ -2848,8 +2935,7 @@ opj_bool opj_j2k_write_poc( opj_j2k_v2_t *p_j2k, OPJ_UINT32 l_nb_poc; OPJ_UINT32 l_poc_size; OPJ_UINT32 l_written_size = 0; - opj_tcp_v2_t *l_tcp = 00; - opj_tccp_t *l_tccp = 00; + opj_tcp_t *l_tcp = 00; OPJ_UINT32 l_poc_room; /* preconditions */ @@ -2858,7 +2944,6 @@ opj_bool opj_j2k_write_poc( opj_j2k_v2_t *p_j2k, assert(p_stream != 00); l_tcp = &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]; - l_tccp = &l_tcp->tccps[0]; l_nb_comp = p_j2k->m_private_image->numcomps; l_nb_poc = 1 + l_tcp->numpocs; @@ -2876,7 +2961,7 @@ opj_bool opj_j2k_write_poc( opj_j2k_v2_t *p_j2k, opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data); p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL; p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to write POC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write POC marker\n"); return OPJ_FALSE; } p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data; @@ -2892,7 +2977,7 @@ opj_bool opj_j2k_write_poc( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -void opj_j2k_write_poc_in_memory( opj_j2k_v2_t *p_j2k, +void opj_j2k_write_poc_in_memory( opj_j2k_t *p_j2k, OPJ_BYTE * p_data, OPJ_UINT32 * p_data_written, opj_event_mgr_t * p_manager @@ -2904,7 +2989,7 @@ void opj_j2k_write_poc_in_memory( opj_j2k_v2_t *p_j2k, OPJ_UINT32 l_nb_poc; OPJ_UINT32 l_poc_size; opj_image_t *l_image = 00; - opj_tcp_v2_t *l_tcp = 00; + opj_tcp_t *l_tcp = 00; opj_tccp_t *l_tccp = 00; opj_poc_t *l_current_poc = 00; OPJ_UINT32 l_poc_room; @@ -2957,9 +3042,9 @@ void opj_j2k_write_poc_in_memory( opj_j2k_v2_t *p_j2k, ++l_current_data; /* change the value of the max layer according to the actual number of layers in the file, components and resolutions*/ - l_current_poc->layno1 = opj_int_min(l_current_poc->layno1, l_tcp->numlayers); - l_current_poc->resno1 = opj_int_min(l_current_poc->resno1, l_tccp->numresolutions); - l_current_poc->compno1 = opj_int_min(l_current_poc->compno1, l_nb_comp); + l_current_poc->layno1 = (OPJ_UINT32)opj_int_min((OPJ_INT32)l_current_poc->layno1, (OPJ_INT32)l_tcp->numlayers); + l_current_poc->resno1 = (OPJ_UINT32)opj_int_min((OPJ_INT32)l_current_poc->resno1, (OPJ_INT32)l_tccp->numresolutions); + l_current_poc->compno1 = (OPJ_UINT32)opj_int_min((OPJ_INT32)l_current_poc->compno1, (OPJ_INT32)l_nb_comp); ++l_current_poc; } @@ -2967,9 +3052,9 @@ void opj_j2k_write_poc_in_memory( opj_j2k_v2_t *p_j2k, *p_data_written = l_poc_size; } -OPJ_UINT32 opj_j2k_get_max_poc_size(opj_j2k_v2_t *p_j2k) +OPJ_UINT32 opj_j2k_get_max_poc_size(opj_j2k_t *p_j2k) { - opj_tcp_v2_t * l_tcp = 00; + opj_tcp_t * l_tcp = 00; OPJ_UINT32 l_nb_tiles = 0; OPJ_UINT32 l_max_poc = 0; OPJ_UINT32 i; @@ -2987,12 +3072,12 @@ OPJ_UINT32 opj_j2k_get_max_poc_size(opj_j2k_v2_t *p_j2k) return 4 + 9 * l_max_poc; } -OPJ_UINT32 opj_j2k_get_max_toc_size (opj_j2k_v2_t *p_j2k) +OPJ_UINT32 opj_j2k_get_max_toc_size (opj_j2k_t *p_j2k) { OPJ_UINT32 i; OPJ_UINT32 l_nb_tiles; OPJ_UINT32 l_max = 0; - opj_tcp_v2_t * l_tcp = 00; + opj_tcp_t * l_tcp = 00; l_tcp = p_j2k->m_cp.tcps; l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th ; @@ -3006,7 +3091,7 @@ OPJ_UINT32 opj_j2k_get_max_toc_size (opj_j2k_v2_t *p_j2k) return 12 * l_max; } -OPJ_UINT32 opj_j2k_get_specific_header_sizes(opj_j2k_v2_t *p_j2k) +OPJ_UINT32 opj_j2k_get_specific_header_sizes(opj_j2k_t *p_j2k) { OPJ_UINT32 l_nb_bytes = 0; OPJ_UINT32 l_nb_comps; @@ -3015,7 +3100,7 @@ OPJ_UINT32 opj_j2k_get_specific_header_sizes(opj_j2k_v2_t *p_j2k) l_nb_comps = p_j2k->m_private_image->numcomps - 1; l_nb_bytes += opj_j2k_get_max_toc_size(p_j2k); - if (p_j2k->m_cp.m_specific_param.m_enc.m_cinema == 0) { + if (!(OPJ_IS_CINEMA(p_j2k->m_cp.rsiz))) { l_coc_bytes = opj_j2k_get_max_coc_size(p_j2k); l_nb_bytes += l_nb_comps * l_coc_bytes; @@ -3038,7 +3123,7 @@ OPJ_UINT32 opj_j2k_get_specific_header_sizes(opj_j2k_v2_t *p_j2k) * @param p_header_size the size of the data contained in the POC marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_poc ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_poc ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager @@ -3049,8 +3134,8 @@ static opj_bool opj_j2k_read_poc ( opj_j2k_v2_t *p_j2k, OPJ_UINT32 l_old_poc_nb, l_current_poc_nb, l_current_poc_remaining; OPJ_UINT32 l_chunk_size, l_comp_room; - opj_cp_v2_t *l_cp = 00; - opj_tcp_v2_t *l_tcp = 00; + opj_cp_t *l_cp = 00; + opj_tcp_t *l_tcp = 00; opj_poc_t *l_current_poc = 00; /* preconditions */ @@ -3071,7 +3156,7 @@ static opj_bool opj_j2k_read_poc ( opj_j2k_v2_t *p_j2k, l_current_poc_remaining = p_header_size % l_chunk_size; if ((l_current_poc_nb <= 0) || (l_current_poc_remaining != 0)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading POC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading POC marker\n"); return OPJ_FALSE; } @@ -3082,6 +3167,11 @@ static opj_bool opj_j2k_read_poc ( opj_j2k_v2_t *p_j2k, l_old_poc_nb = l_tcp->POC ? l_tcp->numpocs + 1 : 0; l_current_poc_nb += l_old_poc_nb; + if(l_current_poc_nb >= 32) + { + opj_event_msg(p_manager, EVT_ERROR, "Too many POCs %d\n", l_current_poc_nb); + return OPJ_FALSE; + } assert(l_current_poc_nb < 32); /* now poc is in use.*/ @@ -3094,6 +3184,8 @@ static opj_bool opj_j2k_read_poc ( opj_j2k_v2_t *p_j2k, opj_read_bytes(p_header_data,&(l_current_poc->compno0),l_comp_room); /* CSpoc_i */ p_header_data+=l_comp_room; opj_read_bytes(p_header_data,&(l_current_poc->layno1),2); /* LYEpoc_i */ + /* make sure layer end is in acceptable bounds */ + l_current_poc->layno1 = opj_uint_min(l_current_poc->layno1, l_tcp->numlayers); p_header_data+=2; opj_read_bytes(p_header_data,&(l_current_poc->resno1),1); /* REpoc_i */ ++p_header_data; @@ -3119,7 +3211,7 @@ static opj_bool opj_j2k_read_poc ( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the TLM marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_crg ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_crg ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager @@ -3134,7 +3226,7 @@ static opj_bool opj_j2k_read_crg ( opj_j2k_v2_t *p_j2k, l_nb_comp = p_j2k->m_private_image->numcomps; if (p_header_size != l_nb_comp *4) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading CRG marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading CRG marker\n"); return OPJ_FALSE; } /* Do not care of this at the moment since only local variables are set here */ @@ -3159,20 +3251,20 @@ static opj_bool opj_j2k_read_crg ( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the TLM marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_tlm ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_tlm ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ) { - OPJ_UINT32 l_Ztlm, l_Stlm, l_ST, l_SP, l_tot_num_tp, l_tot_num_tp_remaining, l_quotient, l_Ptlm_size; + OPJ_UINT32 l_Ztlm, l_Stlm, l_ST, l_SP, l_tot_num_tp_remaining, l_quotient, l_Ptlm_size; /* preconditions */ assert(p_header_data != 00); assert(p_j2k != 00); assert(p_manager != 00); if (p_header_size < 2) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading TLM marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading TLM marker\n"); return OPJ_FALSE; } p_header_size -= 2; @@ -3188,11 +3280,10 @@ static opj_bool opj_j2k_read_tlm ( opj_j2k_v2_t *p_j2k, l_Ptlm_size = (l_SP + 1) * 2; l_quotient = l_Ptlm_size + l_ST; - l_tot_num_tp = p_header_size / l_quotient; l_tot_num_tp_remaining = p_header_size % l_quotient; if (l_tot_num_tp_remaining != 0) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading TLM marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading TLM marker\n"); return OPJ_FALSE; } /* FIXME Do not care of this at the moment since only local variables are set here */ @@ -3216,7 +3307,7 @@ static opj_bool opj_j2k_read_tlm ( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the TLM marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_plm ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_plm ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager @@ -3228,7 +3319,7 @@ static opj_bool opj_j2k_read_plm ( opj_j2k_v2_t *p_j2k, assert(p_manager != 00); if (p_header_size < 1) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading PLM marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading PLM marker\n"); return OPJ_FALSE; } /* Do not care of this at the moment since only local variables are set here */ @@ -3286,7 +3377,7 @@ static opj_bool opj_j2k_read_plm ( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the PLT marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_plt ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_plt ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager @@ -3300,7 +3391,7 @@ static opj_bool opj_j2k_read_plt ( opj_j2k_v2_t *p_j2k, assert(p_manager != 00); if (p_header_size < 1) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading PLT marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading PLT marker\n"); return OPJ_FALSE; } @@ -3323,7 +3414,7 @@ static opj_bool opj_j2k_read_plt ( opj_j2k_v2_t *p_j2k, } if (l_packet_len != 0) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading PLT marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading PLT marker\n"); return OPJ_FALSE; } @@ -3331,15 +3422,15 @@ static opj_bool opj_j2k_read_plt ( opj_j2k_v2_t *p_j2k, } #if 0 -opj_bool j2k_read_ppm_v2 ( - opj_j2k_v2_t *p_j2k, +OPJ_BOOL j2k_read_ppm_v2 ( + opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, struct opj_event_mgr * p_manager ) { - opj_cp_v2_t *l_cp = 00; + opj_cp_t *l_cp = 00; OPJ_UINT32 l_remaining_data, l_Z_ppm, l_N_ppm; /* preconditions */ @@ -3348,7 +3439,7 @@ opj_bool j2k_read_ppm_v2 ( assert(p_manager != 00); if (p_header_size < 1) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading PPM marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n"); return OPJ_FALSE; } @@ -3362,7 +3453,7 @@ opj_bool j2k_read_ppm_v2 ( /* First PPM marker */ if (l_Z_ppm == 0) { if (p_header_size < 4) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading PPM marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n"); return OPJ_FALSE; } @@ -3376,7 +3467,7 @@ opj_bool j2k_read_ppm_v2 ( l_cp->ppm_buffer = (OPJ_BYTE *) opj_malloc(l_cp->ppm_len); if (l_cp->ppm_buffer == 00) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory reading ppm marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory reading ppm marker\n"); return OPJ_FALSE; } memset(l_cp->ppm_buffer,0,l_cp->ppm_len); @@ -3399,7 +3490,7 @@ opj_bool j2k_read_ppm_v2 ( l_cp->ppm_buffer = NULL; l_cp->ppm_len = 0; l_cp->ppm_data = NULL; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory reading ppm marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory reading ppm marker\n"); return OPJ_FALSE; } l_cp->ppm_buffer = new_ppm_buffer; @@ -3433,14 +3524,14 @@ opj_bool j2k_read_ppm_v2 ( } #endif -opj_bool j2k_read_ppm_v3 ( - opj_j2k_v2_t *p_j2k, +OPJ_BOOL j2k_read_ppm_v3 ( + opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, struct opj_event_mgr * p_manager ) { - opj_cp_v2_t *l_cp = 00; + opj_cp_t *l_cp = 00; OPJ_UINT32 l_remaining_data, l_Z_ppm, l_N_ppm; /* preconditions */ @@ -3450,7 +3541,7 @@ opj_bool j2k_read_ppm_v3 ( /* Minimum size of PPM marker is equal to the size of Zppm element */ if (p_header_size < 1) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading PPM marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n"); return OPJ_FALSE; } @@ -3463,9 +3554,17 @@ opj_bool j2k_read_ppm_v3 ( /* First PPM marker */ if (l_Z_ppm == 0) { + if (l_cp->ppm_data != NULL) { + opj_event_msg(p_manager, EVT_ERROR, "Zppm O already processed. Found twice.\n"); + opj_free(l_cp->ppm_data); + l_cp->ppm_data = NULL; + l_cp->ppm_buffer = NULL; + l_cp->ppm = 0; /* do not use PPM */ + return OPJ_FALSE; + } /* We need now at least the Nppm^0 element */ if (p_header_size < 4) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading PPM marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n"); return OPJ_FALSE; } @@ -3473,17 +3572,27 @@ opj_bool j2k_read_ppm_v3 ( p_header_data+=4; p_header_size-=4; + /* sanity check: how much bytes is left for Ippm */ + if( p_header_size < l_N_ppm ) + { + opj_event_msg(p_manager, EVT_ERROR, "Not enough bytes (%u) to hold Ippm series (%u), Index (%d)\n", p_header_size, l_N_ppm, l_Z_ppm ); + opj_free(l_cp->ppm_data); + l_cp->ppm_data = NULL; + l_cp->ppm_buffer = NULL; + l_cp->ppm = 0; /* do not use PPM */ + return OPJ_FALSE; + } + /* First PPM marker: Initialization */ l_cp->ppm_len = l_N_ppm; l_cp->ppm_data_read = 0; - l_cp->ppm_data = (OPJ_BYTE *) opj_malloc(l_cp->ppm_len); + l_cp->ppm_data = (OPJ_BYTE *) opj_calloc(1,l_cp->ppm_len); l_cp->ppm_buffer = l_cp->ppm_data; if (l_cp->ppm_data == 00) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to read ppm marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read ppm marker\n"); return OPJ_FALSE; } - memset(l_cp->ppm_data,0,l_cp->ppm_len); l_cp->ppm_data_current = l_cp->ppm_data; @@ -3491,7 +3600,7 @@ opj_bool j2k_read_ppm_v3 ( } else { if (p_header_size < 4) { - opj_event_msg_v2(p_manager, EVT_WARNING, "Empty PPM marker\n"); + opj_event_msg(p_manager, EVT_WARNING, "Empty PPM marker\n"); return OPJ_TRUE; } else { @@ -3507,6 +3616,16 @@ opj_bool j2k_read_ppm_v3 ( p_header_data+=4; p_header_size-=4; + /* sanity check: how much bytes is left for Ippm */ + if( p_header_size < l_N_ppm ) + { + opj_event_msg(p_manager, EVT_ERROR, "Not enough bytes (%u) to hold Ippm series (%u), Index (%d)\n", p_header_size, l_N_ppm, l_Z_ppm ); + opj_free(l_cp->ppm_data); + l_cp->ppm_data = NULL; + l_cp->ppm_buffer = NULL; + l_cp->ppm = 0; /* do not use PPM */ + return OPJ_FALSE; + } /* Increase the size of ppm_data to add the new Ippm series*/ assert(l_cp->ppm_data == l_cp->ppm_buffer && "We need ppm_data and ppm_buffer to be the same when reallocating"); new_ppm_data = (OPJ_BYTE *) opj_realloc(l_cp->ppm_data, l_cp->ppm_len + l_N_ppm); @@ -3515,7 +3634,7 @@ opj_bool j2k_read_ppm_v3 ( l_cp->ppm_data = NULL; l_cp->ppm_buffer = NULL; /* TODO: no need for a new local variable: ppm_buffer and ppm_data are enough */ l_cp->ppm_len = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to increase the size of ppm_data to add the new Ippm series\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to increase the size of ppm_data to add the new Ippm series\n"); return OPJ_FALSE; } l_cp->ppm_data = new_ppm_data; @@ -3540,6 +3659,15 @@ opj_bool j2k_read_ppm_v3 ( if (p_header_size) { + if (p_header_size < 4) { + opj_free(l_cp->ppm_data); + l_cp->ppm_data = NULL; + l_cp->ppm_buffer = NULL; /* TODO: no need for a new local variable: ppm_buffer and ppm_data are enough */ + l_cp->ppm_len = 0; + l_cp->ppm = 0; + opj_event_msg(p_manager, EVT_ERROR, "Error reading PPM marker\n"); + return OPJ_FALSE; + } opj_read_bytes(p_header_data,&l_N_ppm,4); /* N_ppm^i */ p_header_data+=4; p_header_size-=4; @@ -3552,17 +3680,26 @@ opj_bool j2k_read_ppm_v3 ( l_remaining_data = p_header_size; /* Next Ippm series is a complete series ?*/ - if (l_remaining_data > l_N_ppm) { + if (l_remaining_data >= l_N_ppm) { OPJ_BYTE *new_ppm_data; /* Increase the size of ppm_data to add the new Ippm series*/ assert(l_cp->ppm_data == l_cp->ppm_buffer && "We need ppm_data and ppm_buffer to be the same when reallocating"); + /* Overflow check */ + if ((l_cp->ppm_len + l_N_ppm) < l_N_ppm) { + opj_free(l_cp->ppm_data); + l_cp->ppm_data = NULL; + l_cp->ppm_buffer = NULL; /* TODO: no need for a new local variable: ppm_buffer and ppm_data are enough */ + l_cp->ppm_len = 0; + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to increase the size of ppm_data to add the new (complete) Ippm series\n"); + return OPJ_FALSE; + } new_ppm_data = (OPJ_BYTE *) opj_realloc(l_cp->ppm_data, l_cp->ppm_len + l_N_ppm); if (! new_ppm_data) { opj_free(l_cp->ppm_data); l_cp->ppm_data = NULL; l_cp->ppm_buffer = NULL; /* TODO: no need for a new local variable: ppm_buffer and ppm_data are enough */ l_cp->ppm_len = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to increase the size of ppm_data to add the new (complete) Ippm series\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to increase the size of ppm_data to add the new (complete) Ippm series\n"); return OPJ_FALSE; } l_cp->ppm_data = new_ppm_data; @@ -3579,13 +3716,23 @@ opj_bool j2k_read_ppm_v3 ( if (l_remaining_data) { OPJ_BYTE *new_ppm_data; assert(l_cp->ppm_data == l_cp->ppm_buffer && "We need ppm_data and ppm_buffer to be the same when reallocating"); + + /* Overflow check */ + if ((l_cp->ppm_len + l_N_ppm) < l_N_ppm) { + opj_free(l_cp->ppm_data); + l_cp->ppm_data = NULL; + l_cp->ppm_buffer = NULL; /* TODO: no need for a new local variable: ppm_buffer and ppm_data are enough */ + l_cp->ppm_len = 0; + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to increase the size of ppm_data to add the new (complete) Ippm series\n"); + return OPJ_FALSE; + } new_ppm_data = (OPJ_BYTE *) opj_realloc(l_cp->ppm_data, l_cp->ppm_len + l_N_ppm); if (! new_ppm_data) { opj_free(l_cp->ppm_data); l_cp->ppm_data = NULL; l_cp->ppm_buffer = NULL; /* TODO: no need for a new local variable: ppm_buffer and ppm_data are enough */ l_cp->ppm_len = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to increase the size of ppm_data to add the new (incomplete) Ippm series\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to increase the size of ppm_data to add the new (incomplete) Ippm series\n"); return OPJ_FALSE; } l_cp->ppm_data = new_ppm_data; @@ -3618,7 +3765,7 @@ opj_bool j2k_read_ppm_v3 ( opj_free(l_cp->ppm_buffer); l_cp->ppm_buffer = NULL; l_cp->ppm_len = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to read ppm marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read ppm marker\n"); return OPJ_FALSE; } l_cp->ppm_buffer = new_ppm_buffer; @@ -3660,14 +3807,14 @@ opj_bool j2k_read_ppm_v3 ( * @param p_header_size the size of the data contained in the PPT marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_ppt ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_ppt ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ) { - opj_cp_v2_t *l_cp = 00; - opj_tcp_v2_t *l_tcp = 00; + opj_cp_t *l_cp = 00; + opj_tcp_t *l_tcp = 00; OPJ_UINT32 l_Z_ppt; /* preconditions */ @@ -3677,13 +3824,13 @@ static opj_bool opj_j2k_read_ppt ( opj_j2k_v2_t *p_j2k, /* We need to have the Z_ppt element at minimum */ if (p_header_size < 1) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading PPT marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading PPT marker\n"); return OPJ_FALSE; } l_cp = &(p_j2k->m_cp); if (l_cp->ppm){ - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading PPT marker: packet header have been previously found in the main header (PPM marker).\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading PPT marker: packet header have been previously found in the main header (PPM marker).\n"); return OPJ_FALSE; } @@ -3700,9 +3847,10 @@ static opj_bool opj_j2k_read_ppt ( opj_j2k_v2_t *p_j2k, l_tcp->ppt_data_size = 0; l_tcp->ppt_len = p_header_size; + opj_free(l_tcp->ppt_buffer); l_tcp->ppt_buffer = (OPJ_BYTE *) opj_calloc(l_tcp->ppt_len, sizeof(OPJ_BYTE) ); if (l_tcp->ppt_buffer == 00) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n"); return OPJ_FALSE; } l_tcp->ppt_data = l_tcp->ppt_buffer; @@ -3718,7 +3866,7 @@ static opj_bool opj_j2k_read_ppt ( opj_j2k_v2_t *p_j2k, opj_free(l_tcp->ppt_buffer); l_tcp->ppt_buffer = NULL; l_tcp->ppt_len = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n"); return OPJ_FALSE; } l_tcp->ppt_buffer = new_ppt_buffer; @@ -3735,7 +3883,7 @@ static opj_bool opj_j2k_read_ppt ( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_tlm( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_tlm( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) @@ -3756,7 +3904,7 @@ opj_bool opj_j2k_write_tlm( opj_j2k_v2_t *p_j2k, opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data); p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL; p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to write TLM marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write TLM marker\n"); return OPJ_FALSE; } p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data; @@ -3789,7 +3937,7 @@ opj_bool opj_j2k_write_tlm( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_sot( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_sot( opj_j2k_t *p_j2k, OPJ_BYTE * p_data, OPJ_UINT32 * p_data_written, const opj_stream_private_t *p_stream, @@ -3823,7 +3971,7 @@ opj_bool opj_j2k_write_sot( opj_j2k_v2_t *p_j2k, #ifdef USE_JPWL /* update markers struct */ /* - opj_bool res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOT, p_j2k->sot_start, len + 2); + OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOT, p_j2k->sot_start, len + 2); */ assert( 0 && "TODO" ); #endif /* USE_JPWL */ @@ -3833,13 +3981,13 @@ opj_bool opj_j2k_write_sot( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_read_sot ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ) { - opj_cp_v2_t *l_cp = 00; - opj_tcp_v2_t *l_tcp = 00; + opj_cp_t *l_cp = 00; + opj_tcp_t *l_tcp = 00; OPJ_UINT32 l_tot_len, l_num_parts = 0; OPJ_UINT32 l_current_part; OPJ_UINT32 l_tile_x,l_tile_y; @@ -3851,7 +3999,7 @@ opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k, /* Size of this marker is fixed = 12 (we have already read marker and its size)*/ if (p_header_size != 8) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading SOT marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading SOT marker\n"); return OPJ_FALSE; } @@ -3859,6 +4007,12 @@ opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k, opj_read_bytes(p_header_data,&(p_j2k->m_current_tile_number),2); /* Isot */ p_header_data+=2; + /* testcase 2.pdf.SIGFPE.706.1112 */ + if (p_j2k->m_current_tile_number >= l_cp->tw * l_cp->th) { + opj_event_msg(p_manager, EVT_ERROR, "Invalid tile number %d\n", p_j2k->m_current_tile_number); + return OPJ_FALSE; + } + l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number]; l_tile_x = p_j2k->m_current_tile_number % l_cp->tw; l_tile_y = p_j2k->m_current_tile_number / l_cp->tw; @@ -3871,16 +4025,16 @@ opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k, /* tileno is negative or larger than the number of tiles!!! */ if (tileno > (l_cp->tw * l_cp->th)) { - opj_event_msg_v2(p_manager, EVT_ERROR, + opj_event_msg(p_manager, EVT_ERROR, "JPWL: bad tile number (%d out of a maximum of %d)\n", tileno, (l_cp->tw * l_cp->th)); if (!JPWL_ASSUME) { - opj_event_msg_v2(p_manager, EVT_ERROR, "JPWL: giving up\n"); + opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n"); return OPJ_FALSE; } /* we try to correct */ tileno = backup_tileno; - opj_event_msg_v2(p_manager, EVT_WARNING, "- trying to adjust this\n" + opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n" "- setting tile number to %d\n", tileno); } @@ -3900,8 +4054,15 @@ opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k, /* PSot should be equal to zero or >=14 or <= 2^32-1 */ if ((l_tot_len !=0 ) && (l_tot_len < 14) ) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Psot value (%d) is not correct regards to the JPEG2000 norm!\n", l_tot_len); + if (l_tot_len == 12 ) /* MSD: Special case for the PHR data which are read by kakadu*/ + { + opj_event_msg(p_manager, EVT_WARNING, "Empty SOT marker detected: Psot=%d.\n", l_tot_len); + } + else + { + opj_event_msg(p_manager, EVT_ERROR, "Psot value is not correct regards to the JPEG2000 norm: %d.\n", l_tot_len); return OPJ_FALSE; + } } #ifdef USE_JPWL @@ -3909,16 +4070,16 @@ opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k, /* totlen is negative or larger than the bytes left!!! */ if (/*(l_tot_len < 0) ||*/ (l_tot_len > p_header_size ) ) { /* FIXME it seems correct; for info in V1 -> (p_stream_numbytesleft(p_stream) + 8))) { */ - opj_event_msg_v2(p_manager, EVT_ERROR, + opj_event_msg(p_manager, EVT_ERROR, "JPWL: bad tile byte size (%d bytes against %d bytes left)\n", l_tot_len, p_header_size ); /* FIXME it seems correct; for info in V1 -> p_stream_numbytesleft(p_stream) + 8); */ if (!JPWL_ASSUME) { - opj_event_msg_v2(p_manager, EVT_ERROR, "JPWL: giving up\n"); + opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n"); return OPJ_FALSE; } /* we try to correct */ l_tot_len = 0; - opj_event_msg_v2(p_manager, EVT_WARNING, "- trying to adjust this\n" + opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust this\n" "- setting Psot to %d => assuming it is the last tile\n", l_tot_len); } @@ -3927,7 +4088,7 @@ opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k, /* Ref A.4.2: Psot could be equal zero if it is the last tile-part of the codestream.*/ if (!l_tot_len) { - opj_event_msg_v2(p_manager, EVT_INFO, "Psot value of the current tile-part is equal to zero, " + opj_event_msg(p_manager, EVT_INFO, "Psot value of the current tile-part is equal to zero, " "we assuming it is the last tile-part of the codestream.\n"); p_j2k->m_specific_param.m_decoder.m_last_tile_part = 1; } @@ -3943,18 +4104,25 @@ opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k, * tile-parts for that tile and zero (A.4.2 of 15444-1 : 2002). */ if (l_tcp->m_nb_tile_parts) { if (l_current_part >= l_tcp->m_nb_tile_parts){ - opj_event_msg_v2(p_manager, EVT_ERROR, "In SOT marker, TPSot (%d) is not valid regards to the current " + opj_event_msg(p_manager, EVT_ERROR, "In SOT marker, TPSot (%d) is not valid regards to the current " "number of tile-part (%d), giving up\n", l_current_part, l_tcp->m_nb_tile_parts ); p_j2k->m_specific_param.m_decoder.m_last_tile_part = 1; return OPJ_FALSE; } } + if( l_current_part >= l_num_parts ) { + /* testcase 451.pdf.SIGSEGV.ce9.3723 */ + opj_event_msg(p_manager, EVT_ERROR, "In SOT marker, TPSot (%d) is not valid regards to the current " + "number of tile-part (header) (%d), giving up\n", l_current_part, l_num_parts ); + p_j2k->m_specific_param.m_decoder.m_last_tile_part = 1; + return OPJ_FALSE; + } l_tcp->m_nb_tile_parts = l_num_parts; } /* If know the number of tile part header we will check if we didn't read the last*/ if (l_tcp->m_nb_tile_parts) { - if (l_tcp->m_nb_tile_parts == (l_current_part + 1)) { + if (l_tcp->m_nb_tile_parts == (l_current_part+1)) { p_j2k->m_specific_param.m_decoder.m_can_decode = 1; /* Process the last tile-part header*/ } } @@ -3998,6 +4166,10 @@ opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k, if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index) { p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = (opj_tp_index_t*)opj_calloc(l_num_parts, sizeof(opj_tp_index_t)); + if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index) { + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read SOT marker. Tile index allocation failed\n"); + return OPJ_FALSE; + } } else { opj_tp_index_t *new_tp_index = (opj_tp_index_t *) opj_realloc( @@ -4005,7 +4177,7 @@ opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k, if (! new_tp_index) { opj_free(p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index); p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = NULL; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read SOT marker. Tile index allocation failed\n"); return OPJ_FALSE; } p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = new_tp_index; @@ -4019,11 +4191,16 @@ opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k, p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = (opj_tp_index_t*)opj_calloc( p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps, sizeof(opj_tp_index_t)); + if (!p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index) { + p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = 0; + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read SOT marker. Tile index allocation failed\n"); + return OPJ_FALSE; + } } if ( l_current_part >= p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps ){ opj_tp_index_t *new_tp_index; - p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps += 10; + p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = l_current_part + 1; new_tp_index = (opj_tp_index_t *) opj_realloc( p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index, p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps * sizeof(opj_tp_index_t)); @@ -4031,7 +4208,7 @@ opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k, opj_free(p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index); p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = NULL; p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_nb_tps = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to read PPT marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read SOT marker. Tile index allocation failed\n"); return OPJ_FALSE; } p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tp_index = new_tp_index; @@ -4072,8 +4249,8 @@ opj_bool opj_j2k_read_sot ( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_sod( opj_j2k_v2_t *p_j2k, - opj_tcd_v2_t * p_tile_coder, +OPJ_BOOL opj_j2k_write_sod( opj_j2k_t *p_j2k, + opj_tcd_t * p_tile_coder, OPJ_BYTE * p_data, OPJ_UINT32 * p_data_written, OPJ_UINT32 p_total_data_size, @@ -4081,11 +4258,7 @@ opj_bool opj_j2k_write_sod( opj_j2k_v2_t *p_j2k, opj_event_mgr_t * p_manager ) { - opj_tcp_v2_t *l_tcp = 00; opj_codestream_info_t *l_cstr_info = 00; - opj_cp_v2_t *l_cp = 00; - - OPJ_UINT32 l_size_tile; OPJ_UINT32 l_remaining_data; /* preconditions */ @@ -4099,16 +4272,11 @@ opj_bool opj_j2k_write_sod( opj_j2k_v2_t *p_j2k, /* make room for the EOF marker */ l_remaining_data = p_total_data_size - 4; - l_cp = &(p_j2k->m_cp); - l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number]; - /* update tile coder */ p_tile_coder->tp_num = p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number ; p_tile_coder->cur_tp_num = p_j2k->m_specific_param.m_encoder.m_current_tile_part_number; - l_size_tile = l_cp->th * l_cp->tw; - - /* INDEX >> */ + /* INDEX >> */ /* TODO mergeV2: check this part which use cstr_info */ /*l_cstr_info = p_j2k->cstr_info; if (l_cstr_info) { @@ -4128,7 +4296,7 @@ opj_bool opj_j2k_write_sod( opj_j2k_v2_t *p_j2k, /* UniPG>> */ #ifdef USE_JPWL /* update markers struct */ - /*opj_bool res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOD, p_j2k->sod_start, 2); + /*OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_SOD, p_j2k->sod_start, 2); */ assert( 0 && "TODO" ); #endif /* USE_JPWL */ @@ -4146,7 +4314,7 @@ opj_bool opj_j2k_write_sod( opj_j2k_v2_t *p_j2k, *p_data_written = 0; if (! opj_tcd_encode_tile(p_tile_coder, p_j2k->m_current_tile_number, p_data, p_data_written, l_remaining_data , l_cstr_info)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Cannot encode tile\n"); + opj_event_msg(p_manager, EVT_ERROR, "Cannot encode tile\n"); return OPJ_FALSE; } @@ -4155,16 +4323,17 @@ opj_bool opj_j2k_write_sod( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_read_sod (opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_read_sod (opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) { - OPJ_UINT32 l_current_read_size; + OPJ_SIZE_T l_current_read_size; opj_codestream_index_t * l_cstr_index = 00; OPJ_BYTE ** l_current_data = 00; - opj_tcp_v2_t * l_tcp = 00; + opj_tcp_t * l_tcp = 00; OPJ_UINT32 * l_tile_len = 00; + OPJ_BOOL l_sot_length_pb_detected = OPJ_FALSE; /* preconditions */ assert(p_j2k != 00); @@ -4180,19 +4349,33 @@ opj_bool opj_j2k_read_sod (opj_j2k_v2_t *p_j2k, // a file with a single tile part of more than 4 GB...*/ p_j2k->m_specific_param.m_decoder.m_sot_length = (OPJ_UINT32)(opj_stream_get_number_byte_left(p_stream) - 2); } - else + else { + /* Check to avoid pass the limit of OPJ_UINT32 */ + if (p_j2k->m_specific_param.m_decoder.m_sot_length >= 2 ) p_j2k->m_specific_param.m_decoder.m_sot_length -= 2; + else { + /* MSD: case commented to support empty SOT marker (PHR data) */ + } + } l_current_data = &(l_tcp->m_data); l_tile_len = &l_tcp->m_data_size; - if (! *l_current_data) { + /* Patch to support new PHR data */ + if (p_j2k->m_specific_param.m_decoder.m_sot_length) { + /* If we are here, we'll try to read the data after allocation */ + /* Check enough bytes left in stream before allocation */ + if ((OPJ_OFF_T)p_j2k->m_specific_param.m_decoder.m_sot_length > opj_stream_get_number_byte_left(p_stream)) { + opj_event_msg(p_manager, EVT_ERROR, "Tile part length size inconsistent with stream length\n"); + return OPJ_FALSE; + } + if (! *l_current_data) { /* LH: oddly enough, in this path, l_tile_len!=0. * TODO: If this was consistant, we could simplify the code to only use realloc(), as realloc(0,...) default to malloc(0,...). */ *l_current_data = (OPJ_BYTE*) opj_malloc(p_j2k->m_specific_param.m_decoder.m_sot_length); - } - else { + } + else { OPJ_BYTE *l_new_current_data = (OPJ_BYTE *) opj_realloc(*l_current_data, *l_tile_len + p_j2k->m_specific_param.m_decoder.m_sot_length); if (! l_new_current_data) { opj_free(*l_current_data); @@ -4202,11 +4385,15 @@ opj_bool opj_j2k_read_sod (opj_j2k_v2_t *p_j2k, function. */ } *l_current_data = l_new_current_data; - } - - if (*l_current_data == 00) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to decode tile\n"); + } + + if (*l_current_data == 00) { + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tile\n"); return OPJ_FALSE; + } + } + else { + l_sot_length_pb_detected = OPJ_TRUE; } /* Index */ @@ -4225,18 +4412,25 @@ opj_bool opj_j2k_read_sod (opj_j2k_v2_t *p_j2k, J2K_MS_SOD, l_current_pos, p_j2k->m_specific_param.m_decoder.m_sot_length + 2)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n"); return OPJ_FALSE; } /*l_cstr_index->packno = 0;*/ } - l_current_read_size = opj_stream_read_data( + /* Patch to support new PHR data */ + if (!l_sot_length_pb_detected) { + l_current_read_size = opj_stream_read_data( p_stream, *l_current_data + *l_tile_len, p_j2k->m_specific_param.m_decoder.m_sot_length, p_manager); + } + else + { + l_current_read_size = 0; + } if (l_current_read_size != p_j2k->m_specific_param.m_decoder.m_sot_length) { p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC; @@ -4245,24 +4439,23 @@ opj_bool opj_j2k_read_sod (opj_j2k_v2_t *p_j2k, p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPHSOT; } - *l_tile_len += l_current_read_size; + *l_tile_len += (OPJ_UINT32)l_current_read_size; return OPJ_TRUE; } - opj_bool opj_j2k_write_rgn(opj_j2k_v2_t *p_j2k, - OPJ_UINT32 p_tile_no, - OPJ_UINT32 p_comp_no, - opj_stream_private_t *p_stream, - opj_event_mgr_t * p_manager + OPJ_BOOL opj_j2k_write_rgn(opj_j2k_t *p_j2k, + OPJ_UINT32 p_tile_no, + OPJ_UINT32 p_comp_no, + OPJ_UINT32 nb_comps, + opj_stream_private_t *p_stream, + opj_event_mgr_t * p_manager ) { OPJ_BYTE * l_current_data = 00; - OPJ_UINT32 l_nb_comp; OPJ_UINT32 l_rgn_size; - opj_image_t *l_image = 00; - opj_cp_v2_t *l_cp = 00; - opj_tcp_v2_t *l_tcp = 00; + opj_cp_t *l_cp = 00; + opj_tcp_t *l_tcp = 00; opj_tccp_t *l_tccp = 00; OPJ_UINT32 l_comp_room; @@ -4275,9 +4468,7 @@ opj_bool opj_j2k_read_sod (opj_j2k_v2_t *p_j2k, l_tcp = &l_cp->tcps[p_tile_no]; l_tccp = &l_tcp->tccps[p_comp_no]; - l_nb_comp = l_image->numcomps; - - if (l_nb_comp <= 256) { + if (nb_comps <= 256) { l_comp_room = 1; } else { @@ -4294,13 +4485,13 @@ opj_bool opj_j2k_read_sod (opj_j2k_v2_t *p_j2k, opj_write_bytes(l_current_data,l_rgn_size-2,2); /* Lrgn */ l_current_data += 2; - opj_write_bytes(l_current_data,p_comp_no,l_comp_room); /* Crgn */ + opj_write_bytes(l_current_data,p_comp_no,l_comp_room); /* Crgn */ l_current_data+=l_comp_room; - opj_write_bytes(l_current_data, 0,1); /* Srgn */ + opj_write_bytes(l_current_data, 0,1); /* Srgn */ ++l_current_data; - opj_write_bytes(l_current_data, l_tccp->roishift,1); /* SPrgn */ + opj_write_bytes(l_current_data, (OPJ_UINT32)l_tccp->roishift,1); /* SPrgn */ ++l_current_data; if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_rgn_size,p_manager) != l_rgn_size) { @@ -4310,7 +4501,7 @@ opj_bool opj_j2k_read_sod (opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_eoc( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_eoc( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) @@ -4326,7 +4517,7 @@ opj_bool opj_j2k_write_eoc( opj_j2k_v2_t *p_j2k, #ifdef USE_JPWL /* update markers struct */ /* - opj_bool res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_EOC, p_stream_tell(p_stream) - 2, 2); + OPJ_BOOL res = j2k_add_marker(p_j2k->cstr_info, J2K_MS_EOC, p_stream_tell(p_stream) - 2, 2); */ #endif /* USE_JPWL */ @@ -4349,7 +4540,7 @@ opj_bool opj_j2k_write_eoc( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the POC marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_rgn (opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_rgn (opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager @@ -4358,8 +4549,8 @@ static opj_bool opj_j2k_read_rgn (opj_j2k_v2_t *p_j2k, OPJ_UINT32 l_nb_comp; opj_image_t * l_image = 00; - opj_cp_v2_t *l_cp = 00; - opj_tcp_v2_t *l_tcp = 00; + opj_cp_t *l_cp = 00; + opj_tcp_t *l_tcp = 00; OPJ_UINT32 l_comp_room, l_comp_no, l_roi_sty; /* preconditions*/ @@ -4376,7 +4567,7 @@ static opj_bool opj_j2k_read_rgn (opj_j2k_v2_t *p_j2k, l_comp_room = 2; } if (p_header_size != 2 + l_comp_room) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading RGN marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading RGN marker\n"); return OPJ_FALSE; } @@ -4394,17 +4585,25 @@ static opj_bool opj_j2k_read_rgn (opj_j2k_v2_t *p_j2k, if (l_cp->correct) { /* totlen is negative or larger than the bytes left!!! */ if (l_comp_room >= l_nb_comp) { - opj_event_msg_v2(p_manager, EVT_ERROR, + opj_event_msg(p_manager, EVT_ERROR, "JPWL: bad component number in RGN (%d when there are only %d)\n", l_comp_room, l_nb_comp); if (!JPWL_ASSUME || JPWL_ASSUME) { - opj_event_msg_v2(p_manager, EVT_ERROR, "JPWL: giving up\n"); + opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n"); return OPJ_FALSE; } } }; #endif /* USE_JPWL */ + /* testcase 3635.pdf.asan.77.2930 */ + if (l_comp_no >= l_nb_comp) { + opj_event_msg(p_manager, EVT_ERROR, + "bad component number in RGN (%d when there are only %d)\n", + l_comp_no, l_nb_comp); + return OPJ_FALSE; + } + opj_read_bytes(p_header_data,(OPJ_UINT32 *) (&(l_tcp->tccps[l_comp_no].roishift)),1); /* SPrgn */ ++p_header_data; @@ -4412,24 +4611,24 @@ static opj_bool opj_j2k_read_rgn (opj_j2k_v2_t *p_j2k, } -OPJ_FLOAT32 opj_j2k_get_tp_stride (opj_tcp_v2_t * p_tcp) +OPJ_FLOAT32 opj_j2k_get_tp_stride (opj_tcp_t * p_tcp) { return (OPJ_FLOAT32) ((p_tcp->m_nb_tile_parts - 1) * 14); } -OPJ_FLOAT32 opj_j2k_get_default_stride (opj_tcp_v2_t * p_tcp) +OPJ_FLOAT32 opj_j2k_get_default_stride (opj_tcp_t * p_tcp) { (void)p_tcp; return 0; } -opj_bool opj_j2k_update_rates( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_update_rates( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) { - opj_cp_v2_t * l_cp = 00; + opj_cp_t * l_cp = 00; opj_image_t * l_image = 00; - opj_tcp_v2_t * l_tcp = 00; + opj_tcp_t * l_tcp = 00; opj_image_comp_t * l_img_comp = 00; OPJ_UINT32 i,j,k; @@ -4439,7 +4638,7 @@ opj_bool opj_j2k_update_rates( opj_j2k_v2_t *p_j2k, OPJ_UINT32 l_bits_empty, l_size_pixel; OPJ_UINT32 l_tile_size = 0; OPJ_UINT32 l_last_res; - OPJ_FLOAT32 (* l_tp_stride_func)(opj_tcp_v2_t *) = 00; + OPJ_FLOAT32 (* l_tp_stride_func)(opj_tcp_t *) = 00; /* preconditions */ assert(p_j2k != 00); @@ -4452,7 +4651,7 @@ opj_bool opj_j2k_update_rates( opj_j2k_v2_t *p_j2k, l_bits_empty = 8 * l_image->comps->dx * l_image->comps->dy; l_size_pixel = l_image->numcomps * l_image->comps->prec; - l_sot_remove = ((OPJ_FLOAT32) opj_stream_tell(p_stream)) / (l_cp->th * l_cp->tw); + l_sot_remove = (OPJ_FLOAT32) opj_stream_tell(p_stream) / (OPJ_FLOAT32)(l_cp->th * l_cp->tw); if (l_cp->m_specific_param.m_enc.m_tp_on) { l_tp_stride_func = opj_j2k_get_tp_stride; @@ -4463,21 +4662,21 @@ opj_bool opj_j2k_update_rates( opj_j2k_v2_t *p_j2k, for (i=0;ith;++i) { for (j=0;jtw;++j) { - OPJ_FLOAT32 l_offset = ((*l_tp_stride_func)(l_tcp)) / l_tcp->numlayers; + OPJ_FLOAT32 l_offset = (OPJ_FLOAT32)(*l_tp_stride_func)(l_tcp) / (OPJ_FLOAT32)l_tcp->numlayers; /* 4 borders of the tile rescale on the image if necessary */ - l_x0 = opj_int_max(l_cp->tx0 + j * l_cp->tdx, l_image->x0); - l_y0 = opj_int_max(l_cp->ty0 + i * l_cp->tdy, l_image->y0); - l_x1 = opj_int_min(l_cp->tx0 + (j + 1) * l_cp->tdx, l_image->x1); - l_y1 = opj_int_min(l_cp->ty0 + (i + 1) * l_cp->tdy, l_image->y1); + l_x0 = opj_int_max((OPJ_INT32)(l_cp->tx0 + j * l_cp->tdx), (OPJ_INT32)l_image->x0); + l_y0 = opj_int_max((OPJ_INT32)(l_cp->ty0 + i * l_cp->tdy), (OPJ_INT32)l_image->y0); + l_x1 = opj_int_min((OPJ_INT32)(l_cp->tx0 + (j + 1) * l_cp->tdx), (OPJ_INT32)l_image->x1); + l_y1 = opj_int_min((OPJ_INT32)(l_cp->ty0 + (i + 1) * l_cp->tdy), (OPJ_INT32)l_image->y1); l_rates = l_tcp->rates; /* Modification of the RATE >> */ if (*l_rates) { - *l_rates = (( (float) (l_size_pixel * (l_x1 - l_x0) * (l_y1 - l_y0))) + *l_rates = (( (OPJ_FLOAT32) (l_size_pixel * (OPJ_UINT32)(l_x1 - l_x0) * (OPJ_UINT32)(l_y1 - l_y0))) / - ((*l_rates) * l_bits_empty) + ((*l_rates) * (OPJ_FLOAT32)l_bits_empty) ) - l_offset; @@ -4487,9 +4686,9 @@ opj_bool opj_j2k_update_rates( opj_j2k_v2_t *p_j2k, for (k = 1; k < l_tcp->numlayers; ++k) { if (*l_rates) { - *l_rates = (( (OPJ_FLOAT32) (l_size_pixel * (l_x1 - l_x0) * (l_y1 - l_y0))) + *l_rates = (( (OPJ_FLOAT32) (l_size_pixel * (OPJ_UINT32)(l_x1 - l_x0) * (OPJ_UINT32)(l_y1 - l_y0))) / - ((*l_rates) * l_bits_empty) + ((*l_rates) * (OPJ_FLOAT32)l_bits_empty) ) - l_offset; @@ -4571,7 +4770,7 @@ opj_bool opj_j2k_update_rates( opj_j2k_v2_t *p_j2k, return OPJ_FALSE; } - if (l_cp->m_specific_param.m_enc.m_cinema) { + if (OPJ_IS_CINEMA(l_cp->rsiz)) { p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer = (OPJ_BYTE *) opj_malloc(5*p_j2k->m_specific_param.m_encoder.m_total_tile_parts); if (! p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_buffer) { @@ -4585,15 +4784,16 @@ opj_bool opj_j2k_update_rates( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_read_eoc ( opj_j2k_v2_t *p_j2k, +#if 0 +OPJ_BOOL opj_j2k_read_eoc ( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) { OPJ_UINT32 i; - opj_tcd_v2_t * l_tcd = 00; + opj_tcd_t * l_tcd = 00; OPJ_UINT32 l_nb_tiles; - opj_tcp_v2_t * l_tcp = 00; - opj_bool l_success; + opj_tcp_t * l_tcp = 00; + OPJ_BOOL l_success; /* preconditions */ assert(p_j2k != 00); @@ -4605,7 +4805,7 @@ opj_bool opj_j2k_read_eoc ( opj_j2k_v2_t *p_j2k, l_tcd = opj_tcd_create(OPJ_TRUE); if (l_tcd == 00) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n"); + opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n"); return OPJ_FALSE; } @@ -4613,7 +4813,7 @@ opj_bool opj_j2k_read_eoc ( opj_j2k_v2_t *p_j2k, if (l_tcp->m_data) { if (! opj_tcd_init_decode_tile(l_tcd, i)) { opj_tcd_destroy(l_tcd); - opj_event_msg_v2(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n"); + opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n"); return OPJ_FALSE; } @@ -4633,8 +4833,9 @@ opj_bool opj_j2k_read_eoc ( opj_j2k_v2_t *p_j2k, opj_tcd_destroy(l_tcd); return OPJ_TRUE; } +#endif -opj_bool opj_j2k_get_end_header(opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_get_end_header(opj_j2k_t *p_j2k, struct opj_stream_private *p_stream, struct opj_event_mgr * p_manager ) { @@ -4648,14 +4849,14 @@ opj_bool opj_j2k_get_end_header(opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_mct_data_group( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_mct_data_group( opj_j2k_t *p_j2k, struct opj_stream_private *p_stream, struct opj_event_mgr * p_manager ) { OPJ_UINT32 i; opj_simple_mcc_decorrelation_data_t * l_mcc_record; opj_mct_data_t * l_mct_record; - opj_tcp_v2_t * l_tcp; + opj_tcp_t * l_tcp; /* preconditions */ assert(p_j2k != 00); @@ -4696,7 +4897,8 @@ opj_bool opj_j2k_write_mct_data_group( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_image_components(opj_j2k_v2_t *p_j2k, +#if 0 +OPJ_BOOL opj_j2k_write_all_coc(opj_j2k_t *p_j2k, struct opj_stream_private *p_stream, struct opj_event_mgr * p_manager ) { @@ -4707,12 +4909,31 @@ opj_bool opj_j2k_write_image_components(opj_j2k_v2_t *p_j2k, assert(p_manager != 00); assert(p_stream != 00); - for (compno = 1; compno < p_j2k->m_private_image->numcomps; ++compno) + for (compno = 0; compno < p_j2k->m_private_image->numcomps; ++compno) { if (! opj_j2k_write_coc(p_j2k,compno,p_stream, p_manager)) { return OPJ_FALSE; } + } + + return OPJ_TRUE; +} +#endif + +#if 0 +OPJ_BOOL opj_j2k_write_all_qcc(opj_j2k_t *p_j2k, + struct opj_stream_private *p_stream, + struct opj_event_mgr * p_manager ) +{ + OPJ_UINT32 compno; + /* preconditions */ + assert(p_j2k != 00); + assert(p_manager != 00); + assert(p_stream != 00); + + for (compno = 0; compno < p_j2k->m_private_image->numcomps; ++compno) + { if (! opj_j2k_write_qcc(p_j2k,compno,p_stream, p_manager)) { return OPJ_FALSE; } @@ -4720,8 +4941,10 @@ opj_bool opj_j2k_write_image_components(opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } +#endif + -opj_bool opj_j2k_write_regions( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_regions( opj_j2k_t *p_j2k, struct opj_stream_private *p_stream, struct opj_event_mgr * p_manager ) { @@ -4738,7 +4961,7 @@ opj_bool opj_j2k_write_regions( opj_j2k_v2_t *p_j2k, for (compno = 0; compno < p_j2k->m_private_image->numcomps; ++compno) { if (l_tccp->roishift) { - if (! opj_j2k_write_rgn(p_j2k,0,compno,p_stream,p_manager)) { + if (! opj_j2k_write_rgn(p_j2k,0,compno,p_j2k->m_private_image->numcomps,p_stream,p_manager)) { return OPJ_FALSE; } } @@ -4749,7 +4972,7 @@ opj_bool opj_j2k_write_regions( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_epc( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_epc( opj_j2k_t *p_j2k, struct opj_stream_private *p_stream, struct opj_event_mgr * p_manager ) { @@ -4762,12 +4985,12 @@ opj_bool opj_j2k_write_epc( opj_j2k_v2_t *p_j2k, l_cstr_index = p_j2k->cstr_index; if (l_cstr_index) { - l_cstr_index->codestream_size = opj_stream_tell(p_stream); + l_cstr_index->codestream_size = (OPJ_UINT64)opj_stream_tell(p_stream); /* UniPG>> */ /* The following adjustment is done to adjust the codestream size */ /* if SOD is not at 0 in the buffer. Useful in case of JP2, where */ /* the first bunch of bytes is not in the codestream */ - l_cstr_index->codestream_size -= l_cstr_index->main_head_start; + l_cstr_index->codestream_size -= (OPJ_UINT64)l_cstr_index->main_head_start; /* <m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Stream too short\n"); + opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n"); return OPJ_FALSE; } @@ -4820,7 +5043,7 @@ opj_bool opj_j2k_read_unk ( opj_j2k_v2_t *p_j2k, l_marker_handler = opj_j2k_get_marker_handler(l_unknown_marker); if (!(p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Marker is not compliant with its position\n"); + opj_event_msg(p_manager, EVT_ERROR, "Marker is not compliant with its position\n"); return OPJ_FALSE; } else { @@ -4828,11 +5051,11 @@ opj_bool opj_j2k_read_unk ( opj_j2k_v2_t *p_j2k, /* Add the marker to the codestream index*/ if (l_marker_handler->id != J2K_MS_SOT) { - opj_bool res = opj_j2k_add_mhmarker(p_j2k->cstr_index, J2K_MS_UNK, + OPJ_BOOL res = opj_j2k_add_mhmarker(p_j2k->cstr_index, J2K_MS_UNK, (OPJ_UINT32) opj_stream_tell(p_stream) - l_size_unk, l_size_unk); if (res == OPJ_FALSE) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n"); return OPJ_FALSE; } } @@ -4849,7 +5072,7 @@ opj_bool opj_j2k_read_unk ( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_mct_record( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_mct_record( opj_j2k_t *p_j2k, opj_mct_data_t * p_mct_record, struct opj_stream_private *p_stream, struct opj_event_mgr * p_manager ) @@ -4871,7 +5094,7 @@ opj_bool opj_j2k_write_mct_record( opj_j2k_v2_t *p_j2k, opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data); p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL; p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to write MCT marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write MCT marker\n"); return OPJ_FALSE; } p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data; @@ -4915,14 +5138,14 @@ opj_bool opj_j2k_write_mct_record( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the MCT marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_mct ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_mct ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ) { OPJ_UINT32 i; - opj_tcp_v2_t *l_tcp = 00; + opj_tcp_t *l_tcp = 00; OPJ_UINT32 l_tmp; OPJ_UINT32 l_indix; opj_mct_data_t * l_mct_data; @@ -4936,7 +5159,7 @@ static opj_bool opj_j2k_read_mct ( opj_j2k_v2_t *p_j2k, p_j2k->m_specific_param.m_decoder.m_default_tcp; if (p_header_size < 2) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCT marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n"); return OPJ_FALSE; } @@ -4944,12 +5167,12 @@ static opj_bool opj_j2k_read_mct ( opj_j2k_v2_t *p_j2k, opj_read_bytes(p_header_data,&l_tmp,2); /* Zmct */ p_header_data += 2; if (l_tmp != 0) { - opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge mct data within multiple MCT records\n"); + opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge mct data within multiple MCT records\n"); return OPJ_TRUE; } if(p_header_size <= 6) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCT marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n"); return OPJ_FALSE; } @@ -4971,7 +5194,7 @@ static opj_bool opj_j2k_read_mct ( opj_j2k_v2_t *p_j2k, if (i == l_tcp->m_nb_mct_records) { if (l_tcp->m_nb_mct_records == l_tcp->m_nb_max_mct_records) { opj_mct_data_t *new_mct_records; - l_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS; + l_tcp->m_nb_max_mct_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS; new_mct_records = (opj_mct_data_t *) opj_realloc(l_tcp->m_mct_records, l_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t)); if (! new_mct_records) { @@ -4979,7 +5202,7 @@ static opj_bool opj_j2k_read_mct ( opj_j2k_v2_t *p_j2k, l_tcp->m_mct_records = NULL; l_tcp->m_nb_max_mct_records = 0; l_tcp->m_nb_mct_records = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to read MCT marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read MCT marker\n"); return OPJ_FALSE; } l_tcp->m_mct_records = new_mct_records; @@ -5002,7 +5225,7 @@ static opj_bool opj_j2k_read_mct ( opj_j2k_v2_t *p_j2k, opj_read_bytes(p_header_data,&l_tmp,2); /* Ymct */ p_header_data+=2; if (l_tmp != 0) { - opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge multiple MCT markers\n"); + opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple MCT markers\n"); return OPJ_TRUE; } @@ -5010,7 +5233,7 @@ static opj_bool opj_j2k_read_mct ( opj_j2k_v2_t *p_j2k, l_mct_data->m_data = (OPJ_BYTE*)opj_malloc(p_header_size); if (! l_mct_data->m_data) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCT marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading MCT marker\n"); return OPJ_FALSE; } memcpy(l_mct_data->m_data,p_header_data,p_header_size); @@ -5021,7 +5244,7 @@ static opj_bool opj_j2k_read_mct ( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_mcc_record( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_mcc_record( opj_j2k_t *p_j2k, struct opj_simple_mcc_decorrelation_data * p_mcc_record, struct opj_stream_private *p_stream, struct opj_event_mgr * p_manager ) @@ -5055,7 +5278,7 @@ opj_bool opj_j2k_write_mcc_record( opj_j2k_v2_t *p_j2k, opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data); p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL; p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to write MCC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write MCC marker\n"); return OPJ_FALSE; } p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data; @@ -5124,7 +5347,7 @@ opj_bool opj_j2k_write_mcc_record( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_read_mcc ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager ) @@ -5132,7 +5355,7 @@ opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, OPJ_UINT32 i,j; OPJ_UINT32 l_tmp; OPJ_UINT32 l_indix; - opj_tcp_v2_t * l_tcp; + opj_tcp_t * l_tcp; opj_simple_mcc_decorrelation_data_t * l_mcc_record; opj_mct_data_t * l_mct_data; OPJ_UINT32 l_nb_collections; @@ -5149,7 +5372,7 @@ opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, p_j2k->m_specific_param.m_decoder.m_default_tcp; if (p_header_size < 2) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n"); return OPJ_FALSE; } @@ -5157,12 +5380,12 @@ opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, opj_read_bytes(p_header_data,&l_tmp,2); /* Zmcc */ p_header_data += 2; if (l_tmp != 0) { - opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge multiple data spanning\n"); + opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple data spanning\n"); return OPJ_TRUE; } if (p_header_size < 7) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n"); return OPJ_FALSE; } @@ -5182,7 +5405,7 @@ opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, if (i == l_tcp->m_nb_mcc_records) { if (l_tcp->m_nb_mcc_records == l_tcp->m_nb_max_mcc_records) { opj_simple_mcc_decorrelation_data_t *new_mcc_records; - l_tcp->m_nb_max_mcc_records += J2K_MCC_DEFAULT_NB_RECORDS; + l_tcp->m_nb_max_mcc_records += OPJ_J2K_MCC_DEFAULT_NB_RECORDS; new_mcc_records = (opj_simple_mcc_decorrelation_data_t *) opj_realloc( l_tcp->m_mcc_records, l_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t)); @@ -5191,7 +5414,7 @@ opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, l_tcp->m_mcc_records = NULL; l_tcp->m_nb_max_mcc_records = 0; l_tcp->m_nb_mcc_records = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to read MCC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read MCC marker\n"); return OPJ_FALSE; } l_tcp->m_mcc_records = new_mcc_records; @@ -5206,7 +5429,7 @@ opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, opj_read_bytes(p_header_data,&l_tmp,2); /* Ymcc */ p_header_data+=2; if (l_tmp != 0) { - opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge multiple data spanning\n"); + opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple data spanning\n"); return OPJ_TRUE; } @@ -5214,7 +5437,7 @@ opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, p_header_data+=2; if (l_nb_collections > 1) { - opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge multiple collections\n"); + opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple collections\n"); return OPJ_TRUE; } @@ -5222,7 +5445,7 @@ opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, for (i=0;im_nb_comps = l_nb_comps & 0x7fff; if (p_header_size < (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 2)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n"); return OPJ_FALSE; } @@ -5254,7 +5477,7 @@ opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, p_header_data+=l_nb_bytes_by_comp; if (l_tmp != j) { - opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge collections with indix shuffle\n"); + opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections with indix shuffle\n"); return OPJ_TRUE; } } @@ -5266,12 +5489,12 @@ opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, l_nb_comps &= 0x7fff; if (l_nb_comps != l_mcc_record->m_nb_comps) { - opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge collections without same number of indixes\n"); + opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections without same number of indixes\n"); return OPJ_TRUE; } if (p_header_size < (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 3)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n"); return OPJ_FALSE; } @@ -5282,7 +5505,7 @@ opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, p_header_data+=l_nb_bytes_by_comp; if (l_tmp != j) { - opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge collections with indix shuffle\n"); + opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge collections with indix shuffle\n"); return OPJ_TRUE; } } @@ -5306,7 +5529,7 @@ opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, } if (l_mcc_record->m_decorrelation_array == 00) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n"); return OPJ_FALSE; } } @@ -5323,14 +5546,14 @@ opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, } if (l_mcc_record->m_offset_array == 00) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n"); return OPJ_FALSE; } } } if (p_header_size != 0) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading MCC marker\n"); return OPJ_FALSE; } @@ -5339,14 +5562,14 @@ opj_bool opj_j2k_read_mcc ( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_mco( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_mco( opj_j2k_t *p_j2k, struct opj_stream_private *p_stream, struct opj_event_mgr * p_manager ) { OPJ_BYTE * l_current_data = 00; OPJ_UINT32 l_mco_size; - opj_tcp_v2_t * l_tcp = 00; + opj_tcp_t * l_tcp = 00; opj_simple_mcc_decorrelation_data_t * l_mcc_record; OPJ_UINT32 i; @@ -5366,7 +5589,7 @@ opj_bool opj_j2k_write_mco( opj_j2k_v2_t *p_j2k, opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data); p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL; p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to write MCO marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write MCO marker\n"); return OPJ_FALSE; } p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data; @@ -5405,7 +5628,7 @@ opj_bool opj_j2k_write_mco( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the MCO marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_mco ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_mco ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager @@ -5413,10 +5636,9 @@ static opj_bool opj_j2k_read_mco ( opj_j2k_v2_t *p_j2k, { OPJ_UINT32 l_tmp, i; OPJ_UINT32 l_nb_stages; - opj_tcp_v2_t * l_tcp; + opj_tcp_t * l_tcp; opj_tccp_t * l_tccp; opj_image_t * l_image; - opj_image_comp_t * l_img_comp; /* preconditions */ assert(p_header_data != 00); @@ -5429,7 +5651,7 @@ static opj_bool opj_j2k_read_mco ( opj_j2k_v2_t *p_j2k, p_j2k->m_specific_param.m_decoder.m_default_tcp; if (p_header_size < 1) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCO marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading MCO marker\n"); return OPJ_FALSE; } @@ -5437,17 +5659,16 @@ static opj_bool opj_j2k_read_mco ( opj_j2k_v2_t *p_j2k, ++p_header_data; if (l_nb_stages > 1) { - opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge multiple transformation stages.\n"); + opj_event_msg(p_manager, EVT_WARNING, "Cannot take in charge multiple transformation stages.\n"); return OPJ_TRUE; } if (p_header_size != l_nb_stages + 1) { - opj_event_msg_v2(p_manager, EVT_WARNING, "Error reading MCO marker\n"); + opj_event_msg(p_manager, EVT_WARNING, "Error reading MCO marker\n"); return OPJ_FALSE; } l_tccp = l_tcp->tccps; - l_img_comp = l_image->comps; for (i=0;inumcomps;++i) { l_tccp->m_dc_level_shift = 0; @@ -5471,7 +5692,7 @@ static opj_bool opj_j2k_read_mco ( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_add_mct(opj_tcp_v2_t * p_tcp, opj_image_t * p_image, OPJ_UINT32 p_index) +OPJ_BOOL opj_j2k_add_mct(opj_tcp_t * p_tcp, opj_image_t * p_image, OPJ_UINT32 p_index) { OPJ_UINT32 i; opj_simple_mcc_decorrelation_data_t * l_mcc_record; @@ -5511,7 +5732,7 @@ opj_bool opj_j2k_add_mct(opj_tcp_v2_t * p_tcp, opj_image_t * p_image, OPJ_UINT32 } l_nb_elem = p_image->numcomps * p_image->numcomps; - l_mct_size = l_nb_elem * sizeof(OPJ_FLOAT32); + l_mct_size = l_nb_elem * (OPJ_UINT32)sizeof(OPJ_FLOAT32); p_tcp->m_mct_decoding_matrix = (OPJ_FLOAT32*)opj_malloc(l_mct_size); if (! p_tcp->m_mct_decoding_matrix ) { @@ -5530,7 +5751,7 @@ opj_bool opj_j2k_add_mct(opj_tcp_v2_t * p_tcp, opj_image_t * p_image, OPJ_UINT32 } l_nb_elem = p_image->numcomps; - l_offset_size = l_nb_elem * sizeof(OPJ_UINT32); + l_offset_size = l_nb_elem * (OPJ_UINT32)sizeof(OPJ_UINT32); l_offset_data = (OPJ_UINT32*)opj_malloc(l_offset_size); if (! l_offset_data ) { @@ -5543,7 +5764,7 @@ opj_bool opj_j2k_add_mct(opj_tcp_v2_t * p_tcp, opj_image_t * p_image, OPJ_UINT32 l_current_offset_data = l_offset_data; for (i=0;inumcomps;++i) { - l_tccp->m_dc_level_shift = *(l_current_offset_data++); + l_tccp->m_dc_level_shift = (OPJ_INT32)*(l_current_offset_data++); ++l_tccp; } @@ -5553,7 +5774,7 @@ opj_bool opj_j2k_add_mct(opj_tcp_v2_t * p_tcp, opj_image_t * p_image, OPJ_UINT32 return OPJ_TRUE; } -opj_bool opj_j2k_write_cbd( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_cbd( opj_j2k_t *p_j2k, struct opj_stream_private *p_stream, struct opj_event_mgr * p_manager ) { @@ -5577,7 +5798,7 @@ opj_bool opj_j2k_write_cbd( opj_j2k_v2_t *p_j2k, opj_free(p_j2k->m_specific_param.m_encoder.m_header_tile_data); p_j2k->m_specific_param.m_encoder.m_header_tile_data = NULL; p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to write CBD marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to write CBD marker\n"); return OPJ_FALSE; } p_j2k->m_specific_param.m_encoder.m_header_tile_data = new_header_tile_data; @@ -5618,7 +5839,7 @@ opj_bool opj_j2k_write_cbd( opj_j2k_v2_t *p_j2k, * @param p_header_size the size of the data contained in the CBD marker. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_read_cbd ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_read_cbd ( opj_j2k_t *p_j2k, OPJ_BYTE * p_header_data, OPJ_UINT32 p_header_size, opj_event_mgr_t * p_manager @@ -5637,7 +5858,7 @@ static opj_bool opj_j2k_read_cbd ( opj_j2k_v2_t *p_j2k, l_num_comp = p_j2k->m_private_image->numcomps; if (p_header_size != (p_j2k->m_private_image->numcomps + 2)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Crror reading CBD marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Crror reading CBD marker\n"); return OPJ_FALSE; } @@ -5645,7 +5866,7 @@ static opj_bool opj_j2k_read_cbd ( opj_j2k_v2_t *p_j2k, p_header_data+=2; if (l_nb_comp != l_num_comp) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Crror reading CBD marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Crror reading CBD marker\n"); return OPJ_FALSE; } @@ -5665,7 +5886,7 @@ static opj_bool opj_j2k_read_cbd ( opj_j2k_v2_t *p_j2k, /* J2K / JPT decoder interface */ /* ----------------------------------------------------------------------- */ -void opj_j2k_setup_decoder(opj_j2k_v2_t *j2k, opj_dparameters_t *parameters) +void opj_j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters) { if(j2k && parameters) { j2k->m_cp.m_specific_param.m_dec.m_layer = parameters->cp_layer; @@ -5683,25 +5904,24 @@ void opj_j2k_setup_decoder(opj_j2k_v2_t *j2k, opj_dparameters_t *parameters) /* J2K encoder interface */ /* ----------------------------------------------------------------------- */ -opj_j2k_v2_t* opj_j2k_create_compress(void) +opj_j2k_t* opj_j2k_create_compress(void) { - opj_j2k_v2_t *l_j2k = (opj_j2k_v2_t*) opj_malloc(sizeof(opj_j2k_v2_t)); + opj_j2k_t *l_j2k = (opj_j2k_t*) opj_calloc(1,sizeof(opj_j2k_t)); if (!l_j2k) { return NULL; } - memset(l_j2k,0,sizeof(opj_j2k_v2_t)); l_j2k->m_is_decoder = 0; l_j2k->m_cp.m_is_decoder = 0; - l_j2k->m_specific_param.m_encoder.m_header_tile_data = (OPJ_BYTE *) opj_malloc(J2K_DEFAULT_HEADER_SIZE); + l_j2k->m_specific_param.m_encoder.m_header_tile_data = (OPJ_BYTE *) opj_malloc(OPJ_J2K_DEFAULT_HEADER_SIZE); if (! l_j2k->m_specific_param.m_encoder.m_header_tile_data) { opj_j2k_destroy(l_j2k); return NULL; } - l_j2k->m_specific_param.m_encoder.m_header_tile_data_size = J2K_DEFAULT_HEADER_SIZE; + l_j2k->m_specific_param.m_encoder.m_header_tile_data_size = OPJ_J2K_DEFAULT_HEADER_SIZE; /* validation list creation*/ l_j2k->m_validation_list = opj_procedure_list_create(); @@ -5720,17 +5940,238 @@ opj_j2k_v2_t* opj_j2k_create_compress(void) return l_j2k; } -void opj_j2k_setup_encoder( opj_j2k_v2_t *p_j2k, +int opj_j2k_initialise_4K_poc(opj_poc_t *POC, int numres){ + POC[0].tile = 1; + POC[0].resno0 = 0; + POC[0].compno0 = 0; + POC[0].layno1 = 1; + POC[0].resno1 = (OPJ_UINT32)(numres-1); + POC[0].compno1 = 3; + POC[0].prg1 = OPJ_CPRL; + POC[1].tile = 1; + POC[1].resno0 = (OPJ_UINT32)(numres-1); + POC[1].compno0 = 0; + POC[1].layno1 = 1; + POC[1].resno1 = (OPJ_UINT32)numres; + POC[1].compno1 = 3; + POC[1].prg1 = OPJ_CPRL; + return 2; +} + +void opj_j2k_set_cinema_parameters(opj_cparameters_t *parameters, opj_image_t *image, opj_event_mgr_t *p_manager) +{ + /* Configure cinema parameters */ + int i; + + /* No tiling */ + parameters->tile_size_on = OPJ_FALSE; + parameters->cp_tdx=1; + parameters->cp_tdy=1; + + /* One tile part for each component */ + parameters->tp_flag = 'C'; + parameters->tp_on = 1; + + /* Tile and Image shall be at (0,0) */ + parameters->cp_tx0 = 0; + parameters->cp_ty0 = 0; + parameters->image_offset_x0 = 0; + parameters->image_offset_y0 = 0; + + /* Codeblock size= 32*32 */ + parameters->cblockw_init = 32; + parameters->cblockh_init = 32; + + /* Codeblock style: no mode switch enabled */ + parameters->mode = 0; + + /* No ROI */ + parameters->roi_compno = -1; + + /* No subsampling */ + parameters->subsampling_dx = 1; + parameters->subsampling_dy = 1; + + /* 9-7 transform */ + parameters->irreversible = 1; + + /* Number of layers */ + if (parameters->tcp_numlayers > 1){ + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Profile-3 and 4 (2k/4k dc profile) requires:\n" + "1 single quality layer" + "-> Number of layers forced to 1 (rather than %d)\n" + "-> Rate of the last layer (%3.1f) will be used", + parameters->tcp_numlayers, parameters->tcp_rates[parameters->tcp_numlayers-1]); + parameters->tcp_rates[0] = parameters->tcp_rates[parameters->tcp_numlayers-1]; + parameters->tcp_numlayers = 1; + } + + /* Resolution levels */ + switch (parameters->rsiz){ + case OPJ_PROFILE_CINEMA_2K: + if(parameters->numresolution > 6){ + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Profile-3 (2k dc profile) requires:\n" + "Number of decomposition levels <= 5\n" + "-> Number of decomposition levels forced to 5 (rather than %d)\n", + parameters->numresolution+1); + parameters->numresolution = 6; + } + break; + case OPJ_PROFILE_CINEMA_4K: + if(parameters->numresolution < 2){ + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Profile-4 (4k dc profile) requires:\n" + "Number of decomposition levels >= 1 && <= 6\n" + "-> Number of decomposition levels forced to 1 (rather than %d)\n", + parameters->numresolution+1); + parameters->numresolution = 1; + }else if(parameters->numresolution > 7){ + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Profile-4 (4k dc profile) requires:\n" + "Number of decomposition levels >= 1 && <= 6\n" + "-> Number of decomposition levels forced to 6 (rather than %d)\n", + parameters->numresolution+1); + parameters->numresolution = 7; + } + break; + default : + break; + } + + /* Precincts */ + parameters->csty |= 0x01; + parameters->res_spec = parameters->numresolution-1; + for (i = 0; ires_spec; i++) { + parameters->prcw_init[i] = 256; + parameters->prch_init[i] = 256; + } + + /* The progression order shall be CPRL */ + parameters->prog_order = OPJ_CPRL; + + /* Progression order changes for 4K, disallowed for 2K */ + if (parameters->rsiz == OPJ_PROFILE_CINEMA_4K) { + parameters->numpocs = (OPJ_UINT32)opj_j2k_initialise_4K_poc(parameters->POC,parameters->numresolution); + } else { + parameters->numpocs = 0; + } + + /* Limited bit-rate */ + parameters->cp_disto_alloc = 1; + if (parameters->max_cs_size <= 0) { + /* No rate has been introduced, 24 fps is assumed */ + parameters->max_cs_size = OPJ_CINEMA_24_CS; + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Profile-3 and 4 (2k/4k dc profile) requires:\n" + "Maximum 1302083 compressed bytes @ 24fps\n" + "As no rate has been given, this limit will be used.\n"); + } else if (parameters->max_cs_size > OPJ_CINEMA_24_CS) { + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Profile-3 and 4 (2k/4k dc profile) requires:\n" + "Maximum 1302083 compressed bytes @ 24fps\n" + "-> Specified rate exceeds this limit. Rate will be forced to 1302083 bytes.\n"); + parameters->max_cs_size = OPJ_CINEMA_24_CS; + } + + if (parameters->max_comp_size <= 0) { + /* No rate has been introduced, 24 fps is assumed */ + parameters->max_comp_size = OPJ_CINEMA_24_COMP; + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Profile-3 and 4 (2k/4k dc profile) requires:\n" + "Maximum 1041666 compressed bytes @ 24fps\n" + "As no rate has been given, this limit will be used.\n"); + } else if (parameters->max_comp_size > OPJ_CINEMA_24_COMP) { + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Profile-3 and 4 (2k/4k dc profile) requires:\n" + "Maximum 1041666 compressed bytes @ 24fps\n" + "-> Specified rate exceeds this limit. Rate will be forced to 1041666 bytes.\n"); + parameters->max_comp_size = OPJ_CINEMA_24_COMP; + } + + parameters->tcp_rates[0] = (OPJ_FLOAT32) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec)/ + (OPJ_FLOAT32)(((OPJ_UINT32)parameters->max_cs_size) * 8 * image->comps[0].dx * image->comps[0].dy); + +} + +OPJ_BOOL opj_j2k_is_cinema_compliant(opj_image_t *image, OPJ_UINT16 rsiz, opj_event_mgr_t *p_manager) +{ + OPJ_UINT32 i; + + /* Number of components */ + if (image->numcomps != 3){ + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Profile-3 (2k dc profile) requires:\n" + "3 components" + "-> Number of components of input image (%d) is not compliant\n" + "-> Non-profile-3 codestream will be generated\n", + image->numcomps); + return OPJ_FALSE; + } + + /* Bitdepth */ + for (i = 0; i < image->numcomps; i++) { + if ((image->comps[i].bpp != 12) | (image->comps[i].sgnd)){ + char signed_str[] = "signed"; + char unsigned_str[] = "unsigned"; + char *tmp_str = image->comps[i].sgnd?signed_str:unsigned_str; + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Profile-3 (2k dc profile) requires:\n" + "Precision of each component shall be 12 bits unsigned" + "-> At least component %d of input image (%d bits, %s) is not compliant\n" + "-> Non-profile-3 codestream will be generated\n", + i,image->comps[i].bpp, tmp_str); + return OPJ_FALSE; + } + } + + /* Image size */ + switch (rsiz){ + case OPJ_PROFILE_CINEMA_2K: + if (((image->comps[0].w > 2048) | (image->comps[0].h > 1080))){ + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Profile-3 (2k dc profile) requires:\n" + "width <= 2048 and height <= 1080\n" + "-> Input image size %d x %d is not compliant\n" + "-> Non-profile-3 codestream will be generated\n", + image->comps[0].w,image->comps[0].h); + return OPJ_FALSE; + } + break; + case OPJ_PROFILE_CINEMA_4K: + if (((image->comps[0].w > 4096) | (image->comps[0].h > 2160))){ + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Profile-4 (4k dc profile) requires:\n" + "width <= 4096 and height <= 2160\n" + "-> Image size %d x %d is not compliant\n" + "-> Non-profile-4 codestream will be generated\n", + image->comps[0].w,image->comps[0].h); + return OPJ_FALSE; + } + break; + default : + break; + } + + return OPJ_TRUE; +} + +OPJ_BOOL opj_j2k_setup_encoder( opj_j2k_t *p_j2k, opj_cparameters_t *parameters, opj_image_t *image, opj_event_mgr_t * p_manager) { OPJ_UINT32 i, j, tileno, numpocs_tile; - opj_cp_v2_t *cp = 00; - opj_bool l_res; + opj_cp_t *cp = 00; if(!p_j2k || !parameters || ! image) { - return; + return OPJ_FALSE; + } + + if ((parameters->numresolution <= 0) || (parameters->numresolution > OPJ_J2K_MAXRLVLS)) { + opj_event_msg(p_manager, EVT_ERROR, "Invalid number of resolutions : %d not in range [1,%d]\n", parameters->numresolution, OPJ_J2K_MAXRLVLS); + return OPJ_FALSE; } /* keep a link to cp so that we can destroy it later in j2k_destroy_compress */ @@ -5740,53 +6181,200 @@ void opj_j2k_setup_encoder( opj_j2k_v2_t *p_j2k, cp->tw = 1; cp->th = 1; + /* FIXME ADE: to be removed once deprecated cp_cinema and cp_rsiz have been removed */ + if (parameters->rsiz == OPJ_PROFILE_NONE) { /* consider deprecated fields only if RSIZ has not been set */ + OPJ_BOOL deprecated_used = OPJ_FALSE; + switch (parameters->cp_cinema){ + case OPJ_CINEMA2K_24: + parameters->rsiz = OPJ_PROFILE_CINEMA_2K; + parameters->max_cs_size = OPJ_CINEMA_24_CS; + parameters->max_comp_size = OPJ_CINEMA_24_COMP; + deprecated_used = OPJ_TRUE; + break; + case OPJ_CINEMA2K_48: + parameters->rsiz = OPJ_PROFILE_CINEMA_2K; + parameters->max_cs_size = OPJ_CINEMA_48_CS; + parameters->max_comp_size = OPJ_CINEMA_48_COMP; + deprecated_used = OPJ_TRUE; + break; + case OPJ_CINEMA4K_24: + parameters->rsiz = OPJ_PROFILE_CINEMA_4K; + parameters->max_cs_size = OPJ_CINEMA_24_CS; + parameters->max_comp_size = OPJ_CINEMA_24_COMP; + deprecated_used = OPJ_TRUE; + break; + case OPJ_OFF: + default: + break; + } + switch (parameters->cp_rsiz){ + case OPJ_CINEMA2K: + parameters->rsiz = OPJ_PROFILE_CINEMA_2K; + deprecated_used = OPJ_TRUE; + break; + case OPJ_CINEMA4K: + parameters->rsiz = OPJ_PROFILE_CINEMA_4K; + deprecated_used = OPJ_TRUE; + break; + case OPJ_MCT: + parameters->rsiz = OPJ_PROFILE_PART2 | OPJ_EXTENSION_MCT; + deprecated_used = OPJ_TRUE; + case OPJ_STD_RSIZ: + default: + break; + } + if (deprecated_used) { + opj_event_msg(p_manager, EVT_WARNING, + "Deprecated fields cp_cinema or cp_rsiz are used\n" + "Please consider using only the rsiz field\n" + "See openjpeg.h documentation for more details\n"); + } + } + + /* see if max_codestream_size does limit input rate */ + if (parameters->max_cs_size <= 0) { + if (parameters->tcp_rates[parameters->tcp_numlayers-1] > 0) { + OPJ_FLOAT32 temp_size; + temp_size =(OPJ_FLOAT32)(image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec)/ + (parameters->tcp_rates[parameters->tcp_numlayers-1] * 8 * (OPJ_FLOAT32)image->comps[0].dx * (OPJ_FLOAT32)image->comps[0].dy); + parameters->max_cs_size = (int) floor(temp_size); + } else { + parameters->max_cs_size = 0; + } + } else { + OPJ_FLOAT32 temp_rate; + OPJ_BOOL cap = OPJ_FALSE; + temp_rate = (OPJ_FLOAT32) (image->numcomps * image->comps[0].w * image->comps[0].h * image->comps[0].prec)/ + (OPJ_FLOAT32)(((OPJ_UINT32)parameters->max_cs_size) * 8 * image->comps[0].dx * image->comps[0].dy); + for (i = 0; i < (OPJ_UINT32) parameters->tcp_numlayers; i++) { + if (parameters->tcp_rates[i] < temp_rate) { + parameters->tcp_rates[i] = temp_rate; + cap = OPJ_TRUE; + } + } + if (cap) { + opj_event_msg(p_manager, EVT_WARNING, + "The desired maximum codestream size has limited\n" + "at least one of the desired quality layers\n"); + } + } + + /* Manage profiles and applications and set RSIZ */ + /* set cinema parameters if required */ + if (OPJ_IS_CINEMA(parameters->rsiz)){ + if ((parameters->rsiz == OPJ_PROFILE_CINEMA_S2K) + || (parameters->rsiz == OPJ_PROFILE_CINEMA_S4K)){ + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Scalable Digital Cinema profiles not yet supported\n"); + parameters->rsiz = OPJ_PROFILE_NONE; + } else { + opj_j2k_set_cinema_parameters(parameters,image,p_manager); + if (!opj_j2k_is_cinema_compliant(image,parameters->rsiz,p_manager)) { + parameters->rsiz = OPJ_PROFILE_NONE; + } + } + } else if (OPJ_IS_STORAGE(parameters->rsiz)) { + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Long Term Storage profile not yet supported\n"); + parameters->rsiz = OPJ_PROFILE_NONE; + } else if (OPJ_IS_BROADCAST(parameters->rsiz)) { + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Broadcast profiles not yet supported\n"); + parameters->rsiz = OPJ_PROFILE_NONE; + } else if (OPJ_IS_IMF(parameters->rsiz)) { + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 IMF profiles not yet supported\n"); + parameters->rsiz = OPJ_PROFILE_NONE; + } else if (OPJ_IS_PART2(parameters->rsiz)) { + if (parameters->rsiz == ((OPJ_PROFILE_PART2) | (OPJ_EXTENSION_NONE))) { + opj_event_msg(p_manager, EVT_WARNING, + "JPEG 2000 Part-2 profile defined\n" + "but no Part-2 extension enabled.\n" + "Profile set to NONE.\n"); + parameters->rsiz = OPJ_PROFILE_NONE; + } else if (parameters->rsiz != ((OPJ_PROFILE_PART2) | (OPJ_EXTENSION_MCT))) { + opj_event_msg(p_manager, EVT_WARNING, + "Unsupported Part-2 extension enabled\n" + "Profile set to NONE.\n"); + parameters->rsiz = OPJ_PROFILE_NONE; + } + } + /* copy user encoding parameters */ - cp->m_specific_param.m_enc.m_cinema = parameters->cp_cinema; - cp->m_specific_param.m_enc.m_max_comp_size = parameters->max_comp_size; - cp->rsiz = parameters->cp_rsiz; - cp->m_specific_param.m_enc.m_disto_alloc = parameters->cp_disto_alloc; - cp->m_specific_param.m_enc.m_fixed_alloc = parameters->cp_fixed_alloc; - cp->m_specific_param.m_enc.m_fixed_quality = parameters->cp_fixed_quality; + cp->m_specific_param.m_enc.m_max_comp_size = (OPJ_UINT32)parameters->max_comp_size; + cp->rsiz = parameters->rsiz; + cp->m_specific_param.m_enc.m_disto_alloc = (OPJ_UINT32)parameters->cp_disto_alloc & 1u; + cp->m_specific_param.m_enc.m_fixed_alloc = (OPJ_UINT32)parameters->cp_fixed_alloc & 1u; + cp->m_specific_param.m_enc.m_fixed_quality = (OPJ_UINT32)parameters->cp_fixed_quality & 1u; /* mod fixed_quality */ - if (parameters->cp_matrice) { - size_t array_size = parameters->tcp_numlayers * parameters->numresolution * 3 * sizeof(OPJ_INT32); + if (parameters->cp_fixed_alloc && parameters->cp_matrice) { + size_t array_size = (size_t)parameters->tcp_numlayers * (size_t)parameters->numresolution * 3 * sizeof(OPJ_INT32); cp->m_specific_param.m_enc.m_matrice = (OPJ_INT32 *) opj_malloc(array_size); + if (!cp->m_specific_param.m_enc.m_matrice) { + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to allocate copy of user encoding parameters matrix \n"); + return OPJ_FALSE; + } memcpy(cp->m_specific_param.m_enc.m_matrice, parameters->cp_matrice, array_size); } /* tiles */ - cp->tdx = parameters->cp_tdx; - cp->tdy = parameters->cp_tdy; + cp->tdx = (OPJ_UINT32)parameters->cp_tdx; + cp->tdy = (OPJ_UINT32)parameters->cp_tdy; /* tile offset */ - cp->tx0 = parameters->cp_tx0; - cp->ty0 = parameters->cp_ty0; + cp->tx0 = (OPJ_UINT32)parameters->cp_tx0; + cp->ty0 = (OPJ_UINT32)parameters->cp_ty0; /* comment string */ if(parameters->cp_comment) { - cp->comment = (char*)opj_malloc(strlen(parameters->cp_comment) + 1); - if(cp->comment) { - strcpy(cp->comment, parameters->cp_comment); - } - } + cp->comment = (char*)opj_malloc(strlen(parameters->cp_comment) + 1U); + if(!cp->comment) { + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to allocate copy of comment string\n"); + return OPJ_FALSE; + } + strcpy(cp->comment, parameters->cp_comment); + } else { + /* Create default comment for codestream */ + const char comment[] = "Created by OpenJPEG version "; + const size_t clen = strlen(comment); + const char *version = opj_version(); + + /* UniPG>> */ +#ifdef USE_JPWL + cp->comment = (char*)opj_malloc(clen+strlen(version)+11); + if(!cp->comment) { + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to allocate comment string\n"); + return OPJ_FALSE; + } + sprintf(cp->comment,"%s%s with JPWL", comment, version); +#else + cp->comment = (char*)opj_malloc(clen+strlen(version)+1); + if(!cp->comment) { + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to allocate comment string\n"); + return OPJ_FALSE; + } + sprintf(cp->comment,"%s%s", comment, version); +#endif + /* <tile_size_on) { - cp->tw = opj_int_ceildiv(image->x1 - cp->tx0, cp->tdx); - cp->th = opj_int_ceildiv(image->y1 - cp->ty0, cp->tdy); + cp->tw = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(image->x1 - cp->tx0), (OPJ_INT32)cp->tdx); + cp->th = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)(image->y1 - cp->ty0), (OPJ_INT32)cp->tdy); } else { cp->tdx = image->x1 - cp->tx0; cp->tdy = image->y1 - cp->ty0; } if (parameters->tp_on) { - cp->m_specific_param.m_enc.m_tp_flag = parameters->tp_flag; + cp->m_specific_param.m_enc.m_tp_flag = (OPJ_BYTE)parameters->tp_flag; cp->m_specific_param.m_enc.m_tp_on = 1; } @@ -5848,19 +6436,23 @@ void opj_j2k_setup_encoder( opj_j2k_v2_t *p_j2k, /* initialize the mutiple tiles */ /* ---------------------------- */ - cp->tcps = (opj_tcp_v2_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tcp_v2_t)); + cp->tcps = (opj_tcp_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tcp_t)); + if (!cp->tcps) { + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to allocate tile coding parameters\n"); + return OPJ_FALSE; + } if (parameters->numpocs) { /* initialisation of POC */ - l_res = opj_j2k_check_poc_val(parameters->POC,parameters->numpocs, parameters->numresolution, image->numcomps, parameters->tcp_numlayers, p_manager); - /* TODO */ + opj_j2k_check_poc_val(parameters->POC,parameters->numpocs, (OPJ_UINT32)parameters->numresolution, image->numcomps, (OPJ_UINT32)parameters->tcp_numlayers, p_manager); + /* TODO MSD use the return value*/ } for (tileno = 0; tileno < cp->tw * cp->th; tileno++) { - opj_tcp_v2_t *tcp = &cp->tcps[tileno]; - tcp->numlayers = parameters->tcp_numlayers; + opj_tcp_t *tcp = &cp->tcps[tileno]; + tcp->numlayers = (OPJ_UINT32)parameters->tcp_numlayers; for (j = 0; j < tcp->numlayers; j++) { - if(cp->m_specific_param.m_enc.m_cinema){ + if(OPJ_IS_CINEMA(cp->rsiz)){ if (cp->m_specific_param.m_enc.m_fixed_quality) { tcp->distoratio[j] = parameters->tcp_distoratio[j]; } @@ -5874,9 +6466,9 @@ void opj_j2k_setup_encoder( opj_j2k_v2_t *p_j2k, } } - tcp->csty = parameters->csty; + tcp->csty = (OPJ_UINT32)parameters->csty; tcp->prg = parameters->prog_order; - tcp->mct = parameters->tcp_mct; + tcp->mct = (OPJ_UINT32)parameters->tcp_mct; numpocs_tile = 0; tcp->POC = 0; @@ -5884,9 +6476,8 @@ void opj_j2k_setup_encoder( opj_j2k_v2_t *p_j2k, if (parameters->numpocs) { /* initialisation of POC */ tcp->POC = 1; - /* TODO */ - for (i = 0; i < (unsigned int) parameters->numpocs; i++) { - if((tileno == parameters->POC[i].tile - 1) || (parameters->POC[i].tile == -1)) { + for (i = 0; i < parameters->numpocs; i++) { + if (tileno + 1 == parameters->POC[i].tile ) { opj_poc_t *tcp_poc = &tcp->pocs[numpocs_tile]; tcp_poc->resno0 = parameters->POC[numpocs_tile].resno0; @@ -5907,24 +6498,54 @@ void opj_j2k_setup_encoder( opj_j2k_v2_t *p_j2k, } tcp->tccps = (opj_tccp_t*) opj_calloc(image->numcomps, sizeof(opj_tccp_t)); - + if (!tcp->tccps) { + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to allocate tile component coding parameters\n"); + return OPJ_FALSE; + } if (parameters->mct_data) { - OPJ_UINT32 lMctSize = image->numcomps * image->numcomps * sizeof(OPJ_FLOAT32); + OPJ_UINT32 lMctSize = image->numcomps * image->numcomps * (OPJ_UINT32)sizeof(OPJ_FLOAT32); OPJ_FLOAT32 * lTmpBuf = (OPJ_FLOAT32*)opj_malloc(lMctSize); OPJ_INT32 * l_dc_shift = (OPJ_INT32 *) ((OPJ_BYTE *) parameters->mct_data + lMctSize); + if (!lTmpBuf) { + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to allocate temp buffer\n"); + return OPJ_FALSE; + } + tcp->mct = 2; tcp->m_mct_coding_matrix = (OPJ_FLOAT32*)opj_malloc(lMctSize); + if (! tcp->m_mct_coding_matrix) { + opj_free(lTmpBuf); + lTmpBuf = NULL; + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to allocate encoder MCT coding matrix \n"); + return OPJ_FALSE; + } memcpy(tcp->m_mct_coding_matrix,parameters->mct_data,lMctSize); memcpy(lTmpBuf,parameters->mct_data,lMctSize); tcp->m_mct_decoding_matrix = (OPJ_FLOAT32*)opj_malloc(lMctSize); - assert(opj_matrix_inversion_f(lTmpBuf,(tcp->m_mct_decoding_matrix),image->numcomps)); + if (! tcp->m_mct_decoding_matrix) { + opj_free(lTmpBuf); + lTmpBuf = NULL; + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to allocate encoder MCT decoding matrix \n"); + return OPJ_FALSE; + } + if(opj_matrix_inversion_f(lTmpBuf,(tcp->m_mct_decoding_matrix),image->numcomps) == OPJ_FALSE) { + opj_free(lTmpBuf); + lTmpBuf = NULL; + opj_event_msg(p_manager, EVT_ERROR, "Failed to inverse encoder MCT decoding matrix \n"); + return OPJ_FALSE; + } tcp->mct_norms = (OPJ_FLOAT64*) opj_malloc(image->numcomps * sizeof(OPJ_FLOAT64)); - + if (! tcp->mct_norms) { + opj_free(lTmpBuf); + lTmpBuf = NULL; + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to allocate encoder MCT norms \n"); + return OPJ_FALSE; + } opj_calculate_norms(tcp->mct_norms,image->numcomps,tcp->m_mct_decoding_matrix); opj_free(lTmpBuf); @@ -5933,9 +6554,22 @@ void opj_j2k_setup_encoder( opj_j2k_v2_t *p_j2k, tccp->m_dc_level_shift = l_dc_shift[i]; } - opj_j2k_setup_mct_encoding(tcp,image); + if (opj_j2k_setup_mct_encoding(tcp,image) == OPJ_FALSE) { + /* free will be handled by opj_j2k_destroy */ + opj_event_msg(p_manager, EVT_ERROR, "Failed to setup j2k mct encoding\n"); + return OPJ_FALSE; + } } else { + if(tcp->mct==1 && image->numcomps == 3) { /* RGB->YCC MCT is enabled */ + if ((image->comps[0].dx != image->comps[1].dx) || + (image->comps[0].dx != image->comps[2].dx) || + (image->comps[0].dy != image->comps[1].dy) || + (image->comps[0].dy != image->comps[2].dy)) { + opj_event_msg(p_manager, EVT_WARNING, "Cannot perform MCT on components with different sizes. Disabling MCT.\n"); + tcp->mct = 0; + } + } for (i = 0; i < image->numcomps; i++) { opj_tccp_t *tccp = &tcp->tccps[i]; opj_image_comp_t * l_comp = &(image->comps[i]); @@ -5950,62 +6584,58 @@ void opj_j2k_setup_encoder( opj_j2k_v2_t *p_j2k, opj_tccp_t *tccp = &tcp->tccps[i]; tccp->csty = parameters->csty & 0x01; /* 0 => one precinct || 1 => custom precinct */ - tccp->numresolutions = parameters->numresolution; - tccp->cblkw = opj_int_floorlog2(parameters->cblockw_init); - tccp->cblkh = opj_int_floorlog2(parameters->cblockh_init); - tccp->cblksty = parameters->mode; + tccp->numresolutions = (OPJ_UINT32)parameters->numresolution; + tccp->cblkw = (OPJ_UINT32)opj_int_floorlog2(parameters->cblockw_init); + tccp->cblkh = (OPJ_UINT32)opj_int_floorlog2(parameters->cblockh_init); + tccp->cblksty = (OPJ_UINT32)parameters->mode; tccp->qmfbid = parameters->irreversible ? 0 : 1; tccp->qntsty = parameters->irreversible ? J2K_CCP_QNTSTY_SEQNT : J2K_CCP_QNTSTY_NOQNT; tccp->numgbits = 2; - if (i == parameters->roi_compno) { + if ((OPJ_INT32)i == parameters->roi_compno) { tccp->roishift = parameters->roi_shift; } else { tccp->roishift = 0; } - if(parameters->cp_cinema) { - /*Precinct size for lowest frequency subband=128*/ - tccp->prcw[0] = 7; - tccp->prch[0] = 7; - /*Precinct size at all other resolutions = 256*/ - for (j = 1; j < tccp->numresolutions; j++) { - tccp->prcw[j] = 8; - tccp->prch[j] = 8; - } - }else{ if (parameters->csty & J2K_CCP_CSTY_PRT) { OPJ_INT32 p = 0, it_res; - for (it_res = tccp->numresolutions - 1; it_res >= 0; it_res--) { + assert( tccp->numresolutions > 0 ); + for (it_res = (OPJ_INT32)tccp->numresolutions - 1; it_res >= 0; it_res--) { if (p < parameters->res_spec) { if (parameters->prcw_init[p] < 1) { tccp->prcw[it_res] = 1; } else { - tccp->prcw[it_res] = opj_int_floorlog2(parameters->prcw_init[p]); + tccp->prcw[it_res] = (OPJ_UINT32)opj_int_floorlog2(parameters->prcw_init[p]); } if (parameters->prch_init[p] < 1) { tccp->prch[it_res] = 1; }else { - tccp->prch[it_res] = opj_int_floorlog2(parameters->prch_init[p]); + tccp->prch[it_res] = (OPJ_UINT32)opj_int_floorlog2(parameters->prch_init[p]); } } else { - int res_spec = parameters->res_spec; - int size_prcw = parameters->prcw_init[res_spec - 1] >> (p - (res_spec - 1)); - int size_prch = parameters->prch_init[res_spec - 1] >> (p - (res_spec - 1)); + OPJ_INT32 res_spec = parameters->res_spec; + OPJ_INT32 size_prcw = 0; + OPJ_INT32 size_prch = 0; + + assert(res_spec>0); /* issue 189 */ + size_prcw = parameters->prcw_init[res_spec - 1] >> (p - (res_spec - 1)); + size_prch = parameters->prch_init[res_spec - 1] >> (p - (res_spec - 1)); + if (size_prcw < 1) { tccp->prcw[it_res] = 1; } else { - tccp->prcw[it_res] = opj_int_floorlog2(size_prcw); + tccp->prcw[it_res] = (OPJ_UINT32)opj_int_floorlog2(size_prcw); } if (size_prch < 1) { tccp->prch[it_res] = 1; } else { - tccp->prch[it_res] = opj_int_floorlog2(size_prch); + tccp->prch[it_res] = (OPJ_UINT32)opj_int_floorlog2(size_prch); } } p++; @@ -6017,7 +6647,6 @@ void opj_j2k_setup_encoder( opj_j2k_v2_t *p_j2k, tccp->prch[j] = 15; } } - } opj_dwt_calc_explicit_stepsizes(tccp, image->comps[i].prec); } @@ -6027,23 +6656,24 @@ void opj_j2k_setup_encoder( opj_j2k_v2_t *p_j2k, opj_free(parameters->mct_data); parameters->mct_data = 00; } + return OPJ_TRUE; } -static opj_bool opj_j2k_add_mhmarker(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len) +static OPJ_BOOL opj_j2k_add_mhmarker(opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len) { assert(cstr_index != 00); /* expand the list? */ if ((cstr_index->marknum + 1) > cstr_index->maxmarknum) { opj_marker_info_t *new_marker; - cstr_index->maxmarknum = 100 + (int) ((float) cstr_index->maxmarknum * 1.0F); + cstr_index->maxmarknum = (OPJ_UINT32)(100 + (OPJ_FLOAT32) cstr_index->maxmarknum); new_marker = (opj_marker_info_t *) opj_realloc(cstr_index->marker, cstr_index->maxmarknum *sizeof(opj_marker_info_t)); if (! new_marker) { opj_free(cstr_index->marker); cstr_index->marker = NULL; cstr_index->maxmarknum = 0; cstr_index->marknum = 0; - /* opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n"); */ + /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n"); */ return OPJ_FALSE; } cstr_index->marker = new_marker; @@ -6057,7 +6687,7 @@ static opj_bool opj_j2k_add_mhmarker(opj_codestream_index_t *cstr_index, OPJ_UIN return OPJ_TRUE; } -static opj_bool opj_j2k_add_tlmarker(OPJ_UINT32 tileno, opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len) +static OPJ_BOOL opj_j2k_add_tlmarker(OPJ_UINT32 tileno, opj_codestream_index_t *cstr_index, OPJ_UINT32 type, OPJ_OFF_T pos, OPJ_UINT32 len) { assert(cstr_index != 00); assert(cstr_index->tile_index != 00); @@ -6065,7 +6695,7 @@ static opj_bool opj_j2k_add_tlmarker(OPJ_UINT32 tileno, opj_codestream_index_t * /* expand the list? */ if ((cstr_index->tile_index[tileno].marknum + 1) > cstr_index->tile_index[tileno].maxmarknum) { opj_marker_info_t *new_marker; - cstr_index->tile_index[tileno].maxmarknum = 100 + (int) ((float) cstr_index->tile_index[tileno].maxmarknum * 1.0F); + cstr_index->tile_index[tileno].maxmarknum = (OPJ_UINT32)(100 + (OPJ_FLOAT32) cstr_index->tile_index[tileno].maxmarknum); new_marker = (opj_marker_info_t *) opj_realloc( cstr_index->tile_index[tileno].marker, cstr_index->tile_index[tileno].maxmarknum *sizeof(opj_marker_info_t)); @@ -6074,7 +6704,7 @@ static opj_bool opj_j2k_add_tlmarker(OPJ_UINT32 tileno, opj_codestream_index_t * cstr_index->tile_index[tileno].marker = NULL; cstr_index->tile_index[tileno].maxmarknum = 0; cstr_index->tile_index[tileno].marknum = 0; - /* opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n"); */ + /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n"); */ return OPJ_FALSE; } cstr_index->tile_index[tileno].marker = new_marker; @@ -6102,7 +6732,7 @@ static opj_bool opj_j2k_add_tlmarker(OPJ_UINT32 tileno, opj_codestream_index_t * * ----------------------------------------------------------------------- */ -opj_bool opj_j2k_end_decompress(opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_end_decompress(opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) @@ -6113,8 +6743,8 @@ opj_bool opj_j2k_end_decompress(opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_read_header( opj_stream_private_t *p_stream, - opj_j2k_v2_t* p_j2k, +OPJ_BOOL opj_j2k_read_header( opj_stream_private_t *p_stream, + opj_j2k_t* p_j2k, opj_image_t** p_image, opj_event_mgr_t* p_manager ) { @@ -6165,7 +6795,7 @@ opj_bool opj_j2k_read_header( opj_stream_private_t *p_stream, return OPJ_TRUE; } -void opj_j2k_setup_header_reading (opj_j2k_v2_t *p_j2k) +void opj_j2k_setup_header_reading (opj_j2k_t *p_j2k) { /* preconditions*/ assert(p_j2k != 00); @@ -6177,7 +6807,7 @@ void opj_j2k_setup_header_reading (opj_j2k_v2_t *p_j2k) } -void opj_j2k_setup_decoding_validation (opj_j2k_v2_t *p_j2k) +void opj_j2k_setup_decoding_validation (opj_j2k_t *p_j2k) { /* preconditions*/ assert(p_j2k != 00); @@ -6188,11 +6818,11 @@ void opj_j2k_setup_decoding_validation (opj_j2k_v2_t *p_j2k) } -opj_bool opj_j2k_mct_validation ( opj_j2k_v2_t * p_j2k, +OPJ_BOOL opj_j2k_mct_validation ( opj_j2k_t * p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) { - opj_bool l_is_valid = OPJ_TRUE; + OPJ_BOOL l_is_valid = OPJ_TRUE; OPJ_UINT32 i,j; /* preconditions */ @@ -6202,7 +6832,7 @@ opj_bool opj_j2k_mct_validation ( opj_j2k_v2_t * p_j2k, if ((p_j2k->m_cp.rsiz & 0x8200) == 0x8200) { OPJ_UINT32 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw; - opj_tcp_v2_t * l_tcp = p_j2k->m_cp.tcps; + opj_tcp_t * l_tcp = p_j2k->m_cp.tcps; for (i=0;imct == 2) { @@ -6221,7 +6851,7 @@ opj_bool opj_j2k_mct_validation ( opj_j2k_v2_t * p_j2k, return l_is_valid; } -opj_bool opj_j2k_setup_mct_encoding(opj_tcp_v2_t * p_tcp, opj_image_t * p_image) +OPJ_BOOL opj_j2k_setup_mct_encoding(opj_tcp_t * p_tcp, opj_image_t * p_image) { OPJ_UINT32 i; OPJ_UINT32 l_indix = 1; @@ -6241,7 +6871,7 @@ opj_bool opj_j2k_setup_mct_encoding(opj_tcp_v2_t * p_tcp, opj_image_t * p_image) if (p_tcp->m_mct_decoding_matrix) { if (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records) { opj_mct_data_t *new_mct_records; - p_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS; + p_tcp->m_nb_max_mct_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS; new_mct_records = (opj_mct_data_t *) opj_realloc(p_tcp->m_mct_records, p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t)); if (! new_mct_records) { @@ -6249,7 +6879,7 @@ opj_bool opj_j2k_setup_mct_encoding(opj_tcp_v2_t * p_tcp, opj_image_t * p_image) p_tcp->m_mct_records = NULL; p_tcp->m_nb_max_mct_records = 0; p_tcp->m_nb_mct_records = 0; - /* opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to setup mct encoding\n"); */ + /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to setup mct encoding\n"); */ return OPJ_FALSE; } p_tcp->m_mct_records = new_mct_records; @@ -6283,14 +6913,14 @@ opj_bool opj_j2k_setup_mct_encoding(opj_tcp_v2_t * p_tcp, opj_image_t * p_image) if (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records) { opj_mct_data_t *new_mct_records; - p_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS; + p_tcp->m_nb_max_mct_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS; new_mct_records = (opj_mct_data_t *) opj_realloc(p_tcp->m_mct_records, p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t)); if (! new_mct_records) { opj_free(p_tcp->m_mct_records); p_tcp->m_mct_records = NULL; p_tcp->m_nb_max_mct_records = 0; p_tcp->m_nb_mct_records = 0; - /* opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to setup mct encoding\n"); */ + /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to setup mct encoding\n"); */ return OPJ_FALSE; } p_tcp->m_mct_records = new_mct_records; @@ -6346,7 +6976,7 @@ opj_bool opj_j2k_setup_mct_encoding(opj_tcp_v2_t * p_tcp, opj_image_t * p_image) if (p_tcp->m_nb_mcc_records == p_tcp->m_nb_max_mcc_records) { opj_simple_mcc_decorrelation_data_t *new_mcc_records; - p_tcp->m_nb_max_mcc_records += J2K_MCT_DEFAULT_NB_RECORDS; + p_tcp->m_nb_max_mcc_records += OPJ_J2K_MCT_DEFAULT_NB_RECORDS; new_mcc_records = (opj_simple_mcc_decorrelation_data_t *) opj_realloc( p_tcp->m_mcc_records, p_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t)); if (! new_mcc_records) { @@ -6354,7 +6984,7 @@ opj_bool opj_j2k_setup_mct_encoding(opj_tcp_v2_t * p_tcp, opj_image_t * p_image) p_tcp->m_mcc_records = NULL; p_tcp->m_nb_max_mcc_records = 0; p_tcp->m_nb_mcc_records = 0; - /* opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to setup mct encoding\n"); */ + /* opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to setup mct encoding\n"); */ return OPJ_FALSE; } p_tcp->m_mcc_records = new_mcc_records; @@ -6374,7 +7004,7 @@ opj_bool opj_j2k_setup_mct_encoding(opj_tcp_v2_t * p_tcp, opj_image_t * p_image) return OPJ_TRUE; } -opj_bool opj_j2k_build_decoder (opj_j2k_v2_t * p_j2k, +OPJ_BOOL opj_j2k_build_decoder (opj_j2k_t * p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) { @@ -6386,7 +7016,7 @@ opj_bool opj_j2k_build_decoder (opj_j2k_v2_t * p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_build_encoder (opj_j2k_v2_t * p_j2k, +OPJ_BOOL opj_j2k_build_encoder (opj_j2k_t * p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) { @@ -6398,11 +7028,11 @@ opj_bool opj_j2k_build_encoder (opj_j2k_v2_t * p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_encoding_validation ( opj_j2k_v2_t * p_j2k, +OPJ_BOOL opj_j2k_encoding_validation ( opj_j2k_t * p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) { - opj_bool l_is_valid = OPJ_TRUE; + OPJ_BOOL l_is_valid = OPJ_TRUE; /* preconditions */ assert(p_j2k != 00); @@ -6419,13 +7049,22 @@ opj_bool opj_j2k_encoding_validation ( opj_j2k_v2_t * p_j2k, /* make sure a validation list is present */ l_is_valid &= (p_j2k->m_validation_list != 00); + /* ISO 15444-1:2004 states between 1 & 33 (0 -> 32) */ + /* 33 (32) would always fail the 2 checks below (if a cast to 64bits was done) */ + /* 32 (31) would always fail the 2 checks below (if a cast to 64bits was done) */ + /* FIXME Shall we change OPJ_J2K_MAXRLVLS to 31 ? */ + if ((p_j2k->m_cp.tcps->tccps->numresolutions <= 0) || (p_j2k->m_cp.tcps->tccps->numresolutions > 31)) { + opj_event_msg(p_manager, EVT_ERROR, "Number of resolutions is too high in comparison to the size of tiles\n"); + return OPJ_FALSE; + } + if ((p_j2k->m_cp.tdx) < (OPJ_UINT32) (1 << p_j2k->m_cp.tcps->tccps->numresolutions)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Number of resolutions is too high in comparison to the size of tiles\n"); + opj_event_msg(p_manager, EVT_ERROR, "Number of resolutions is too high in comparison to the size of tiles\n"); return OPJ_FALSE; } if ((p_j2k->m_cp.tdy) < (OPJ_UINT32) (1 << p_j2k->m_cp.tcps->tccps->numresolutions)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Number of resolutions is too high in comparison to the size of tiles\n"); + opj_event_msg(p_manager, EVT_ERROR, "Number of resolutions is too high in comparison to the size of tiles\n"); return OPJ_FALSE; } @@ -6433,12 +7072,12 @@ opj_bool opj_j2k_encoding_validation ( opj_j2k_v2_t * p_j2k, return l_is_valid; } -opj_bool opj_j2k_decoding_validation ( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_decoding_validation ( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) { - opj_bool l_is_valid = OPJ_TRUE; + OPJ_BOOL l_is_valid = OPJ_TRUE; /* preconditions*/ assert(p_j2k != 00); @@ -6463,13 +7102,16 @@ opj_bool opj_j2k_decoding_validation ( opj_j2k_v2_t *p_j2k, return l_is_valid; } -opj_bool opj_j2k_read_header_procedure( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_read_header_procedure( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager) { OPJ_UINT32 l_current_marker; OPJ_UINT32 l_marker_size; const opj_dec_memory_marker_handler_t * l_marker_handler = 00; + OPJ_BOOL l_has_siz = 0; + OPJ_BOOL l_has_cod = 0; + OPJ_BOOL l_has_qcd = 0; /* preconditions */ assert(p_stream != 00); @@ -6481,13 +7123,13 @@ opj_bool opj_j2k_read_header_procedure( opj_j2k_v2_t *p_j2k, /* Try to read the SOC marker, the codestream must begin with SOC marker */ if (! opj_j2k_read_soc(p_j2k,p_stream,p_manager)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Expected a SOC marker \n"); + opj_event_msg(p_manager, EVT_ERROR, "Expected a SOC marker \n"); return OPJ_FALSE; } /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */ if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Stream too short\n"); + opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n"); return OPJ_FALSE; } @@ -6499,7 +7141,7 @@ opj_bool opj_j2k_read_header_procedure( opj_j2k_v2_t *p_j2k, /* Check if the current marker ID is valid */ if (l_current_marker < 0xff00) { - opj_event_msg_v2(p_manager, EVT_ERROR, "We expected read a marker ID (0xff--) instead of %.8x\n", l_current_marker); + opj_event_msg(p_manager, EVT_ERROR, "We expected read a marker ID (0xff--) instead of %.8x\n", l_current_marker); return OPJ_FALSE; } @@ -6509,7 +7151,7 @@ opj_bool opj_j2k_read_header_procedure( opj_j2k_v2_t *p_j2k, /* Manage case where marker is unknown */ if (l_marker_handler->id == J2K_MS_UNK) { if (! opj_j2k_read_unk(p_j2k, p_stream, &l_current_marker, p_manager)){ - opj_event_msg_v2(p_manager, EVT_ERROR, "Unknow marker have been detected and generated error.\n"); + opj_event_msg(p_manager, EVT_ERROR, "Unknow marker have been detected and generated error.\n"); return OPJ_FALSE; } @@ -6519,15 +7161,28 @@ opj_bool opj_j2k_read_header_procedure( opj_j2k_v2_t *p_j2k, l_marker_handler = opj_j2k_get_marker_handler(l_current_marker); } + if (l_marker_handler->id == J2K_MS_SIZ) { + /* Mark required SIZ marker as found */ + l_has_siz = 1; + } + if (l_marker_handler->id == J2K_MS_COD) { + /* Mark required COD marker as found */ + l_has_cod = 1; + } + if (l_marker_handler->id == J2K_MS_QCD) { + /* Mark required QCD marker as found */ + l_has_qcd = 1; + } + /* Check if the marker is known and if it is the right place to find it */ if (! (p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states) ) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Marker is not compliant with its position\n"); + opj_event_msg(p_manager, EVT_ERROR, "Marker is not compliant with its position\n"); return OPJ_FALSE; } /* Try to read 2 bytes (the marker size) from stream and copy them into the buffer */ if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Stream too short\n"); + opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n"); return OPJ_FALSE; } @@ -6542,7 +7197,7 @@ opj_bool opj_j2k_read_header_procedure( opj_j2k_v2_t *p_j2k, opj_free(p_j2k->m_specific_param.m_decoder.m_header_data); p_j2k->m_specific_param.m_decoder.m_header_data = NULL; p_j2k->m_specific_param.m_decoder.m_header_data_size = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to read header\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read header\n"); return OPJ_FALSE; } p_j2k->m_specific_param.m_decoder.m_header_data = new_header_data; @@ -6551,13 +7206,13 @@ opj_bool opj_j2k_read_header_procedure( opj_j2k_v2_t *p_j2k, /* Try to read the rest of the marker segment from stream and copy them into the buffer */ if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager) != l_marker_size) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Stream too short\n"); + opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n"); return OPJ_FALSE; } /* Read the marker segment with the correct marker handler */ if (! (*(l_marker_handler->handler))(p_j2k,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Marker handler function failed to read the marker segment\n"); + opj_event_msg(p_manager, EVT_ERROR, "Marker handler function failed to read the marker segment\n"); return OPJ_FALSE; } @@ -6567,13 +7222,13 @@ opj_bool opj_j2k_read_header_procedure( opj_j2k_v2_t *p_j2k, l_marker_handler->id, (OPJ_UINT32) opj_stream_tell(p_stream) - l_marker_size - 4, l_marker_size + 4 )) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add mh marker\n"); return OPJ_FALSE; } /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */ if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Stream too short\n"); + opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n"); return OPJ_FALSE; } @@ -6581,7 +7236,20 @@ opj_bool opj_j2k_read_header_procedure( opj_j2k_v2_t *p_j2k, opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2); } - opj_event_msg_v2(p_manager, EVT_INFO, "Main header has been correctly decoded.\n"); + if (l_has_siz == 0) { + opj_event_msg(p_manager, EVT_ERROR, "required SIZ marker not found in main header\n"); + return OPJ_FALSE; + } + if (l_has_cod == 0) { + opj_event_msg(p_manager, EVT_ERROR, "required COD marker not found in main header\n"); + return OPJ_FALSE; + } + if (l_has_qcd == 0) { + opj_event_msg(p_manager, EVT_ERROR, "required QCD marker not found in main header\n"); + return OPJ_FALSE; + } + + opj_event_msg(p_manager, EVT_INFO, "Main header has been correctly decoded.\n"); /* Position of the last element if the main header */ p_j2k->cstr_index->main_head_end = (OPJ_UINT32) opj_stream_tell(p_stream) - 2; @@ -6592,13 +7260,13 @@ opj_bool opj_j2k_read_header_procedure( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_exec ( opj_j2k_v2_t * p_j2k, +OPJ_BOOL opj_j2k_exec ( opj_j2k_t * p_j2k, opj_procedure_list_t * p_procedure_list, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) { - opj_bool (** l_procedure) (opj_j2k_v2_t * ,opj_stream_private_t *,opj_event_mgr_t *) = 00; - opj_bool l_result = OPJ_TRUE; + OPJ_BOOL (** l_procedure) (opj_j2k_t * ,opj_stream_private_t *,opj_event_mgr_t *) = 00; + OPJ_BOOL l_result = OPJ_TRUE; OPJ_UINT32 l_nb_proc, i; /* preconditions*/ @@ -6608,7 +7276,7 @@ opj_bool opj_j2k_exec ( opj_j2k_v2_t * p_j2k, assert(p_manager != 00); l_nb_proc = opj_procedure_list_get_nb_procedures(p_procedure_list); - l_procedure = (opj_bool (**) (opj_j2k_v2_t * ,opj_stream_private_t *,opj_event_mgr_t *)) opj_procedure_list_get_first_procedure(p_procedure_list); + l_procedure = (OPJ_BOOL (**) (opj_j2k_t * ,opj_stream_private_t *,opj_event_mgr_t *)) opj_procedure_list_get_first_procedure(p_procedure_list); for (i=0;im_private_image; l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw; l_tcp = p_j2k->m_cp.tcps; - l_tccp_size = l_image->numcomps * sizeof(opj_tccp_t); + l_tccp_size = l_image->numcomps * (OPJ_UINT32)sizeof(opj_tccp_t); l_default_tcp = p_j2k->m_specific_param.m_decoder.m_default_tcp; - l_mct_size = l_image->numcomps * l_image->numcomps * sizeof(OPJ_FLOAT32); + l_mct_size = l_image->numcomps * l_image->numcomps * (OPJ_UINT32)sizeof(OPJ_FLOAT32); /* For each tile */ for (i=0; itccps; /*Copy default coding parameters into the current tile coding parameters*/ - memcpy(l_tcp, l_default_tcp, sizeof(opj_tcp_v2_t)); + memcpy(l_tcp, l_default_tcp, sizeof(opj_tcp_t)); /* Initialize some values of the current tile coding parameters*/ l_tcp->ppt = 0; l_tcp->ppt_data = 00; @@ -6673,7 +7341,7 @@ static opj_bool opj_j2k_copy_default_tcp_and_create_tcd ( opj_j2k_v2_t * p } /* Get the mct_record of the dflt_tile_cp and copy them into the current tile cp*/ - l_mct_records_size = l_default_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t); + l_mct_records_size = l_default_tcp->m_nb_max_mct_records * (OPJ_UINT32)sizeof(opj_mct_data_t); l_tcp->m_mct_records = (opj_mct_data_t*)opj_malloc(l_mct_records_size); if (! l_tcp->m_mct_records) { return OPJ_FALSE; @@ -6700,7 +7368,7 @@ static opj_bool opj_j2k_copy_default_tcp_and_create_tcd ( opj_j2k_v2_t * p } /* Get the mcc_record of the dflt_tile_cp and copy them into the current tile cp*/ - l_mcc_records_size = l_default_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t); + l_mcc_records_size = l_default_tcp->m_nb_max_mcc_records * (OPJ_UINT32)sizeof(opj_simple_mcc_decorrelation_data_t); l_tcp->m_mcc_records = (opj_simple_mcc_decorrelation_data_t*) opj_malloc(l_mcc_records_size); if (! l_tcp->m_mcc_records) { return OPJ_FALSE; @@ -6714,12 +7382,12 @@ static opj_bool opj_j2k_copy_default_tcp_and_create_tcd ( opj_j2k_v2_t * p for (j=0;jm_nb_max_mcc_records;++j) { if (l_src_mcc_rec->m_decorrelation_array) { - l_offset = l_src_mcc_rec->m_decorrelation_array - l_default_tcp->m_mct_records; + l_offset = (OPJ_UINT32)(l_src_mcc_rec->m_decorrelation_array - l_default_tcp->m_mct_records); l_dest_mcc_rec->m_decorrelation_array = l_tcp->m_mct_records + l_offset; } if (l_src_mcc_rec->m_offset_array) { - l_offset = l_src_mcc_rec->m_offset_array - l_default_tcp->m_mct_records; + l_offset = (OPJ_UINT32)(l_src_mcc_rec->m_offset_array - l_default_tcp->m_mct_records); l_dest_mcc_rec->m_offset_array = l_tcp->m_mct_records + l_offset; } @@ -6735,7 +7403,7 @@ static opj_bool opj_j2k_copy_default_tcp_and_create_tcd ( opj_j2k_v2_t * p } /* Create the current tile decoder*/ - p_j2k->m_tcd = (opj_tcd_v2_t*)opj_tcd_create(OPJ_TRUE); /* FIXME why a cast ? */ + p_j2k->m_tcd = (opj_tcd_t*)opj_tcd_create(OPJ_TRUE); /* FIXME why a cast ? */ if (! p_j2k->m_tcd ) { return OPJ_FALSE; } @@ -6743,7 +7411,7 @@ static opj_bool opj_j2k_copy_default_tcp_and_create_tcd ( opj_j2k_v2_t * p if ( !opj_tcd_init(p_j2k->m_tcd, l_image, &(p_j2k->m_cp)) ) { opj_tcd_destroy(p_j2k->m_tcd); p_j2k->m_tcd = 00; - opj_event_msg_v2(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n"); + opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n"); return OPJ_FALSE; } @@ -6761,7 +7429,7 @@ const opj_dec_memory_marker_handler_t * opj_j2k_get_marker_handler (OPJ_UINT32 p return e; } -void opj_j2k_destroy (opj_j2k_v2_t *p_j2k) +void opj_j2k_destroy (opj_j2k_t *p_j2k) { if (p_j2k == 00) { return; @@ -6804,7 +7472,7 @@ void opj_j2k_destroy (opj_j2k_v2_t *p_j2k) opj_tcd_destroy(p_j2k->m_tcd); opj_j2k_cp_destroy(&(p_j2k->m_cp)); - memset(&(p_j2k->m_cp),0,sizeof(opj_cp_v2_t)); + memset(&(p_j2k->m_cp),0,sizeof(opj_cp_t)); opj_procedure_list_destroy(p_j2k->m_procedure_list); p_j2k->m_procedure_list = 00; @@ -6863,7 +7531,7 @@ void j2k_destroy_cstr_index (opj_codestream_index_t *p_cstr_ind) } } -void opj_j2k_tcp_destroy (opj_tcp_v2_t *p_tcp) +void opj_j2k_tcp_destroy (opj_tcp_t *p_tcp) { if (p_tcp == 00) { return; @@ -6922,7 +7590,7 @@ void opj_j2k_tcp_destroy (opj_tcp_v2_t *p_tcp) } -void opj_j2k_tcp_data_destroy (opj_tcp_v2_t *p_tcp) +void opj_j2k_tcp_data_destroy (opj_tcp_t *p_tcp) { if (p_tcp->m_data) { opj_free(p_tcp->m_data); @@ -6931,10 +7599,10 @@ void opj_j2k_tcp_data_destroy (opj_tcp_v2_t *p_tcp) } } -void opj_j2k_cp_destroy (opj_cp_v2_t *p_cp) +void opj_j2k_cp_destroy (opj_cp_t *p_cp) { OPJ_UINT32 l_nb_tiles; - opj_tcp_v2_t * l_current_tile = 00; + opj_tcp_t * l_current_tile = 00; OPJ_UINT32 i; if (p_cp == 00) @@ -6966,20 +7634,20 @@ void opj_j2k_cp_destroy (opj_cp_v2_t *p_cp) } } -opj_bool opj_j2k_read_tile_header( opj_j2k_v2_t * p_j2k, +OPJ_BOOL opj_j2k_read_tile_header( opj_j2k_t * p_j2k, 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_BOOL * p_go_on, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) { OPJ_UINT32 l_current_marker = J2K_MS_SOT; OPJ_UINT32 l_marker_size; const opj_dec_memory_marker_handler_t * l_marker_handler = 00; - opj_tcp_v2_t * l_tcp = NULL; + opj_tcp_t * l_tcp = NULL; OPJ_UINT32 l_nb_tiles; /* preconditions */ @@ -7001,16 +7669,34 @@ opj_bool opj_j2k_read_tile_header( opj_j2k_v2_t * p_j2k, /* Try to read until the Start Of Data is detected */ while (l_current_marker != J2K_MS_SOD) { + + if(opj_stream_get_number_byte_left(p_stream) == 0) + { + p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC; + break; + } /* Try to read 2 bytes (the marker size) from stream and copy them into the buffer */ if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Stream too short\n"); + opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n"); return OPJ_FALSE; } /* Read 2 bytes from the buffer as the marker size */ opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_marker_size,2); + /* Check marker size (does not include marker ID but includes marker size) */ + if (l_marker_size < 2) { + opj_event_msg(p_manager, EVT_ERROR, "Inconsistent marker size\n"); + return OPJ_FALSE; + } + + /* cf. https://code.google.com/p/openjpeg/issues/detail?id=226 */ + if (l_current_marker == 0x8080 && opj_stream_get_number_byte_left(p_stream) == 0) { + p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC; + break; + } + /* Why this condition? FIXME */ if (p_j2k->m_specific_param.m_decoder.m_state & J2K_STATE_TPH){ p_j2k->m_specific_param.m_decoder.m_sot_length -= (l_marker_size + 2); @@ -7022,19 +7708,26 @@ opj_bool opj_j2k_read_tile_header( opj_j2k_v2_t * p_j2k, /* Check if the marker is known and if it is the right place to find it */ if (! (p_j2k->m_specific_param.m_decoder.m_state & l_marker_handler->states) ) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Marker is not compliant with its position\n"); + opj_event_msg(p_manager, EVT_ERROR, "Marker is not compliant with its position\n"); return OPJ_FALSE; } /* FIXME manage case of unknown marker as in the main header ? */ /* Check if the marker size is compatible with the header data size */ if (l_marker_size > p_j2k->m_specific_param.m_decoder.m_header_data_size) { - OPJ_BYTE *new_header_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size); + OPJ_BYTE *new_header_data = NULL; + /* If we are here, this means we consider this marker as known & we will read it */ + /* Check enough bytes left in stream before allocation */ + if ((OPJ_OFF_T)l_marker_size > opj_stream_get_number_byte_left(p_stream)) { + opj_event_msg(p_manager, EVT_ERROR, "Marker size inconsistent with stream length\n"); + return OPJ_FALSE; + } + new_header_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_decoder.m_header_data, l_marker_size); if (! new_header_data) { opj_free(p_j2k->m_specific_param.m_decoder.m_header_data); p_j2k->m_specific_param.m_decoder.m_header_data = NULL; p_j2k->m_specific_param.m_decoder.m_header_data_size = 0; - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to read header\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to read header\n"); return OPJ_FALSE; } p_j2k->m_specific_param.m_decoder.m_header_data = new_header_data; @@ -7043,18 +7736,18 @@ opj_bool opj_j2k_read_tile_header( opj_j2k_v2_t * p_j2k, /* Try to read the rest of the marker segment from stream and copy them into the buffer */ if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager) != l_marker_size) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Stream too short\n"); + opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n"); return OPJ_FALSE; } if (!l_marker_handler->handler) { /* See issue #175 */ - opj_event_msg_v2(p_manager, EVT_ERROR, "Not sure how that happened.\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not sure how that happened.\n"); return OPJ_FALSE; } /* Read the marker segment with the correct marker handler */ if (! (*(l_marker_handler->handler))(p_j2k,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Fail to read the current marker segment (%#x)\n", l_current_marker); + opj_event_msg(p_manager, EVT_ERROR, "Fail to read the current marker segment (%#x)\n", l_current_marker); return OPJ_FALSE; } @@ -7064,7 +7757,7 @@ opj_bool opj_j2k_read_tile_header( opj_j2k_v2_t * p_j2k, l_marker_handler->id, (OPJ_UINT32) opj_stream_tell(p_stream) - l_marker_size - 4, l_marker_size + 4 )) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to add tl marker\n"); return OPJ_FALSE; } @@ -7080,7 +7773,7 @@ opj_bool opj_j2k_read_tile_header( opj_j2k_v2_t * p_j2k, if (p_j2k->m_specific_param.m_decoder.m_skip_data) { /* Skip the rest of the tile part header*/ if (opj_stream_skip(p_stream,p_j2k->m_specific_param.m_decoder.m_sot_length,p_manager) != p_j2k->m_specific_param.m_decoder.m_sot_length) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Stream too short\n"); + opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n"); return OPJ_FALSE; } l_current_marker = J2K_MS_SOD; /* Normally we reached a SOD */ @@ -7088,13 +7781,16 @@ opj_bool opj_j2k_read_tile_header( opj_j2k_v2_t * p_j2k, else { /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer*/ if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Stream too short\n"); + opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n"); return OPJ_FALSE; } /* Read 2 bytes from the buffer as the new marker ID */ opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2); } } + if(opj_stream_get_number_byte_left(p_stream) == 0 + && p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NEOC) + break; /* If we didn't skip data before, we need to read the SOD marker*/ if (! p_j2k->m_specific_param.m_decoder.m_skip_data) { @@ -7106,7 +7802,7 @@ opj_bool opj_j2k_read_tile_header( opj_j2k_v2_t * p_j2k, if (! p_j2k->m_specific_param.m_decoder.m_can_decode){ /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */ if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Stream too short\n"); + opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n"); return OPJ_FALSE; } @@ -7122,7 +7818,7 @@ opj_bool opj_j2k_read_tile_header( opj_j2k_v2_t * p_j2k, /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */ if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Stream too short\n"); + opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n"); return OPJ_FALSE; } @@ -7157,12 +7853,12 @@ opj_bool opj_j2k_read_tile_header( opj_j2k_v2_t * p_j2k, /*FIXME ???*/ if (! opj_tcd_init_decode_tile(p_j2k->m_tcd, p_j2k->m_current_tile_number)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n"); + opj_event_msg(p_manager, EVT_ERROR, "Cannot decode tile, memory error\n"); return OPJ_FALSE; } - opj_event_msg_v2(p_manager, EVT_INFO, "Header of tile %d / %d has been read.\n", - p_j2k->m_current_tile_number, (p_j2k->m_cp.th * p_j2k->m_cp.tw) - 1); + opj_event_msg(p_manager, EVT_INFO, "Header of tile %d / %d has been read.\n", + p_j2k->m_current_tile_number+1, (p_j2k->m_cp.th * p_j2k->m_cp.tw)); *p_tile_index = p_j2k->m_current_tile_number; *p_go_on = OPJ_TRUE; @@ -7178,7 +7874,7 @@ opj_bool opj_j2k_read_tile_header( opj_j2k_v2_t * p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_decode_tile ( opj_j2k_v2_t * p_j2k, +OPJ_BOOL opj_j2k_decode_tile ( opj_j2k_t * p_j2k, OPJ_UINT32 p_tile_index, OPJ_BYTE * p_data, OPJ_UINT32 p_data_size, @@ -7187,7 +7883,7 @@ opj_bool opj_j2k_decode_tile ( opj_j2k_v2_t * p_j2k, { OPJ_UINT32 l_current_marker; OPJ_BYTE l_data [2]; - opj_tcp_v2_t * l_tcp; + opj_tcp_t * l_tcp; /* preconditions */ assert(p_stream != 00); @@ -7212,6 +7908,7 @@ opj_bool opj_j2k_decode_tile ( opj_j2k_v2_t * p_j2k, p_j2k->cstr_index) ) { opj_j2k_tcp_destroy(l_tcp); p_j2k->m_specific_param.m_decoder.m_state |= 0x8000;/*FIXME J2K_DEC_STATE_ERR;*/ + opj_event_msg(p_manager, EVT_ERROR, "Failed to decode.\n"); return OPJ_FALSE; } @@ -7226,11 +7923,16 @@ opj_bool opj_j2k_decode_tile ( opj_j2k_v2_t * p_j2k, opj_j2k_tcp_data_destroy(l_tcp); p_j2k->m_specific_param.m_decoder.m_can_decode = 0; - p_j2k->m_specific_param.m_decoder.m_state &= (~ (0x0080));/* FIXME J2K_DEC_STATE_DATA);*/ + p_j2k->m_specific_param.m_decoder.m_state &= (~ (0x0080u));/* FIXME J2K_DEC_STATE_DATA);*/ + + if(opj_stream_get_number_byte_left(p_stream) == 0 + && p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NEOC){ + return OPJ_TRUE; + } if (p_j2k->m_specific_param.m_decoder.m_state != 0x0100){ /*FIXME J2K_DEC_STATE_EOC)*/ if (opj_stream_read_data(p_stream,l_data,2,p_manager) != 2) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Stream too short\n"); + opj_event_msg(p_manager, EVT_ERROR, "Stream too short\n"); return OPJ_FALSE; } @@ -7241,8 +7943,13 @@ opj_bool opj_j2k_decode_tile ( opj_j2k_v2_t * p_j2k, p_j2k->m_specific_param.m_decoder.m_state = 0x0100;/*FIXME J2K_DEC_STATE_EOC;*/ } else if (l_current_marker != J2K_MS_SOT) - { - opj_event_msg_v2(p_manager, EVT_ERROR, "Stream too short, expected SOT\n"); + { + if(opj_stream_get_number_byte_left(p_stream) == 0) { + p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_NEOC; + opj_event_msg(p_manager, EVT_WARNING, "Stream does not end with EOC\n"); + return OPJ_TRUE; + } + opj_event_msg(p_manager, EVT_ERROR, "Stream too short, expected SOT\n"); return OPJ_FALSE; } } @@ -7250,7 +7957,7 @@ opj_bool opj_j2k_decode_tile ( opj_j2k_v2_t * p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data, opj_image_t* p_output_image) +OPJ_BOOL opj_j2k_update_image_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data, opj_image_t* p_output_image) { OPJ_UINT32 i,j,k = 0; OPJ_UINT32 l_width_src,l_height_src; @@ -7264,11 +7971,11 @@ opj_bool opj_j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data, opj opj_image_comp_t * l_img_comp_src = 00; opj_image_comp_t * l_img_comp_dest = 00; - opj_tcd_tilecomp_v2_t * l_tilec = 00; + opj_tcd_tilecomp_t * l_tilec = 00; opj_image_t * l_image_src = 00; OPJ_UINT32 l_size_comp, l_remaining; OPJ_INT32 * l_dest_ptr; - opj_tcd_resolution_v2_t* l_res= 00; + opj_tcd_resolution_t* l_res= 00; l_tilec = p_tcd->tcd_image->tiles->comps; l_image_src = p_tcd->image; @@ -7311,12 +8018,12 @@ opj_bool opj_j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data, opj l_res->x0, l_res->x1, l_res->y0, l_res->y1); }*/ - l_width_src = (l_res->x1 - l_res->x0); - l_height_src = (l_res->y1 - l_res->y0); + l_width_src = (OPJ_UINT32)(l_res->x1 - l_res->x0); + l_height_src = (OPJ_UINT32)(l_res->y1 - l_res->y0); /* Border of the current output component*/ - l_x0_dest = opj_int_ceildivpow2(l_img_comp_dest->x0, l_img_comp_dest->factor); - l_y0_dest = opj_int_ceildivpow2(l_img_comp_dest->y0, l_img_comp_dest->factor); + l_x0_dest = (OPJ_UINT32)opj_int_ceildivpow2((OPJ_INT32)l_img_comp_dest->x0, (OPJ_INT32)l_img_comp_dest->factor); + l_y0_dest = (OPJ_UINT32)opj_int_ceildivpow2((OPJ_INT32)l_img_comp_dest->y0, (OPJ_INT32)l_img_comp_dest->factor); l_x1_dest = l_x0_dest + l_img_comp_dest->w; l_y1_dest = l_y0_dest + l_img_comp_dest->h; @@ -7335,7 +8042,7 @@ opj_bool opj_j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data, opj assert( l_res->x0 >= 0); assert( l_res->x1 >= 0); if ( l_x0_dest < (OPJ_UINT32)l_res->x0 ) { - l_start_x_dest = l_res->x0 - l_x0_dest; + l_start_x_dest = (OPJ_UINT32)l_res->x0 - l_x0_dest; l_offset_x0_src = 0; if ( l_x1_dest >= (OPJ_UINT32)l_res->x1 ) { @@ -7343,26 +8050,26 @@ opj_bool opj_j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data, opj l_offset_x1_src = 0; } else { - l_width_dest = l_x1_dest - l_res->x0 ; - l_offset_x1_src = l_width_src - l_width_dest; + l_width_dest = l_x1_dest - (OPJ_UINT32)l_res->x0 ; + l_offset_x1_src = (OPJ_INT32)(l_width_src - l_width_dest); } } else { l_start_x_dest = 0 ; - l_offset_x0_src = l_x0_dest - l_res->x0; + l_offset_x0_src = (OPJ_INT32)l_x0_dest - l_res->x0; if ( l_x1_dest >= (OPJ_UINT32)l_res->x1 ) { - l_width_dest = l_width_src - l_offset_x0_src; + l_width_dest = l_width_src - (OPJ_UINT32)l_offset_x0_src; l_offset_x1_src = 0; } else { l_width_dest = l_img_comp_dest->w ; - l_offset_x1_src = l_res->x1 - l_x1_dest; + l_offset_x1_src = l_res->x1 - (OPJ_INT32)l_x1_dest; } } if ( l_y0_dest < (OPJ_UINT32)l_res->y0 ) { - l_start_y_dest = l_res->y0 - l_y0_dest; + l_start_y_dest = (OPJ_UINT32)l_res->y0 - l_y0_dest; l_offset_y0_src = 0; if ( l_y1_dest >= (OPJ_UINT32)l_res->y1 ) { @@ -7370,37 +8077,41 @@ opj_bool opj_j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data, opj l_offset_y1_src = 0; } else { - l_height_dest = l_y1_dest - l_res->y0 ; - l_offset_y1_src = l_height_src - l_height_dest; + l_height_dest = l_y1_dest - (OPJ_UINT32)l_res->y0 ; + l_offset_y1_src = (OPJ_INT32)(l_height_src - l_height_dest); } } else { l_start_y_dest = 0 ; - l_offset_y0_src = l_y0_dest - l_res->y0; + l_offset_y0_src = (OPJ_INT32)l_y0_dest - l_res->y0; if ( l_y1_dest >= (OPJ_UINT32)l_res->y1 ) { - l_height_dest = l_height_src - l_offset_y0_src; + l_height_dest = l_height_src - (OPJ_UINT32)l_offset_y0_src; l_offset_y1_src = 0; } else { l_height_dest = l_img_comp_dest->h ; - l_offset_y1_src = l_res->y1 - l_y1_dest; + l_offset_y1_src = l_res->y1 - (OPJ_INT32)l_y1_dest; } } if( (l_offset_x0_src < 0 ) || (l_offset_y0_src < 0 ) || (l_offset_x1_src < 0 ) || (l_offset_y1_src < 0 ) ){ return OPJ_FALSE; } + /* testcase 2977.pdf.asan.67.2198 */ + if ((OPJ_INT32)l_width_dest < 0 || (OPJ_INT32)l_height_dest < 0) { + return OPJ_FALSE; + } /*-----*/ /* Compute the input buffer offset */ - l_start_offset_src = l_offset_x0_src + l_offset_y0_src * l_width_src; + l_start_offset_src = l_offset_x0_src + l_offset_y0_src * (OPJ_INT32)l_width_src; l_line_offset_src = l_offset_x1_src + l_offset_x0_src; - l_end_offset_src = l_offset_y1_src * l_width_src - l_offset_x0_src; + l_end_offset_src = l_offset_y1_src * (OPJ_INT32)l_width_src - l_offset_x0_src; /* Compute the output buffer offset */ - l_start_offset_dest = l_start_x_dest + l_start_y_dest * l_img_comp_dest->w; - l_line_offset_dest = l_img_comp_dest->w - l_width_dest; + l_start_offset_dest = (OPJ_INT32)(l_start_x_dest + l_start_y_dest * l_img_comp_dest->w); + l_line_offset_dest = (OPJ_INT32)(l_img_comp_dest->w - l_width_dest); /* Move the output buffer to the first place where we will write*/ l_dest_ptr = l_img_comp_dest->data + l_start_offset_dest; @@ -7508,13 +8219,13 @@ opj_bool opj_j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data, opj return OPJ_TRUE; } -opj_bool opj_j2k_set_decode_area( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_set_decode_area( opj_j2k_t *p_j2k, 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 ) { - opj_cp_v2_t * l_cp = &(p_j2k->m_cp); + opj_cp_t * l_cp = &(p_j2k->m_cp); opj_image_t * l_image = p_j2k->m_private_image; OPJ_UINT32 it_comp; @@ -7523,12 +8234,12 @@ opj_bool opj_j2k_set_decode_area( opj_j2k_v2_t *p_j2k, /* Check if we are read the main header */ if (p_j2k->m_specific_param.m_decoder.m_state != J2K_STATE_TPHSOT) { /* FIXME J2K_DEC_STATE_TPHSOT)*/ - opj_event_msg_v2(p_manager, EVT_ERROR, "Need to decode the main header before begin to decode the remaining codestream"); + opj_event_msg(p_manager, EVT_ERROR, "Need to decode the main header before begin to decode the remaining codestream"); return OPJ_FALSE; } if ( !p_start_x && !p_start_y && !p_end_x && !p_end_y){ - opj_event_msg_v2(p_manager, EVT_INFO, "No decoded area parameters, set the decoded area to the whole image\n"); + opj_event_msg(p_manager, EVT_INFO, "No decoded area parameters, set the decoded area to the whole image\n"); p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0; p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0; @@ -7546,80 +8257,80 @@ opj_bool opj_j2k_set_decode_area( opj_j2k_v2_t *p_j2k, assert(p_start_y >= 0 ); if ((OPJ_UINT32)p_start_x > l_image->x1 ) { - opj_event_msg_v2(p_manager, EVT_ERROR, + opj_event_msg(p_manager, EVT_ERROR, "Left position of the decoded area (region_x0=%d) is outside the image area (Xsiz=%d).\n", p_start_x, l_image->x1); return OPJ_FALSE; } else if ((OPJ_UINT32)p_start_x < l_image->x0){ - opj_event_msg_v2(p_manager, EVT_WARNING, + opj_event_msg(p_manager, EVT_WARNING, "Left position of the decoded area (region_x0=%d) is outside the image area (XOsiz=%d).\n", p_start_x, l_image->x0); p_j2k->m_specific_param.m_decoder.m_start_tile_x = 0; p_image->x0 = l_image->x0; } else { - p_j2k->m_specific_param.m_decoder.m_start_tile_x = (p_start_x - l_cp->tx0) / l_cp->tdx; - p_image->x0 = p_start_x; + p_j2k->m_specific_param.m_decoder.m_start_tile_x = ((OPJ_UINT32)p_start_x - l_cp->tx0) / l_cp->tdx; + p_image->x0 = (OPJ_UINT32)p_start_x; } /* Up */ if ((OPJ_UINT32)p_start_y > l_image->y1){ - opj_event_msg_v2(p_manager, EVT_ERROR, + opj_event_msg(p_manager, EVT_ERROR, "Up position of the decoded area (region_y0=%d) is outside the image area (Ysiz=%d).\n", p_start_y, l_image->y1); return OPJ_FALSE; } else if ((OPJ_UINT32)p_start_y < l_image->y0){ - opj_event_msg_v2(p_manager, EVT_WARNING, + opj_event_msg(p_manager, EVT_WARNING, "Up position of the decoded area (region_y0=%d) is outside the image area (YOsiz=%d).\n", p_start_y, l_image->y0); p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0; p_image->y0 = l_image->y0; } else { - p_j2k->m_specific_param.m_decoder.m_start_tile_y = (p_start_y - l_cp->ty0) / l_cp->tdy; - p_image->y0 = p_start_y; + p_j2k->m_specific_param.m_decoder.m_start_tile_y = ((OPJ_UINT32)p_start_y - l_cp->ty0) / l_cp->tdy; + p_image->y0 = (OPJ_UINT32)p_start_y; } /* Right */ assert((OPJ_UINT32)p_end_x > 0); assert((OPJ_UINT32)p_end_y > 0); if ((OPJ_UINT32)p_end_x < l_image->x0) { - opj_event_msg_v2(p_manager, EVT_ERROR, + opj_event_msg(p_manager, EVT_ERROR, "Right position of the decoded area (region_x1=%d) is outside the image area (XOsiz=%d).\n", p_end_x, l_image->x0); return OPJ_FALSE; } else if ((OPJ_UINT32)p_end_x > l_image->x1) { - opj_event_msg_v2(p_manager, EVT_WARNING, + opj_event_msg(p_manager, EVT_WARNING, "Right position of the decoded area (region_x1=%d) is outside the image area (Xsiz=%d).\n", p_end_x, l_image->x1); p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw; p_image->x1 = l_image->x1; } else { - p_j2k->m_specific_param.m_decoder.m_end_tile_x = opj_int_ceildiv((p_end_x - l_cp->tx0), l_cp->tdx); - p_image->x1 = p_end_x; + p_j2k->m_specific_param.m_decoder.m_end_tile_x = (OPJ_UINT32)opj_int_ceildiv(p_end_x - (OPJ_INT32)l_cp->tx0, (OPJ_INT32)l_cp->tdx); + p_image->x1 = (OPJ_UINT32)p_end_x; } /* Bottom */ if ((OPJ_UINT32)p_end_y < l_image->y0) { - opj_event_msg_v2(p_manager, EVT_ERROR, + opj_event_msg(p_manager, EVT_ERROR, "Bottom position of the decoded area (region_y1=%d) is outside the image area (YOsiz=%d).\n", p_end_y, l_image->y0); return OPJ_FALSE; } if ((OPJ_UINT32)p_end_y > l_image->y1){ - opj_event_msg_v2(p_manager, EVT_WARNING, + opj_event_msg(p_manager, EVT_WARNING, "Bottom position of the decoded area (region_y1=%d) is outside the image area (Ysiz=%d).\n", p_end_y, l_image->y1); p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th; p_image->y1 = l_image->y1; } else{ - p_j2k->m_specific_param.m_decoder.m_end_tile_y = opj_int_ceildiv((p_end_y - l_cp->ty0), l_cp->tdy); - p_image->y1 = p_end_y; + p_j2k->m_specific_param.m_decoder.m_end_tile_y = (OPJ_UINT32)opj_int_ceildiv(p_end_y - (OPJ_INT32)l_cp->ty0, (OPJ_INT32)l_cp->tdy); + p_image->y1 = (OPJ_UINT32)p_end_y; } /* ----- */ @@ -7630,65 +8341,63 @@ opj_bool opj_j2k_set_decode_area( opj_j2k_v2_t *p_j2k, { OPJ_INT32 l_h,l_w; - l_img_comp->x0 = opj_int_ceildiv(p_image->x0, l_img_comp->dx); - l_img_comp->y0 = opj_int_ceildiv(p_image->y0, l_img_comp->dy); - l_comp_x1 = opj_int_ceildiv(p_image->x1, l_img_comp->dx); - l_comp_y1 = opj_int_ceildiv(p_image->y1, l_img_comp->dy); + l_img_comp->x0 = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)p_image->x0, (OPJ_INT32)l_img_comp->dx); + l_img_comp->y0 = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)p_image->y0, (OPJ_INT32)l_img_comp->dy); + l_comp_x1 = opj_int_ceildiv((OPJ_INT32)p_image->x1, (OPJ_INT32)l_img_comp->dx); + l_comp_y1 = opj_int_ceildiv((OPJ_INT32)p_image->y1, (OPJ_INT32)l_img_comp->dy); - l_w = opj_int_ceildivpow2(l_comp_x1, l_img_comp->factor) - - opj_int_ceildivpow2(l_img_comp->x0, l_img_comp->factor); + l_w = opj_int_ceildivpow2(l_comp_x1, (OPJ_INT32)l_img_comp->factor) + - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->x0, (OPJ_INT32)l_img_comp->factor); if (l_w < 0){ - opj_event_msg_v2(p_manager, EVT_ERROR, + opj_event_msg(p_manager, EVT_ERROR, "Size x of the decoded component image is incorrect (comp[%d].w=%d).\n", it_comp, l_w); return OPJ_FALSE; } - l_img_comp->w = l_w; + l_img_comp->w = (OPJ_UINT32)l_w; - l_h = opj_int_ceildivpow2(l_comp_y1, l_img_comp->factor) - - opj_int_ceildivpow2(l_img_comp->y0, l_img_comp->factor); + l_h = opj_int_ceildivpow2(l_comp_y1, (OPJ_INT32)l_img_comp->factor) + - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->y0, (OPJ_INT32)l_img_comp->factor); if (l_h < 0){ - opj_event_msg_v2(p_manager, EVT_ERROR, + opj_event_msg(p_manager, EVT_ERROR, "Size y of the decoded component image is incorrect (comp[%d].h=%d).\n", it_comp, l_h); return OPJ_FALSE; } - l_img_comp->h = l_h; + l_img_comp->h = (OPJ_UINT32)l_h; l_img_comp++; } - opj_event_msg_v2( p_manager, EVT_INFO,"Setting decoding area to %d,%d,%d,%d\n", + opj_event_msg( p_manager, EVT_INFO,"Setting decoding area to %d,%d,%d,%d\n", p_image->x0, p_image->y0, p_image->x1, p_image->y1); return OPJ_TRUE; } -opj_j2k_v2_t* opj_j2k_create_decompress(void) +opj_j2k_t* opj_j2k_create_decompress(void) { - opj_j2k_v2_t *l_j2k = (opj_j2k_v2_t*) opj_malloc(sizeof(opj_j2k_v2_t)); + opj_j2k_t *l_j2k = (opj_j2k_t*) opj_calloc(1,sizeof(opj_j2k_t)); if (!l_j2k) { return 00; } - memset(l_j2k,0,sizeof(opj_j2k_v2_t)); l_j2k->m_is_decoder = 1; l_j2k->m_cp.m_is_decoder = 1; - l_j2k->m_specific_param.m_decoder.m_default_tcp = (opj_tcp_v2_t*) opj_malloc(sizeof(opj_tcp_v2_t)); + l_j2k->m_specific_param.m_decoder.m_default_tcp = (opj_tcp_t*) opj_calloc(1,sizeof(opj_tcp_t)); if (!l_j2k->m_specific_param.m_decoder.m_default_tcp) { opj_j2k_destroy(l_j2k); return 00; } - memset(l_j2k->m_specific_param.m_decoder.m_default_tcp,0,sizeof(opj_tcp_v2_t)); - l_j2k->m_specific_param.m_decoder.m_header_data = (OPJ_BYTE *) opj_malloc(J2K_DEFAULT_HEADER_SIZE); + l_j2k->m_specific_param.m_decoder.m_header_data = (OPJ_BYTE *) opj_calloc(1,OPJ_J2K_DEFAULT_HEADER_SIZE); if (! l_j2k->m_specific_param.m_decoder.m_header_data) { opj_j2k_destroy(l_j2k); return 00; } - l_j2k->m_specific_param.m_decoder.m_header_data_size = J2K_DEFAULT_HEADER_SIZE; + l_j2k->m_specific_param.m_decoder.m_header_data_size = OPJ_J2K_DEFAULT_HEADER_SIZE; l_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec = -1 ; @@ -7696,16 +8405,11 @@ opj_j2k_v2_t* opj_j2k_create_decompress(void) /* codestream index creation */ l_j2k->cstr_index = opj_j2k_create_cstr_index(); - - /*(opj_codestream_index_t*) opj_malloc(sizeof(opj_codestream_index_t)); if (!l_j2k->cstr_index){ opj_j2k_destroy(l_j2k); - return NULL; + return 00; } - l_j2k->cstr_index->marker = (opj_marker_info_t*) opj_malloc(100 * sizeof(opj_marker_info_t)); -*/ - /* validation list creation */ l_j2k->m_validation_list = opj_procedure_list_create(); if (! l_j2k->m_validation_list) { @@ -7742,12 +8446,12 @@ opj_codestream_index_t* opj_j2k_create_cstr_index(void) return cstr_index; } -OPJ_UINT32 opj_j2k_get_SPCod_SPCoc_size ( opj_j2k_v2_t *p_j2k, +OPJ_UINT32 opj_j2k_get_SPCod_SPCoc_size ( opj_j2k_t *p_j2k, OPJ_UINT32 p_tile_no, OPJ_UINT32 p_comp_no ) { - opj_cp_v2_t *l_cp = 00; - opj_tcp_v2_t *l_tcp = 00; + opj_cp_t *l_cp = 00; + opj_tcp_t *l_tcp = 00; opj_tccp_t *l_tccp = 00; /* preconditions */ @@ -7769,7 +8473,7 @@ OPJ_UINT32 opj_j2k_get_SPCod_SPCoc_size ( opj_j2k_v2_t *p_j2k, } } -opj_bool opj_j2k_write_SPCod_SPCoc( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_SPCod_SPCoc( opj_j2k_t *p_j2k, OPJ_UINT32 p_tile_no, OPJ_UINT32 p_comp_no, OPJ_BYTE * p_data, @@ -7777,8 +8481,8 @@ opj_bool opj_j2k_write_SPCod_SPCoc( opj_j2k_v2_t *p_j2k, struct opj_event_mgr * p_manager ) { OPJ_UINT32 i; - opj_cp_v2_t *l_cp = 00; - opj_tcp_v2_t *l_tcp = 00; + opj_cp_t *l_cp = 00; + opj_tcp_t *l_tcp = 00; opj_tccp_t *l_tccp = 00; /* preconditions */ @@ -7796,7 +8500,7 @@ opj_bool opj_j2k_write_SPCod_SPCoc( opj_j2k_v2_t *p_j2k, assert(p_comp_no <(p_j2k->m_private_image->numcomps)); if (*p_header_size < 5) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error writing SPCod SPCoc element\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error writing SPCod SPCoc element\n"); return OPJ_FALSE; } @@ -7820,7 +8524,7 @@ opj_bool opj_j2k_write_SPCod_SPCoc( opj_j2k_v2_t *p_j2k, if (l_tccp->csty & J2K_CCP_CSTY_PRT) { if (*p_header_size < l_tccp->numresolutions) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error writing SPCod SPCoc element\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error writing SPCod SPCoc element\n"); return OPJ_FALSE; } @@ -7835,15 +8539,15 @@ opj_bool opj_j2k_write_SPCod_SPCoc( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_read_SPCod_SPCoc( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_read_SPCod_SPCoc( opj_j2k_t *p_j2k, OPJ_UINT32 compno, OPJ_BYTE * p_header_data, OPJ_UINT32 * p_header_size, opj_event_mgr_t * p_manager) { OPJ_UINT32 i, l_tmp; - opj_cp_v2_t *l_cp = NULL; - opj_tcp_v2_t *l_tcp = NULL; + opj_cp_t *l_cp = NULL; + opj_tcp_t *l_tcp = NULL; opj_tccp_t *l_tccp = NULL; OPJ_BYTE * l_current_ptr = NULL; @@ -7865,17 +8569,23 @@ opj_bool opj_j2k_read_SPCod_SPCoc( opj_j2k_v2_t *p_j2k, /* make sure room is sufficient */ if (*p_header_size < 5) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading SPCod SPCoc element\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading SPCod SPCoc element\n"); return OPJ_FALSE; } opj_read_bytes(l_current_ptr, &l_tccp->numresolutions ,1); /* SPcox (D) */ ++l_tccp->numresolutions; /* tccp->numresolutions = read() + 1 */ + if (l_tccp->numresolutions > OPJ_J2K_MAXRLVLS) { + opj_event_msg(p_manager, EVT_ERROR, + "Invalid value for numresolutions : %d, max value is set in openjpeg.h at %d\n", + l_tccp->numresolutions, OPJ_J2K_MAXRLVLS); + return OPJ_FALSE; + } ++l_current_ptr; /* If user wants to remove more resolutions than the codestream contains, return error */ if (l_cp->m_specific_param.m_dec.m_reduce >= l_tccp->numresolutions) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error decoding component %d.\nThe number of resolutions to remove is higher than the number " + opj_event_msg(p_manager, EVT_ERROR, "Error decoding component %d.\nThe number of resolutions to remove is higher than the number " "of resolutions of this component\nModify the cp_reduce parameter.\n\n", compno); p_j2k->m_specific_param.m_decoder.m_state |= 0x8000;/* FIXME J2K_DEC_STATE_ERR;*/ return OPJ_FALSE; @@ -7900,7 +8610,7 @@ opj_bool opj_j2k_read_SPCod_SPCoc( opj_j2k_v2_t *p_j2k, /* use custom precinct size ? */ if (l_tccp->csty & J2K_CCP_CSTY_PRT) { if (*p_header_size < l_tccp->numresolutions) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading SPCod SPCoc element\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading SPCod SPCoc element\n"); return OPJ_FALSE; } @@ -7941,12 +8651,12 @@ opj_bool opj_j2k_read_SPCod_SPCoc( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -void opj_j2k_copy_tile_component_parameters( opj_j2k_v2_t *p_j2k ) +void opj_j2k_copy_tile_component_parameters( opj_j2k_t *p_j2k ) { /* loop */ OPJ_UINT32 i; - opj_cp_v2_t *l_cp = NULL; - opj_tcp_v2_t *l_tcp = NULL; + opj_cp_t *l_cp = NULL; + opj_tcp_t *l_tcp = NULL; opj_tccp_t *l_ref_tccp = NULL, *l_copied_tccp = NULL; OPJ_UINT32 l_prc_size; @@ -7960,7 +8670,7 @@ void opj_j2k_copy_tile_component_parameters( opj_j2k_v2_t *p_j2k ) l_ref_tccp = &l_tcp->tccps[0]; l_copied_tccp = l_ref_tccp + 1; - l_prc_size = l_ref_tccp->numresolutions * sizeof(OPJ_UINT32); + l_prc_size = l_ref_tccp->numresolutions * (OPJ_UINT32)sizeof(OPJ_UINT32); for (i=1; im_private_image->numcomps; ++i) { l_copied_tccp->numresolutions = l_ref_tccp->numresolutions; @@ -7974,14 +8684,14 @@ void opj_j2k_copy_tile_component_parameters( opj_j2k_v2_t *p_j2k ) } } -OPJ_UINT32 opj_j2k_get_SQcd_SQcc_size ( opj_j2k_v2_t *p_j2k, +OPJ_UINT32 opj_j2k_get_SQcd_SQcc_size ( opj_j2k_t *p_j2k, OPJ_UINT32 p_tile_no, OPJ_UINT32 p_comp_no ) { OPJ_UINT32 l_num_bands; - opj_cp_v2_t *l_cp = 00; - opj_tcp_v2_t *l_tcp = 00; + opj_cp_t *l_cp = 00; + opj_tcp_t *l_tcp = 00; opj_tccp_t *l_tccp = 00; /* preconditions */ @@ -8005,7 +8715,7 @@ OPJ_UINT32 opj_j2k_get_SQcd_SQcc_size ( opj_j2k_v2_t *p_j2k, } } -opj_bool opj_j2k_write_SQcd_SQcc( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_SQcd_SQcc( opj_j2k_t *p_j2k, OPJ_UINT32 p_tile_no, OPJ_UINT32 p_comp_no, OPJ_BYTE * p_data, @@ -8016,8 +8726,8 @@ opj_bool opj_j2k_write_SQcd_SQcc( opj_j2k_v2_t *p_j2k, OPJ_UINT32 l_band_no, l_num_bands; OPJ_UINT32 l_expn,l_mant; - opj_cp_v2_t *l_cp = 00; - opj_tcp_v2_t *l_tcp = 00; + opj_cp_t *l_cp = 00; + opj_tcp_t *l_tcp = 00; opj_tccp_t *l_tccp = 00; /* preconditions */ @@ -8040,7 +8750,7 @@ opj_bool opj_j2k_write_SQcd_SQcc( opj_j2k_v2_t *p_j2k, l_header_size = 1 + l_num_bands; if (*p_header_size < l_header_size) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error writing SQcd SQcc element\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error writing SQcd SQcc element\n"); return OPJ_FALSE; } @@ -8048,7 +8758,7 @@ opj_bool opj_j2k_write_SQcd_SQcc( opj_j2k_v2_t *p_j2k, ++p_data; for (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no) { - l_expn = l_tccp->stepsizes[l_band_no].expn; + l_expn = (OPJ_UINT32)l_tccp->stepsizes[l_band_no].expn; opj_write_bytes(p_data, l_expn << 3, 1); /* SPqcx_i */ ++p_data; } @@ -8057,7 +8767,7 @@ opj_bool opj_j2k_write_SQcd_SQcc( opj_j2k_v2_t *p_j2k, l_header_size = 1 + 2*l_num_bands; if (*p_header_size < l_header_size) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error writing SQcd SQcc element\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error writing SQcd SQcc element\n"); return OPJ_FALSE; } @@ -8065,8 +8775,8 @@ opj_bool opj_j2k_write_SQcd_SQcc( opj_j2k_v2_t *p_j2k, ++p_data; for (l_band_no = 0; l_band_no < l_num_bands; ++l_band_no) { - l_expn = l_tccp->stepsizes[l_band_no].expn; - l_mant = l_tccp->stepsizes[l_band_no].mant; + l_expn = (OPJ_UINT32)l_tccp->stepsizes[l_band_no].expn; + l_mant = (OPJ_UINT32)l_tccp->stepsizes[l_band_no].mant; opj_write_bytes(p_data, (l_expn << 11) + l_mant, 2); /* SPqcx_i */ p_data += 2; @@ -8078,7 +8788,7 @@ opj_bool opj_j2k_write_SQcd_SQcc( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_read_SQcd_SQcc(opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_read_SQcd_SQcc(opj_j2k_t *p_j2k, OPJ_UINT32 p_comp_no, OPJ_BYTE* p_header_data, OPJ_UINT32 * p_header_size, @@ -8087,8 +8797,8 @@ opj_bool opj_j2k_read_SQcd_SQcc(opj_j2k_v2_t *p_j2k, { /* loop*/ OPJ_UINT32 l_band_no; - opj_cp_v2_t *l_cp = 00; - opj_tcp_v2_t *l_tcp = 00; + opj_cp_t *l_cp = 00; + opj_tcp_t *l_tcp = 00; opj_tccp_t *l_tccp = 00; OPJ_BYTE * l_current_ptr = 00; OPJ_UINT32 l_tmp, l_num_band; @@ -8111,7 +8821,7 @@ opj_bool opj_j2k_read_SQcd_SQcc(opj_j2k_v2_t *p_j2k, l_current_ptr = p_header_data; if (*p_header_size < 1) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading SQcd or SQcc element\n"); + opj_event_msg(p_manager, EVT_ERROR, "Error reading SQcd or SQcc element\n"); return OPJ_FALSE; } *p_header_size -= 1; @@ -8129,10 +8839,10 @@ opj_bool opj_j2k_read_SQcd_SQcc(opj_j2k_v2_t *p_j2k, (*p_header_size) : (*p_header_size) / 2; - if( l_num_band > J2K_MAXBANDS ) { - opj_event_msg_v2(p_manager, EVT_WARNING, "While reading CCP_QNTSTY element inside QCD or QCC marker segment, " - "number of subbands (%d) is greater to J2K_MAXBANDS (%d). So we limit the number of elements stored to " - "J2K_MAXBANDS (%d) and skip the rest. \n", l_num_band, J2K_MAXBANDS, J2K_MAXBANDS); + if( l_num_band > OPJ_J2K_MAXBANDS ) { + opj_event_msg(p_manager, EVT_WARNING, "While reading CCP_QNTSTY element inside QCD or QCC marker segment, " + "number of subbands (%d) is greater to OPJ_J2K_MAXBANDS (%d). So we limit the number of elements stored to " + "OPJ_J2K_MAXBANDS (%d) and skip the rest. \n", l_num_band, OPJ_J2K_MAXBANDS, OPJ_J2K_MAXBANDS); /*return OPJ_FALSE;*/ } } @@ -8141,17 +8851,17 @@ opj_bool opj_j2k_read_SQcd_SQcc(opj_j2k_v2_t *p_j2k, if (l_cp->correct) { /* if JPWL is on, we check whether there are too many subbands */ - if (/*(l_num_band < 0) ||*/ (l_num_band >= J2K_MAXBANDS)) { - opj_event_msg_v2(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR, + if (/*(l_num_band < 0) ||*/ (l_num_band >= OPJ_J2K_MAXBANDS)) { + opj_event_msg(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR, "JPWL: bad number of subbands in Sqcx (%d)\n", l_num_band); if (!JPWL_ASSUME) { - opj_event_msg_v2(p_manager, EVT_ERROR, "JPWL: giving up\n"); + opj_event_msg(p_manager, EVT_ERROR, "JPWL: giving up\n"); return OPJ_FALSE; } /* we try to correct */ l_num_band = 1; - opj_event_msg_v2(p_manager, EVT_WARNING, "- trying to adjust them\n" + opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust them\n" "- setting number of bands to %d => HYPOTHESIS!!!\n", l_num_band); }; @@ -8163,8 +8873,8 @@ opj_bool opj_j2k_read_SQcd_SQcc(opj_j2k_v2_t *p_j2k, for (l_band_no = 0; l_band_no < l_num_band; l_band_no++) { opj_read_bytes(l_current_ptr, &l_tmp ,1); /* SPqcx_i */ ++l_current_ptr; - if (l_band_no < J2K_MAXBANDS){ - l_tccp->stepsizes[l_band_no].expn = l_tmp>>3; + if (l_band_no < OPJ_J2K_MAXBANDS){ + l_tccp->stepsizes[l_band_no].expn = (OPJ_INT32)(l_tmp >> 3); l_tccp->stepsizes[l_band_no].mant = 0; } } @@ -8174,8 +8884,8 @@ opj_bool opj_j2k_read_SQcd_SQcc(opj_j2k_v2_t *p_j2k, for (l_band_no = 0; l_band_no < l_num_band; l_band_no++) { opj_read_bytes(l_current_ptr, &l_tmp ,2); /* SPqcx_i */ l_current_ptr+=2; - if (l_band_no < J2K_MAXBANDS){ - l_tccp->stepsizes[l_band_no].expn = l_tmp >> 11; + if (l_band_no < OPJ_J2K_MAXBANDS){ + l_tccp->stepsizes[l_band_no].expn = (OPJ_INT32)(l_tmp >> 11); l_tccp->stepsizes[l_band_no].mant = l_tmp & 0x7ff; } } @@ -8184,10 +8894,10 @@ opj_bool opj_j2k_read_SQcd_SQcc(opj_j2k_v2_t *p_j2k, /* Add Antonin : if scalar_derived -> compute other stepsizes */ if (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) { - for (l_band_no = 1; l_band_no < J2K_MAXBANDS; l_band_no++) { + for (l_band_no = 1; l_band_no < OPJ_J2K_MAXBANDS; l_band_no++) { l_tccp->stepsizes[l_band_no].expn = - ((l_tccp->stepsizes[0].expn) - ((l_band_no - 1) / 3) > 0) ? - (l_tccp->stepsizes[0].expn) - ((l_band_no - 1) / 3) : 0; + ((OPJ_INT32)(l_tccp->stepsizes[0].expn) - (OPJ_INT32)((l_band_no - 1) / 3) > 0) ? + (OPJ_INT32)(l_tccp->stepsizes[0].expn) - (OPJ_INT32)((l_band_no - 1) / 3) : 0; l_tccp->stepsizes[l_band_no].mant = l_tccp->stepsizes[0].mant; } } @@ -8195,11 +8905,11 @@ opj_bool opj_j2k_read_SQcd_SQcc(opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -void opj_j2k_copy_tile_quantization_parameters( opj_j2k_v2_t *p_j2k ) +void opj_j2k_copy_tile_quantization_parameters( opj_j2k_t *p_j2k ) { OPJ_UINT32 i; - opj_cp_v2_t *l_cp = NULL; - opj_tcp_v2_t *l_tcp = NULL; + opj_cp_t *l_cp = NULL; + opj_tcp_t *l_tcp = NULL; opj_tccp_t *l_ref_tccp = NULL; opj_tccp_t *l_copied_tccp = NULL; OPJ_UINT32 l_size; @@ -8214,7 +8924,7 @@ void opj_j2k_copy_tile_quantization_parameters( opj_j2k_v2_t *p_j2k ) l_ref_tccp = &l_tcp->tccps[0]; l_copied_tccp = l_ref_tccp + 1; - l_size = J2K_MAXBANDS * sizeof(opj_stepsize_t); + l_size = OPJ_J2K_MAXBANDS * sizeof(opj_stepsize_t); for (i=1;im_private_image->numcomps;++i) { l_copied_tccp->qntsty = l_ref_tccp->qntsty; @@ -8224,7 +8934,59 @@ void opj_j2k_copy_tile_quantization_parameters( opj_j2k_v2_t *p_j2k ) } } -void j2k_dump (opj_j2k_v2_t* p_j2k, OPJ_INT32 flag, FILE* out_stream) +static void opj_j2k_dump_tile_info( opj_tcp_t * l_default_tile,OPJ_INT32 numcomps,FILE* out_stream) +{ + if (l_default_tile) + { + OPJ_INT32 compno; + + fprintf(out_stream, "\t default tile {\n"); + fprintf(out_stream, "\t\t csty=%#x\n", l_default_tile->csty); + fprintf(out_stream, "\t\t prg=%#x\n", l_default_tile->prg); + fprintf(out_stream, "\t\t numlayers=%d\n", l_default_tile->numlayers); + fprintf(out_stream, "\t\t mct=%x\n", l_default_tile->mct); + + for (compno = 0; compno < numcomps; compno++) { + opj_tccp_t *l_tccp = &(l_default_tile->tccps[compno]); + OPJ_UINT32 resno; + OPJ_INT32 bandno, numbands; + + /* coding style*/ + fprintf(out_stream, "\t\t comp %d {\n", compno); + fprintf(out_stream, "\t\t\t csty=%#x\n", l_tccp->csty); + fprintf(out_stream, "\t\t\t numresolutions=%d\n", l_tccp->numresolutions); + fprintf(out_stream, "\t\t\t cblkw=2^%d\n", l_tccp->cblkw); + fprintf(out_stream, "\t\t\t cblkh=2^%d\n", l_tccp->cblkh); + fprintf(out_stream, "\t\t\t cblksty=%#x\n", l_tccp->cblksty); + fprintf(out_stream, "\t\t\t qmfbid=%d\n", l_tccp->qmfbid); + + fprintf(out_stream, "\t\t\t preccintsize (w,h)="); + for (resno = 0; resno < l_tccp->numresolutions; resno++) { + fprintf(out_stream, "(%d,%d) ", l_tccp->prcw[resno], l_tccp->prch[resno]); + } + fprintf(out_stream, "\n"); + + /* quantization style*/ + fprintf(out_stream, "\t\t\t qntsty=%d\n", l_tccp->qntsty); + fprintf(out_stream, "\t\t\t numgbits=%d\n", l_tccp->numgbits); + fprintf(out_stream, "\t\t\t stepsizes (m,e)="); + numbands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 : (OPJ_INT32)l_tccp->numresolutions * 3 - 2; + for (bandno = 0; bandno < numbands; bandno++) { + fprintf(out_stream, "(%d,%d) ", l_tccp->stepsizes[bandno].mant, + l_tccp->stepsizes[bandno].expn); + } + fprintf(out_stream, "\n"); + + /* RGN value*/ + fprintf(out_stream, "\t\t\t roishift=%d\n", l_tccp->roishift); + + fprintf(out_stream, "\t\t }\n"); + } /*end of component of default tile*/ + fprintf(out_stream, "\t }\n"); /*end of default tile*/ + } +} + +void j2k_dump (opj_j2k_t* p_j2k, OPJ_INT32 flag, FILE* out_stream) { /* Check if the flag is compatible with j2k file*/ if ( (flag & OPJ_JP2_INFO) || (flag & OPJ_JP2_IND)){ @@ -8242,6 +9004,16 @@ void j2k_dump (opj_j2k_v2_t* p_j2k, OPJ_INT32 flag, FILE* out_stream) if (flag & OPJ_J2K_MH_INFO){ opj_j2k_dump_MH_info(p_j2k, out_stream); } + /* Dump all tile/codestream info */ + if (flag & OPJ_J2K_TCH_INFO){ + OPJ_UINT32 l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw; + OPJ_UINT32 i; + opj_tcp_t * l_tcp = p_j2k->m_cp.tcps; + for (i=0;im_private_image->numcomps, out_stream); + ++l_tcp; + } + } /* Dump the codestream info of the current tile */ if (flag & OPJ_J2K_TH_INFO){ @@ -8260,7 +9032,7 @@ void j2k_dump (opj_j2k_v2_t* p_j2k, OPJ_INT32 flag, FILE* out_stream) } -void opj_j2k_dump_MH_index(opj_j2k_v2_t* p_j2k, FILE* out_stream) +void opj_j2k_dump_MH_index(opj_j2k_t* p_j2k, FILE* out_stream) { opj_codestream_index_t* cstr_index = p_j2k->cstr_index; OPJ_UINT32 it_marker, it_tile, it_tile_part; @@ -8328,73 +9100,20 @@ void opj_j2k_dump_MH_index(opj_j2k_v2_t* p_j2k, FILE* out_stream) } -void opj_j2k_dump_MH_info(opj_j2k_v2_t* p_j2k, FILE* out_stream) + +void opj_j2k_dump_MH_info(opj_j2k_t* p_j2k, FILE* out_stream) { - opj_tcp_v2_t * l_default_tile=NULL; fprintf(out_stream, "Codestream info from main header: {\n"); fprintf(out_stream, "\t tx0=%d, ty0=%d\n", p_j2k->m_cp.tx0, p_j2k->m_cp.ty0); fprintf(out_stream, "\t tdx=%d, tdy=%d\n", p_j2k->m_cp.tdx, p_j2k->m_cp.tdy); fprintf(out_stream, "\t tw=%d, th=%d\n", p_j2k->m_cp.tw, p_j2k->m_cp.th); - - l_default_tile = p_j2k->m_specific_param.m_decoder.m_default_tcp; - if (l_default_tile) - { - OPJ_INT32 compno; - OPJ_INT32 numcomps = p_j2k->m_private_image->numcomps; - - fprintf(out_stream, "\t default tile {\n"); - fprintf(out_stream, "\t\t csty=%#x\n", l_default_tile->csty); - fprintf(out_stream, "\t\t prg=%#x\n", l_default_tile->prg); - fprintf(out_stream, "\t\t numlayers=%d\n", l_default_tile->numlayers); - fprintf(out_stream, "\t\t mct=%x\n", l_default_tile->mct); - - for (compno = 0; compno < numcomps; compno++) { - opj_tccp_t *l_tccp = &(l_default_tile->tccps[compno]); - OPJ_UINT32 resno; - OPJ_INT32 bandno, numbands; - - /* coding style*/ - fprintf(out_stream, "\t\t comp %d {\n", compno); - fprintf(out_stream, "\t\t\t csty=%#x\n", l_tccp->csty); - fprintf(out_stream, "\t\t\t numresolutions=%d\n", l_tccp->numresolutions); - fprintf(out_stream, "\t\t\t cblkw=2^%d\n", l_tccp->cblkw); - fprintf(out_stream, "\t\t\t cblkh=2^%d\n", l_tccp->cblkh); - fprintf(out_stream, "\t\t\t cblksty=%#x\n", l_tccp->cblksty); - fprintf(out_stream, "\t\t\t qmfbid=%d\n", l_tccp->qmfbid); - - fprintf(out_stream, "\t\t\t preccintsize (w,h)="); - for (resno = 0; resno < l_tccp->numresolutions; resno++) { - fprintf(out_stream, "(%d,%d) ", l_tccp->prcw[resno], l_tccp->prch[resno]); - } - fprintf(out_stream, "\n"); - - /* quantization style*/ - fprintf(out_stream, "\t\t\t qntsty=%d\n", l_tccp->qntsty); - fprintf(out_stream, "\t\t\t numgbits=%d\n", l_tccp->numgbits); - fprintf(out_stream, "\t\t\t stepsizes (m,e)="); - numbands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 : l_tccp->numresolutions * 3 - 2; - for (bandno = 0; bandno < numbands; bandno++) { - fprintf(out_stream, "(%d,%d) ", l_tccp->stepsizes[bandno].mant, - l_tccp->stepsizes[bandno].expn); - } - fprintf(out_stream, "\n"); - - /* RGN value*/ - fprintf(out_stream, "\t\t\t roishift=%d\n", l_tccp->roishift); - - fprintf(out_stream, "\t\t }\n"); - } /*end of component of default tile*/ - fprintf(out_stream, "\t }\n"); /*end of default tile*/ - - } - + opj_j2k_dump_tile_info(p_j2k->m_specific_param.m_decoder.m_default_tcp,(OPJ_INT32)p_j2k->m_private_image->numcomps, out_stream); fprintf(out_stream, "}\n"); - } -void j2k_dump_image_header(opj_image_t* img_header, opj_bool dev_dump_flag, FILE* out_stream) +void j2k_dump_image_header(opj_image_t* img_header, OPJ_BOOL dev_dump_flag, FILE* out_stream) { char tab[2]; @@ -8423,7 +9142,7 @@ void j2k_dump_image_header(opj_image_t* img_header, opj_bool dev_dump_flag, FILE fprintf(out_stream, "}\n"); } -void j2k_dump_image_comp_header(opj_image_comp_t* comp_header, opj_bool dev_dump_flag, FILE* out_stream) +void j2k_dump_image_comp_header(opj_image_comp_t* comp_header, OPJ_BOOL dev_dump_flag, FILE* out_stream) { char tab[3]; @@ -8442,12 +9161,14 @@ void j2k_dump_image_comp_header(opj_image_comp_t* comp_header, opj_bool dev_dump fprintf(out_stream, "}\n"); } -opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_v2_t* p_j2k) +opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_t* p_j2k) { - OPJ_UINT16 compno; - OPJ_UINT16 numcomps = p_j2k->m_private_image->numcomps; - opj_tcp_v2_t *l_default_tile; + OPJ_UINT32 compno; + OPJ_UINT32 numcomps = p_j2k->m_private_image->numcomps; + opj_tcp_t *l_default_tile; opj_codestream_info_v2_t* cstr_info = (opj_codestream_info_v2_t*) opj_calloc(1,sizeof(opj_codestream_info_v2_t)); + if (!cstr_info) + return NULL; cstr_info->nbcomps = p_j2k->m_private_image->numcomps; @@ -8468,6 +9189,11 @@ opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_v2_t* p_j2k) cstr_info->m_default_tile_info.mct = l_default_tile->mct; cstr_info->m_default_tile_info.tccp_info = (opj_tccp_info_t*) opj_calloc(cstr_info->nbcomps, sizeof(opj_tccp_info_t)); + if (!cstr_info->m_default_tile_info.tccp_info) + { + opj_destroy_cstr_info(&cstr_info); + return NULL; + } for (compno = 0; compno < numcomps; compno++) { opj_tccp_t *l_tccp = &(l_default_tile->tccps[compno]); @@ -8481,7 +9207,7 @@ opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_v2_t* p_j2k) l_tccp_info->cblkh = l_tccp->cblkh; l_tccp_info->cblksty = l_tccp->cblksty; l_tccp_info->qmfbid = l_tccp->qmfbid; - if (l_tccp->numresolutions < J2K_MAXRLVLS) + if (l_tccp->numresolutions < OPJ_J2K_MAXRLVLS) { memcpy(l_tccp_info->prch, l_tccp->prch, l_tccp->numresolutions); memcpy(l_tccp_info->prcw, l_tccp->prcw, l_tccp->numresolutions); @@ -8491,11 +9217,11 @@ opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_v2_t* p_j2k) l_tccp_info->qntsty = l_tccp->qntsty; l_tccp_info->numgbits = l_tccp->numgbits; - numbands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 : l_tccp->numresolutions * 3 - 2; - if (numbands < J2K_MAXBANDS) { + numbands = (l_tccp->qntsty == J2K_CCP_QNTSTY_SIQNT) ? 1 : (OPJ_INT32)l_tccp->numresolutions * 3 - 2; + if (numbands < OPJ_J2K_MAXBANDS) { for (bandno = 0; bandno < numbands; bandno++) { - l_tccp_info->stepsizes_mant[bandno] = l_tccp->stepsizes[bandno].mant; - l_tccp_info->stepsizes_expn[bandno] = l_tccp->stepsizes[bandno].expn; + l_tccp_info->stepsizes_mant[bandno] = (OPJ_UINT32)l_tccp->stepsizes[bandno].mant; + l_tccp_info->stepsizes_expn[bandno] = (OPJ_UINT32)l_tccp->stepsizes[bandno].expn; } } @@ -8506,7 +9232,7 @@ opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_v2_t* p_j2k) return cstr_info; } -opj_codestream_index_t* j2k_get_cstr_index(opj_j2k_v2_t* p_j2k) +opj_codestream_index_t* j2k_get_cstr_index(opj_j2k_t* p_j2k) { opj_codestream_index_t* l_cstr_index = (opj_codestream_index_t*) opj_calloc(1,sizeof(opj_codestream_index_t)); @@ -8615,7 +9341,7 @@ opj_codestream_index_t* j2k_get_cstr_index(opj_j2k_v2_t* p_j2k) return l_cstr_index; } -opj_bool opj_j2k_allocate_tile_element_cstr_index(opj_j2k_v2_t *p_j2k) +OPJ_BOOL opj_j2k_allocate_tile_element_cstr_index(opj_j2k_t *p_j2k) { OPJ_UINT32 it_tile=0; @@ -8636,20 +9362,21 @@ opj_bool opj_j2k_allocate_tile_element_cstr_index(opj_j2k_v2_t *p_j2k) return OPJ_TRUE; } -opj_bool opj_j2k_decode_tiles ( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_decode_tiles ( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager) { - opj_bool l_go_on = OPJ_TRUE; + OPJ_BOOL l_go_on = OPJ_TRUE; OPJ_UINT32 l_current_tile_no; OPJ_UINT32 l_data_size,l_max_data_size; OPJ_INT32 l_tile_x0,l_tile_y0,l_tile_x1,l_tile_y1; OPJ_UINT32 l_nb_comps; OPJ_BYTE * l_current_data; + OPJ_UINT32 nr_tiles = 0; l_current_data = (OPJ_BYTE*)opj_malloc(1000); if (! l_current_data) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to decode tiles\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tiles\n"); return OPJ_FALSE; } l_max_data_size = 1000; @@ -8676,7 +9403,7 @@ opj_bool opj_j2k_decode_tiles ( opj_j2k_v2_t *p_j2k, OPJ_BYTE *l_new_current_data = (OPJ_BYTE *) opj_realloc(l_current_data, l_data_size); if (! l_new_current_data) { opj_free(l_current_data); - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to decode tile %d/%d\n", l_current_tile_no +1, p_j2k->m_cp.th * p_j2k->m_cp.tw); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tile %d/%d\n", l_current_tile_no +1, p_j2k->m_cp.th * p_j2k->m_cp.tw); return OPJ_FALSE; } l_current_data = l_new_current_data; @@ -8685,16 +9412,22 @@ opj_bool opj_j2k_decode_tiles ( opj_j2k_v2_t *p_j2k, if (! opj_j2k_decode_tile(p_j2k,l_current_tile_no,l_current_data,l_data_size,p_stream,p_manager)) { opj_free(l_current_data); + opj_event_msg(p_manager, EVT_ERROR, "Failed to decode tile %d/%d\n", l_current_tile_no +1, p_j2k->m_cp.th * p_j2k->m_cp.tw); return OPJ_FALSE; } - opj_event_msg_v2(p_manager, EVT_INFO, "Tile %d/%d has been decoded.\n", l_current_tile_no +1, p_j2k->m_cp.th * p_j2k->m_cp.tw); + opj_event_msg(p_manager, EVT_INFO, "Tile %d/%d has been decoded.\n", l_current_tile_no +1, p_j2k->m_cp.th * p_j2k->m_cp.tw); if (! opj_j2k_update_image_data(p_j2k->m_tcd,l_current_data, p_j2k->m_output_image)) { opj_free(l_current_data); return OPJ_FALSE; } - opj_event_msg_v2(p_manager, EVT_INFO, "Image data has been updated with tile %d.\n\n", l_current_tile_no + 1); - + opj_event_msg(p_manager, EVT_INFO, "Image data has been updated with tile %d.\n\n", l_current_tile_no + 1); + + if(opj_stream_get_number_byte_left(p_stream) == 0 + && p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_NEOC) + break; + if(++nr_tiles == p_j2k->m_cp.th * p_j2k->m_cp.tw) + break; } opj_free(l_current_data); @@ -8705,7 +9438,7 @@ opj_bool opj_j2k_decode_tiles ( opj_j2k_v2_t *p_j2k, /** * Sets up the procedures to do on decoding data. Developpers wanting to extend the library can add their own reading procedures. */ -static void opj_j2k_setup_decoding (opj_j2k_v2_t *p_j2k) +static void opj_j2k_setup_decoding (opj_j2k_t *p_j2k) { /* preconditions*/ assert(p_j2k != 00); @@ -8718,11 +9451,11 @@ static void opj_j2k_setup_decoding (opj_j2k_v2_t *p_j2k) /* * Read and decode one tile. */ -static opj_bool opj_j2k_decode_one_tile ( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_decode_one_tile ( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager) { - opj_bool l_go_on = OPJ_TRUE; + OPJ_BOOL l_go_on = OPJ_TRUE; OPJ_UINT32 l_current_tile_no; OPJ_UINT32 l_tile_no_to_dec; OPJ_UINT32 l_data_size,l_max_data_size; @@ -8732,7 +9465,7 @@ static opj_bool opj_j2k_decode_one_tile ( opj_j2k_v2_t *p_j2k, l_current_data = (OPJ_BYTE*)opj_malloc(1000); if (! l_current_data) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to decode one tile\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode one tile\n"); return OPJ_FALSE; } l_max_data_size = 1000; @@ -8746,7 +9479,7 @@ static opj_bool opj_j2k_decode_one_tile ( opj_j2k_v2_t *p_j2k, } } /* Move into the codestream to the first SOT used to decode the desired tile */ - l_tile_no_to_dec = p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec; + l_tile_no_to_dec = (OPJ_UINT32)p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec; if (p_j2k->cstr_index->tile_index) if(p_j2k->cstr_index->tile_index->tp_index) { @@ -8754,13 +9487,15 @@ static opj_bool opj_j2k_decode_one_tile ( opj_j2k_v2_t *p_j2k, /* the index for this tile has not been built, * so move to the last SOT read */ if ( !(opj_stream_read_seek(p_stream, p_j2k->m_specific_param.m_decoder.m_last_sot_read_pos+2, p_manager)) ){ - opj_event_msg_v2(p_manager, EVT_ERROR, "Problem with seek function\n"); + opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n"); + opj_free(l_current_data); return OPJ_FALSE; } } else{ if ( !(opj_stream_read_seek(p_stream, p_j2k->cstr_index->tile_index[l_tile_no_to_dec].tp_index[0].start_pos+2, p_manager)) ) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Problem with seek function\n"); + opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n"); + opj_free(l_current_data); return OPJ_FALSE; } } @@ -8794,7 +9529,7 @@ static opj_bool opj_j2k_decode_one_tile ( opj_j2k_v2_t *p_j2k, l_current_data = NULL; /* TODO: LH: why tile numbering policy used in messages differs from the one used in opj_j2k_decode_tiles() ? */ - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to decode tile %d/%d\n", l_current_tile_no, (p_j2k->m_cp.th * p_j2k->m_cp.tw) - 1); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to decode tile %d/%d\n", l_current_tile_no, (p_j2k->m_cp.th * p_j2k->m_cp.tw) - 1); return OPJ_FALSE; } l_current_data = l_new_current_data; @@ -8805,25 +9540,25 @@ static opj_bool opj_j2k_decode_one_tile ( opj_j2k_v2_t *p_j2k, opj_free(l_current_data); return OPJ_FALSE; } - opj_event_msg_v2(p_manager, EVT_INFO, "Tile %d/%d has been decoded.\n", l_current_tile_no, (p_j2k->m_cp.th * p_j2k->m_cp.tw) - 1); + opj_event_msg(p_manager, EVT_INFO, "Tile %d/%d has been decoded.\n", l_current_tile_no, (p_j2k->m_cp.th * p_j2k->m_cp.tw) - 1); if (! opj_j2k_update_image_data(p_j2k->m_tcd,l_current_data, p_j2k->m_output_image)) { opj_free(l_current_data); return OPJ_FALSE; } - opj_event_msg_v2(p_manager, EVT_INFO, "Image data has been updated with tile %d.\n\n", l_current_tile_no); + opj_event_msg(p_manager, EVT_INFO, "Image data has been updated with tile %d.\n\n", l_current_tile_no); if(l_current_tile_no == l_tile_no_to_dec) { /* move into the codestream to the the first SOT (FIXME or not move?)*/ if (!(opj_stream_read_seek(p_stream, p_j2k->cstr_index->main_head_end + 2, p_manager) ) ) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Problem with seek function\n"); + opj_event_msg(p_manager, EVT_ERROR, "Problem with seek function\n"); return OPJ_FALSE; } break; } else { - opj_event_msg_v2(p_manager, EVT_WARNING, "Tile read, decode and updated is not the desired (%d vs %d).\n", l_current_tile_no, l_tile_no_to_dec); + opj_event_msg(p_manager, EVT_WARNING, "Tile read, decode and updated is not the desired (%d vs %d).\n", l_current_tile_no, l_tile_no_to_dec); } } @@ -8836,7 +9571,7 @@ static opj_bool opj_j2k_decode_one_tile ( opj_j2k_v2_t *p_j2k, /** * Sets up the procedures to do on decoding one tile. Developpers wanting to extend the library can add their own reading procedures. */ -static void opj_j2k_setup_decoding_tile (opj_j2k_v2_t *p_j2k) +static void opj_j2k_setup_decoding_tile (opj_j2k_t *p_j2k) { /* preconditions*/ assert(p_j2k != 00); @@ -8846,7 +9581,7 @@ static void opj_j2k_setup_decoding_tile (opj_j2k_v2_t *p_j2k) } -opj_bool opj_j2k_decode(opj_j2k_v2_t * p_j2k, +OPJ_BOOL opj_j2k_decode(opj_j2k_t * p_j2k, opj_stream_private_t * p_stream, opj_image_t * p_image, opj_event_mgr_t * p_manager) @@ -8876,13 +9611,20 @@ opj_bool opj_j2k_decode(opj_j2k_v2_t * p_j2k, for (compno = 0; compno < p_image->numcomps; compno++) { p_image->comps[compno].resno_decoded = p_j2k->m_output_image->comps[compno].resno_decoded; p_image->comps[compno].data = p_j2k->m_output_image->comps[compno].data; +#if 0 + char fn[256]; + sprintf( fn, "/tmp/%d.raw", compno ); + FILE *debug = fopen( fn, "wb" ); + fwrite( p_image->comps[compno].data, sizeof(OPJ_INT32), p_image->comps[compno].w * p_image->comps[compno].h, debug ); + fclose( debug ); +#endif p_j2k->m_output_image->comps[compno].data = NULL; } return OPJ_TRUE; } -opj_bool opj_j2k_get_tile( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_get_tile( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_image_t* p_image, opj_event_mgr_t * p_manager, @@ -8893,12 +9635,12 @@ opj_bool opj_j2k_get_tile( opj_j2k_v2_t *p_j2k, opj_image_comp_t* l_img_comp; if (!p_image) { - opj_event_msg_v2(p_manager, EVT_ERROR, "We need an image previously created.\n"); + opj_event_msg(p_manager, EVT_ERROR, "We need an image previously created.\n"); return OPJ_FALSE; } if ( /*(tile_index < 0) &&*/ (tile_index >= p_j2k->m_cp.tw * p_j2k->m_cp.th) ){ - opj_event_msg_v2(p_manager, EVT_ERROR, "Tile index provided by the user is incorrect %d (max = %d) \n", tile_index, (p_j2k->m_cp.tw * p_j2k->m_cp.th) - 1); + opj_event_msg(p_manager, EVT_ERROR, "Tile index provided by the user is incorrect %d (max = %d) \n", tile_index, (p_j2k->m_cp.tw * p_j2k->m_cp.th) - 1); return OPJ_FALSE; } @@ -8927,13 +9669,13 @@ opj_bool opj_j2k_get_tile( opj_j2k_v2_t *p_j2k, l_img_comp->factor = p_j2k->m_private_image->comps[compno].factor; - l_img_comp->x0 = opj_int_ceildiv(p_image->x0, l_img_comp->dx); - l_img_comp->y0 = opj_int_ceildiv(p_image->y0, l_img_comp->dy); - l_comp_x1 = opj_int_ceildiv(p_image->x1, l_img_comp->dx); - l_comp_y1 = opj_int_ceildiv(p_image->y1, l_img_comp->dy); + l_img_comp->x0 = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)p_image->x0, (OPJ_INT32)l_img_comp->dx); + l_img_comp->y0 = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)p_image->y0, (OPJ_INT32)l_img_comp->dy); + l_comp_x1 = opj_int_ceildiv((OPJ_INT32)p_image->x1, (OPJ_INT32)l_img_comp->dx); + l_comp_y1 = opj_int_ceildiv((OPJ_INT32)p_image->y1, (OPJ_INT32)l_img_comp->dy); - l_img_comp->w = opj_int_ceildivpow2(l_comp_x1, l_img_comp->factor) - opj_int_ceildivpow2(l_img_comp->x0, l_img_comp->factor); - l_img_comp->h = opj_int_ceildivpow2(l_comp_y1, l_img_comp->factor) - opj_int_ceildivpow2(l_img_comp->y0, l_img_comp->factor); + l_img_comp->w = (OPJ_UINT32)(opj_int_ceildivpow2(l_comp_x1, (OPJ_INT32)l_img_comp->factor) - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->x0, (OPJ_INT32)l_img_comp->factor)); + l_img_comp->h = (OPJ_UINT32)(opj_int_ceildivpow2(l_comp_y1, (OPJ_INT32)l_img_comp->factor) - opj_int_ceildivpow2((OPJ_INT32)l_img_comp->y0, (OPJ_INT32)l_img_comp->factor)); l_img_comp++; } @@ -8949,7 +9691,7 @@ opj_bool opj_j2k_get_tile( opj_j2k_v2_t *p_j2k, } opj_copy_image_header(p_image, p_j2k->m_output_image); - p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec = tile_index; + p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec = (OPJ_INT32)tile_index; /* customization of the decoding */ opj_j2k_setup_decoding_tile(p_j2k); @@ -8976,7 +9718,7 @@ opj_bool opj_j2k_get_tile( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_set_decoded_resolution_factor(opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_set_decoded_resolution_factor(opj_j2k_t *p_j2k, OPJ_UINT32 res_factor, opj_event_mgr_t * p_manager) { @@ -8991,7 +9733,7 @@ opj_bool opj_j2k_set_decoded_resolution_factor(opj_j2k_v2_t *p_j2k, for (it_comp = 0 ; it_comp < p_j2k->m_private_image->numcomps; it_comp++) { OPJ_UINT32 max_res = p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps[it_comp].numresolutions; if ( res_factor >= max_res){ - opj_event_msg_v2(p_manager, EVT_ERROR, "Resolution factor is greater than the maximum resolution in the component.\n"); + opj_event_msg(p_manager, EVT_ERROR, "Resolution factor is greater than the maximum resolution in the component.\n"); return OPJ_FALSE; } p_j2k->m_private_image->comps[it_comp].factor = res_factor; @@ -9005,9 +9747,9 @@ opj_bool opj_j2k_set_decoded_resolution_factor(opj_j2k_v2_t *p_j2k, return OPJ_FALSE; } -opj_bool opj_j2k_encode_v2( opj_j2k_v2_t * p_j2k, - opj_stream_private_t *p_stream, - opj_event_mgr_t * p_manager ) +OPJ_BOOL opj_j2k_encode(opj_j2k_t * p_j2k, + opj_stream_private_t *p_stream, + opj_event_mgr_t * p_manager ) { OPJ_UINT32 i; OPJ_UINT32 l_nb_tiles; @@ -9021,7 +9763,7 @@ opj_bool opj_j2k_encode_v2( opj_j2k_v2_t * p_j2k, l_current_data = (OPJ_BYTE*)opj_malloc(1000); if (! l_current_data) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to encode all tiles\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to encode all tiles\n"); return OPJ_FALSE; } l_max_tile_size = 1000; @@ -9038,7 +9780,7 @@ opj_bool opj_j2k_encode_v2( opj_j2k_v2_t * p_j2k, OPJ_BYTE *l_new_current_data = (OPJ_BYTE *) opj_realloc(l_current_data, l_current_tile_size); if (! l_new_current_data) { opj_free(l_current_data); - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to encode all tiles\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to encode all tiles\n"); return OPJ_FALSE; } l_current_data = l_new_current_data; @@ -9056,7 +9798,7 @@ opj_bool opj_j2k_encode_v2( opj_j2k_v2_t * p_j2k, return OPJ_TRUE; } -opj_bool OPJ_CALLCONV opj_j2k_end_compress( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_end_compress( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager) { @@ -9071,7 +9813,7 @@ opj_bool OPJ_CALLCONV opj_j2k_end_compress( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -OPJ_API opj_bool OPJ_CALLCONV opj_j2k_start_compress(opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_start_compress(opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_image_t * p_image, opj_event_mgr_t * p_manager) @@ -9082,6 +9824,10 @@ OPJ_API opj_bool OPJ_CALLCONV opj_j2k_start_compress(opj_j2k_v2_t *p_j2k, assert(p_manager != 00); p_j2k->m_private_image = opj_image_create0(); + if (! p_j2k->m_private_image) { + opj_event_msg(p_manager, EVT_ERROR, "Failed to allocate image header." ); + return OPJ_FALSE; + } opj_copy_image_header(p_image, p_j2k->m_private_image); /* TODO_MSD: Find a better way */ @@ -9115,18 +9861,18 @@ OPJ_API opj_bool OPJ_CALLCONV opj_j2k_start_compress(opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_pre_write_tile ( opj_j2k_v2_t * p_j2k, +OPJ_BOOL opj_j2k_pre_write_tile ( opj_j2k_t * p_j2k, OPJ_UINT32 p_tile_index, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) { (void)p_stream; if (p_tile_index != p_j2k->m_current_tile_number) { - opj_event_msg_v2(p_manager, EVT_ERROR, "The given tile index does not match." ); + opj_event_msg(p_manager, EVT_ERROR, "The given tile index does not match." ); return OPJ_FALSE; } - opj_event_msg_v2(p_manager, EVT_INFO, "tile number %d / %d\n", p_j2k->m_current_tile_number + 1, p_j2k->m_cp.tw * p_j2k->m_cp.th); + opj_event_msg(p_manager, EVT_INFO, "tile number %d / %d\n", p_j2k->m_current_tile_number + 1, p_j2k->m_cp.tw * p_j2k->m_cp.th); p_j2k->m_specific_param.m_encoder.m_current_tile_part_number = 0; p_j2k->m_tcd->cur_totnum_tp = p_j2k->m_cp.tcps[p_tile_index].m_nb_tile_parts; @@ -9140,12 +9886,12 @@ opj_bool opj_j2k_pre_write_tile ( opj_j2k_v2_t * p_j2k, return OPJ_TRUE; } -void opj_j2k_get_tile_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data) +void opj_j2k_get_tile_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data) { OPJ_UINT32 i,j,k = 0; OPJ_UINT32 l_width,l_height,l_stride, l_offset_x,l_offset_y, l_image_width; opj_image_comp_t * l_img_comp = 00; - opj_tcd_tilecomp_v2_t * l_tilec = 00; + opj_tcd_tilecomp_t * l_tilec = 00; opj_image_t * l_image = 00; OPJ_UINT32 l_size_comp, l_remaining; OPJ_INT32 * l_src_ptr; @@ -9164,13 +9910,13 @@ void opj_j2k_get_tile_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data) l_size_comp = 4; } - l_width = (l_tilec->x1 - l_tilec->x0); - l_height = (l_tilec->y1 - l_tilec->y0); - l_offset_x = opj_int_ceildiv(l_image->x0, l_img_comp->dx); - l_offset_y = opj_int_ceildiv(l_image->y0, l_img_comp->dy); - l_image_width = opj_int_ceildiv(l_image->x1 - l_image->x0, l_img_comp->dx); + l_width = (OPJ_UINT32)(l_tilec->x1 - l_tilec->x0); + l_height = (OPJ_UINT32)(l_tilec->y1 - l_tilec->y0); + l_offset_x = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)l_image->x0, (OPJ_INT32)l_img_comp->dx); + l_offset_y = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)l_image->y0, (OPJ_INT32)l_img_comp->dy); + l_image_width = (OPJ_UINT32)opj_int_ceildiv((OPJ_INT32)l_image->x1 - (OPJ_INT32)l_image->x0, (OPJ_INT32)l_img_comp->dx); l_stride = l_image_width - l_width; - l_src_ptr = l_img_comp->data + (l_tilec->x0 - l_offset_x) + (l_tilec->y0 - l_offset_y) * l_image_width; + l_src_ptr = l_img_comp->data + ((OPJ_UINT32)l_tilec->x0 - l_offset_x) + ((OPJ_UINT32)l_tilec->y0 - l_offset_y) * l_image_width; switch (l_size_comp) { case 1: @@ -9189,7 +9935,7 @@ void opj_j2k_get_tile_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data) else { for (j=0;jm_specific_param.m_encoder.m_encoded_tile_data); l_tcd = p_j2k->m_tcd; - l_cp = &(p_j2k->m_cp); - l_tcp = l_cp->tcps + p_j2k->m_current_tile_number; - + l_tile_size = p_j2k->m_specific_param.m_encoder.m_encoded_tile_size; l_available_data = l_tile_size; l_current_data = p_j2k->m_specific_param.m_encoder.m_encoded_tile_data; if (! opj_tcd_copy_tile_data(l_tcd,p_data,p_data_size)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Size mismatch between tile data and sent data." ); + opj_event_msg(p_manager, EVT_ERROR, "Size mismatch between tile data and sent data." ); return OPJ_FALSE; } @@ -9299,7 +10041,7 @@ opj_bool opj_j2k_post_write_tile ( opj_j2k_v2_t * p_j2k, return OPJ_TRUE; } -void opj_j2k_setup_end_compress (opj_j2k_v2_t *p_j2k) +void opj_j2k_setup_end_compress (opj_j2k_t *p_j2k) { /* preconditions */ assert(p_j2k != 00); @@ -9307,7 +10049,7 @@ void opj_j2k_setup_end_compress (opj_j2k_v2_t *p_j2k) /* DEVELOPER CORNER, insert your custom procedures */ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_eoc ); - if (p_j2k->m_cp.m_specific_param.m_enc.m_cinema) { + if (OPJ_IS_CINEMA(p_j2k->m_cp.rsiz)) { opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_updated_tlm); } @@ -9316,7 +10058,7 @@ void opj_j2k_setup_end_compress (opj_j2k_v2_t *p_j2k) opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_destroy_header_memory); } -void opj_j2k_setup_encoding_validation (opj_j2k_v2_t *p_j2k) +void opj_j2k_setup_encoding_validation (opj_j2k_t *p_j2k) { /* preconditions */ assert(p_j2k != 00); @@ -9328,7 +10070,7 @@ void opj_j2k_setup_encoding_validation (opj_j2k_v2_t *p_j2k) opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)opj_j2k_mct_validation); } -void opj_j2k_setup_header_writing (opj_j2k_v2_t *p_j2k) +void opj_j2k_setup_header_writing (opj_j2k_t *p_j2k) { /* preconditions */ assert(p_j2k != 00); @@ -9339,11 +10081,14 @@ void opj_j2k_setup_header_writing (opj_j2k_v2_t *p_j2k) opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_cod ); opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_qcd ); - if (p_j2k->m_cp.m_specific_param.m_enc.m_cinema) { - opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_image_components ); + if (OPJ_IS_CINEMA(p_j2k->m_cp.rsiz)) { + /* No need for COC or QCC, QCD and COD are used + opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_all_coc ); + opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_all_qcc ); + */ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_tlm ); - if (p_j2k->m_cp.m_specific_param.m_enc.m_cinema == CINEMA4K_24) { + if (p_j2k->m_cp.rsiz == OPJ_PROFILE_CINEMA_4K) { opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_poc ); } } @@ -9355,7 +10100,7 @@ void opj_j2k_setup_header_writing (opj_j2k_v2_t *p_j2k) } /* DEVELOPER CORNER, insert your custom procedures */ - if (p_j2k->m_cp.rsiz & MCT) { + if (p_j2k->m_cp.rsiz & OPJ_EXTENSION_MCT) { opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_write_mct_data_group ); } /* End of Developer Corner */ @@ -9368,25 +10113,22 @@ void opj_j2k_setup_header_writing (opj_j2k_v2_t *p_j2k) opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)opj_j2k_update_rates); } -opj_bool opj_j2k_write_first_tile_part (opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_first_tile_part (opj_j2k_t *p_j2k, OPJ_BYTE * p_data, OPJ_UINT32 * p_data_written, OPJ_UINT32 p_total_data_size, opj_stream_private_t *p_stream, struct opj_event_mgr * p_manager ) { - OPJ_UINT32 compno; OPJ_UINT32 l_nb_bytes_written = 0; OPJ_UINT32 l_current_nb_bytes_written; OPJ_BYTE * l_begin_data = 00; - opj_tcp_v2_t *l_tcp = 00; - opj_tcd_v2_t * l_tcd = 00; - opj_cp_v2_t * l_cp = 00; + opj_tcd_t * l_tcd = 00; + opj_cp_t * l_cp = 00; l_tcd = p_j2k->m_tcd; l_cp = &(p_j2k->m_cp); - l_tcp = l_cp->tcps + p_j2k->m_current_tile_number; l_tcd->cur_pino = 0; @@ -9407,7 +10149,8 @@ opj_bool opj_j2k_write_first_tile_part (opj_j2k_v2_t *p_j2k, p_data += l_current_nb_bytes_written; p_total_data_size -= l_current_nb_bytes_written; - if (l_cp->m_specific_param.m_enc.m_cinema == 0) { + if (!OPJ_IS_CINEMA(l_cp->rsiz)) { +#if 0 for (compno = 1; compno < p_j2k->m_private_image->numcomps; compno++) { l_current_nb_bytes_written = 0; opj_j2k_write_coc_in_memory(p_j2k,compno,p_data,&l_current_nb_bytes_written,p_manager); @@ -9421,6 +10164,7 @@ opj_bool opj_j2k_write_first_tile_part (opj_j2k_v2_t *p_j2k, p_data += l_current_nb_bytes_written; p_total_data_size -= l_current_nb_bytes_written; } +#endif if (l_cp->tcps[p_j2k->m_current_tile_number].numpocs) { l_current_nb_bytes_written = 0; @@ -9442,14 +10186,14 @@ opj_bool opj_j2k_write_first_tile_part (opj_j2k_v2_t *p_j2k, /* Writing Psot in SOT marker */ opj_write_bytes(l_begin_data + 6,l_nb_bytes_written,4); /* PSOT */ - if (l_cp->m_specific_param.m_enc.m_cinema){ + if (OPJ_IS_CINEMA(l_cp->rsiz)){ opj_j2k_update_tlm(p_j2k,l_nb_bytes_written); } return OPJ_TRUE; } -opj_bool opj_j2k_write_all_tile_parts( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_all_tile_parts( opj_j2k_t *p_j2k, OPJ_BYTE * p_data, OPJ_UINT32 * p_data_written, OPJ_UINT32 p_total_data_size, @@ -9465,9 +10209,9 @@ opj_bool opj_j2k_write_all_tile_parts( opj_j2k_v2_t *p_j2k, OPJ_UINT32 pino; OPJ_BYTE * l_begin_data; - opj_tcp_v2_t *l_tcp = 00; - opj_tcd_v2_t * l_tcd = 00; - opj_cp_v2_t * l_cp = 00; + opj_tcp_t *l_tcp = 00; + opj_tcd_t * l_tcd = 00; + opj_cp_t * l_cp = 00; l_tcd = p_j2k->m_tcd; l_cp = &(p_j2k->m_cp); @@ -9476,6 +10220,8 @@ opj_bool opj_j2k_write_all_tile_parts( opj_j2k_v2_t *p_j2k, /*Get number of tile parts*/ tot_num_tp = opj_j2k_get_num_tp(l_cp,0,p_j2k->m_current_tile_number); + /* start writing remaining tile parts */ + ++p_j2k->m_specific_param.m_encoder.m_current_tile_part_number; for (tilepartno = 1; tilepartno < tot_num_tp ; ++tilepartno) { p_j2k->m_specific_param.m_encoder.m_current_poc_tile_part_number = tilepartno; l_current_nb_bytes_written = 0; @@ -9489,7 +10235,7 @@ opj_bool opj_j2k_write_all_tile_parts( opj_j2k_v2_t *p_j2k, l_nb_bytes_written += l_current_nb_bytes_written; p_data += l_current_nb_bytes_written; p_total_data_size -= l_current_nb_bytes_written; - l_part_tile_size += l_nb_bytes_written; + l_part_tile_size += l_current_nb_bytes_written; l_current_nb_bytes_written = 0; if (! opj_j2k_write_sod(p_j2k,l_tcd,p_data,&l_current_nb_bytes_written,p_total_data_size,p_stream,p_manager)) { @@ -9499,12 +10245,12 @@ opj_bool opj_j2k_write_all_tile_parts( opj_j2k_v2_t *p_j2k, p_data += l_current_nb_bytes_written; l_nb_bytes_written += l_current_nb_bytes_written; p_total_data_size -= l_current_nb_bytes_written; - l_part_tile_size += l_nb_bytes_written; + l_part_tile_size += l_current_nb_bytes_written; /* Writing Psot in SOT marker */ opj_write_bytes(l_begin_data + 6,l_part_tile_size,4); /* PSOT */ - if (l_cp->m_specific_param.m_enc.m_cinema) { + if (OPJ_IS_CINEMA(l_cp->rsiz)) { opj_j2k_update_tlm(p_j2k,l_part_tile_size); } @@ -9545,7 +10291,7 @@ opj_bool opj_j2k_write_all_tile_parts( opj_j2k_v2_t *p_j2k, /* Writing Psot in SOT marker */ opj_write_bytes(l_begin_data + 6,l_part_tile_size,4); /* PSOT */ - if (l_cp->m_specific_param.m_enc.m_cinema) { + if (OPJ_IS_CINEMA(l_cp->rsiz)) { opj_j2k_update_tlm(p_j2k,l_part_tile_size); } @@ -9558,7 +10304,7 @@ opj_bool opj_j2k_write_all_tile_parts( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_updated_tlm( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_write_updated_tlm( opj_j2k_t *p_j2k, struct opj_stream_private *p_stream, struct opj_event_mgr * p_manager ) { @@ -9589,7 +10335,7 @@ opj_bool opj_j2k_write_updated_tlm( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_end_encoding( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_end_encoding( opj_j2k_t *p_j2k, struct opj_stream_private *p_stream, struct opj_event_mgr * p_manager ) { @@ -9620,7 +10366,7 @@ opj_bool opj_j2k_end_encoding( opj_j2k_v2_t *p_j2k, /** * Destroys the memory associated with the decoding of headers. */ -static opj_bool opj_j2k_destroy_header_memory ( opj_j2k_v2_t * p_j2k, +static OPJ_BOOL opj_j2k_destroy_header_memory ( opj_j2k_t * p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) @@ -9640,7 +10386,7 @@ static opj_bool opj_j2k_destroy_header_memory ( opj_j2k_v2_t * p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_init_info( opj_j2k_v2_t *p_j2k, +OPJ_BOOL opj_j2k_init_info( opj_j2k_t *p_j2k, struct opj_stream_private *p_stream, struct opj_event_mgr * p_manager ) { @@ -9701,7 +10447,7 @@ opj_bool opj_j2k_init_info( opj_j2k_v2_t *p_j2k, * @param p_j2k J2K codec. * @param p_manager the user event manager. */ -static opj_bool opj_j2k_create_tcd( opj_j2k_v2_t *p_j2k, +static OPJ_BOOL opj_j2k_create_tcd( opj_j2k_t *p_j2k, opj_stream_private_t *p_stream, opj_event_mgr_t * p_manager ) @@ -9714,7 +10460,7 @@ static opj_bool opj_j2k_create_tcd( opj_j2k_v2_t *p_j2k, p_j2k->m_tcd = opj_tcd_create(OPJ_FALSE); if (! p_j2k->m_tcd) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to create Tile Coder\n"); + opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to create Tile Coder\n"); return OPJ_FALSE; } @@ -9727,7 +10473,7 @@ static opj_bool opj_j2k_create_tcd( opj_j2k_v2_t *p_j2k, return OPJ_TRUE; } -opj_bool opj_j2k_write_tile (opj_j2k_v2_t * p_j2k, +OPJ_BOOL opj_j2k_write_tile (opj_j2k_t * p_j2k, OPJ_UINT32 p_tile_index, OPJ_BYTE * p_data, OPJ_UINT32 p_data_size, @@ -9735,12 +10481,12 @@ opj_bool opj_j2k_write_tile (opj_j2k_v2_t * p_j2k, opj_event_mgr_t * p_manager ) { if (! opj_j2k_pre_write_tile(p_j2k,p_tile_index,p_stream,p_manager)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error while opj_j2k_pre_write_tile with tile index = %d\n", p_tile_index); + opj_event_msg(p_manager, EVT_ERROR, "Error while opj_j2k_pre_write_tile with tile index = %d\n", p_tile_index); return OPJ_FALSE; } else { if (! opj_j2k_post_write_tile(p_j2k,p_data,p_data_size,p_stream,p_manager)) { - opj_event_msg_v2(p_manager, EVT_ERROR, "Error while opj_j2k_post_write_tile with tile index = %d\n", p_tile_index); + opj_event_msg(p_manager, EVT_ERROR, "Error while opj_j2k_post_write_tile with tile index = %d\n", p_tile_index); return OPJ_FALSE; } }