opj_j2k_v2_t *p_j2k
);
+/**
+ * Reads the tiles.
+ */
+opj_bool j2k_decode_tiles ( opj_j2k_v2_t *p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager);
+
+static opj_bool j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data);
+
+
/*
* -----------------------------------------------------------------------
* -----------------------------------------------------------------------
OPJ_UINT32 *output_marker,
struct opj_event_mgr * 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 j2k_read_mct ( opj_j2k_v2_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * 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 j2k_read_mcc ( opj_j2k_v2_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * 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 j2k_read_mco ( opj_j2k_v2_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager );
+
+static opj_bool j2k_add_mct(opj_tcp_v2_t * p_tcp, opj_image_t * p_image, OPJ_UINT32 p_index);
+
+static void j2k_read_int16_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_read_int32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_read_float32_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_read_float64_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+
+static void j2k_read_int16_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_read_int32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_read_float32_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_read_float64_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+
+static void j2k_write_float_to_int16 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_write_float_to_int32 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_write_float_to_float (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+static void j2k_write_float_to_float64 (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+
+/**
+ * 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 j2k_read_cbd ( opj_j2k_v2_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager);
+
+
/**
* Copy the image header from the jpeg2000 codec into an external image_header
*
*
* @return true if the image header is correctly copy.
*/
-static opj_bool j2k_copy_img_header(opj_j2k_v2_t* p_j2k, opj_image_header_t* p_img_header);
+static opj_bool j2k_copy_img_header(opj_j2k_v2_t* p_j2k, opj_image_t** p_image);
static void j2k_dump_MH_info(opj_j2k_v2_t* p_j2k, FILE* out_stream);
{(OPJ_PROG_ORDER)-1, ""}
};
+/**
+ * FIXME DOC
+ */
+const OPJ_UINT32 MCT_ELEMENT_SIZE [] =
+{
+ 2,
+ 4,
+ 4,
+ 8
+};
+
+typedef void (* j2k_mct_function) (const void * p_src_data, void * p_dest_data, OPJ_UINT32 p_nb_elem);
+
+const j2k_mct_function j2k_mct_read_functions_to_float [] =
+{
+ j2k_read_int16_to_float,
+ j2k_read_int32_to_float,
+ j2k_read_float32_to_float,
+ j2k_read_float64_to_float
+};
+
+const j2k_mct_function j2k_mct_read_functions_to_int32 [] =
+{
+ j2k_read_int16_to_int32,
+ j2k_read_int32_to_int32,
+ j2k_read_float32_to_int32,
+ j2k_read_float64_to_int32
+};
+
+const j2k_mct_function j2k_mct_write_functions_from_float [] =
+{
+ j2k_write_float_to_int16,
+ j2k_write_float_to_int32,
+ j2k_write_float_to_float,
+ j2k_write_float_to_float64
+};
+
typedef struct opj_dec_memory_marker_handler
{
/** marker value */
{J2K_MS_SOP, 0, 0},
{J2K_MS_CRG, J2K_STATE_MH, j2k_read_crg_v2},
{J2K_MS_COM, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_com_v2},
-#ifdef TODO_MS /* FIXME */
{J2K_MS_MCT, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_mct},
{J2K_MS_CBD, J2K_STATE_MH , j2k_read_cbd},
{J2K_MS_MCC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_mcc},
{J2K_MS_MCO, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_mco},
-#endif
#ifdef USE_JPWL
#ifdef TODO_MS /* FIXME */
{J2K_MS_EPC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_epc},
+void 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 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 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 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 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 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 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 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 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 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 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 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);
+ }
+}
+
+
+/**
+ * Converts an enum type progression order to string type.
+ *
+ * @param prg_order the progression order to get.
+ *
+ * @return the string representation of the given progression order.
+ */
char *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){
- break;
+ return po->str_prog;
}
}
return po->str_prog;
OPJ_UINT32 l_remaining_size;
OPJ_UINT32 l_nb_tiles;
OPJ_UINT32 l_tmp;
- opj_image_header_t *l_image = 00;
+ opj_image_t *l_image = 00;
opj_cp_v2_t *l_cp = 00;
- opj_image_comp_header_t * l_img_comp = 00;
+ opj_image_comp_t * l_img_comp = 00;
opj_tcp_v2_t * l_current_tile_param = 00;
// preconditions
assert(p_manager != 00);
assert(p_header_data != 00);
- l_image = p_j2k->m_image_header;
+ l_image = p_j2k->m_image;
l_cp = &(p_j2k->m_cp);
// minimum size == 39 - 3 (= minimum component parameter)
#endif /* USE_JPWL */
// Allocate the resulting image components
- l_image->comps = (opj_image_comp_header_t*) opj_calloc(l_image->numcomps, sizeof(opj_image_comp_header_t));
+ l_image->comps = (opj_image_comp_t*) opj_calloc(l_image->numcomps, sizeof(opj_image_comp_t));
if (l_image->comps == 00){
l_image->numcomps = 0;
opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to take in charge SIZ marker\n");
return OPJ_FALSE;
}
- memset(l_image->comps,0,l_image->numcomps * sizeof(opj_image_comp_header_t));
+ memset(l_image->comps,0,l_image->numcomps * sizeof(opj_image_comp_t));
l_img_comp = l_image->comps;
// Read the component information
OPJ_UINT32 l_tmp;
opj_cp_v2_t *l_cp = 00;
opj_tcp_v2_t *l_tcp = 00;
- opj_image_header_t *l_image = 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_image_header;
+ l_image = p_j2k->m_image;
l_cp = &(p_j2k->m_cp);
/* If we are in the first tile-part header of the current tile */
{
opj_cp_v2_t *l_cp = NULL;
opj_tcp_v2_t *l_tcp = NULL;
- opj_image_header_t *l_image = NULL;
+ opj_image_t *l_image = NULL;
OPJ_UINT32 l_comp_room;
OPJ_UINT32 l_comp_no;
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_image_header;
+ l_image = p_j2k->m_image;
l_comp_room = l_image->numcomps <= 256 ? 1 : 2;
assert(p_j2k != 00);
assert(p_manager != 00);
- l_num_comp = p_j2k->m_image_header->numcomps;
+ l_num_comp = p_j2k->m_image->numcomps;
if (l_num_comp <= 256) {
if (p_header_size < 1) {
struct opj_event_mgr * p_manager)
{
OPJ_UINT32 i, l_nb_comp, l_tmp;
- opj_image_header_t * l_image = 00;
+ opj_image_t * l_image = 00;
OPJ_UINT32 l_old_poc_nb, l_current_poc_nb, l_current_poc_remaining;
OPJ_UINT32 l_chunk_size, l_comp_room;
assert(p_j2k != 00);
assert(p_manager != 00);
- l_image = p_j2k->m_image_header;
+ l_image = p_j2k->m_image;
l_nb_comp = l_image->numcomps;
if (l_nb_comp <= 256) {
l_comp_room = 1;
assert(p_j2k != 00);
assert(p_manager != 00);
- l_nb_comp = p_j2k->m_image_header->numcomps;
+ l_nb_comp = p_j2k->m_image->numcomps;
if (p_header_size != l_nb_comp *4) {
opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading CRG marker\n");
};
#endif /* USE_JPWL */
+ /* Ref A.4.2: Psot could be equal zero if it is the last tile-part of the codestream.*/
if (!l_tot_len) {
- opj_event_msg_v2(p_manager, EVT_ERROR, "Cannot read data with no size known, giving up\n");
- return OPJ_FALSE;
+ opj_event_msg_v2(p_manager, EVT_INFO, "Psot value of the current tile-part is equal to zero, "
+ "we assuming it is the last tile-part of the codestream.\n");
+ p_j2k->m_specific_param.m_decoder.m_last_tile_part = 1;
}
opj_read_bytes(p_header_data,&l_current_part ,1); /* TPsot */
++p_header_data;
if (l_num_parts != 0) { /* Number of tile-part header is provided by this tile-part header */
+ /* Useful to manage the case of textGBR.jp2 file because two values of TNSot are allowed: the correct numbers of
+ * tile-parts for that tile and zero (A.4.2 of 15444-1 : 2002). */
+ if (l_tcp->m_nb_tile_parts) {
+ if (l_current_part >= l_tcp->m_nb_tile_parts){
+ opj_event_msg_v2(p_manager, EVT_ERROR, "In SOT marker, TPSot (%d) is not valid regards to the current "
+ "number of tile-part (%d), giving up\n", l_current_part, l_tcp->m_nb_tile_parts );
+ p_j2k->m_specific_param.m_decoder.m_last_tile_part = 1;
+ return OPJ_FALSE;
+ }
+ }
l_tcp->m_nb_tile_parts = l_num_parts;
}
}
}
- /* Keep the size of data to skip after this marker */
- p_j2k->m_specific_param.m_decoder.m_sot_length = l_tot_len - 12; /* SOT_marker_size = 12 */
+ if (!p_j2k->m_specific_param.m_decoder.m_last_tile_part){
+ /* Keep the size of data to skip after this marker */
+ p_j2k->m_specific_param.m_decoder.m_sot_length = l_tot_len - 12; /* SOT_marker_size = 12 */
+ }
+ else {
+ /* FIXME: need to be computed from the number of bytes remaining in the codestream */
+ p_j2k->m_specific_param.m_decoder.m_sot_length = 0;
+ }
+
p_j2k->m_specific_param.m_decoder.m_state = J2K_STATE_TPH;
/* Check if the current tile is outside the area we want decode (in tile index)*/
assert(p_stream != 00);
l_tcp = &(p_j2k->m_cp.tcps[p_j2k->m_current_tile_number]);
- p_j2k->m_specific_param.m_decoder.m_sot_length -= 2;
+
+ if (p_j2k->m_specific_param.m_decoder.m_last_tile_part)
+ p_j2k->m_specific_param.m_decoder.m_sot_length = opj_stream_get_number_byte_left(p_stream) - 2;
+ else
+ p_j2k->m_specific_param.m_decoder.m_sot_length -= 2;
l_current_data = &(l_tcp->m_data);
l_tile_len = &l_tcp->m_data_size;
return OPJ_FALSE;
}
+#ifdef TODO_MSD /* FIXME */
l_cstr_index = p_j2k->cstr_index;
/* Index */
l_cstr_index->packno = 0;
}
+#endif
l_current_read_size = opj_stream_read_data( p_stream,
*l_current_data + *l_tile_len,
)
{
OPJ_UINT32 l_nb_comp;
- opj_image_header_t * l_image = 00;
+ opj_image_t * l_image = 00;
opj_cp_v2_t *l_cp = 00;
opj_tcp_v2_t *l_tcp = 00;
assert(p_j2k != 00);
assert(p_manager != 00);
- l_image = p_j2k->m_image_header;
+ l_image = p_j2k->m_image;
l_nb_comp = l_image->numcomps;
if (l_nb_comp <= 256) {
return e;
}
-/* ----------------------------------------------------------------------- */
-/* J2K / JPT decoder interface */
-/* ----------------------------------------------------------------------- */
-
-opj_j2k_t* j2k_create_decompress(opj_common_ptr cinfo) {
- opj_j2k_t *j2k = (opj_j2k_t*) opj_calloc(1, sizeof(opj_j2k_t));
- if(!j2k)
- return NULL;
- j2k->default_tcp = (opj_tcp_t*) opj_calloc(1, sizeof(opj_tcp_t));
- if(!j2k->default_tcp) {
- opj_free(j2k);
- return NULL;
- }
+/**
+ * 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.
+*/
+opj_bool j2k_read_mct ( opj_j2k_v2_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager )
+{
+ OPJ_UINT32 i;
+ opj_tcp_v2_t *l_tcp = 00;
+ OPJ_UINT32 l_tmp;
+ OPJ_UINT32 l_indix;
+ opj_mct_data_t * l_mct_data;
- j2k->cinfo = cinfo;
- j2k->tile_data = NULL;
+ /* preconditions */
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
- return j2k;
-}
+ l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ?
+ &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] :
+ p_j2k->m_specific_param.m_decoder.m_default_tcp;
-void j2k_destroy_decompress(opj_j2k_t *j2k) {
- int i = 0;
+ if (p_header_size < 2) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCT marker\n");
+ return OPJ_FALSE;
+ }
- if(j2k->tile_len != NULL) {
- opj_free(j2k->tile_len);
+ /* first marker */
+ opj_read_bytes(p_header_data,&l_tmp,2); /* Zmct */
+ p_header_data += 2;
+ if (l_tmp != 0) {
+ opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge mct data within multiple MCT records\n");
+ return OPJ_TRUE;
}
- if(j2k->tile_data != NULL) {
- opj_free(j2k->tile_data);
+
+ if(p_header_size <= 6) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCT marker\n");
+ return OPJ_FALSE;
}
- if(j2k->default_tcp != NULL) {
- opj_tcp_t *default_tcp = j2k->default_tcp;
- if(default_tcp->ppt_data_first != NULL) {
- opj_free(default_tcp->ppt_data_first);
- }
- if(j2k->default_tcp->tccps != NULL) {
- opj_free(j2k->default_tcp->tccps);
+
+ /* Imct -> no need for other values, take the first, type is double with decorrelation x0000 1101 0000 0000*/
+ opj_read_bytes(p_header_data,&l_tmp,2); /* Imct */
+ p_header_data += 2;
+
+ l_indix = l_tmp & 0xff;
+ l_mct_data = l_tcp->m_mct_records;
+
+ for (i=0;i<l_tcp->m_nb_mct_records;++i) {
+ if (l_mct_data->m_index == l_indix) {
+ break;
}
- opj_free(j2k->default_tcp);
+ ++l_mct_data;
}
- if(j2k->cp != NULL) {
- opj_cp_t *cp = j2k->cp;
- if(cp->tcps != NULL) {
- for(i = 0; i < cp->tw * cp->th; i++) {
- if(cp->tcps[i].ppt_data_first != NULL) {
- opj_free(cp->tcps[i].ppt_data_first);
- }
- if(cp->tcps[i].tccps != NULL) {
- opj_free(cp->tcps[i].tccps);
- }
+
+ /* NOT FOUND */
+ if (i == l_tcp->m_nb_mct_records) {
+ if (l_tcp->m_nb_mct_records == l_tcp->m_nb_max_mct_records) {
+ l_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS;
+
+ l_tcp->m_mct_records = (opj_mct_data_t*)opj_realloc(l_tcp->m_mct_records,l_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
+ if(! l_tcp->m_mct_records) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCT marker\n");
+ return OPJ_FALSE;
}
- opj_free(cp->tcps);
- }
- if(cp->ppm_data_first != NULL) {
- opj_free(cp->ppm_data_first);
- }
- if(cp->tileno != NULL) {
- opj_free(cp->tileno);
- }
- if(cp->comment != NULL) {
- opj_free(cp->comment);
+
+ l_mct_data = l_tcp->m_mct_records + l_tcp->m_nb_mct_records;
+ memset(l_mct_data ,0,(l_tcp->m_nb_max_mct_records - l_tcp->m_nb_mct_records) * sizeof(opj_mct_data_t));
}
- opj_free(cp);
+ l_mct_data = l_tcp->m_mct_records + l_tcp->m_nb_mct_records;
}
- opj_free(j2k);
-}
-void j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters) {
- if(j2k && parameters) {
- /* create and initialize the coding parameters structure */
- opj_cp_t *cp = (opj_cp_t*) opj_calloc(1, sizeof(opj_cp_t));
+ if (l_mct_data->m_data) {
+ opj_free(l_mct_data->m_data);
+ l_mct_data->m_data = 00;
+ }
+
+ l_mct_data->m_index = l_indix;
+ l_mct_data->m_array_type = (J2K_MCT_ARRAY_TYPE)((l_tmp >> 8) & 3);
+ l_mct_data->m_element_type = (J2K_MCT_ELEMENT_TYPE)((l_tmp >> 10) & 3);
+
+ opj_read_bytes(p_header_data,&l_tmp,2); /* Ymct */
+ p_header_data+=2;
+ if (l_tmp != 0) {
+ opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge multiple MCT markers\n");
+ return OPJ_TRUE;
+ }
+
+ p_header_size -= 6;
+
+ l_mct_data->m_data = (OPJ_BYTE*)opj_malloc(p_header_size);
+ if (! l_mct_data->m_data) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCT marker\n");
+ return OPJ_FALSE;
+ }
+ memcpy(l_mct_data->m_data,p_header_data,p_header_size);
+
+ l_mct_data->m_data_size = p_header_size;
+ ++l_tcp->m_nb_mct_records;
+
+ return OPJ_TRUE;
+}
+
+/**
+ * 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.
+*/
+opj_bool j2k_read_mcc ( opj_j2k_v2_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager )
+{
+ OPJ_UINT32 i,j;
+ OPJ_UINT32 l_tmp;
+ OPJ_UINT32 l_indix;
+ opj_tcp_v2_t * l_tcp;
+ opj_simple_mcc_decorrelation_data_t * l_mcc_record;
+ opj_mct_data_t * l_mct_data;
+ OPJ_UINT32 l_nb_collections;
+ OPJ_UINT32 l_nb_comps;
+ OPJ_UINT32 l_nb_bytes_by_comp;
+
+
+ /* preconditions */
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ?
+ &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] :
+ p_j2k->m_specific_param.m_decoder.m_default_tcp;
+
+ if (p_header_size < 2) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return OPJ_FALSE;
+ }
+
+ /* first marker */
+ opj_read_bytes(p_header_data,&l_tmp,2); /* Zmcc */
+ p_header_data += 2;
+ if (l_tmp != 0) {
+ opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge multiple data spanning\n");
+ return OPJ_TRUE;
+ }
+
+ if (p_header_size < 7) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return OPJ_FALSE;
+ }
+
+ opj_read_bytes(p_header_data,&l_indix,1); /* Imcc -> no need for other values, take the first */
+ ++p_header_data;
+
+ l_mcc_record = l_tcp->m_mcc_records;
+
+ for(i=0;i<l_tcp->m_nb_mcc_records;++i) {
+ if (l_mcc_record->m_index == l_indix) {
+ break;
+ }
+ ++l_mcc_record;
+ }
+
+ /** NOT FOUND */
+ if (i == l_tcp->m_nb_mcc_records) {
+ if (l_tcp->m_nb_mcc_records == l_tcp->m_nb_max_mcc_records) {
+ l_tcp->m_nb_max_mcc_records += J2K_MCC_DEFAULT_NB_RECORDS;
+
+ l_tcp->m_mcc_records = (opj_simple_mcc_decorrelation_data_t*)
+ opj_realloc(l_tcp->m_mcc_records,l_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t));
+ if (! l_tcp->m_mcc_records) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return OPJ_FALSE;
+ }
+ l_mcc_record = l_tcp->m_mcc_records + l_tcp->m_nb_mcc_records;
+ memset(l_mcc_record,0,(l_tcp->m_nb_max_mcc_records-l_tcp->m_nb_mcc_records) * sizeof(opj_simple_mcc_decorrelation_data_t));
+ }
+ l_mcc_record = l_tcp->m_mcc_records + l_tcp->m_nb_mcc_records;
+ }
+ l_mcc_record->m_index = l_indix;
+
+ /* only one marker atm */
+ opj_read_bytes(p_header_data,&l_tmp,2); /* Ymcc */
+ p_header_data+=2;
+ if (l_tmp != 0) {
+ opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge multiple data spanning\n");
+ return OPJ_TRUE;
+ }
+
+ opj_read_bytes(p_header_data,&l_nb_collections,2); /* Qmcc -> number of collections -> 1 */
+ p_header_data+=2;
+
+ if (l_nb_collections > 1) {
+ opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge multiple collections\n");
+ return OPJ_TRUE;
+ }
+
+ p_header_size -= 7;
+
+ for (i=0;i<l_nb_collections;++i) {
+ if (p_header_size < 3) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return OPJ_FALSE;
+ }
+
+ opj_read_bytes(p_header_data,&l_tmp,1); /* Xmcci type of component transformation -> array based decorrelation */
+ ++p_header_data;
+
+ if (l_tmp != 1) {
+ opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge collections other than array decorrelation\n");
+ return OPJ_TRUE;
+ }
+
+ opj_read_bytes(p_header_data,&l_nb_comps,2);
+
+ p_header_data+=2;
+ p_header_size-=3;
+
+ l_nb_bytes_by_comp = 1 + (l_nb_comps>>15);
+ l_mcc_record->m_nb_comps = l_nb_comps & 0x7fff;
+
+ if (p_header_size < (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 2)) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return OPJ_FALSE;
+ }
+
+ p_header_size -= (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 2);
+
+ for (j=0;j<l_mcc_record->m_nb_comps;++j) {
+ opj_read_bytes(p_header_data,&l_tmp,l_nb_bytes_by_comp); /* Cmccij Component offset*/
+ p_header_data+=l_nb_bytes_by_comp;
+
+ if (l_tmp != j) {
+ opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge collections with indix shuffle\n");
+ return OPJ_TRUE;
+ }
+ }
+
+ opj_read_bytes(p_header_data,&l_nb_comps,2);
+ p_header_data+=2;
+
+ l_nb_bytes_by_comp = 1 + (l_nb_comps>>15);
+ l_nb_comps &= 0x7fff;
+
+ if (l_nb_comps != l_mcc_record->m_nb_comps) {
+ opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge collections without same number of indixes\n");
+ return OPJ_TRUE;
+ }
+
+ if (p_header_size < (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 3)) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return OPJ_FALSE;
+ }
+
+ p_header_size -= (l_nb_bytes_by_comp * l_mcc_record->m_nb_comps + 3);
+
+ for (j=0;j<l_mcc_record->m_nb_comps;++j) {
+ opj_read_bytes(p_header_data,&l_tmp,l_nb_bytes_by_comp); /* Wmccij Component offset*/
+ p_header_data+=l_nb_bytes_by_comp;
+
+ if (l_tmp != j) {
+ opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge collections with indix shuffle\n");
+ return OPJ_TRUE;
+ }
+ }
+
+ opj_read_bytes(p_header_data,&l_tmp,3); /* Wmccij Component offset*/
+ p_header_data += 3;
+
+ l_mcc_record->m_is_irreversible = ! ((l_tmp>>16) & 1);
+ l_mcc_record->m_decorrelation_array = 00;
+ l_mcc_record->m_offset_array = 00;
+
+ l_indix = l_tmp & 0xff;
+ if (l_indix != 0) {
+ l_mct_data = l_tcp->m_mct_records;
+ for (j=0;j<l_tcp->m_nb_mct_records;++j) {
+ if (l_mct_data->m_index == l_indix) {
+ l_mcc_record->m_decorrelation_array = l_mct_data;
+ break;
+ }
+ ++l_mct_data;
+ }
+
+ if (l_mcc_record->m_decorrelation_array == 00) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return OPJ_FALSE;
+ }
+ }
+
+ l_indix = (l_tmp >> 8) & 0xff;
+ if (l_indix != 0) {
+ l_mct_data = l_tcp->m_mct_records;
+ for (j=0;j<l_tcp->m_nb_mct_records;++j) {
+ if (l_mct_data->m_index == l_indix) {
+ l_mcc_record->m_offset_array = l_mct_data;
+ break;
+ }
+ ++l_mct_data;
+ }
+
+ if (l_mcc_record->m_offset_array == 00) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return OPJ_FALSE;
+ }
+ }
+ }
+
+ if (p_header_size != 0) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCC marker\n");
+ return OPJ_FALSE;
+ }
+
+ ++l_tcp->m_nb_mcc_records;
+
+ return OPJ_TRUE;
+}
+
+/**
+ * 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.
+*/
+opj_bool j2k_read_mco ( opj_j2k_v2_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager )
+{
+ OPJ_UINT32 l_tmp, i;
+ OPJ_UINT32 l_nb_stages;
+ opj_tcp_v2_t * l_tcp;
+ opj_tccp_t * l_tccp;
+ opj_image_t * l_image;
+ opj_image_comp_t * l_img_comp;
+
+ /* preconditions */
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_image = p_j2k->m_image;
+ l_tcp = p_j2k->m_specific_param.m_decoder.m_state == J2K_STATE_TPH ?
+ &p_j2k->m_cp.tcps[p_j2k->m_current_tile_number] :
+ p_j2k->m_specific_param.m_decoder.m_default_tcp;
+
+ if (p_header_size < 1) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading MCO marker\n");
+ return OPJ_FALSE;
+ }
+
+ opj_read_bytes(p_header_data,&l_nb_stages,1); /* Nmco : only one tranform stage*/
+ ++p_header_data;
+
+ if (l_nb_stages > 1) {
+ opj_event_msg_v2(p_manager, EVT_WARNING, "Cannot take in charge multiple transformation stages.\n");
+ return OPJ_TRUE;
+ }
+
+ if (p_header_size != l_nb_stages + 1) {
+ opj_event_msg_v2(p_manager, EVT_WARNING, "Error reading MCO marker\n");
+ return OPJ_FALSE;
+ }
+
+ l_tccp = l_tcp->tccps;
+ l_img_comp = l_image->comps;
+
+ for (i=0;i<l_image->numcomps;++i) {
+ l_tccp->m_dc_level_shift = 0;
+ ++l_tccp;
+ }
+
+ if (l_tcp->m_mct_decoding_matrix) {
+ opj_free(l_tcp->m_mct_decoding_matrix);
+ l_tcp->m_mct_decoding_matrix = 00;
+ }
+
+ for (i=0;i<l_nb_stages;++i) {
+ opj_read_bytes(p_header_data,&l_tmp,1);
+ ++p_header_data;
+
+ if (! j2k_add_mct(l_tcp,p_j2k->m_image,l_tmp)) {
+ return OPJ_FALSE;
+ }
+ }
+
+ return OPJ_TRUE;
+}
+
+opj_bool j2k_add_mct(opj_tcp_v2_t * p_tcp, opj_image_t * p_image, OPJ_UINT32 p_index)
+{
+ OPJ_UINT32 i;
+ opj_simple_mcc_decorrelation_data_t * l_mcc_record;
+ opj_mct_data_t * l_deco_array, * l_offset_array;
+ OPJ_UINT32 l_data_size,l_mct_size, l_offset_size;
+ OPJ_UINT32 l_nb_elem;
+ OPJ_UINT32 * l_offset_data, * l_current_offset_data;
+ opj_tccp_t * l_tccp;
+
+ /* preconditions */
+ assert(p_tcp != 00);
+
+ l_mcc_record = p_tcp->m_mcc_records;
+
+ for (i=0;i<p_tcp->m_nb_mcc_records;++i) {
+ if (l_mcc_record->m_index == p_index) {
+ break;
+ }
+ }
+
+ if (i==p_tcp->m_nb_mcc_records) {
+ /** element discarded **/
+ return OPJ_TRUE;
+ }
+
+ if (l_mcc_record->m_nb_comps != p_image->numcomps) {
+ /** do not support number of comps != image */
+ return OPJ_TRUE;
+ }
+
+ l_deco_array = l_mcc_record->m_decorrelation_array;
+
+ if (l_deco_array) {
+ l_data_size = MCT_ELEMENT_SIZE[l_deco_array->m_element_type] * p_image->numcomps * p_image->numcomps;
+ if (l_deco_array->m_data_size != l_data_size) {
+ return OPJ_FALSE;
+ }
+
+ l_nb_elem = p_image->numcomps * p_image->numcomps;
+ l_mct_size = l_nb_elem * sizeof(OPJ_FLOAT32);
+ p_tcp->m_mct_decoding_matrix = (OPJ_FLOAT32*)opj_malloc(l_mct_size);
+
+ if (! p_tcp->m_mct_decoding_matrix ) {
+ return OPJ_FALSE;
+ }
+
+ j2k_mct_read_functions_to_float[l_deco_array->m_element_type](l_deco_array->m_data,p_tcp->m_mct_decoding_matrix,l_nb_elem);
+ }
+
+ l_offset_array = l_mcc_record->m_offset_array;
+
+ if (l_offset_array) {
+ l_data_size = MCT_ELEMENT_SIZE[l_offset_array->m_element_type] * p_image->numcomps;
+ if (l_offset_array->m_data_size != l_data_size) {
+ return OPJ_FALSE;
+ }
+
+ l_nb_elem = p_image->numcomps;
+ l_offset_size = l_nb_elem * sizeof(OPJ_UINT32);
+ l_offset_data = (OPJ_UINT32*)opj_malloc(l_offset_size);
+
+ if (! l_offset_data ) {
+ return OPJ_FALSE;
+ }
+
+ j2k_mct_read_functions_to_int32[l_offset_array->m_element_type](l_offset_array->m_data,l_offset_data,l_nb_elem);
+
+ l_tccp = p_tcp->tccps;
+ l_current_offset_data = l_offset_data;
+
+ for (i=0;i<p_image->numcomps;++i) {
+ l_tccp->m_dc_level_shift = *(l_current_offset_data++);
+ ++l_tccp;
+ }
+
+ opj_free(l_offset_data);
+ }
+
+ return OPJ_TRUE;
+}
+
+/**
+ * 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.
+*/
+opj_bool j2k_read_cbd ( opj_j2k_v2_t *p_j2k,
+ OPJ_BYTE * p_header_data,
+ OPJ_UINT32 p_header_size,
+ struct opj_event_mgr * p_manager)
+{
+ OPJ_UINT32 l_nb_comp,l_num_comp;
+ OPJ_UINT32 l_comp_def;
+ OPJ_UINT32 i;
+ opj_image_comp_t * l_comp = 00;
+
+ /* preconditions */
+ assert(p_header_data != 00);
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+
+ l_num_comp = p_j2k->m_image->numcomps;
+
+ if (p_header_size != (p_j2k->m_image->numcomps + 2)) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Crror reading CBD marker\n");
+ return OPJ_FALSE;
+ }
+
+ opj_read_bytes(p_header_data,&l_nb_comp,2); /* Ncbd */
+ p_header_data+=2;
+
+ if (l_nb_comp != l_num_comp) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Crror reading CBD marker\n");
+ return OPJ_FALSE;
+ }
+
+ l_comp = p_j2k->m_image->comps;
+ for (i=0;i<l_num_comp;++i) {
+ opj_read_bytes(p_header_data,&l_comp_def,1); /* Component bit depth */
+ ++p_header_data;
+ l_comp->sgnd = (l_comp_def>>7) & 1;
+ l_comp->prec = (l_comp_def&0x7f) + 1;
+ ++l_comp;
+ }
+
+ return OPJ_TRUE;
+}
+
+
+/* ----------------------------------------------------------------------- */
+/* J2K / JPT decoder interface */
+/* ----------------------------------------------------------------------- */
+
+opj_j2k_t* j2k_create_decompress(opj_common_ptr cinfo) {
+ opj_j2k_t *j2k = (opj_j2k_t*) opj_calloc(1, sizeof(opj_j2k_t));
+ if(!j2k)
+ return NULL;
+
+ j2k->default_tcp = (opj_tcp_t*) opj_calloc(1, sizeof(opj_tcp_t));
+ if(!j2k->default_tcp) {
+ opj_free(j2k);
+ return NULL;
+ }
+
+ j2k->cinfo = cinfo;
+ j2k->tile_data = NULL;
+
+ return j2k;
+}
+
+void j2k_destroy_decompress(opj_j2k_t *j2k) {
+ int i = 0;
+
+ if(j2k->tile_len != NULL) {
+ opj_free(j2k->tile_len);
+ }
+ if(j2k->tile_data != NULL) {
+ opj_free(j2k->tile_data);
+ }
+ if(j2k->default_tcp != NULL) {
+ opj_tcp_t *default_tcp = j2k->default_tcp;
+ if(default_tcp->ppt_data_first != NULL) {
+ opj_free(default_tcp->ppt_data_first);
+ }
+ if(j2k->default_tcp->tccps != NULL) {
+ opj_free(j2k->default_tcp->tccps);
+ }
+ opj_free(j2k->default_tcp);
+ }
+ if(j2k->cp != NULL) {
+ opj_cp_t *cp = j2k->cp;
+ if(cp->tcps != NULL) {
+ for(i = 0; i < cp->tw * cp->th; i++) {
+ if(cp->tcps[i].ppt_data_first != NULL) {
+ opj_free(cp->tcps[i].ppt_data_first);
+ }
+ if(cp->tcps[i].tccps != NULL) {
+ opj_free(cp->tcps[i].tccps);
+ }
+ }
+ opj_free(cp->tcps);
+ }
+ if(cp->ppm_data_first != NULL) {
+ opj_free(cp->ppm_data_first);
+ }
+ if(cp->tileno != NULL) {
+ opj_free(cp->tileno);
+ }
+ if(cp->comment != NULL) {
+ opj_free(cp->comment);
+ }
+
+ opj_free(cp);
+ }
+ opj_free(j2k);
+}
+
+void j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters) {
+ if(j2k && parameters) {
+ /* create and initialize the coding parameters structure */
+ opj_cp_t *cp = (opj_cp_t*) opj_calloc(1, sizeof(opj_cp_t));
cp->reduce = parameters->cp_reduce;
cp->layer = parameters->cp_layer;
cp->limit_decoding = parameters->cp_limit_decoding;
/* expand the list? */
if ((cstr_index->marknum + 1) > cstr_index->maxmarknum) {
- cstr_index->maxmarknum = 100 + (int) ((float) cstr_index ->maxmarknum * 1.0F);
- cstr_index->marker = (opj_marker_info_t*)opj_realloc(cstr_index->marker, cstr_index->maxmarknum);
+ cstr_index->maxmarknum = 100 + (int) ((float) cstr_index->maxmarknum * 1.0F);
+ cstr_index->marker = (opj_marker_info_t*)opj_realloc(cstr_index->marker, cstr_index->maxmarknum *sizeof(opj_marker_info_t));
}
/* add the marker */
- cstr_index->marker[cstr_index->marknum].type = type;
- cstr_index->marker[cstr_index->marknum].pos = pos;
- cstr_index->marker[cstr_index->marknum].len = len;
+ cstr_index->marker[cstr_index->marknum].type = (OPJ_UINT16)type;
+ cstr_index->marker[cstr_index->marknum].pos = (OPJ_INT32)pos;
+ cstr_index->marker[cstr_index->marknum].len = (OPJ_INT32)len;
cstr_index->marknum++;
}
*/
opj_bool j2k_read_header( struct opj_stream_private *p_stream,
opj_j2k_v2_t* p_j2k,
- opj_image_header_t* p_img_header,
+ opj_image_t** p_image,
struct opj_event_mgr* p_manager )
{
/* preconditions */
assert(p_j2k != 00);
assert(p_stream != 00);
- assert(p_img_header != 00);
assert(p_manager != 00);
/* create an empty image header */
- p_j2k->m_image_header = opj_image_header_create0();
- if (! p_j2k->m_image_header) {
+ p_j2k->m_image = opj_image_create0();
+ if (! p_j2k->m_image) {
return OPJ_FALSE;
}
/* validation of the parameters codec */
if (! j2k_exec(p_j2k, p_j2k->m_validation_list, p_stream,p_manager)) {
- opj_image_header_destroy(p_j2k->m_image_header);
- p_j2k->m_image_header = NULL;
+ opj_image_destroy(p_j2k->m_image);
+ p_j2k->m_image = NULL;
return OPJ_FALSE;
}
/* read header */
if (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
- opj_image_header_destroy(p_j2k->m_image_header);
- p_j2k->m_image_header = NULL;
+ opj_image_destroy(p_j2k->m_image);
+ p_j2k->m_image = NULL;
return OPJ_FALSE;
}
- if (! j2k_copy_img_header(p_j2k, p_img_header)){
- opj_image_header_destroy(p_j2k->m_image_header);
- p_j2k->m_image_header = NULL;
+ *p_image = opj_image_create0();
+ if (! (*p_image)) {
+ return OPJ_FALSE;
+ }
+
+ if (! j2k_copy_img_header(p_j2k, p_image)){
+ opj_image_destroy(p_j2k->m_image);
+ p_j2k->m_image = NULL;
return OPJ_FALSE;
}
return OPJ_TRUE;
}
-opj_bool j2k_copy_img_header(opj_j2k_v2_t* p_j2k, opj_image_header_t* p_img_header)
+opj_bool j2k_copy_img_header(opj_j2k_v2_t* p_j2k, opj_image_t** p_image)
{
OPJ_UINT16 compno;
/* preconditions */
assert(p_j2k != 00);
- assert(p_img_header != 00);
- p_img_header->x0 = p_j2k->m_image_header->x0;
- p_img_header->y0 = p_j2k->m_image_header->y0;
- p_img_header->x1 = p_j2k->m_image_header->x1;
- p_img_header->y1 = p_j2k->m_image_header->y1;
+ (*p_image)->x0 = p_j2k->m_image->x0;
+ (*p_image)->y0 = p_j2k->m_image->y0;
+ (*p_image)->x1 = p_j2k->m_image->x1;
+ (*p_image)->y1 = p_j2k->m_image->y1;
- p_img_header->numcomps = p_j2k->m_image_header->numcomps;
- p_img_header->comps = (opj_image_comp_header_t*)opj_malloc(p_img_header->numcomps * sizeof(opj_image_comp_header_t));
- if (!p_img_header->comps)
+ (*p_image)->numcomps = p_j2k->m_image->numcomps;
+ (*p_image)->comps = (opj_image_comp_t*)opj_malloc((*p_image)->numcomps * sizeof(opj_image_comp_t));
+ if (!(*p_image)->comps)
return OPJ_FALSE;
- for (compno=0; compno < p_img_header->numcomps; compno++){
- memcpy( &(p_img_header->comps[compno]),
- &(p_j2k->m_image_header->comps[compno]),
- sizeof(opj_image_comp_header_t));
+ for (compno=0; compno < (*p_image)->numcomps; compno++){
+ memcpy( &((*p_image)->comps[compno]),
+ &(p_j2k->m_image->comps[compno]),
+ sizeof(opj_image_comp_t));
}
- p_img_header->color_space = p_j2k->m_image_header->color_space;
- p_img_header->icc_profile_len = p_j2k->m_image_header->icc_profile_len;
- p_img_header->icc_profile_buf = (unsigned char*)opj_malloc(p_img_header->icc_profile_len);
- if (!p_img_header->icc_profile_buf)
- return OPJ_FALSE;
- memcpy( p_img_header->icc_profile_buf,
- p_j2k->m_image_header->icc_profile_buf,
- p_j2k->m_image_header->icc_profile_len);
+ (*p_image)->color_space = p_j2k->m_image->color_space;
+ (*p_image)->icc_profile_len = p_j2k->m_image->icc_profile_len;
+ if (!(*p_image)->icc_profile_len) {
+
+ (*p_image)->icc_profile_buf = (unsigned char*)opj_malloc((*p_image)->icc_profile_len);
+ if (!(*p_image)->icc_profile_buf)
+ return OPJ_FALSE;
+ memcpy( (*p_image)->icc_profile_buf,
+ p_j2k->m_image->icc_profile_buf,
+ p_j2k->m_image->icc_profile_len);
+ }
+ else
+ (*p_image)->icc_profile_buf = NULL;
return OPJ_TRUE;
}
opj_tccp_t *l_current_tccp = 00;
OPJ_UINT32 l_tccp_size;
OPJ_UINT32 l_mct_size;
- opj_image_header_t * l_image;
+ opj_image_t * l_image;
OPJ_UINT32 l_mcc_records_size,l_mct_records_size;
opj_mct_data_t * l_src_mct_rec, *l_dest_mct_rec;
opj_simple_mcc_decorrelation_data_t * l_src_mcc_rec, *l_dest_mcc_rec;
assert(p_stream != 00);
assert(p_manager != 00);
- l_image = p_j2k->m_image_header;
+ l_image = p_j2k->m_image;
l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
l_tcp = p_j2k->m_cp.tcps;
l_tccp_size = l_image->numcomps * sizeof(opj_tccp_t);
/* For each tile */
for (i=0; i<l_nb_tiles; ++i) {
+ /* keep the tile-compo coding parameters pointer of the current tile coding parameters*/
l_current_tccp = l_tcp->tccps;
+ /*Copy default coding parameters into the current tile coding parameters*/
memcpy(l_tcp, l_default_tcp, sizeof(opj_tcp_v2_t));
+ /* Initialize some values of the current tile coding parameters*/
l_tcp->ppt = 0;
l_tcp->ppt_data = 00;
+ /* Reconnect the tile-compo coding parameters pointer to the current tile coding parameters*/
l_tcp->tccps = l_current_tccp;
+ /* Get the mct_decoding_matrix of the dflt_tile_cp and copy them into the current tile cp*/
if (l_default_tcp->m_mct_decoding_matrix) {
l_tcp->m_mct_decoding_matrix = (OPJ_FLOAT32*)opj_malloc(l_mct_size);
if (! l_tcp->m_mct_decoding_matrix ) {
memcpy(l_tcp->m_mct_decoding_matrix,l_default_tcp->m_mct_decoding_matrix,l_mct_size);
}
+ /* Get the mct_record of the dflt_tile_cp and copy them into the current tile cp*/
l_mct_records_size = l_default_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t);
l_tcp->m_mct_records = (opj_mct_data_t*)opj_malloc(l_mct_records_size);
if (! l_tcp->m_mct_records) {
}
memcpy(l_tcp->m_mct_records, l_default_tcp->m_mct_records,l_mct_records_size);
+ /* Copy the mct record data from dflt_tile_cp to the current tile*/
l_src_mct_rec = l_default_tcp->m_mct_records;
l_dest_mct_rec = l_tcp->m_mct_records;
++l_dest_mct_rec;
}
+ /* Get the mcc_record of the dflt_tile_cp and copy them into the current tile cp*/
l_mcc_records_size = l_default_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t);
l_tcp->m_mcc_records = (opj_simple_mcc_decorrelation_data_t*) opj_malloc(l_mcc_records_size);
if (! l_tcp->m_mcc_records) {
}
memcpy(l_tcp->m_mcc_records,l_default_tcp->m_mcc_records,l_mcc_records_size);
+ /* Copy the mcc record data from dflt_tile_cp to the current tile*/
l_src_mcc_rec = l_default_tcp->m_mcc_records;
l_dest_mcc_rec = l_tcp->m_mcc_records;
+
for (j=0;j<l_default_tcp->m_nb_max_mcc_records;++j) {
if (l_src_mcc_rec->m_decorrelation_array) {
++l_dest_mcc_rec;
}
+ /* Copy all the dflt_tile_compo_cp to the current tile cp */
memcpy(l_current_tccp,l_default_tcp->tccps,l_tccp_size);
+
+ /* Move to next tile cp*/
++l_tcp;
}
+ /* Create the current tile decoder*/
p_j2k->m_tcd = (opj_tcd_v2_t*)tcd_create_v2(OPJ_TRUE); // FIXME why a cast ?
if (! p_j2k->m_tcd ) {
return OPJ_FALSE;
tcd_destroy_v2(p_j2k->m_tcd);
j2k_cp_destroy(&(p_j2k->m_cp));
- memset(&(p_j2k->m_cp),0,sizeof(opj_cp_t));
+ memset(&(p_j2k->m_cp),0,sizeof(opj_cp_v2_t));
opj_procedure_list_destroy(p_j2k->m_procedure_list);
p_j2k->m_procedure_list = 00;
j2k_destroy_cstr_index(p_j2k->cstr_index);
p_j2k->cstr_index = NULL;
+ opj_image_destroy(p_j2k->m_image);
+ p_j2k->m_image = NULL;
+
opj_free(p_j2k);
}
void j2k_destroy_cstr_index (opj_codestream_index_t *p_cstr_ind)
{
- if (!p_cstr_ind) {
- return;
- }
+ if (p_cstr_ind) {
- if (p_cstr_ind->marker) {
- opj_free(p_cstr_ind->marker);
- p_cstr_ind->marker = NULL;
- }
+ if (p_cstr_ind->marker) {
+ opj_free(p_cstr_ind->marker);
+ p_cstr_ind->marker = NULL;
+ }
- if (p_cstr_ind->tile_index) {
- // FIXME
+ if (p_cstr_ind->tile_index) {
+ // FIXME not used for the moment
+ }
+
+ opj_free(p_cstr_ind);
}
}
/* Read the marker segment with the correct marker handler */
if (! (*(l_marker_handler->handler))(p_j2k,p_j2k->m_specific_param.m_decoder.m_header_data,l_marker_size,p_manager)) {
- opj_event_msg_v2(p_manager, EVT_ERROR, "Marker is not compliant with its position\n");
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Fail to read the current marker segment (%#x)\n", l_current_marker);
return OPJ_FALSE;
}
if (! j2k_read_sod_v2(p_j2k, p_stream, p_manager)) {
return OPJ_FALSE;
}
+
+ if (! p_j2k->m_specific_param.m_decoder.m_can_decode){
+ /* Try to read 2 bytes (the next marker ID) from stream and copy them into the buffer */
+ if (opj_stream_read_data(p_stream,p_j2k->m_specific_param.m_decoder.m_header_data,2,p_manager) != 2) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Stream too short\n");
+ return OPJ_FALSE;
+ }
+
+ /* Read 2 bytes from buffer as the new marker ID */
+ opj_read_bytes(p_j2k->m_specific_param.m_decoder.m_header_data,&l_current_marker,2);
+ }
}
else {
/* Indicate we will try to read a new tile-part header*/
}
}
- /* FIXME ???*/
+ /* FIXME DOC ???*/
if ( ! p_j2k->m_specific_param.m_decoder.m_can_decode) {
l_tcp = p_j2k->m_cp.tcps + p_j2k->m_current_tile_number;
l_nb_tiles = p_j2k->m_cp.th * p_j2k->m_cp.tw;
return OPJ_FALSE;
}
+ opj_event_msg_v2(p_manager, EVT_INFO, "Header of tile %d / %d has been read.\n",
+ p_j2k->m_current_tile_number +1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
+
*p_tile_index = p_j2k->m_current_tile_number;
*p_go_on = OPJ_TRUE;
*p_data_size = tcd_get_decoded_tile_size(p_j2k->m_tcd);
}
+opj_bool j2k_update_image_data (opj_tcd_v2_t * p_tcd, OPJ_BYTE * p_data)
+{
+ OPJ_UINT32 i,j,k = 0;
+ OPJ_UINT32 l_width,l_height,l_offset_x,l_offset_y;
+ opj_image_comp_t * l_img_comp = 00;
+ opj_tcd_tilecomp_v2_t * l_tilec = 00;
+ opj_image_t * l_image = 00;
+ OPJ_UINT32 l_size_comp, l_remaining;
+ OPJ_UINT32 l_dest_stride;
+ OPJ_INT32 * l_dest_ptr;
+ opj_tcd_resolution_v2_t* l_res= 00;
+
+
+ l_tilec = p_tcd->tcd_image->tiles->comps;
+ l_image = p_tcd->image;
+ l_img_comp = l_image->comps;
+
+ for (i=0;i<p_tcd->image->numcomps;++i) {
+
+ if (!l_img_comp->data) {
+
+ l_img_comp->data = (OPJ_INT32*) opj_malloc(l_img_comp->w * l_img_comp->h * sizeof(OPJ_INT32));
+ if (! l_img_comp->data) {
+ return OPJ_FALSE;
+ }
+ memset(l_img_comp->data,0,l_img_comp->w * l_img_comp->h * sizeof(OPJ_INT32));
+ }
+
+ l_size_comp = l_img_comp->prec >> 3; /*(/ 8)*/
+ l_remaining = l_img_comp->prec & 7; /* (%8) */
+ l_res = l_tilec->resolutions + l_img_comp->resno_decoded;
+
+ if (l_remaining) {
+ ++l_size_comp;
+ }
+
+ if (l_size_comp == 3) {
+ l_size_comp = 4;
+ }
+
+ l_width = (l_res->x1 - l_res->x0);
+ l_height = (l_res->y1 - l_res->y0);
+
+ l_dest_stride = (l_img_comp->w) - l_width;
+
+ l_offset_x = int_ceildivpow2(l_img_comp->x0, l_img_comp->factor);
+ l_offset_y = int_ceildivpow2(l_img_comp->y0, l_img_comp->factor);
+ l_dest_ptr = l_img_comp->data + (l_res->x0 - l_offset_x) + (l_res->y0 - l_offset_y) * l_img_comp->w;
+
+ switch (l_size_comp) {
+ case 1:
+ {
+ OPJ_CHAR * l_src_ptr = (OPJ_CHAR*) p_data;
+ if (l_img_comp->sgnd) {
+ for (j=0;j<l_height;++j) {
+ for (k=0;k<l_width;++k) {
+ *(l_dest_ptr++) = (OPJ_INT32) (*(l_src_ptr++));
+ }
+
+ l_dest_ptr += l_dest_stride;
+ }
+ }
+ else {
+ for (j=0;j<l_height;++j) {
+ for (k=0;k<l_width;++k) {
+ *(l_dest_ptr++) = (OPJ_INT32) ((*(l_src_ptr++))&0xff);
+ }
+
+ l_dest_ptr += l_dest_stride;
+ }
+ }
+
+ p_data = (OPJ_BYTE*) l_src_ptr;
+ }
+ break;
+ case 2:
+ {
+ OPJ_INT16 * l_src_ptr = (OPJ_INT16 *) p_data;
+
+ if (l_img_comp->sgnd) {
+ for (j=0;j<l_height;++j) {
+ for (k=0;k<l_width;++k) {
+ *(l_dest_ptr++) = *(l_src_ptr++);
+ }
+
+ l_dest_ptr += l_dest_stride;
+ }
+ }
+ else {
+ for (j=0;j<l_height;++j) {
+ for (k=0;k<l_width;++k) {
+ *(l_dest_ptr++) = (*(l_src_ptr++))&0xffff;
+ }
+
+ l_dest_ptr += l_dest_stride;
+ }
+ }
+
+ p_data = (OPJ_BYTE*) l_src_ptr;
+ }
+ break;
+ case 4:
+ {
+ OPJ_INT32 * l_src_ptr = (OPJ_INT32 *) p_data;
+ for (j=0;j<l_height;++j) {
+ for (k=0;k<l_width;++k) {
+ *(l_dest_ptr++) = (*(l_src_ptr++));
+ }
+
+ l_dest_ptr += l_dest_stride;
+ }
+
+ p_data = (OPJ_BYTE*) l_src_ptr;
+ }
+ break;
+ }
+
+ ++l_img_comp;
+ ++l_tilec;
+ }
+ return OPJ_TRUE;
+}
+
/**
* Sets the given area to be decoded. This function should be called right after opj_read_header and before any tile header reading.
*
p_j2k->m_specific_param.m_decoder.m_end_tile_x = int_ceildiv((p_end_x - l_cp->tx0), l_cp->tdx);
/* Bottom */
- if (p_end_x < l_cp->ty0) {
+ if (p_end_y < l_cp->ty0) {
opj_event_msg_v2(p_manager, EVT_ERROR,
"Right position of the decoded area (ROI_y1=%d) is outside the tile area (YTOsiz=%d).\n",
- p_end_x, l_cp->ty0);
+ p_end_y, l_cp->ty0);
return OPJ_FALSE;
}
if (p_end_y > l_cp->ty0 + l_cp->th * l_cp->tdy){
return NULL;
cstr_index->maxmarknum = 100;
+ cstr_index->marknum = 0;
cstr_index->marker = (opj_marker_info_t*)
opj_calloc(cstr_index->maxmarknum, sizeof(opj_marker_info_t));
if (!cstr_index-> marker)
p_j2k->m_specific_param.m_decoder.m_default_tcp;
/* precondition again */
- assert(compno < p_j2k->m_image_header->numcomps);
+ assert(compno < p_j2k->m_image->numcomps);
l_tccp = &l_tcp->tccps[compno];
l_current_ptr = p_header_data;
l_copied_tccp = l_ref_tccp + 1;
l_prc_size = l_ref_tccp->numresolutions * sizeof(OPJ_UINT32);
- for (i=1; i<p_j2k->m_image_header->numcomps; ++i) {
+ for (i=1; i<p_j2k->m_image->numcomps; ++i) {
l_copied_tccp->numresolutions = l_ref_tccp->numresolutions;
l_copied_tccp->cblkw = l_ref_tccp->cblkw;
l_copied_tccp->cblkh = l_ref_tccp->cblkh;
p_j2k->m_specific_param.m_decoder.m_default_tcp;
// precondition again
- assert(p_comp_no < p_j2k->m_image_header->numcomps);
+ assert(p_comp_no < p_j2k->m_image->numcomps);
l_tccp = &l_tcp->tccps[p_comp_no];
l_current_ptr = p_header_data;
l_copied_tccp = l_ref_tccp + 1;
l_size = J2K_MAXBANDS * sizeof(opj_stepsize_t);
- for (i=1;i<p_j2k->m_image_header->numcomps;++i) {
+ for (i=1;i<p_j2k->m_image->numcomps;++i) {
l_copied_tccp->qntsty = l_ref_tccp->qntsty;
l_copied_tccp->numgbits = l_ref_tccp->numgbits;
memcpy(l_copied_tccp->stepsizes,l_ref_tccp->stepsizes,l_size);
/* Dump the image_header */
if (flag & OPJ_IMG_INFO){
- if (p_j2k->m_image_header)
- j2k_dump_image_header(p_j2k->m_image_header, 0, out_stream);
+ if (p_j2k->m_image)
+ j2k_dump_image_header(p_j2k->m_image, 0, out_stream);
}
/* Dump the codestream info from main header */
if (l_default_tile)
{
OPJ_INT32 compno;
- OPJ_INT32 numcomps = p_j2k->m_image_header->numcomps;
+ OPJ_INT32 numcomps = p_j2k->m_image->numcomps;
fprintf(out_stream, "\t default tile {\n");
fprintf(out_stream, "\t\t csty=%#x\n", l_default_tile->csty);
*@param dev_dump_flag flag to describe if we are in the case of this function is use outside j2k_dump function
*@param out_stream output stream where dump the elements.
*/
-void j2k_dump_image_header(opj_image_header_t* img_header, opj_bool dev_dump_flag, FILE* out_stream)
+void j2k_dump_image_header(opj_image_t* img_header, opj_bool dev_dump_flag, FILE* out_stream)
{
char tab[2];
*@param dev_dump_flag flag to describe if we are in the case of this function is use outside j2k_dump function
*@param out_stream output stream where dump the elements.
*/
-void j2k_dump_image_comp_header(opj_image_comp_header_t* comp_header, opj_bool dev_dump_flag, FILE* out_stream)
+void j2k_dump_image_comp_header(opj_image_comp_t* comp_header, opj_bool dev_dump_flag, FILE* out_stream)
{
char tab[3];
opj_codestream_info_v2_t* j2k_get_cstr_info(opj_j2k_v2_t* p_j2k)
{
OPJ_UINT16 compno;
- OPJ_UINT16 numcomps = p_j2k->m_image_header->numcomps;
+ OPJ_UINT16 numcomps = p_j2k->m_image->numcomps;
opj_tcp_v2_t *l_default_tile;
opj_codestream_info_v2_t* cstr_info = (opj_codestream_info_v2_t*) opj_calloc(1,sizeof(opj_codestream_info_v2_t));
- cstr_info->nbcomps = p_j2k->m_image_header->numcomps;
+ cstr_info->nbcomps = p_j2k->m_image->numcomps;
cstr_info->tx0 = p_j2k->m_cp.tx0;
cstr_info->ty0 = p_j2k->m_cp.ty0;
cstr_info->tw = p_j2k->m_cp.tw;
cstr_info->th = p_j2k->m_cp.th;
+ cstr_info->tile_info = NULL; /* Not fill from the main header*/
+
l_default_tile = p_j2k->m_specific_param.m_decoder.m_default_tcp;
cstr_info->m_default_tile_info.csty = l_default_tile->csty;
cstr_info->m_default_tile_info.numlayers = l_default_tile->numlayers;
cstr_info->m_default_tile_info.mct = l_default_tile->mct;
- cstr_info->m_default_tile_info.tccp_info = (opj_tccp_info_t*) opj_calloc(1,sizeof(opj_tccp_info_t));
+ cstr_info->m_default_tile_info.tccp_info = (opj_tccp_info_t*) opj_calloc(cstr_info->nbcomps, sizeof(opj_tccp_info_t));
for (compno = 0; compno < numcomps; compno++) {
opj_tccp_t *l_tccp = &(l_default_tile->tccps[compno]);
memcpy(l_cstr_index->marker, p_j2k->cstr_index->marker, l_cstr_index->marknum * sizeof(opj_marker_info_t) );
+ l_cstr_index->tile_index = NULL; /* FIXME not used for the moment*/
return l_cstr_index;
}
+
+
+
+/**
+ * Reads the tiles.
+ */
+opj_bool j2k_decode_tiles ( opj_j2k_v2_t *p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager)
+{
+ opj_bool l_go_on = OPJ_TRUE;
+ OPJ_UINT32 l_current_tile_no;
+ OPJ_UINT32 l_data_size,l_max_data_size;
+ OPJ_INT32 l_tile_x0,l_tile_y0,l_tile_x1,l_tile_y1;
+ OPJ_UINT32 l_nb_comps;
+ OPJ_BYTE * l_current_data;
+
+ l_current_data = (OPJ_BYTE*)opj_malloc(1000);
+ if (! l_current_data) {
+ return OPJ_FALSE;
+ }
+ l_max_data_size = 1000;
+
+ while (OPJ_TRUE) {
+ if (! j2k_read_tile_header( p_j2k,
+ &l_current_tile_no,
+ &l_data_size,
+ &l_tile_x0, &l_tile_y0,
+ &l_tile_x1, &l_tile_y1,
+ &l_nb_comps,
+ &l_go_on,
+ p_stream,
+ p_manager)) {
+ opj_free(l_current_data);
+ return OPJ_FALSE;
+ }
+
+ if (! l_go_on) {
+ break;
+ }
+
+ if (l_data_size > l_max_data_size) {
+ l_current_data = (OPJ_BYTE*)opj_realloc(l_current_data,l_data_size);
+ if (! l_current_data) {
+ return OPJ_FALSE;
+ }
+
+ l_max_data_size = l_data_size;
+ }
+
+ if (! j2k_decode_tile(p_j2k,l_current_tile_no,l_current_data,l_data_size,p_stream,p_manager)) {
+ opj_free(l_current_data);
+ return OPJ_FALSE;
+ }
+ opj_event_msg_v2(p_manager, EVT_INFO, "Tile %d/%d has been decode.\n", l_current_tile_no +1, p_j2k->m_cp.th * p_j2k->m_cp.tw);
+
+ if (! j2k_update_image_data(p_j2k->m_tcd,l_current_data)) {
+ opj_free(l_current_data);
+ return OPJ_FALSE;
+ }
+ opj_event_msg_v2(p_manager, EVT_INFO, "Image data has been updated with tile %d.\n\n", l_current_tile_no + 1);
+
+ }
+
+ opj_free(l_current_data);
+ return OPJ_TRUE;
+}
+
+
+/**
+ * Sets up the procedures to do on decoding data. Developpers wanting to extend the library can add their own reading procedures.
+ */
+void j2k_setup_decoding (opj_j2k_v2_t *p_j2k)
+{
+ // preconditions
+ assert(p_j2k != 00);
+
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_decode_tiles);
+ /* DEVELOPER CORNER, add your custom procedures */
+
+}
+
+
+/**
+ * Decodes the tiles of the stream.
+ */
+opj_bool j2k_decode_v2( opj_j2k_v2_t * p_j2k,
+ opj_stream_private_t * p_stream,
+ opj_image_t * p_image,
+ opj_event_mgr_t * p_manager)
+{
+ OPJ_UINT32 compno;
+
+ if (!p_image)
+ return OPJ_FALSE;
+
+ /* customization of the decoding */
+ j2k_setup_decoding(p_j2k);
+
+ /* Decode the codestream */
+ if (! j2k_exec (p_j2k,p_j2k->m_procedure_list,p_stream,p_manager)) {
+ opj_image_destroy(p_j2k->m_image);
+ p_j2k->m_image = NULL;
+ return OPJ_FALSE;
+ }
+
+ /* Copy data from codec to output image*/
+ for (compno = 0; compno < p_image->numcomps; compno++) {
+ p_image->comps[compno].data = p_j2k->m_image->comps[compno].data;
+ p_j2k->m_image->comps[compno].data = NULL;
+ }
+
+ return OPJ_TRUE;
+}