| /* |
| * 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 |
| * Copyright (c) 2003-2014, Antonin Descampe |
| * Copyright (c) 2005, Herve Drolon, FreeImage Team |
| * Copyright (c) 2008, Jerome Fimes, Communications & Systemes <jerome.fimes@c-s.fr> |
| * Copyright (c) 2006-2007, Parvatha Elangovan |
| * Copyright (c) 2010-2011, Kaori Hagihara |
| * 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 |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "opj_includes.h" |
| |
| /** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */ |
| /*@{*/ |
| |
| /** @name Local static functions */ |
| /*@{*/ |
| |
| /** |
| * 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_t *p_j2k); |
| |
| /** |
| * The read header procedure. |
| */ |
| 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); |
| |
| /** |
| * The default encoding validation procedure without any extension. |
| * |
| * @param p_j2k the jpeg2000 codec to validate. |
| * @param p_stream the input stream to validate. |
| * @param p_manager the user event manager. |
| * |
| * @return true if the parameters are correct. |
| */ |
| static OPJ_BOOL opj_j2k_encoding_validation ( opj_j2k_t * p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * The default decoding validation procedure without any extension. |
| * |
| * @param p_j2k the jpeg2000 codec to validate. |
| * @param p_stream the input stream to validate. |
| * @param p_manager the user event manager. |
| * |
| * @return true if the parameters are correct. |
| */ |
| static OPJ_BOOL opj_j2k_decoding_validation ( opj_j2k_t * p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * 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_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_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_t *p_j2k); |
| |
| /** |
| * The mct encoding validation procedure. |
| * |
| * @param p_j2k the jpeg2000 codec to validate. |
| * @param p_stream the input stream to validate. |
| * @param p_manager the user event manager. |
| * |
| * @return true if the parameters are correct. |
| */ |
| 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_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_t * p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Creates a tile-coder decoder. |
| * |
| * @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_create_tcd( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Excutes the given procedures on the given codec. |
| * |
| * @param p_procedure_list the list of procedures to execute |
| * @param p_j2k the jpeg2000 codec to execute the procedures on. |
| * @param p_stream the stream to execute the procedures on. |
| * @param p_manager the user manager. |
| * |
| * @return true if all the procedures were successfully executed. |
| */ |
| 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); |
| |
| /** |
| * Updates the rates of the tcp. |
| * |
| * @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_update_rates( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * 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_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_t * p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Reads the lookup table containing all the marker, status and action, and returns the handler associated |
| * with the marker value. |
| * @param p_id Marker value to look up |
| * |
| * @return the handler associated with the id. |
| */ |
| static const struct opj_dec_memory_marker_handler * opj_j2k_get_marker_handler (OPJ_UINT32 p_id); |
| |
| /** |
| * Destroys a tile coding parameter structure. |
| * |
| * @param p_tcp the tile coding parameter to destroy. |
| */ |
| 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_t *p_tcp); |
| |
| /** |
| * Destroys a coding parameter structure. |
| * |
| * @param p_cp the coding parameter to destroy. |
| */ |
| 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. |
| * |
| * @param p_j2k J2K codec. |
| * @param p_tile_no FIXME DOC |
| * @param p_comp_no the component number to output. |
| * @param p_data FIXME DOC |
| * @param p_header_size FIXME DOC |
| * @param p_manager the user event manager. |
| * |
| * @return FIXME DOC |
| */ |
| 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, |
| OPJ_UINT32 * p_header_size, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Gets the size taken by writing a SPCod or SPCoc for the given tile and component. |
| * |
| * @param p_j2k the J2K codec. |
| * @param p_tile_no the tile index. |
| * @param p_comp_no the component being outputted. |
| * |
| * @return the number of bytes taken by the SPCod element. |
| */ |
| static OPJ_UINT32 opj_j2k_get_SPCod_SPCoc_size (opj_j2k_t *p_j2k, |
| OPJ_UINT32 p_tile_no, |
| OPJ_UINT32 p_comp_no ); |
| |
| /** |
| * Reads a SPCod or SPCoc element, i.e. the coding style of a given component of a tile. |
| * @param p_j2k the jpeg2000 codec. |
| * @param compno FIXME DOC |
| * @param p_header_data the data contained in the COM box. |
| * @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_t *p_j2k, |
| OPJ_UINT32 compno, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 * p_header_size, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Gets the size taken by writing SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC. |
| * |
| * @param p_tile_no the tile index. |
| * @param p_comp_no the component being outputted. |
| * @param p_j2k the J2K codec. |
| * |
| * @return the number of bytes taken by the SPCod element. |
| */ |
| static OPJ_UINT32 opj_j2k_get_SQcd_SQcc_size ( opj_j2k_t *p_j2k, |
| OPJ_UINT32 p_tile_no, |
| OPJ_UINT32 p_comp_no ); |
| |
| /** |
| * Writes a SQcd or SQcc element, i.e. the quantization values of a band in the QCD or QCC. |
| * |
| * @param p_tile_no the tile to output. |
| * @param p_comp_no the component number to output. |
| * @param p_data the data buffer. |
| * @param p_header_size pointer to the size of the data buffer, it is changed by the function. |
| * @param p_j2k J2K codec. |
| * @param p_manager the user event manager. |
| * |
| */ |
| 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, |
| OPJ_UINT32 * p_header_size, |
| opj_event_mgr_t * p_manager); |
| |
| /** |
| * Updates the Tile Length Marker. |
| */ |
| 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. |
| * |
| * @param p_j2k J2K codec. |
| * @param compno the component number to output. |
| * @param p_header_data the data buffer. |
| * @param p_header_size pointer to the size of the data buffer, it is changed by the function. |
| * @param p_manager the user event manager. |
| * |
| */ |
| 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, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Copies the tile component parameters of all the component from the first tile component. |
| * |
| * @param p_j2k the J2k codec. |
| */ |
| 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_t *p_j2k ); |
| |
| /** |
| * Reads the tiles. |
| */ |
| 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_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_t * p_tcd, OPJ_BYTE * p_data, opj_image_t* p_output_image); |
| |
| static void opj_get_tile_dimensions(opj_image_t * l_image, |
| opj_tcd_tilecomp_t * l_tilec, |
| opj_image_comp_t * l_img_comp, |
| OPJ_UINT32* l_size_comp, |
| OPJ_UINT32* l_width, |
| OPJ_UINT32* l_height, |
| OPJ_UINT32* l_offset_x, |
| OPJ_UINT32* l_offset_y, |
| OPJ_UINT32* l_image_width, |
| OPJ_UINT32* l_stride, |
| OPJ_UINT32* l_tile_offset); |
| |
| 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_t * p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * 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_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_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 ); |
| |
| /** |
| * Gets the offset of the header. |
| * |
| * @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_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_t *p_j2k); |
| |
| /* |
| * ----------------------------------------------------------------------- |
| * ----------------------------------------------------------------------- |
| * ----------------------------------------------------------------------- |
| */ |
| |
| /** |
| * Writes the SOC marker (Start Of Codestream) |
| * |
| * @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_soc( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Reads a SOC marker (Start of Codestream) |
| * @param p_j2k the jpeg2000 file codec. |
| * @param p_stream XXX needs data |
| * @param p_manager the user event manager. |
| */ |
| static OPJ_BOOL opj_j2k_read_soc( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Writes the SIZ marker (image and tile size) |
| * |
| * @param p_j2k J2K codec. |
| * @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_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Reads a SIZ marker (image and tile size) |
| * @param p_j2k the jpeg2000 file codec. |
| * @param p_header_data the data contained in the SIZ box. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager); |
| |
| /** |
| * Writes the COM marker (comment) |
| * |
| * @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_com( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Reads a COM marker (comments) |
| * @param p_j2k the jpeg2000 file codec. |
| * @param p_header_data the data contained in the COM box. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager ); |
| /** |
| * Writes the COD marker (Coding style default) |
| * |
| * @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_cod( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Reads a COD marker (Coding Styke defaults) |
| * @param p_header_data the data contained in the COD box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_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) |
| * |
| * @param p_j2k J2K codec. |
| * @param p_comp_no the index of the component to output. |
| * @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_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) |
| * |
| * @param p_j2k J2K codec. |
| * @param p_comp_no the index of the component to output. |
| * @param p_data FIXME DOC |
| * @param p_data_written FIXME DOC |
| * @param p_manager the user event manager. |
| */ |
| 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_t *p_j2k); |
| |
| /** |
| * Reads a COC marker (Coding Style Component) |
| * @param p_header_data the data contained in the COC box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Writes the QCD marker (quantization default) |
| * |
| * @param p_j2k J2K codec. |
| * @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_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Reads a QCD marker (Quantization defaults) |
| * @param p_header_data the data contained in the QCD box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_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) |
| * |
| * @param p_comp_no the index of the component to output. |
| * @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_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) |
| * |
| * @param p_j2k J2K codec. |
| * @param p_comp_no the index of the component to output. |
| * @param p_data FIXME DOC |
| * @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_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_t *p_j2k); |
| |
| /** |
| * Reads a QCC marker (Quantization component) |
| * @param p_header_data the data contained in the QCC box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager); |
| /** |
| * Writes the POC marker (Progression Order Change) |
| * |
| * @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_poc( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| /** |
| * Writes the POC marker (Progression Order Change) |
| * |
| * @param p_j2k J2K codec. |
| * @param p_data FIXME DOC |
| * @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_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_t *p_j2k); |
| |
| /** |
| * Reads a POC marker (Progression Order Change) |
| * |
| * @param p_header_data the data contained in the POC box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * 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_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_t *p_j2k); |
| |
| /** |
| * Reads a CRG marker (Component registration) |
| * |
| * @param p_header_data the data contained in the TLM box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager ); |
| /** |
| * Reads a TLM marker (Tile Length Marker) |
| * |
| * @param p_header_data the data contained in the TLM box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager); |
| |
| /** |
| * Writes the updated tlm. |
| * |
| * @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_updated_tlm( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Reads a PLM marker (Packet length, main header marker) |
| * |
| * @param p_header_data the data contained in the TLM box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager); |
| /** |
| * Reads a PLT marker (Packet length, tile-part header) |
| * |
| * @param p_header_data the data contained in the PLT box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager ); |
| |
| #if 0 |
| /** |
| * Reads a PPM marker (Packed packet headers, main header) |
| * |
| * @param p_header_data the data contained in the POC box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Reads a PPT marker (Packed packet headers, tile-part header) |
| * |
| * @param p_header_data the data contained in the PPT box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager ); |
| /** |
| * Writes the TLM marker (Tile Length Marker) |
| * |
| * @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_tlm( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Writes the SOT marker (Start of tile-part) |
| * |
| * @param p_j2k J2K codec. |
| * @param p_data FIXME DOC |
| * @param p_data_written FIXME DOC |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_data, |
| OPJ_UINT32 * p_data_written, |
| const opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Reads a PPT marker (Packed packet headers, tile-part header) |
| * |
| * @param p_header_data the data contained in the PPT box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager ); |
| /** |
| * Writes the SOD marker (Start of data) |
| * |
| * @param p_j2k J2K codec. |
| * @param p_tile_coder FIXME DOC |
| * @param p_data FIXME DOC |
| * @param p_data_written FIXME DOC |
| * @param p_total_data_size FIXME DOC |
| * @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_t *p_j2k, |
| opj_tcd_t * p_tile_coder, |
| OPJ_BYTE * p_data, |
| OPJ_UINT32 * p_data_written, |
| OPJ_UINT32 p_total_data_size, |
| const opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Reads a SOD marker (Start Of Data) |
| * |
| * @param p_j2k the jpeg2000 codec. |
| * @param p_stream FIXME DOC |
| * @param p_manager the user event manager. |
| */ |
| 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_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; |
| |
| opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current,p_tile_part_size,4); /* PSOT */ |
| p_j2k->m_specific_param.m_encoder.m_tlm_sot_offsets_current += 4; |
| } |
| |
| /** |
| * Writes the RGN marker (Region Of Interest) |
| * |
| * @param p_tile_no the tile to output |
| * @param p_comp_no the component to output |
| * @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_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) |
| * |
| * @param p_header_data the data contained in the POC box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Writes the EOC marker (End of Codestream) |
| * |
| * @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_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) |
| * |
| * @param p_j2k the jpeg2000 codec. |
| * @param p_stream FIXME DOC |
| * @param p_manager the user event manager. |
| */ |
| 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) |
| * |
| * @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_mct_data_group( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Inits the Info |
| * |
| * @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_init_info( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| Add main header marker information |
| @param cstr_index Codestream information structure |
| @param type marker type |
| @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) ; |
| /** |
| Add tile header marker information |
| @param tileno tile index number |
| @param cstr_index Codestream information structure |
| @param type marker type |
| @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); |
| |
| /** |
| * Reads an unknown marker |
| * |
| * @param p_j2k the jpeg2000 codec. |
| * @param p_stream the stream object to read from. |
| * @param output_marker FIXME DOC |
| * @param p_manager the user event manager. |
| * |
| * @return true if the marker could be deduced. |
| */ |
| 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 ); |
| |
| /** |
| * Writes the MCT marker (Multiple Component Transform) |
| * |
| * @param p_j2k J2K codec. |
| * @param p_mct_record FIXME DOC |
| * @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_t *p_j2k, |
| opj_mct_data_t * p_mct_record, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Reads a MCT marker (Multiple Component Transform) |
| * |
| * @param p_header_data the data contained in the MCT box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Writes the MCC marker (Multiple Component Collection) |
| * |
| * @param p_j2k J2K codec. |
| * @param p_mcc_record FIXME DOC |
| * @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_t *p_j2k, |
| opj_simple_mcc_decorrelation_data_t * p_mcc_record, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Reads a MCC marker (Multiple Component Collection) |
| * |
| * @param p_header_data the data contained in the MCC box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Writes the MCO marker (Multiple component transformation ordering) |
| * |
| * @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_mco( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Reads a MCO marker (Multiple Component Transform Ordering) |
| * |
| * @param p_header_data the data contained in the MCO box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_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_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); |
| static void opj_j2k_read_float32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem); |
| static void opj_j2k_read_float64_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem); |
| |
| static void opj_j2k_read_int16_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem); |
| static void opj_j2k_read_int32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem); |
| static void opj_j2k_read_float32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem); |
| static void opj_j2k_read_float64_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem); |
| |
| static void opj_j2k_write_float_to_int16 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem); |
| static void opj_j2k_write_float_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem); |
| static void opj_j2k_write_float_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem); |
| static void opj_j2k_write_float_to_float64 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem); |
| |
| /** |
| * Ends the encoding, i.e. frees memory. |
| * |
| * @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_end_encoding( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Writes the CBD marker (Component bit depth definition) |
| * |
| * @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_cbd( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Reads a CBD marker (Component bit depth definition) |
| * @param p_header_data the data contained in the CBD box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager); |
| |
| #if 0 |
| /** |
| * 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_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. |
| * |
| * @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_regions( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Writes EPC ???? |
| * |
| * @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_epc( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ); |
| |
| /** |
| * Checks the progression order changes values. Tells of the poc given as input are valid. |
| * A nice message is outputted at errors. |
| * |
| * @param p_pocs the progression order changes. |
| * @param p_nb_pocs the number of progression order changes. |
| * @param p_nb_resolutions the number of resolutions. |
| * @param numcomps the number of components |
| * @param numlayers the number of layers. |
| * @param p_manager the user event manager. |
| * |
| * @return true if the pocs are valid. |
| */ |
| 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, |
| OPJ_UINT32 numlayers, |
| opj_event_mgr_t * p_manager); |
| |
| /** |
| * Gets the number of tile parts used for the given change of progression (if any) and the given tile. |
| * |
| * @param cp the coding parameters. |
| * @param pino the offset of the given poc (i.e. its position in the coding parameter). |
| * @param tileno the given tile. |
| * |
| * @return the number of tile parts. |
| */ |
| 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 |
| * encode such an image. If not enough memory is available, then the function return false. |
| * |
| * @param p_nb_tiles pointer that will hold the number of tile parts. |
| * @param cp the coding parameters for the image. |
| * @param image the image to encode. |
| * @param p_j2k the p_j2k encoder. |
| * @param p_manager the user event manager. |
| * |
| * @return true if the function was successful, false else. |
| */ |
| 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_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_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 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); |
| |
| /*@}*/ |
| |
| /*@}*/ |
| |
| /* ----------------------------------------------------------------------- */ |
| typedef struct j2k_prog_order{ |
| OPJ_PROG_ORDER enum_prog; |
| char str_prog[5]; |
| }j2k_prog_order_t; |
| |
| j2k_prog_order_t j2k_prog_order_list[] = { |
| {OPJ_CPRL, "CPRL"}, |
| {OPJ_LRCP, "LRCP"}, |
| {OPJ_PCRL, "PCRL"}, |
| {OPJ_RLCP, "RLCP"}, |
| {OPJ_RPCL, "RPCL"}, |
| {(OPJ_PROG_ORDER)-1, ""} |
| }; |
| |
| /** |
| * FIXME DOC |
| */ |
| static const OPJ_UINT32 MCT_ELEMENT_SIZE [] = |
| { |
| 2, |
| 4, |
| 4, |
| 8 |
| }; |
| |
| typedef void (* opj_j2k_mct_function) (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem); |
| |
| const opj_j2k_mct_function j2k_mct_read_functions_to_float [] = |
| { |
| opj_j2k_read_int16_to_float, |
| opj_j2k_read_int32_to_float, |
| opj_j2k_read_float32_to_float, |
| opj_j2k_read_float64_to_float |
| }; |
| |
| const opj_j2k_mct_function j2k_mct_read_functions_to_int32 [] = |
| { |
| opj_j2k_read_int16_to_int32, |
| opj_j2k_read_int32_to_int32, |
| opj_j2k_read_float32_to_int32, |
| opj_j2k_read_float64_to_int32 |
| }; |
| |
| const opj_j2k_mct_function j2k_mct_write_functions_from_float [] = |
| { |
| opj_j2k_write_float_to_int16, |
| opj_j2k_write_float_to_int32, |
| opj_j2k_write_float_to_float, |
| opj_j2k_write_float_to_float64 |
| }; |
| |
| typedef struct opj_dec_memory_marker_handler |
| { |
| /** marker value */ |
| OPJ_UINT32 id; |
| /** value of the state when the marker can appear */ |
| OPJ_UINT32 states; |
| /** action linked to the marker */ |
| OPJ_BOOL (*handler) ( opj_j2k_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager ); |
| } |
| opj_dec_memory_marker_handler_t; |
| |
| const opj_dec_memory_marker_handler_t j2k_memory_marker_handler_tab [] = |
| { |
| {J2K_MS_SOT, J2K_STATE_MH | J2K_STATE_TPHSOT, opj_j2k_read_sot}, |
| {J2K_MS_COD, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_cod}, |
| {J2K_MS_COC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_coc}, |
| {J2K_MS_RGN, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_rgn}, |
| {J2K_MS_QCD, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_qcd}, |
| {J2K_MS_QCC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_qcc}, |
| {J2K_MS_POC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_poc}, |
| {J2K_MS_SIZ, J2K_STATE_MHSIZ, opj_j2k_read_siz}, |
| {J2K_MS_TLM, J2K_STATE_MH, opj_j2k_read_tlm}, |
| {J2K_MS_PLM, J2K_STATE_MH, opj_j2k_read_plm}, |
| {J2K_MS_PLT, J2K_STATE_TPH, opj_j2k_read_plt}, |
| {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm_v3}, |
| {J2K_MS_PPT, J2K_STATE_TPH, opj_j2k_read_ppt}, |
| {J2K_MS_SOP, 0, 0}, |
| {J2K_MS_CRG, J2K_STATE_MH, opj_j2k_read_crg}, |
| {J2K_MS_COM, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_com}, |
| {J2K_MS_MCT, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_mct}, |
| {J2K_MS_CBD, J2K_STATE_MH , opj_j2k_read_cbd}, |
| {J2K_MS_MCC, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_mcc}, |
| {J2K_MS_MCO, J2K_STATE_MH | J2K_STATE_TPH, opj_j2k_read_mco}, |
| #ifdef USE_JPWL |
| #ifdef TODO_MS /* remove these functions which are not commpatible with the v2 API */ |
| {J2K_MS_EPC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epc}, |
| {J2K_MS_EPB, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epb}, |
| {J2K_MS_ESD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_esd}, |
| {J2K_MS_RED, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_red}, |
| #endif |
| #endif /* USE_JPWL */ |
| #ifdef USE_JPSEC |
| {J2K_MS_SEC, J2K_DEC_STATE_MH, j2k_read_sec}, |
| {J2K_MS_INSEC, 0, j2k_read_insec} |
| #endif /* USE_JPSEC */ |
| {J2K_MS_UNK, J2K_STATE_MH | J2K_STATE_TPH, 0}/*opj_j2k_read_unk is directly used*/ |
| }; |
| |
| void opj_j2k_read_int16_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem) |
| { |
| OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data; |
| OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data; |
| OPJ_UINT32 i; |
| OPJ_UINT32 l_temp; |
| |
| for (i=0;i<p_nb_elem;++i) { |
| opj_read_bytes(l_src_data,&l_temp,2); |
| |
| l_src_data+=sizeof(OPJ_INT16); |
| |
| *(l_dest_data++) = (OPJ_FLOAT32) l_temp; |
| } |
| } |
| |
| void opj_j2k_read_int32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem) |
| { |
| OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data; |
| OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data; |
| OPJ_UINT32 i; |
| OPJ_UINT32 l_temp; |
| |
| for (i=0;i<p_nb_elem;++i) { |
| opj_read_bytes(l_src_data,&l_temp,4); |
| |
| l_src_data+=sizeof(OPJ_INT32); |
| |
| *(l_dest_data++) = (OPJ_FLOAT32) l_temp; |
| } |
| } |
| |
| void opj_j2k_read_float32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem) |
| { |
| OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data; |
| OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data; |
| OPJ_UINT32 i; |
| OPJ_FLOAT32 l_temp; |
| |
| for (i=0;i<p_nb_elem;++i) { |
| opj_read_float(l_src_data,&l_temp); |
| |
| l_src_data+=sizeof(OPJ_FLOAT32); |
| |
| *(l_dest_data++) = l_temp; |
| } |
| } |
| |
| void opj_j2k_read_float64_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem) |
| { |
| OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data; |
| OPJ_FLOAT32 * l_dest_data = (OPJ_FLOAT32 *) p_dest_data; |
| OPJ_UINT32 i; |
| OPJ_FLOAT64 l_temp; |
| |
| for (i=0;i<p_nb_elem;++i) { |
| opj_read_double(l_src_data,&l_temp); |
| |
| l_src_data+=sizeof(OPJ_FLOAT64); |
| |
| *(l_dest_data++) = (OPJ_FLOAT32) l_temp; |
| } |
| } |
| |
| void opj_j2k_read_int16_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem) |
| { |
| OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data; |
| OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data; |
| OPJ_UINT32 i; |
| OPJ_UINT32 l_temp; |
| |
| for (i=0;i<p_nb_elem;++i) { |
| opj_read_bytes(l_src_data,&l_temp,2); |
| |
| l_src_data+=sizeof(OPJ_INT16); |
| |
| *(l_dest_data++) = (OPJ_INT32) l_temp; |
| } |
| } |
| |
| void opj_j2k_read_int32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem) |
| { |
| OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data; |
| OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data; |
| OPJ_UINT32 i; |
| OPJ_UINT32 l_temp; |
| |
| for (i=0;i<p_nb_elem;++i) { |
| opj_read_bytes(l_src_data,&l_temp,4); |
| |
| l_src_data+=sizeof(OPJ_INT32); |
| |
| *(l_dest_data++) = (OPJ_INT32) l_temp; |
| } |
| } |
| |
| void opj_j2k_read_float32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem) |
| { |
| OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data; |
| OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data; |
| OPJ_UINT32 i; |
| OPJ_FLOAT32 l_temp; |
| |
| for (i=0;i<p_nb_elem;++i) { |
| opj_read_float(l_src_data,&l_temp); |
| |
| l_src_data+=sizeof(OPJ_FLOAT32); |
| |
| *(l_dest_data++) = (OPJ_INT32) l_temp; |
| } |
| } |
| |
| void opj_j2k_read_float64_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem) |
| { |
| OPJ_BYTE * l_src_data = (OPJ_BYTE *) p_src_data; |
| OPJ_INT32 * l_dest_data = (OPJ_INT32 *) p_dest_data; |
| OPJ_UINT32 i; |
| OPJ_FLOAT64 l_temp; |
| |
| for (i=0;i<p_nb_elem;++i) { |
| opj_read_double(l_src_data,&l_temp); |
| |
| l_src_data+=sizeof(OPJ_FLOAT64); |
| |
| *(l_dest_data++) = (OPJ_INT32) l_temp; |
| } |
| } |
| |
| void opj_j2k_write_float_to_int16 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem) |
| { |
| OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data; |
| OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data; |
| OPJ_UINT32 i; |
| OPJ_UINT32 l_temp; |
| |
| for (i=0;i<p_nb_elem;++i) { |
| l_temp = (OPJ_UINT32) *(l_src_data++); |
| |
| opj_write_bytes(l_dest_data,l_temp,sizeof(OPJ_INT16)); |
| |
| l_dest_data+=sizeof(OPJ_INT16); |
| } |
| } |
| |
| void opj_j2k_write_float_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem) |
| { |
| OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data; |
| OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data; |
| OPJ_UINT32 i; |
| OPJ_UINT32 l_temp; |
| |
| for (i=0;i<p_nb_elem;++i) { |
| l_temp = (OPJ_UINT32) *(l_src_data++); |
| |
| opj_write_bytes(l_dest_data,l_temp,sizeof(OPJ_INT32)); |
| |
| l_dest_data+=sizeof(OPJ_INT32); |
| } |
| } |
| |
| void opj_j2k_write_float_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem) |
| { |
| OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data; |
| OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data; |
| OPJ_UINT32 i; |
| OPJ_FLOAT32 l_temp; |
| |
| for (i=0;i<p_nb_elem;++i) { |
| l_temp = (OPJ_FLOAT32) *(l_src_data++); |
| |
| opj_write_float(l_dest_data,l_temp); |
| |
| l_dest_data+=sizeof(OPJ_FLOAT32); |
| } |
| } |
| |
| void opj_j2k_write_float_to_float64 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem) |
| { |
| OPJ_BYTE * l_dest_data = (OPJ_BYTE *) p_dest_data; |
| OPJ_FLOAT32 * l_src_data = (OPJ_FLOAT32 *) p_src_data; |
| OPJ_UINT32 i; |
| OPJ_FLOAT64 l_temp; |
| |
| for (i=0;i<p_nb_elem;++i) { |
| l_temp = (OPJ_FLOAT64) *(l_src_data++); |
| |
| opj_write_double(l_dest_data,l_temp); |
| |
| l_dest_data+=sizeof(OPJ_FLOAT64); |
| } |
| } |
| |
| char *opj_j2k_convert_progression_order(OPJ_PROG_ORDER prg_order){ |
| j2k_prog_order_t *po; |
| for(po = j2k_prog_order_list; po->enum_prog != -1; po++ ){ |
| if(po->enum_prog == prg_order){ |
| return po->str_prog; |
| } |
| } |
| return po->str_prog; |
| } |
| |
| 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, |
| OPJ_UINT32 p_num_layers, |
| opj_event_mgr_t * p_manager) |
| { |
| OPJ_UINT32* packet_array; |
| OPJ_UINT32 index , resno, compno, layno; |
| OPJ_UINT32 i; |
| 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_UINT32 layno0 = 0; |
| |
| packet_array = (OPJ_UINT32*) opj_calloc(step_l * p_num_layers, sizeof(OPJ_UINT32)); |
| if (packet_array == 00) { |
| opj_event_msg(p_manager , EVT_ERROR, "Not enough memory for checking the poc values.\n"); |
| return OPJ_FALSE; |
| } |
| |
| if (p_nb_pocs == 0) { |
| opj_free(packet_array); |
| return OPJ_TRUE; |
| } |
| |
| index = step_r * p_pocs->resno0; |
| /* take each resolution for each poc */ |
| for (resno = p_pocs->resno0 ; resno < p_pocs->resno1 ; ++resno) |
| { |
| OPJ_UINT32 res_index = index + p_pocs->compno0 * step_c; |
| |
| /* take each comp of each resolution for each poc */ |
| for (compno = p_pocs->compno0 ; compno < p_pocs->compno1 ; ++compno) { |
| OPJ_UINT32 comp_index = res_index + layno0 * step_l; |
| |
| /* and finally take each layer of each res of ... */ |
| for (layno = layno0; layno < p_pocs->layno1 ; ++layno) { |
| /*index = step_r * resno + step_c * compno + step_l * layno;*/ |
| packet_array[comp_index] = 1; |
| comp_index += step_l; |
| } |
| |
| res_index += step_c; |
| } |
| |
| index += step_r; |
| } |
| ++p_pocs; |
| |
| /* iterate through all the pocs */ |
| for (i = 1; i < p_nb_pocs ; ++i) { |
| OPJ_UINT32 l_last_layno1 = (p_pocs-1)->layno1 ; |
| |
| layno0 = (p_pocs->layno1 > l_last_layno1)? l_last_layno1 : 0; |
| index = step_r * p_pocs->resno0; |
| |
| /* take each resolution for each poc */ |
| for (resno = p_pocs->resno0 ; resno < p_pocs->resno1 ; ++resno) { |
| OPJ_UINT32 res_index = index + p_pocs->compno0 * step_c; |
| |
| /* take each comp of each resolution for each poc */ |
| for (compno = p_pocs->compno0 ; compno < p_pocs->compno1 ; ++compno) { |
| OPJ_UINT32 comp_index = res_index + layno0 * step_l; |
| |
| /* and finally take each layer of each res of ... */ |
| for (layno = layno0; layno < p_pocs->layno1 ; ++layno) { |
| /*index = step_r * resno + step_c * compno + step_l * layno;*/ |
| packet_array[comp_index] = 1; |
| comp_index += step_l; |
| } |
| |
| res_index += step_c; |
| } |
| |
| index += step_r; |
| } |
| |
| ++p_pocs; |
| } |
| |
| index = 0; |
| for (layno = 0; layno < p_num_layers ; ++layno) { |
| for (resno = 0; resno < p_nb_resolutions; ++resno) { |
| for (compno = 0; compno < p_num_comps; ++compno) { |
| loss |= (packet_array[index]!=1); |
| /*index = step_r * resno + step_c * compno + step_l * layno;*/ |
| index += step_c; |
| } |
| } |
| } |
| |
| if (loss) { |
| opj_event_msg(p_manager , EVT_ERROR, "Missing packets possible loss of data\n"); |
| } |
| |
| opj_free(packet_array); |
| |
| return !loss; |
| } |
| |
| /* ----------------------------------------------------------------------- */ |
| |
| OPJ_UINT32 opj_j2k_get_num_tp(opj_cp_t *cp, OPJ_UINT32 pino, OPJ_UINT32 tileno) |
| { |
| const OPJ_CHAR *prog = 00; |
| OPJ_INT32 i; |
| OPJ_UINT32 tpnum = 1; |
| opj_tcp_t *tcp = 00; |
| opj_poc_t * l_current_poc = 00; |
| |
| /* preconditions */ |
| assert(tileno < (cp->tw * cp->th)); |
| assert(pino < (cp->tcps[tileno].numpocs + 1)); |
| |
| /* get the given tile coding parameter */ |
| tcp = &cp->tcps[tileno]; |
| assert(tcp != 00); |
| |
| l_current_poc = &(tcp->pocs[pino]); |
| assert(l_current_poc != 0); |
| |
| /* get the progression order as a character string */ |
| prog = opj_j2k_convert_progression_order(tcp->prg); |
| assert(strlen(prog) > 0); |
| |
| if (cp->m_specific_param.m_enc.m_tp_on == 1) { |
| for (i=0;i<4;++i) { |
| switch (prog[i]) |
| { |
| /* component wise */ |
| case 'C': |
| tpnum *= l_current_poc->compE; |
| break; |
| /* resolution wise */ |
| case 'R': |
| tpnum *= l_current_poc->resE; |
| break; |
| /* precinct wise */ |
| case 'P': |
| tpnum *= l_current_poc->prcE; |
| break; |
| /* layer wise */ |
| case 'L': |
| tpnum *= l_current_poc->layE; |
| break; |
| } |
| /* whould we split here ? */ |
| if ( cp->m_specific_param.m_enc.m_tp_flag == prog[i] ) { |
| cp->m_specific_param.m_enc.m_tp_pos=i; |
| break; |
| } |
| } |
| } |
| else { |
| tpnum=1; |
| } |
| |
| return tpnum; |
| } |
| |
| 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 |
| ) |
| { |
| OPJ_UINT32 pino,tileno; |
| OPJ_UINT32 l_nb_tiles; |
| opj_tcp_t *tcp; |
| |
| /* preconditions */ |
| assert(p_nb_tiles != 00); |
| assert(cp != 00); |
| assert(image != 00); |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| |
| l_nb_tiles = cp->tw * cp->th; |
| * p_nb_tiles = 0; |
| tcp = cp->tcps; |
| |
| /* INDEX >> */ |
| /* TODO mergeV2: check this part which use cstr_info */ |
| /*if (p_j2k->cstr_info) { |
| opj_tile_info_t * l_info_tile_ptr = p_j2k->cstr_info->tile; |
| |
| for (tileno = 0; tileno < l_nb_tiles; ++tileno) { |
| OPJ_UINT32 cur_totnum_tp = 0; |
| |
| opj_pi_update_encoding_parameters(image,cp,tileno); |
| |
| for (pino = 0; pino <= tcp->numpocs; ++pino) |
| { |
| OPJ_UINT32 tp_num = opj_j2k_get_num_tp(cp,pino,tileno); |
| |
| *p_nb_tiles = *p_nb_tiles + tp_num; |
| |
| cur_totnum_tp += tp_num; |
| } |
| |
| tcp->m_nb_tile_parts = cur_totnum_tp; |
| |
| l_info_tile_ptr->tp = (opj_tp_info_t *) opj_malloc(cur_totnum_tp * sizeof(opj_tp_info_t)); |
| if (l_info_tile_ptr->tp == 00) { |
| return OPJ_FALSE; |
| } |
| |
| memset(l_info_tile_ptr->tp,0,cur_totnum_tp * sizeof(opj_tp_info_t)); |
| |
| l_info_tile_ptr->num_tps = cur_totnum_tp; |
| |
| ++l_info_tile_ptr; |
| ++tcp; |
| } |
| } |
| else */{ |
| for (tileno = 0; tileno < l_nb_tiles; ++tileno) { |
| OPJ_UINT32 cur_totnum_tp = 0; |
| |
| opj_pi_update_encoding_parameters(image,cp,tileno); |
| |
| for (pino = 0; pino <= tcp->numpocs; ++pino) { |
| OPJ_UINT32 tp_num = opj_j2k_get_num_tp(cp,pino,tileno); |
| |
| *p_nb_tiles = *p_nb_tiles + tp_num; |
| |
| cur_totnum_tp += tp_num; |
| } |
| tcp->m_nb_tile_parts = cur_totnum_tp; |
| |
| ++tcp; |
| } |
| } |
| |
| return OPJ_TRUE; |
| } |
| |
| OPJ_BOOL opj_j2k_write_soc( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ) |
| { |
| /* 2 bytes will be written */ |
| OPJ_BYTE * l_start_stream = 00; |
| |
| /* preconditions */ |
| assert(p_stream != 00); |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| |
| l_start_stream = p_j2k->m_specific_param.m_encoder.m_header_tile_data; |
| |
| /* write SOC identifier */ |
| opj_write_bytes(l_start_stream,J2K_MS_SOC,2); |
| |
| if (opj_stream_write_data(p_stream,l_start_stream,2,p_manager) != 2) { |
| return OPJ_FALSE; |
| } |
| |
| /* UniPG>> */ |
| #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); |
| */ |
| assert( 0 && "TODO" ); |
| #endif /* USE_JPWL */ |
| /* <<UniPG */ |
| |
| return OPJ_TRUE; |
| } |
| |
| /** |
| * Reads a SOC marker (Start of Codestream) |
| * @param p_j2k the jpeg2000 file codec. |
| * @param p_stream FIXME DOC |
| * @param p_manager the user event manager. |
| */ |
| static OPJ_BOOL opj_j2k_read_soc( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager |
| ) |
| { |
| OPJ_BYTE l_data [2]; |
| OPJ_UINT32 l_marker; |
| |
| /* preconditions */ |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| assert(p_stream != 00); |
| |
| if (opj_stream_read_data(p_stream,l_data,2,p_manager) != 2) { |
| return OPJ_FALSE; |
| } |
| |
| opj_read_bytes(l_data,&l_marker,2); |
| if (l_marker != J2K_MS_SOC) { |
| return OPJ_FALSE; |
| } |
| |
| /* Next marker should be a SIZ marker in the main header */ |
| p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_MHSIZ; |
| |
| /* 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(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(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_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager ) |
| { |
| OPJ_UINT32 i; |
| OPJ_UINT32 l_size_len; |
| OPJ_BYTE * l_current_ptr; |
| opj_image_t * l_image = 00; |
| opj_cp_t *cp = 00; |
| opj_image_comp_t * l_img_comp = 00; |
| |
| /* preconditions */ |
| assert(p_stream != 00); |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| |
| l_image = p_j2k->m_private_image; |
| cp = &(p_j2k->m_cp); |
| l_size_len = 40 + 3 * l_image->numcomps; |
| l_img_comp = l_image->comps; |
| |
| if (l_size_len > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) { |
| |
| OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_size_len); |
| 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(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; |
| p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_size_len; |
| } |
| |
| l_current_ptr = p_j2k->m_specific_param.m_encoder.m_header_tile_data; |
| |
| /* write SOC identifier */ |
| opj_write_bytes(l_current_ptr,J2K_MS_SIZ,2); /* SIZ */ |
| l_current_ptr+=2; |
| |
| opj_write_bytes(l_current_ptr,l_size_len-2,2); /* L_SIZ */ |
| l_current_ptr+=2; |
| |
| opj_write_bytes(l_current_ptr, cp->rsiz, 2); /* Rsiz (capabilities) */ |
| l_current_ptr+=2; |
| |
| opj_write_bytes(l_current_ptr, l_image->x1, 4); /* Xsiz */ |
| l_current_ptr+=4; |
| |
| opj_write_bytes(l_current_ptr, l_image->y1, 4); /* Ysiz */ |
| l_current_ptr+=4; |
| |
| opj_write_bytes(l_current_ptr, l_image->x0, 4); /* X0siz */ |
| l_current_ptr+=4; |
| |
| opj_write_bytes(l_current_ptr, l_image->y0, 4); /* Y0siz */ |
| l_current_ptr+=4; |
| |
| opj_write_bytes(l_current_ptr, cp->tdx, 4); /* XTsiz */ |
| l_current_ptr+=4; |
| |
| opj_write_bytes(l_current_ptr, cp->tdy, 4); /* YTsiz */ |
| l_current_ptr+=4; |
| |
| opj_write_bytes(l_current_ptr, cp->tx0, 4); /* XT0siz */ |
| l_current_ptr+=4; |
| |
| opj_write_bytes(l_current_ptr, cp->ty0, 4); /* YT0siz */ |
| l_current_ptr+=4; |
| |
| opj_write_bytes(l_current_ptr, l_image->numcomps, 2); /* Csiz */ |
| l_current_ptr+=2; |
| |
| for (i = 0; i < l_image->numcomps; ++i) { |
| /* TODO here with MCT ? */ |
| opj_write_bytes(l_current_ptr, l_img_comp->prec - 1 + (l_img_comp->sgnd << 7), 1); /* Ssiz_i */ |
| ++l_current_ptr; |
| |
| opj_write_bytes(l_current_ptr, l_img_comp->dx, 1); /* XRsiz_i */ |
| ++l_current_ptr; |
| |
| opj_write_bytes(l_current_ptr, l_img_comp->dy, 1); /* YRsiz_i */ |
| ++l_current_ptr; |
| |
| ++l_img_comp; |
| } |
| |
| if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_size_len,p_manager) != l_size_len) { |
| return OPJ_FALSE; |
| } |
| |
| return OPJ_TRUE; |
| } |
| |
| /** |
| * Reads a SIZ marker (image and tile size) |
| * @param p_j2k the jpeg2000 file codec. |
| * @param p_header_data the data contained in the SIZ box. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager |
| ) |
| { |
| 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, l_tx1, l_ty1; |
| opj_image_t *l_image = 00; |
| opj_cp_t *l_cp = 00; |
| opj_image_comp_t * l_img_comp = 00; |
| opj_tcp_t * l_current_tile_param = 00; |
| |
| /* preconditions */ |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| assert(p_header_data != 00); |
| |
| l_image = p_j2k->m_private_image; |
| l_cp = &(p_j2k->m_cp); |
| |
| /* minimum size == 39 - 3 (= minimum component parameter) */ |
| if (p_header_size < 36) { |
| opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n"); |
| return OPJ_FALSE; |
| } |
| |
| l_remaining_size = p_header_size - 36; |
| l_nb_comp = l_remaining_size / 3; |
| l_nb_comp_remain = l_remaining_size % 3; |
| if (l_nb_comp_remain != 0){ |
| opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker size\n"); |
| return OPJ_FALSE; |
| } |
| |
| opj_read_bytes(p_header_data,&l_tmp ,2); /* Rsiz (capabilities) */ |
| p_header_data+=2; |
| 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 */ |
| p_header_data+=4; |
| opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->x0, 4); /* X0siz */ |
| p_header_data+=4; |
| opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_image->y0, 4); /* Y0siz */ |
| p_header_data+=4; |
| opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->tdx, 4); /* XTsiz */ |
| p_header_data+=4; |
| opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->tdy, 4); /* YTsiz */ |
| p_header_data+=4; |
| opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->tx0, 4); /* XT0siz */ |
| p_header_data+=4; |
| opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_cp->ty0, 4); /* YT0siz */ |
| p_header_data+=4; |
| opj_read_bytes(p_header_data, (OPJ_UINT32*) &l_tmp, 2); /* Csiz */ |
| p_header_data+=2; |
| if (l_tmp < 16385) |
| l_image->numcomps = (OPJ_UINT16) l_tmp; |
| else { |
| 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(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 */ |
| /* testcase issue427-null-image-size.jp2 */ |
| 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 or zero 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; |
| } |
| |
| /* testcase issue427-illegal-tile-offset.jp2 */ |
| l_tx1 = l_cp->tx0 + l_cp->tdx; |
| if (l_tx1 < l_cp->tx0) { /* manage overflow */ |
| l_tx1 = 0xFFFFFFFFU; |
| } |
| l_ty1 = l_cp->ty0 + l_cp->tdy; |
| if (l_ty1 < l_cp->ty0) { /* manage overflow */ |
| l_ty1 = 0xFFFFFFFFU; |
| } |
| if ((l_cp->tx0 > l_image->x0) || (l_cp->ty0 > l_image->y0) || (l_tx1 <= l_image->x0) || (l_ty1 <= l_image->y0) ) { |
| opj_event_msg(p_manager, EVT_ERROR, "Error with SIZ marker: illegal tile offset\n"); |
| 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 */ |
| if (!(l_image->x1 * l_image->y1)) { |
| 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(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(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(p_manager, EVT_ERROR, "JPWL: giving up\n"); |
| return OPJ_FALSE; |
| } |
| */ /* we try to correct */ |
| /* 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(p_manager, EVT_WARNING, "- setting Lsiz to %d => HYPOTHESIS!!!\n", |
| len); |
| } else { |
| l_image->numcomps = ((len - 38) / 3); |
| opj_event_msg(p_manager, EVT_WARNING, "- setting Csiz to %d => HYPOTHESIS!!!\n", |
| l_image->numcomps); |
| } |
| } |
| */ |
| |
| /* update components number in the jpwl_exp_comps filed */ |
| l_cp->exp_comps = l_image->numcomps; |
| } |
| #endif /* USE_JPWL */ |
| |
| /* Allocate the resulting image components */ |
| 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(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); |
| return OPJ_FALSE; |
| } |
| |
| l_img_comp = l_image->comps; |
| |
| /* Read the component information */ |
| for (i = 0; i < l_image->numcomps; ++i){ |
| OPJ_UINT32 tmp; |
| opj_read_bytes(p_header_data,&tmp,1); /* Ssiz_i */ |
| ++p_header_data; |
| l_img_comp->prec = (tmp & 0x7f) + 1; |
| l_img_comp->sgnd = tmp >> 7; |
| opj_read_bytes(p_header_data,&tmp,1); /* XRsiz_i */ |
| ++p_header_data; |
| 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_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(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(p_manager, EVT_ERROR, "JPWL: giving up\n"); |
| return OPJ_FALSE; |
| } |
| /* we try to correct */ |
| 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(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(p_manager, EVT_WARNING, "- setting YRsiz_%d to %d => HYPOTHESIS!!!\n", |
| i, l_image->comps[i].dy); |
| } |
| } |
| } |
| #endif /* USE_JPWL */ |
| l_img_comp->resno_decoded = 0; /* number of resolution decoded */ |
| l_img_comp->factor = l_cp->m_specific_param.m_dec.m_reduce; /* reducing factor per component */ |
| ++l_img_comp; |
| } |
| |
| /* Compute the number of tiles */ |
| 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_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; |
| p_j2k->m_specific_param.m_decoder.m_start_tile_y = 0; |
| p_j2k->m_specific_param.m_decoder.m_end_tile_x = l_cp->tw; |
| p_j2k->m_specific_param.m_decoder.m_end_tile_y = l_cp->th; |
| } |
| |
| #ifdef USE_JPWL |
| if (l_cp->correct) { |
| /* 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(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(p_manager, EVT_ERROR, "JPWL: giving up\n"); |
| return OPJ_FALSE; |
| } |
| /* we try to correct */ |
| opj_event_msg(p_manager, EVT_WARNING, "- trying to adjust them\n"); |
| if (l_cp->tw < 1) { |
| l_cp->tw= 1; |
| 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(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(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(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); |
| } |
| } |
| } |
| #endif /* USE_JPWL */ |
| |
| /* memory allocations */ |
| l_cp->tcps = (opj_tcp_t*) opj_calloc(l_nb_tiles, sizeof(opj_tcp_t)); |
| if (l_cp->tcps == 00) { |
| opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); |
| return OPJ_FALSE; |
| } |
| |
| #ifdef USE_JPWL |
| if (l_cp->correct) { |
| if (!l_cp->tcps) { |
| 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(p_manager, EVT_ERROR, "JPWL: giving up\n"); |
| return OPJ_FALSE; |
| } |
| } |
| } |
| #endif /* USE_JPWL */ |
| |
| 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(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); |
| return OPJ_FALSE; |
| } |
| |
| p_j2k->m_specific_param.m_decoder.m_default_tcp->m_mct_records = |
| (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(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); |
| return OPJ_FALSE; |
| } |
| 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_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(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); |
| return OPJ_FALSE; |
| } |
| 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;i<l_image->numcomps;++i) { |
| if (! l_image->comps[i].sgnd) { |
| p_j2k->m_specific_param.m_decoder.m_default_tcp->tccps[i].m_dc_level_shift = 1 << (l_image->comps[i].prec - 1); |
| } |
| } |
| |
| l_current_tile_param = l_cp->tcps; |
| for (i = 0; i < l_nb_tiles; ++i) { |
| 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(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n"); |
| return OPJ_FALSE; |
| } |
| |
| ++l_current_tile_param; |
| } |
| |
| p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_MH; /* FIXME J2K_DEC_STATE_MH; */ |
| opj_image_comp_header_update(l_image,l_cp); |
| |
| return OPJ_TRUE; |
| } |
| |
| OPJ_BOOL opj_j2k_write_com( opj_j2k_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager |
| ) |
| { |
| OPJ_UINT32 l_comment_size; |
| OPJ_UINT32 l_total_com_size; |
| const OPJ_CHAR *l_comment; |
| OPJ_BYTE * l_current_ptr = 00; |
| |
| /* preconditions */ |
| assert(p_j2k != 00); |
| assert(p_stream != 00); |
| assert(p_manager != 00); |
| |
| l_comment = p_j2k->m_cp.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) { |
| OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_total_com_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(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; |
| p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_total_com_size; |
| } |
| |
| l_current_ptr = p_j2k->m_specific_param.m_encoder.m_header_tile_data; |
| |
| opj_write_bytes(l_current_ptr,J2K_MS_COM , 2); /* COM */ |
| l_current_ptr+=2; |
| |
| opj_write_bytes(l_current_ptr,l_total_com_size - 2 , 2); /* L_COM */ |
| l_current_ptr+=2; |
| |
| opj_write_bytes(l_current_ptr,1 , 2); /* General use (IS 8859-15:1999 (Latin) values) */ |
| l_current_ptr+=2; |
| |
| memcpy( l_current_ptr,l_comment,l_comment_size); |
| |
| if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_total_com_size,p_manager) != l_total_com_size) { |
| return OPJ_FALSE; |
| } |
| |
| return OPJ_TRUE; |
| } |
| |
| /** |
| * Reads a COM marker (comments) |
| * @param p_j2k the jpeg2000 file codec. |
| * @param p_header_data the data contained in the COM box. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager |
| ) |
| { |
| /* preconditions */ |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| assert(p_header_data != 00); |
| (void)p_header_size; |
| |
| return OPJ_TRUE; |
| } |
| |
| 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_t *l_cp = 00; |
| opj_tcp_t *l_tcp = 00; |
| OPJ_UINT32 l_code_size,l_remaining_size; |
| OPJ_BYTE * l_current_data = 00; |
| |
| /* preconditions */ |
| assert(p_j2k != 00); |
| 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_code_size = 9 + opj_j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,0); |
| l_remaining_size = l_code_size; |
| |
| if (l_code_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) { |
| OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_code_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(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; |
| p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_code_size; |
| } |
| |
| l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data; |
| |
| opj_write_bytes(l_current_data,J2K_MS_COD,2); /* COD */ |
| l_current_data += 2; |
| |
| opj_write_bytes(l_current_data,l_code_size-2,2); /* L_COD */ |
| l_current_data += 2; |
| |
| opj_write_bytes(l_current_data,l_tcp->csty,1); /* Scod */ |
| ++l_current_data; |
| |
| opj_write_bytes(l_current_data,l_tcp->prg,1); /* SGcod (A) */ |
| ++l_current_data; |
| |
| opj_write_bytes(l_current_data,l_tcp->numlayers,2); /* SGcod (B) */ |
| l_current_data+=2; |
| |
| opj_write_bytes(l_current_data,l_tcp->mct,1); /* SGcod (C) */ |
| ++l_current_data; |
| |
| 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(p_manager, EVT_ERROR, "Error writing COD marker\n"); |
| return OPJ_FALSE; |
| } |
| |
| if (l_remaining_size != 0) { |
| opj_event_msg(p_manager, EVT_ERROR, "Error writing COD marker\n"); |
| return OPJ_FALSE; |
| } |
| |
| if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_code_size,p_manager) != l_code_size) { |
| return OPJ_FALSE; |
| } |
| |
| return OPJ_TRUE; |
| } |
| |
| /** |
| * Reads a COD marker (Coding Styke defaults) |
| * @param p_header_data the data contained in the COD box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager |
| ) |
| { |
| /* loop */ |
| OPJ_UINT32 i; |
| OPJ_UINT32 l_tmp; |
| opj_cp_t *l_cp = 00; |
| opj_tcp_t *l_tcp = 00; |
| opj_image_t *l_image = 00; |
| |
| /* preconditions */ |
| assert(p_header_data != 00); |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| |
| l_image = p_j2k->m_private_image; |
| l_cp = &(p_j2k->m_cp); |
| |
| /* If we are in the first tile-part header of the current tile */ |
| l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH) ? |
| &l_cp->tcps[p_j2k->m_current_tile_number] : |
| p_j2k->m_specific_param.m_decoder.m_default_tcp; |
| |
| /* Make sure room is sufficient */ |
| if (p_header_size < 5) { |
| 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; |
| |
| /* If user didn't set a number layer to decode take the max specify in the codestream. */ |
| if (l_cp->m_specific_param.m_dec.m_layer) { |
| l_tcp->num_layers_to_decode = l_cp->m_specific_param.m_dec.m_layer; |
| } |
| else { |
| l_tcp->num_layers_to_decode = l_tcp->numlayers; |
| } |
| |
| opj_read_bytes(p_header_data,&l_tcp->mct,1); /* SGcod (C) */ |
| ++p_header_data; |
| |
| p_header_size -= 5; |
| for (i = 0; i < l_image->numcomps; ++i) { |
| l_tcp->tccps[i].csty = l_tcp->csty & J2K_CCP_CSTY_PRT; |
| } |
| |
| if (! opj_j2k_read_SPCod_SPCoc(p_j2k,0,p_header_data,&p_header_size,p_manager)) { |
| opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n"); |
| return OPJ_FALSE; |
| } |
| |
| if (p_header_size != 0) { |
| opj_event_msg(p_manager, EVT_ERROR, "Error reading COD marker\n"); |
| return OPJ_FALSE; |
| } |
| |
| /* Apply the coding style to other components of the current tile or the m_default_tcp*/ |
| opj_j2k_copy_tile_component_parameters(p_j2k); |
| |
| /* Index */ |
| #ifdef WIP_REMOVE_MSD |
| if (p_j2k->cstr_info) { |
| /*opj_codestream_info_t *l_cstr_info = p_j2k->cstr_info;*/ |
| p_j2k->cstr_info->prog = l_tcp->prg; |
| p_j2k->cstr_info->numlayers = l_tcp->numlayers; |
| p_j2k->cstr_info->numdecompos = (OPJ_INT32*) opj_malloc(l_image->numcomps * sizeof(OPJ_UINT32)); |
| for (i = 0; i < l_image->numcomps; ++i) { |
| p_j2k->cstr_info->numdecompos[i] = l_tcp->tccps[i].numresolutions - 1; |
| } |
| } |
| #endif |
| |
| return OPJ_TRUE; |
| } |
| |
| #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 ) |
| { |
| OPJ_UINT32 l_coc_size,l_remaining_size; |
| OPJ_UINT32 l_comp_room; |
| |
| /* preconditions */ |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| assert(p_stream != 00); |
| |
| l_comp_room = (p_j2k->m_private_image->numcomps <= 256) ? 1 : 2; |
| |
| l_coc_size = 5 + l_comp_room + opj_j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no); |
| |
| 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 |
| = (OPJ_BYTE*)opj_realloc( |
| p_j2k->m_specific_param.m_encoder.m_header_tile_data, |
| 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(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; |
| p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_coc_size; |
| } |
| |
| opj_j2k_write_coc_in_memory(p_j2k,p_comp_no,p_j2k->m_specific_param.m_encoder.m_header_tile_data,&l_remaining_size,p_manager); |
| |
| if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_coc_size,p_manager) != l_coc_size) { |
| return OPJ_FALSE; |
| } |
| |
| return OPJ_TRUE; |
| } |
| #endif |
| |
| #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_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; |
| OPJ_UINT32 l_comp_room; |
| |
| /* preconditions */ |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| |
| l_cp = &(p_j2k->m_cp); |
| l_tcp = &l_cp->tcps[p_j2k->m_current_tile_number]; |
| l_image = p_j2k->m_private_image; |
| l_comp_room = (l_image->numcomps <= 256) ? 1 : 2; |
| |
| l_coc_size = 5 + l_comp_room + opj_j2k_get_SPCod_SPCoc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no); |
| l_remaining_size = l_coc_size; |
| |
| l_current_data = p_data; |
| |
| opj_write_bytes(l_current_data,J2K_MS_COC,2); /* COC */ |
| l_current_data += 2; |
| |
| opj_write_bytes(l_current_data,l_coc_size-2,2); /* L_COC */ |
| l_current_data += 2; |
| |
| opj_write_bytes(l_current_data,p_comp_no, l_comp_room); /* Ccoc */ |
| l_current_data+=l_comp_room; |
| |
| opj_write_bytes(l_current_data, l_tcp->tccps[p_comp_no].csty, 1); /* Scoc */ |
| ++l_current_data; |
| |
| l_remaining_size -= (5 + l_comp_room); |
| 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_t *p_j2k) |
| { |
| OPJ_UINT32 i,j; |
| OPJ_UINT32 l_nb_comp; |
| OPJ_UINT32 l_nb_tiles; |
| OPJ_UINT32 l_max = 0; |
| |
| /* preconditions */ |
| |
| l_nb_tiles = p_j2k->m_cp.tw * p_j2k->m_cp.th ; |
| l_nb_comp = p_j2k->m_private_image->numcomps; |
| |
| for (i=0;i<l_nb_tiles;++i) { |
| for (j=0;j<l_nb_comp;++j) { |
| l_max = opj_uint_max(l_max,opj_j2k_get_SPCod_SPCoc_size(p_j2k,i,j)); |
| } |
| } |
| |
| return 6 + l_max; |
| } |
| |
| /** |
| * Reads a COC marker (Coding Style Component) |
| * @param p_header_data the data contained in the COC box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager |
| ) |
| { |
| 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; |
| |
| /* preconditions */ |
| assert(p_header_data != 00); |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| |
| l_cp = &(p_j2k->m_cp); |
| l_tcp = (p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ) ? /*FIXME J2K_DEC_STATE_TPH*/ |
| &l_cp->tcps[p_j2k->m_current_tile_number] : |
| p_j2k->m_specific_param.m_decoder.m_default_tcp; |
| l_image = p_j2k->m_private_image; |
| |
| l_comp_room = l_image->numcomps <= 256 ? 1 : 2; |
| |
| /* make sure room is sufficient*/ |
| if (p_header_size < l_comp_room + 1) { |
| opj_event_msg(p_manager, EVT_ERROR, "Error reading COC marker\n"); |
| return OPJ_FALSE; |
| } |
| p_header_size -= l_comp_room + 1; |
| |
| 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(p_manager, EVT_ERROR, "Error reading COC marker (bad number of components)\n"); |
| return OPJ_FALSE; |
| } |
| |
| opj_read_bytes(p_header_data,&l_tcp->tccps[l_comp_no].csty,1); /* Scoc */ |
| ++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(p_manager, EVT_ERROR, "Error reading COC marker\n"); |
| return OPJ_FALSE; |
| } |
| |
| if (p_header_size != 0) { |
| 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_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager |
| ) |
| { |
| OPJ_UINT32 l_qcd_size,l_remaining_size; |
| OPJ_BYTE * l_current_data = 00; |
| |
| /* preconditions */ |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| assert(p_stream != 00); |
| |
| 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; |
| |
| if (l_qcd_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) { |
| OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_qcd_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(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; |
| p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_qcd_size; |
| } |
| |
| l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data; |
| |
| opj_write_bytes(l_current_data,J2K_MS_QCD,2); /* QCD */ |
| l_current_data += 2; |
| |
| opj_write_bytes(l_current_data,l_qcd_size-2,2); /* L_QCD */ |
| l_current_data += 2; |
| |
| 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(p_manager, EVT_ERROR, "Error writing QCD marker\n"); |
| return OPJ_FALSE; |
| } |
| |
| if (l_remaining_size != 0) { |
| opj_event_msg(p_manager, EVT_ERROR, "Error writing QCD marker\n"); |
| return OPJ_FALSE; |
| } |
| |
| if (opj_stream_write_data(p_stream, p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_qcd_size,p_manager) != l_qcd_size) { |
| return OPJ_FALSE; |
| } |
| |
| return OPJ_TRUE; |
| } |
| |
| /** |
| * Reads a QCD marker (Quantization defaults) |
| * @param p_header_data the data contained in the QCD box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager |
| ) |
| { |
| /* preconditions */ |
| assert(p_header_data != 00); |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| |
| if (! opj_j2k_read_SQcd_SQcc(p_j2k,0,p_header_data,&p_header_size,p_manager)) { |
| opj_event_msg(p_manager, EVT_ERROR, "Error reading QCD marker\n"); |
| return OPJ_FALSE; |
| } |
| |
| if (p_header_size != 0) { |
| opj_event_msg(p_manager, EVT_ERROR, "Error reading QCD marker\n"); |
| return OPJ_FALSE; |
| } |
| |
| /* Apply the quantization parameters to other components of the current tile or the m_default_tcp */ |
| opj_j2k_copy_tile_quantization_parameters(p_j2k); |
| |
| return OPJ_TRUE; |
| } |
| |
| #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 |
| ) |
| { |
| OPJ_UINT32 l_qcc_size,l_remaining_size; |
| |
| /* preconditions */ |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| assert(p_stream != 00); |
| |
| 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) { |
| OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_qcc_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(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; |
| p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_qcc_size; |
| } |
| |
| opj_j2k_write_qcc_in_memory(p_j2k,p_comp_no,p_j2k->m_specific_param.m_encoder.m_header_tile_data,&l_remaining_size,p_manager); |
| |
| if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_qcc_size,p_manager) != l_qcc_size) { |
| return OPJ_FALSE; |
| } |
| |
| return OPJ_TRUE; |
| } |
| #endif |
| |
| #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, |
| opj_event_mgr_t * p_manager |
| ) |
| { |
| OPJ_UINT32 l_qcc_size,l_remaining_size; |
| OPJ_BYTE * l_current_data = 00; |
| |
| /* preconditions */ |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| |
| l_qcc_size = 6 + opj_j2k_get_SQcd_SQcc_size(p_j2k,p_j2k->m_current_tile_number,p_comp_no); |
| l_remaining_size = l_qcc_size; |
| |
| l_current_data = p_data; |
| |
| opj_write_bytes(l_current_data,J2K_MS_QCC,2); /* QCC */ |
| l_current_data += 2; |
| |
| if (p_j2k->m_private_image->numcomps <= 256) { |
| --l_qcc_size; |
| |
| opj_write_bytes(l_current_data,l_qcc_size-2,2); /* L_QCC */ |
| l_current_data += 2; |
| |
| opj_write_bytes(l_current_data, p_comp_no, 1); /* Cqcc */ |
| ++l_current_data; |
| |
| /* in the case only one byte is sufficient the last byte allocated is useless -> still do -6 for available */ |
| l_remaining_size -= 6; |
| } |
| else { |
| opj_write_bytes(l_current_data,l_qcc_size-2,2); /* L_QCC */ |
| l_current_data += 2; |
| |
| opj_write_bytes(l_current_data, p_comp_no, 2); /* Cqcc */ |
| l_current_data+=2; |
| |
| l_remaining_size -= 6; |
| } |
| |
| opj_j2k_write_SQcd_SQcc(p_j2k,p_j2k->m_current_tile_number,p_comp_no,l_current_data,&l_remaining_size,p_manager); |
| |
| *p_data_written = l_qcc_size; |
| } |
| #endif |
| |
| OPJ_UINT32 opj_j2k_get_max_qcc_size (opj_j2k_t *p_j2k) |
| { |
| return opj_j2k_get_max_coc_size(p_j2k); |
| } |
| |
| /** |
| * Reads a QCC marker (Quantization component) |
| * @param p_header_data the data contained in the QCC box. |
| * @param p_j2k the jpeg2000 codec. |
| * @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_t *p_j2k, |
| OPJ_BYTE * p_header_data, |
| OPJ_UINT32 p_header_size, |
| opj_event_mgr_t * p_manager |
| ) |
| { |
| OPJ_UINT32 l_num_comp,l_comp_no; |
| |
| /* preconditions */ |
| assert(p_header_data != 00); |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| |
| l_num_comp = p_j2k->m_private_image->numcomps; |
| |
| if (l_num_comp <= 256) { |
| if (p_header_size < 1) { |
| 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); |
| ++p_header_data; |
| --p_header_size; |
| } |
| else { |
| if (p_header_size < 2) { |
| 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); |
| p_header_data+=2; |
| p_header_size-=2; |
| } |
| |
| #ifdef USE_JPWL |
| if (p_j2k->m_cp.correct) { |
| |
| static OPJ_UINT32 backup_compno = 0; |
| |
| /* compno is negative or larger than the number of components!!! */ |
| if (/*(l_comp_no < 0) ||*/ (l_comp_no >= l_num_comp)) { |
| 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(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(p_manager, EVT_WARNING, "- trying to adjust this\n" |
| "- setting component number to %d\n", |
| l_comp_no); |
| } |
| |
| /* keep your private count of tiles */ |
| backup_compno++; |
| }; |
| #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(p_manager, EVT_ERROR, "Error reading QCC marker\n"); |
| return OPJ_FALSE; |
| } |
| |
| if (p_header_size != 0) { |
| 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_t *p_j2k, |
| opj_stream_private_t *p_stream, |
| opj_event_mgr_t * p_manager |
| ) |
| { |
| OPJ_UINT32 l_nb_comp; |
| OPJ_UINT32 l_nb_poc; |
| OPJ_UINT32 l_poc_size; |
| OPJ_UINT32 l_written_size = 0; |
| opj_tcp_t *l_tcp = 00; |
| OPJ_UINT32 l_poc_room; |
| |
| /* preconditions */ |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| assert(p_stream != 00); |
| |
| l_tcp = &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]; |
| l_nb_comp = p_j2k->m_private_image->numcomps; |
| l_nb_poc = 1 + l_tcp->numpocs; |
| |
| if (l_nb_comp <= 256) { |
| l_poc_room = 1; |
| } |
| else { |
| l_poc_room = 2; |
| } |
| l_poc_size = 4 + (5 + 2 * l_poc_room) * l_nb_poc; |
| |
| if (l_poc_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) { |
| OPJ_BYTE *new_header_tile_data = (OPJ_BYTE *) opj_realloc(p_j2k->m_specific_param.m_encoder.m_header_tile_data, l_poc_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(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; |
| p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_poc_size; |
| } |
| |
| opj_j2k_write_poc_in_memory(p_j2k,p_j2k->m_specific_param.m_encoder.m_header_tile_data,&l_written_size,p_manager); |
| |
| if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_poc_size,p_manager) != l_poc_size) { |
| return OPJ_FALSE; |
| } |
| |
| return OPJ_TRUE; |
| } |
| |
| 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 |
| ) |
| { |
| OPJ_UINT32 i; |
| OPJ_BYTE * l_current_data = 00; |
| OPJ_UINT32 l_nb_comp; |
| OPJ_UINT32 l_nb_poc; |
| OPJ_UINT32 l_poc_size; |
| opj_image_t *l_image = 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; |
| |
| /* preconditions */ |
| assert(p_j2k != 00); |
| assert(p_manager != 00); |
| |
| l_tcp = &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]; |
| l_tccp = &l_tcp->tccps[0]; |
| l_image = p_j2k->m_private_image; |
| l_nb_comp = l_image->numcomps; |
| l_nb_poc = 1 + l_tcp->numpocs; |
| |
| if (l_nb_comp <= 256) { |
| l_poc_room = 1; |
| } |
| else { |
| l_poc_room = 2; |
| } |
| |
| l_poc_size = 4 + (5 + 2 * l_poc_room) * l_nb_poc; |
| |
| l_current_data = p_data; |
| |
| opj_write_bytes(l_current_data,J2K_MS_POC,2); /* POC */ |
| l_current_data += 2; |
| |
| opj_write_bytes(l_current_data,l_poc_size-2,2); /* Lpoc */ |
| l_current_data += 2; |
| |
| l_current_poc = l_tcp->pocs; |
| for (i = 0; i < l_nb_poc; ++i) { |
| opj_write_bytes(l_current_data,l_current_poc->resno0,1); /* RSpoc_i */ |
| ++l_current_data; |
| |
| opj_write_bytes(l_current_data,l_current_poc->compno0,l_poc_room); /* CSpoc_i */ |
| l_current_data+=l_poc_room; |
| |
| opj_write_bytes(l_current_data,l_current_poc->layno1,2); /* LYEpoc_i */ |
| l_current_data+=2; |
| |
| opj_write_bytes(l_current_data,l_current_poc->resno1,1); /* REpoc_i */ |
| ++l_current_data; |
| |
| opj_write_bytes(l_current_data,l_current_poc->compno1,l_poc_room); /* CEpoc_i */ |
| l_current_data+=l_poc_room; |
| |
| opj_write_bytes(l_current_data,l_current_poc->prg,1); /* Ppoc_i */ |
| ++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 = (
|