* 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, Mickael Savinaud, Communications & Systemes <mickael.savinaud@c-s.fr>
+ * Copyright (c) 2011-2012, Mickael Savinaud, Communications & Systemes <mickael.savinaud@c-s.fr>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
/**
* The read header procedure.
*/
-opj_bool j2k_read_header_procedure(
- opj_j2k_v2_t *p_j2k,
- struct opj_stream_private *p_stream,
- struct opj_event_mgr * p_manager);
+static opj_bool j2k_read_header_procedure( opj_j2k_v2_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_stream the input stream to validate.
* @param p_manager the user event manager.
*
* @return true if the parameters are correct.
*/
-opj_bool j2k_encoding_validation ( opj_j2k_v2_t * p_j2k,
- opj_stream_private_t *p_stream,
- opj_event_mgr_t * p_manager );
+static opj_bool j2k_encoding_validation ( opj_j2k_v2_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager );
/**
* The default decoding validation procedure without any extension.
*
* @return true if the parameters are correct.
*/
-opj_bool j2k_decoding_validation (
- opj_j2k_v2_t * p_j2k,
- opj_stream_private_t *p_stream,
- opj_event_mgr_t * p_manager
- );
+static opj_bool j2k_decoding_validation ( opj_j2k_v2_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
*
* @return true if the parameters are correct.
*/
-opj_bool j2k_mct_validation ( opj_j2k_v2_t * p_j2k,
- opj_stream_private_t *p_stream,
- opj_event_mgr_t * p_manager );
+static opj_bool j2k_mct_validation (opj_j2k_v2_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager );
/**
* Builds the tcd decoder to use to decode tile.
*/
-opj_bool j2k_build_decoder (opj_j2k_v2_t * p_j2k,
- opj_stream_private_t *p_stream,
- opj_event_mgr_t * p_manager );
+static opj_bool j2k_build_decoder ( opj_j2k_v2_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager );
/**
* Builds the tcd encoder to use to encode tile.
*/
-opj_bool j2k_build_encoder (opj_j2k_v2_t * p_j2k,
- opj_stream_private_t *p_stream,
- opj_event_mgr_t * p_manager );
+static opj_bool j2k_build_encoder ( opj_j2k_v2_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_stream the stream to write data to.
* @param p_j2k J2K codec.
- * @param p_manager the user event manager.
+ * @param p_manager the user event manager.
*/
static opj_bool j2k_create_tcd( opj_j2k_v2_t *p_j2k,
struct opj_stream_private *p_stream,
* 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_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 j2k_exec (
- opj_j2k_v2_t * p_j2k,
- opj_procedure_list_t * p_procedure_list,
- opj_stream_private_t *p_stream,
- opj_event_mgr_t * p_manager
- );
+static opj_bool j2k_exec ( opj_j2k_v2_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_manager the user event manager.
*/
static opj_bool j2k_update_rates( opj_j2k_v2_t *p_j2k,
- struct opj_stream_private *p_stream,
- struct opj_event_mgr * p_manager );
+ 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.
*/
-opj_bool j2k_copy_default_tcp_and_create_tcd ( opj_j2k_v2_t * p_j2k,
- opj_stream_private_t *p_stream,
- opj_event_mgr_t * p_manager );
+static opj_bool j2k_copy_default_tcp_and_create_tcd ( opj_j2k_v2_t * p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager );
/**
* Destroys the memory associated with the decoding of headers.
*/
-opj_bool j2k_destroy_header_memory (opj_j2k_v2_t * p_j2k,
- opj_stream_private_t *p_stream,
- opj_event_mgr_t * p_manager );
+static opj_bool j2k_destroy_header_memory ( opj_j2k_v2_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
* @param p_header_size the size of the data contained in the COM marker.
* @param p_manager the user event manager.
*/
-static opj_bool j2k_read_SPCod_SPCoc(
- opj_j2k_v2_t *p_j2k,
- OPJ_UINT32 compno,
- OPJ_BYTE * p_header_data,
- OPJ_UINT32 * p_header_size,
- struct opj_event_mgr * p_manager
- );
+static opj_bool j2k_read_SPCod_SPCoc( opj_j2k_v2_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.
OPJ_UINT32 p_comp_no,
OPJ_BYTE * p_data,
OPJ_UINT32 * p_header_size,
- struct opj_event_mgr * p_manager
- );
+ opj_event_mgr_t * p_manager);
/**
* Updates the Tile Length Marker.
* @param p_manager the user event manager.
*
*/
-static opj_bool j2k_read_SQcd_SQcc(
- opj_j2k_v2_t *p_j2k,
- OPJ_UINT32 compno,
- OPJ_BYTE * p_header_data,
- OPJ_UINT32 * p_header_size,
- struct opj_event_mgr * p_manager
- );
+static opj_bool j2k_read_SQcd_SQcc( opj_j2k_v2_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 j2k_copy_tile_component_parameters(
- opj_j2k_v2_t *p_j2k
- );
+static void j2k_copy_tile_component_parameters( opj_j2k_v2_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 j2k_copy_tile_quantization_parameters(
- opj_j2k_v2_t *p_j2k
- );
+static void j2k_copy_tile_quantization_parameters( 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_decode_tiles ( opj_j2k_v2_t *p_j2k,
+ opj_stream_private_t *p_stream,
+ opj_event_mgr_t * p_manager);
static opj_bool j2k_pre_write_tile ( opj_j2k_v2_t * p_j2k,
* Sets up the procedures to do on writing header.
* Developers wanting to extend the library can add their own writing procedures.
*/
-void j2k_setup_header_writting (opj_j2k_v2_t *p_j2k);
+static void j2k_setup_header_writting (opj_j2k_v2_t *p_j2k);
static opj_bool j2k_write_first_tile_part( opj_j2k_v2_t *p_j2k,
OPJ_BYTE * p_data,
@param j2k J2K handle
*/
static void j2k_write_com(opj_j2k_t *j2k);
+
+/**
+ * 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 j2k_write_com_v2( opj_j2k_v2_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager );
+
/**
Read the COM marker (comment)
@param j2k J2K handle
*/
static void j2k_write_poc(opj_j2k_t *j2k);
+/**
+ * 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 j2k_write_poc_v2( opj_j2k_v2_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager );
+
/**
* Writes the POC marker (Progression Order Change)
*
* @param p_header_size the size of the data contained in the POC marker.
* @param p_manager the user event manager.
*/
+#if 0
static opj_bool j2k_read_ppm_v2 (
opj_j2k_v2_t *p_j2k,
OPJ_BYTE * p_header_data,
OPJ_UINT32 p_header_size,
struct opj_event_mgr * p_manager
);
+#endif
static opj_bool j2k_read_ppm_v3 (
opj_j2k_v2_t *p_j2k,
@param j2k J2K handle
*/
static void j2k_write_tlm(opj_j2k_t *j2k);
+
+/**
+ * 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 j2k_write_tlm_v2( opj_j2k_v2_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager );
+
/**
Write the SOT marker (start of tile-part)
@param j2k J2K handle
struct opj_event_mgr * 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 j2k_write_eoc_v2( opj_j2k_v2_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager );
+
/**
Write the EOC marker (end of codestream)
@param j2k J2K handle
* @param p_header_size the size of the data contained in the SOD marker.
* @param p_manager the user event manager.
*/
+#if 0
static opj_bool j2k_read_eoc_v2 (
opj_j2k_v2_t *p_j2k,
struct opj_stream_private *p_stream,
struct opj_event_mgr * p_manager
) ;
+#endif
struct opj_stream_private *p_stream,
struct opj_event_mgr * 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.
+ *
+ * @return true if the pocs are valid.
+ */
+static opj_bool 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.
*
*/
static OPJ_UINT32 j2k_get_num_tp_v2( opj_cp_v2_t *cp, OPJ_UINT32 pino, OPJ_UINT32 tileno);
+/** mem allocation for TLM marker*/
+static int j2k_calculate_tp(opj_cp_t *cp,int img_numcomp,opj_image_t *image,opj_j2k_t *j2k );
+
/**
* 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.
return po->str_prog;
}
+/**
+ * Checks the progression order changes values. Tells if the poc given as input are valid.
+ *
+ * @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.
+ */
+opj_bool 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_v2(p_manager , EVT_ERROR, "Not enough memory for checking the poc values.\n");
+ return OPJ_FALSE;
+ }
+ memset(packet_array,0,step_l * p_num_layers* sizeof(OPJ_UINT32));
+
+ if (p_nb_pocs == 0) {
+ 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_v2(p_manager , EVT_ERROR, "Missing packets possible loss of data\n");
+ }
+
+ opj_free(packet_array);
+
+ return !loss;
+}
+
/* ----------------------------------------------------------------------- */
static int j2k_get_num_tp(opj_cp_t *cp,int pino,int tileno){
char *prog;
case 'R':
tpnum *= l_current_poc->resE;
break;
- // precinct wise
+ /* precinct wise */
case 'P':
tpnum *= l_current_poc->prcE;
break;
}
static void j2k_write_siz(opj_j2k_t *j2k) {
- int i;
+ OPJ_UINT32 i;
int lenp, len;
opj_cio_t *cio = j2k->cio;
l_current_ptr+=2;
for (i = 0; i < l_image->numcomps; ++i) {
- // TODO here with MCT ?
+ /* 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;
}
static void j2k_read_siz(opj_j2k_t *j2k) {
- int len, i;
+ int len;
+ OPJ_UINT32 i;
opj_cio_t *cio = j2k->cio;
opj_image_t *image = j2k->image;
cp->tx0 = cio_read(cio, 4); /* XT0siz */
cp->ty0 = cio_read(cio, 4); /* YT0siz */
+ /* the following code triggers: */
+ /* warning: comparison of unsigned expression < 0 is always false */
+#if 0
if ((image->x0<0)||(image->x1<0)||(image->y0<0)||(image->y1<0)) {
opj_event_msg(j2k->cinfo, EVT_ERROR,
"%s: invalid image size (x0:%d, x1:%d, y0:%d, y1:%d)\n",
image->x0,image->x1,image->y0,image->y1);
return;
}
+#endif
image->numcomps = cio_read(cio, 2); /* Csiz */
return;
}
}
- if (image->numcomps != ((len - 38) / 3)) {
+ assert( len >= 38 );
+ if (image->numcomps != (OPJ_UINT32)((len - 38) / 3)) {
opj_event_msg(j2k->cinfo, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
"JPWL: Csiz is %d => space in SIZ only for %d comps.!!!\n",
image->numcomps, ((len - 38) / 3));
}
/* we try to correct */
opj_event_msg(j2k->cinfo, EVT_WARNING, "- trying to adjust this\n");
- if (image->numcomps < ((len - 38) / 3)) {
+ if (image->numcomps < (OPJ_UINT32)((len - 38) / 3)) {
len = 38 + 3 * image->numcomps;
opj_event_msg(j2k->cinfo, EVT_WARNING, "- setting Lsiz to %d => HYPOTHESIS!!!\n",
len);
}
#endif /* USE_JPWL */
- for (i = 0; i < cp->tw * cp->th; i++) {
+ for (i = 0; i < (OPJ_UINT32)cp->tw * cp->th; i++) {
cp->tcps[i].POC = 0;
cp->tcps[i].numpocs = 0;
cp->tcps[i].first = 1;
cp->ppm_store = 0;
j2k->default_tcp->tccps = (opj_tccp_t*) opj_calloc(image->numcomps, sizeof(opj_tccp_t));
- for (i = 0; i < cp->tw * cp->th; i++) {
+ for (i = 0; i < (OPJ_UINT32)cp->tw * cp->th; i++) {
cp->tcps[i].tccps = (opj_tccp_t*) opj_malloc(image->numcomps * sizeof(opj_tccp_t));
}
j2k->tile_data = (unsigned char**) opj_calloc(cp->tw * cp->th, sizeof(unsigned char*));
}
}
+/**
+ * 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.
+*/
+opj_bool j2k_write_com_v2( opj_j2k_v2_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * 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 = 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) {
+ 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_total_com_size);
+
+ if(! p_j2k->m_specific_param.m_encoder.m_header_tile_data) {
+ return OPJ_FALSE;
+ }
+
+ 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;
+}
+
static void j2k_read_com(opj_j2k_t *j2k) {
int len;
assert(p_j2k != 00);
assert(p_manager != 00);
assert(p_header_data != 00);
+ (void)p_header_size;
return OPJ_TRUE;
}
static void j2k_write_cox(opj_j2k_t *j2k, int compno) {
- int i;
+ OPJ_UINT32 i;
opj_cp_t *cp = j2k->cp;
opj_tcp_t *tcp = &cp->tcps[j2k->curtileno];
}
static void j2k_read_cox(opj_j2k_t *j2k, int compno) {
- int i;
+ OPJ_UINT32 i;
opj_cp_t *cp = j2k->cp;
opj_tcp_t *tcp = j2k->state == J2K_STATE_TPH ? &cp->tcps[j2k->curtileno] : j2k->default_tcp;
tccp->numresolutions = cio_read(cio, 1) + 1; /* SPcox (D) */
/* If user wants to remove more resolutions than the codestream contains, return error*/
- if (cp->reduce >= tccp->numresolutions) {
+ assert(cp->reduce >= 0);
+ if ((OPJ_UINT32)cp->reduce >= tccp->numresolutions) {
opj_event_msg(j2k->cinfo, EVT_ERROR, "Error decoding component %d.\nThe number of resolutions to remove is higher than the number "
"of resolutions of this component\nModify the cp_reduce parameter.\n\n", compno);
j2k->state |= J2K_STATE_ERR;
}
static void j2k_read_cod(opj_j2k_t *j2k) {
- int len, i, pos;
+ int len, pos;
+ OPJ_UINT32 i;
opj_cio_t *cio = j2k->cio;
opj_cp_t *cp = j2k->cp;
static void j2k_read_qcd(opj_j2k_t *j2k) {
- int len, i, pos;
+ int len, pos;
+ OPJ_UINT32 i;
opj_cio_t *cio = j2k->cio;
opj_image_t *image = j2k->image;
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)) {
+ if (/*(l_comp_no < 0) ||*/ (l_comp_no >= l_num_comp)) {
opj_event_msg_v2(p_manager, EVT_ERROR,
"JPWL: bad component number in QCC (%d out of a maximum of %d)\n",
l_comp_no, l_num_comp);
}
}
+/**
+ * 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.
+*/
+opj_bool j2k_write_poc_v2( opj_j2k_v2_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * 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_v2_t *l_tcp = 00;
+ opj_tccp_t *l_tccp = 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_tccp = &l_tcp->tccps[0];
+ 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) {
+ 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_poc_size);
+
+ if (! p_j2k->m_specific_param.m_encoder.m_header_tile_data) {
+ return OPJ_FALSE;
+ }
+
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_poc_size;
+ }
+
+ 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;
+}
+
+
/**
* Writes the POC marker (Progression Order Change)
*
assert(p_manager != 00);
if (p_header_size < 1) {
- opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading PLM marker\n");
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading PLT marker\n");
return OPJ_FALSE;
}
}
if (l_packet_len != 0) {
- opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading PLM marker\n");
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error reading PLT marker\n");
return OPJ_FALSE;
}
* @param p_header_size the size of the data contained in the POC marker.
* @param p_manager the user event manager.
*/
+#if 0
opj_bool j2k_read_ppm_v2 (
opj_j2k_v2_t *p_j2k,
OPJ_BYTE * p_header_data,
return OPJ_TRUE;
}
+#endif
return OPJ_TRUE;
}
-static void j2k_write_tlm(opj_j2k_t *j2k){
- int lenp;
- opj_cio_t *cio = j2k->cio;
- j2k->tlm_start = cio_tell(cio);
- cio_write(cio, J2K_MS_TLM, 2);/* TLM */
- lenp = 4 + (5*j2k->totnum_tp);
- cio_write(cio,lenp,2); /* Ltlm */
- cio_write(cio, 0,1); /* Ztlm=0*/
- cio_write(cio,80,1); /* Stlm ST=1(8bits-255 tiles max),SP=1(Ptlm=32bits) */
- cio_skip(cio,5*j2k->totnum_tp);
-}
+/**
+ * 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.
+*/
+opj_bool j2k_write_tlm_v2( opj_j2k_v2_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager )
+{
+ OPJ_BYTE * l_current_data = 00;
+ OPJ_UINT32 l_tlm_size;
-static void j2k_write_sot(opj_j2k_t *j2k) {
+ // preconditions
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ l_tlm_size = 6 + (5*p_j2k->m_specific_param.m_encoder.m_total_tile_parts);
+
+ if (l_tlm_size > p_j2k->m_specific_param.m_encoder.m_header_tile_data_size) {
+ 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_tlm_size);
+
+ if (! p_j2k->m_specific_param.m_encoder.m_header_tile_data) {
+ return OPJ_FALSE;
+ }
+
+ p_j2k->m_specific_param.m_encoder.m_header_tile_data_size = l_tlm_size;
+ }
+
+ l_current_data = p_j2k->m_specific_param.m_encoder.m_header_tile_data;
+
+ /* change the way data is written to avoid seeking if possible */
+ // TODO
+ p_j2k->m_specific_param.m_encoder.m_tlm_start = opj_stream_tell(p_stream);
+
+ opj_write_bytes(l_current_data,J2K_MS_TLM,2); /* TLM */
+ l_current_data += 2;
+
+ opj_write_bytes(l_current_data,l_tlm_size-2,2); /* Lpoc */
+ l_current_data += 2;
+
+ opj_write_bytes(l_current_data,0,1); /* Ztlm=0*/
+ ++l_current_data;
+
+ opj_write_bytes(l_current_data,0x50,1); /* Stlm ST=1(8bits-255 tiles max),SP=1(Ptlm=32bits) */
+ ++l_current_data;
+
+ /* do nothing on the 5 * l_j2k->m_specific_param.m_encoder.m_total_tile_parts remaining data */
+ if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,l_tlm_size,p_manager) != l_tlm_size) {
+ return OPJ_FALSE;
+ }
+
+ return OPJ_TRUE;
+}
+
+static void j2k_write_tlm(opj_j2k_t *j2k){
+ int lenp;
+ opj_cio_t *cio = j2k->cio;
+ j2k->tlm_start = cio_tell(cio);
+ cio_write(cio, J2K_MS_TLM, 2);/* TLM */
+ lenp = 4 + (5*j2k->totnum_tp);
+ cio_write(cio,lenp,2); /* Ltlm */
+ cio_write(cio, 0,1); /* Ztlm=0*/
+ cio_write(cio,80,1); /* Stlm ST=1(8bits-255 tiles max),SP=1(Ptlm=32bits) */
+ cio_skip(cio,5*j2k->totnum_tp);
+}
+
+static void j2k_write_sot(opj_j2k_t *j2k) {
int lenp, len;
opj_cio_t *cio = j2k->cio;
static void j2k_read_sot(opj_j2k_t *j2k) {
- int len, tileno, totlen, partno, numparts, i;
+ int len, tileno, totlen, partno, numparts;
+ OPJ_UINT32 i;
opj_tcp_t *tcp = NULL;
char status = 0;
static int backup_tileno = 0;
/* tileno is negative or larger than the number of tiles!!! */
- if ((tileno < 0) || (tileno > (cp->tw * cp->th))) {
+ if ((tileno < 0) || (tileno >= (cp->tw * cp->th))) {
opj_event_msg(j2k->cinfo, EVT_ERROR,
"JPWL: bad tile number (%d out of a maximum of %d)\n",
tileno, (cp->tw * cp->th));
/* keep your private count of tiles */
backup_tileno++;
- };
+ }
+ else
#endif /* USE_JPWL */
+ {
+ /* tileno is negative or larger than the number of tiles!!! */
+ if ((tileno < 0) || (tileno >= (cp->tw * cp->th))) {
+ opj_event_msg(j2k->cinfo, EVT_ERROR,
+ "JPWL: bad tile number (%d out of a maximum of %d)\n",
+ tileno, (cp->tw * cp->th));
+ return;
+ }
+ }
if (cp->tileno_size == 0) {
cp->tileno[cp->tileno_size] = tileno;
cp->tileno_size++;
} else {
i = 0;
- while (i < cp->tileno_size && status == 0) {
+ assert(cp->tileno_size >= 0);
+ while (i < (OPJ_UINT32)cp->tileno_size && status == 0) {
status = cp->tileno[i] == tileno ? 1 : 0;
i++;
}
totlen);
}
- };
+ }
+ else
#endif /* USE_JPWL */
+ {
+ /* totlen is negative or larger than the bytes left!!! */
+ if ((totlen < 0) || (totlen > (cio_numbytesleft(cio) + 8))) {
+ opj_event_msg(j2k->cinfo, EVT_ERROR,
+ "JPWL: bad tile byte size (%d bytes against %d bytes left)\n",
+ totlen, cio_numbytesleft(cio) + 8);
+ return;
+ }
+ }
if (!totlen)
totlen = cio_numbytesleft(cio) + 8;
if (l_cp->correct) {
/* totlen is negative or larger than the bytes left!!! */
- if ((l_tot_len < 0) || (l_tot_len > p_header_size ) ) { /* FIXME it seems correct; for info in V1 -> (p_stream_numbytesleft(p_stream) + 8))) { */
+ if (/*(l_tot_len < 0) ||*/ (l_tot_len > p_header_size ) ) { /* FIXME it seems correct; for info in V1 -> (p_stream_numbytesleft(p_stream) + 8))) { */
opj_event_msg_v2(p_manager, EVT_ERROR,
"JPWL: bad tile byte size (%d bytes against %d bytes left)\n",
l_tot_len, p_header_size ); /* FIXME it seems correct; for info in V1 -> p_stream_numbytesleft(p_stream) + 8); */
|| (l_tile_y < p_j2k->m_specific_param.m_decoder.m_start_tile_y)
|| (l_tile_y >= p_j2k->m_specific_param.m_decoder.m_end_tile_y);
}
- else
- p_j2k->m_specific_param.m_decoder.m_skip_data =
- (p_j2k->m_current_tile_number != p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec);
+ else {
+ assert( p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec >= 0 );
+ p_j2k->m_specific_param.m_decoder.m_skip_data =
+ (p_j2k->m_current_tile_number != (OPJ_UINT32)p_j2k->m_specific_param.m_decoder.m_tile_ind_to_dec);
+ }
/* Index */
if (p_j2k->cstr_index)
{
+ assert(p_j2k->cstr_index->tile_index != 00);
p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].tileno = p_j2k->m_current_tile_number;
p_j2k->cstr_index->tile_index[p_j2k->m_current_tile_number].current_tpsno = l_current_part;
/* <<UniPG */
}
+/**
+ * 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.
+*/
+opj_bool j2k_write_eoc_v2( opj_j2k_v2_t *p_j2k,
+ struct opj_stream_private *p_stream,
+ struct opj_event_mgr * p_manager )
+{
+ /* preconditions */
+ assert(p_j2k != 00);
+ assert(p_manager != 00);
+ assert(p_stream != 00);
+
+ opj_write_bytes(p_j2k->m_specific_param.m_encoder.m_header_tile_data,J2K_MS_EOC,2); /* EOC */
+
+
+/* UniPG>> */
+#ifdef USE_JPWL
+ /* update markers struct */
+ /*
+ j2k_add_marker(p_j2k->cstr_info, J2K_MS_EOC, p_stream_tell(p_stream) - 2, 2);
+*/
+#endif /* USE_JPWL */
+
+ if ( opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_header_tile_data,2,p_manager) != 2) {
+ return OPJ_FALSE;
+ }
+
+ if ( ! opj_stream_flush(p_stream,p_manager) ) {
+ return OPJ_FALSE;
+ }
+
+ return OPJ_TRUE;
+}
+
+
/**
* Reads a RGN marker (Region Of Interest)
*
}
-OPJ_FLOAT32 get_tp_stride (opj_tcp_v2_t * p_tcp)
+static OPJ_FLOAT32 get_tp_stride (opj_tcp_v2_t * p_tcp)
{
return (OPJ_FLOAT32) ((p_tcp->m_nb_tile_parts - 1) * 14);
}
-OPJ_FLOAT32 get_default_stride (opj_tcp_v2_t * p_tcp)
+static OPJ_FLOAT32 get_default_stride (opj_tcp_v2_t * p_tcp)
{
+ (void)p_tcp;
return 0;
}
static void j2k_read_eoc(opj_j2k_t *j2k) {
int i, tileno;
- opj_bool success;
+ opj_bool success = OPJ_FALSE;
/* if packets should be decoded */
if (j2k->cp->limit_decoding != DECODE_ALL_BUT_PACKETS) {
tcd_malloc_decode(tcd, j2k->image, j2k->cp);
for (i = 0; i < j2k->cp->tileno_size; i++) {
tcd_malloc_decode_tile(tcd, j2k->image, j2k->cp, i, j2k->cstr_info);
- tileno = j2k->cp->tileno[i];
- success = tcd_decode_tile(tcd, j2k->tile_data[tileno], j2k->tile_len[tileno], tileno, j2k->cstr_info);
- opj_free(j2k->tile_data[tileno]);
- j2k->tile_data[tileno] = NULL;
- tcd_free_decode_tile(tcd, i);
+ if (j2k->cp->tileno[i] != -1)
+ {
+ tileno = j2k->cp->tileno[i];
+ success = tcd_decode_tile(tcd, j2k->tile_data[tileno], j2k->tile_len[tileno], tileno, j2k->cstr_info);
+ opj_free(j2k->tile_data[tileno]);
+ j2k->tile_data[tileno] = NULL;
+ tcd_free_decode_tile(tcd, i);
+ }
+ else
+ success = OPJ_FALSE;
if (success == OPJ_FALSE) {
j2k->state |= J2K_STATE_ERR;
break;
* @param p_header_size the size of the data contained in the SOD marker.
* @param p_manager the user event manager.
*/
+#if 0
opj_bool j2k_read_eoc_v2 ( opj_j2k_v2_t *p_j2k,
struct opj_stream_private *p_stream,
struct opj_event_mgr * p_manager )
tcd_destroy_v2(l_tcd);
return OPJ_TRUE;
}
+#endif
/**
* Gets the offset of the header.
/* 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;
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;
-
-#ifdef USE_JPWL
- cp->correct = parameters->jpwl_correct;
- cp->exp_comps = parameters->jpwl_exp_comps;
- cp->max_tiles = parameters->jpwl_max_tiles;
-#endif /* USE_JPWL */
-
-
- /* keep a link to cp so that we can destroy it later in j2k_destroy_decompress */
- j2k->cp = cp;
- }
-}
-void j2k_setup_decoder_v2(opj_j2k_v2_t *j2k, opj_dparameters_t *parameters)
+void opj_j2k_setup_decoder(opj_j2k_v2_t *j2k, opj_dparameters_t *parameters)
{
if(j2k && parameters) {
j2k->m_cp.m_specific_param.m_dec.m_layer = parameters->cp_layer;
return j2k;
}
-opj_j2k_v2_t* j2k_create_compress_v2()
+opj_j2k_v2_t* j2k_create_compress_v2(void)
{
opj_j2k_v2_t *l_j2k = (opj_j2k_v2_t*) opj_malloc(sizeof(opj_j2k_v2_t));
if (!l_j2k) {
}
void j2k_setup_encoder(opj_j2k_t *j2k, opj_cparameters_t *parameters, opj_image_t *image) {
- int i, j, tileno, numpocs_tile;
+ OPJ_UINT32 i,j;
+ int tileno, numpocs_tile;
opj_cp_t *cp = NULL;
if(!j2k || !parameters || ! image) {
*/
if (parameters->jpwl_epc_on) {
- int i;
+ OPJ_UINT32 i;
/* set JPWL on */
cp->epc_on = OPJ_TRUE;
for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
opj_tcp_t *tcp = &cp->tcps[tileno];
tcp->numlayers = parameters->tcp_numlayers;
- for (j = 0; j < tcp->numlayers; j++) {
+ assert ( tcp->numlayers >= 0 );
+ for (j = 0; j < (OPJ_UINT32)tcp->numlayers; j++) {
if(cp->cinema){
if (cp->fixed_quality) {
tcp->distoratio[j] = parameters->tcp_distoratio[j];
if (parameters->numpocs) {
/* initialisation of POC */
tcp->POC = 1;
- for (i = 0; i < parameters->numpocs; i++) {
+ assert( parameters->numpocs >= 0 );
+ for (i = 0; i < (OPJ_UINT32)parameters->numpocs; i++) {
if((tileno == parameters->POC[i].tile - 1) || (parameters->POC[i].tile == -1)) {
opj_poc_t *tcp_poc = &tcp->pocs[numpocs_tile];
tcp_poc->resno0 = parameters->POC[numpocs_tile].resno0;
tccp->qmfbid = parameters->irreversible ? 0 : 1;
tccp->qntsty = parameters->irreversible ? J2K_CCP_QNTSTY_SEQNT : J2K_CCP_QNTSTY_NOQNT;
tccp->numgbits = 2;
- if (i == parameters->roi_compno) {
+ assert(parameters->roi_compno >= 0);
+ if (i == (OPJ_UINT32)parameters->roi_compno) {
tccp->roishift = parameters->roi_shift;
} else {
tccp->roishift = 0;
}else{
if (parameters->csty & J2K_CCP_CSTY_PRT) {
int p = 0;
- for (j = tccp->numresolutions - 1; j >= 0; j--) {
+ assert(tccp->numresolutions > 0);
+ for (j = (OPJ_UINT32)(tccp->numresolutions - 1); (int)j >= 0; j--) {
if (p < parameters->res_spec) {
if (parameters->prcw_init[p] < 1) {
}
}
+void j2k_setup_encoder_v2( opj_j2k_v2_t *p_j2k,
+ opj_cparameters_t *parameters,
+ opj_image_t *image,
+ struct opj_event_mgr * p_manager)
+{
+ OPJ_UINT32 i, j, tileno, numpocs_tile;
+ opj_cp_v2_t *cp = 00;
+ opj_bool l_res;
+
+ if(!p_j2k || !parameters || ! image) {
+ return;
+ }
+
+ /* keep a link to cp so that we can destroy it later in j2k_destroy_compress */
+ cp = &(p_j2k->m_cp);
+
+ /* set default values for cp */
+ cp->tw = 1;
+ cp->th = 1;
+
+ /*
+ copy user encoding parameters
+ */
+ cp->m_specific_param.m_enc.m_cinema = parameters->cp_cinema;
+ cp->m_specific_param.m_enc.m_max_comp_size = parameters->max_comp_size;
+ cp->rsiz = parameters->cp_rsiz;
+ cp->m_specific_param.m_enc.m_disto_alloc = parameters->cp_disto_alloc;
+ cp->m_specific_param.m_enc.m_fixed_alloc = parameters->cp_fixed_alloc;
+ cp->m_specific_param.m_enc.m_fixed_quality = parameters->cp_fixed_quality;
+
+ /* mod fixed_quality */
+ if (parameters->cp_matrice) {
+ size_t array_size = parameters->tcp_numlayers * parameters->numresolution * 3 * sizeof(OPJ_INT32);
+ cp->m_specific_param.m_enc.m_matrice = (OPJ_INT32 *) opj_malloc(array_size);
+ memcpy(cp->m_specific_param.m_enc.m_matrice, parameters->cp_matrice, array_size);
+ }
+
+ /* tiles */
+ cp->tdx = parameters->cp_tdx;
+ cp->tdy = parameters->cp_tdy;
+
+ /* tile offset */
+ cp->tx0 = parameters->cp_tx0;
+ cp->ty0 = parameters->cp_ty0;
+
+ /* comment string */
+ if(parameters->cp_comment) {
+ cp->comment = (char*)opj_malloc(strlen(parameters->cp_comment) + 1);
+ if(cp->comment) {
+ strcpy(cp->comment, parameters->cp_comment);
+ }
+ }
+
+ /*
+ calculate other encoding parameters
+ */
+
+ if (parameters->tile_size_on) {
+ cp->tw = int_ceildiv(image->x1 - cp->tx0, cp->tdx);
+ cp->th = int_ceildiv(image->y1 - cp->ty0, cp->tdy);
+ } else {
+ cp->tdx = image->x1 - cp->tx0;
+ cp->tdy = image->y1 - cp->ty0;
+ }
+
+ if (parameters->tp_on) {
+ cp->m_specific_param.m_enc.m_tp_flag = parameters->tp_flag;
+ cp->m_specific_param.m_enc.m_tp_on = 1;
+ }
+
+#ifdef USE_JPWL
+ /*
+ calculate JPWL encoding parameters
+ */
+
+ if (parameters->jpwl_epc_on) {
+ OPJ_INT32 i;
+
+ /* set JPWL on */
+ cp->epc_on = OPJ_TRUE;
+ cp->info_on = OPJ_FALSE; /* no informative technique */
+
+ /* set EPB on */
+ if ((parameters->jpwl_hprot_MH > 0) || (parameters->jpwl_hprot_TPH[0] > 0)) {
+ cp->epb_on = OPJ_TRUE;
+
+ cp->hprot_MH = parameters->jpwl_hprot_MH;
+ for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
+ cp->hprot_TPH_tileno[i] = parameters->jpwl_hprot_TPH_tileno[i];
+ cp->hprot_TPH[i] = parameters->jpwl_hprot_TPH[i];
+ }
+ /* if tile specs are not specified, copy MH specs */
+ if (cp->hprot_TPH[0] == -1) {
+ cp->hprot_TPH_tileno[0] = 0;
+ cp->hprot_TPH[0] = parameters->jpwl_hprot_MH;
+ }
+ for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
+ cp->pprot_tileno[i] = parameters->jpwl_pprot_tileno[i];
+ cp->pprot_packno[i] = parameters->jpwl_pprot_packno[i];
+ cp->pprot[i] = parameters->jpwl_pprot[i];
+ }
+ }
+
+ /* set ESD writing */
+ if ((parameters->jpwl_sens_size == 1) || (parameters->jpwl_sens_size == 2)) {
+ cp->esd_on = OPJ_TRUE;
+
+ cp->sens_size = parameters->jpwl_sens_size;
+ cp->sens_addr = parameters->jpwl_sens_addr;
+ cp->sens_range = parameters->jpwl_sens_range;
+
+ cp->sens_MH = parameters->jpwl_sens_MH;
+ for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
+ cp->sens_TPH_tileno[i] = parameters->jpwl_sens_TPH_tileno[i];
+ cp->sens_TPH[i] = parameters->jpwl_sens_TPH[i];
+ }
+ }
+
+ /* always set RED writing to false: we are at the encoder */
+ cp->red_on = OPJ_FALSE;
+
+ } else {
+ cp->epc_on = OPJ_FALSE;
+ }
+#endif /* USE_JPWL */
+
+
+ /* initialize the mutiple tiles */
+ /* ---------------------------- */
+ cp->tcps = (opj_tcp_v2_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tcp_v2_t));
+ if (parameters->numpocs) {
+ /* initialisation of POC */
+ l_res = j2k_check_poc_val(parameters->POC,parameters->numpocs, parameters->numresolution, image->numcomps, parameters->tcp_numlayers, p_manager);
+ // TODO
+ }
+
+ for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
+ opj_tcp_v2_t *tcp = &cp->tcps[tileno];
+ tcp->numlayers = parameters->tcp_numlayers;
+
+ for (j = 0; j < tcp->numlayers; j++) {
+ if(cp->m_specific_param.m_enc.m_cinema){
+ if (cp->m_specific_param.m_enc.m_fixed_quality) {
+ tcp->distoratio[j] = parameters->tcp_distoratio[j];
+ }
+ tcp->rates[j] = parameters->tcp_rates[j];
+ }else{
+ if (cp->m_specific_param.m_enc.m_fixed_quality) { /* add fixed_quality */
+ tcp->distoratio[j] = parameters->tcp_distoratio[j];
+ } else {
+ tcp->rates[j] = parameters->tcp_rates[j];
+ }
+ }
+ }
+
+ tcp->csty = parameters->csty;
+ tcp->prg = parameters->prog_order;
+ tcp->mct = parameters->tcp_mct;
+
+ numpocs_tile = 0;
+ tcp->POC = 0;
+
+ if (parameters->numpocs) {
+ /* initialisation of POC */
+ tcp->POC = 1;
+ // TODO
+ for (i = 0; i < (unsigned int) parameters->numpocs; i++) {
+ if((tileno == parameters->POC[i].tile - 1) || (parameters->POC[i].tile == -1)) {
+ opj_poc_t *tcp_poc = &tcp->pocs[numpocs_tile];
+
+ tcp_poc->resno0 = parameters->POC[numpocs_tile].resno0;
+ tcp_poc->compno0 = parameters->POC[numpocs_tile].compno0;
+ tcp_poc->layno1 = parameters->POC[numpocs_tile].layno1;
+ tcp_poc->resno1 = parameters->POC[numpocs_tile].resno1;
+ tcp_poc->compno1 = parameters->POC[numpocs_tile].compno1;
+ tcp_poc->prg1 = parameters->POC[numpocs_tile].prg1;
+ tcp_poc->tile = parameters->POC[numpocs_tile].tile;
+
+ numpocs_tile++;
+ }
+ }
+
+ tcp->numpocs = numpocs_tile -1 ;
+ }else{
+ tcp->numpocs = 0;
+ }
+
+ tcp->tccps = (opj_tccp_t*) opj_calloc(image->numcomps, sizeof(opj_tccp_t));
+
+ if (parameters->mct_data) {
+
+ opj_event_msg_v2(p_manager, EVT_ERROR, "MCT not supported for now\n");
+ return;
+
+ /* TODO MSD : merge v2 add invert.c or used a external lib ?
+ OPJ_UINT32 lMctSize = image->numcomps * image->numcomps * sizeof(OPJ_FLOAT32);
+ OPJ_FLOAT32 * lTmpBuf = (OPJ_FLOAT32*)opj_malloc(lMctSize);
+ OPJ_INT32 * l_dc_shift = (OPJ_INT32 *) ((OPJ_BYTE *) parameters->mct_data + lMctSize);
+
+ tcp->mct = 2;
+ tcp->m_mct_coding_matrix = (OPJ_FLOAT32*)opj_malloc(lMctSize);
+ memcpy(tcp->m_mct_coding_matrix,parameters->mct_data,lMctSize);
+ memcpy(lTmpBuf,parameters->mct_data,lMctSize);
+
+ tcp->m_mct_decoding_matrix = (OPJ_FLOAT32*)opj_malloc(lMctSize);
+ assert(opj_matrix_inversion_f(lTmpBuf,(tcp->m_mct_decoding_matrix),image->numcomps));
+
+ tcp->mct_norms = (OPJ_FLOAT64*)
+ opj_malloc(image->numcomps * sizeof(OPJ_FLOAT64));
+
+ opj_calculate_norms(tcp->mct_norms,image->numcomps,tcp->m_mct_decoding_matrix);
+ opj_free(lTmpBuf);
+
+ for (i = 0; i < image->numcomps; i++) {
+ opj_tccp_t *tccp = &tcp->tccps[i];
+ tccp->m_dc_level_shift = l_dc_shift[i];
+ }
+
+ j2k_setup_mct_encoding(tcp,image);
+ */
+ }
+ else {
+ for (i = 0; i < image->numcomps; i++) {
+ opj_tccp_t *tccp = &tcp->tccps[i];
+ opj_image_comp_t * l_comp = &(image->comps[i]);
+
+ if (! l_comp->sgnd) {
+ tccp->m_dc_level_shift = 1 << (l_comp->prec - 1);
+ }
+ }
+ }
+
+ for (i = 0; i < image->numcomps; i++) {
+ opj_tccp_t *tccp = &tcp->tccps[i];
+
+ tccp->csty = parameters->csty & 0x01; /* 0 => one precinct || 1 => custom precinct */
+ tccp->numresolutions = parameters->numresolution;
+ tccp->cblkw = int_floorlog2(parameters->cblockw_init);
+ tccp->cblkh = int_floorlog2(parameters->cblockh_init);
+ tccp->cblksty = parameters->mode;
+ tccp->qmfbid = parameters->irreversible ? 0 : 1;
+ tccp->qntsty = parameters->irreversible ? J2K_CCP_QNTSTY_SEQNT : J2K_CCP_QNTSTY_NOQNT;
+ tccp->numgbits = 2;
+
+ if (i == parameters->roi_compno) {
+ tccp->roishift = parameters->roi_shift;
+ } else {
+ tccp->roishift = 0;
+ }
+
+ if(parameters->cp_cinema) {
+ //Precinct size for lowest frequency subband=128
+ tccp->prcw[0] = 7;
+ tccp->prch[0] = 7;
+ //Precinct size at all other resolutions = 256
+ for (j = 1; j < tccp->numresolutions; j++) {
+ tccp->prcw[j] = 8;
+ tccp->prch[j] = 8;
+ }
+ }else{
+ if (parameters->csty & J2K_CCP_CSTY_PRT) {
+ OPJ_INT32 p = 0, it_res;
+ for (it_res = tccp->numresolutions - 1; it_res >= 0; it_res--) {
+ if (p < parameters->res_spec) {
+
+ if (parameters->prcw_init[p] < 1) {
+ tccp->prcw[it_res] = 1;
+ } else {
+ tccp->prcw[it_res] = int_floorlog2(parameters->prcw_init[p]);
+ }
+
+ if (parameters->prch_init[p] < 1) {
+ tccp->prch[it_res] = 1;
+ }else {
+ tccp->prch[it_res] = int_floorlog2(parameters->prch_init[p]);
+ }
+
+ } else {
+ int res_spec = parameters->res_spec;
+ int size_prcw = parameters->prcw_init[res_spec - 1] >> (p - (res_spec - 1));
+ int size_prch = parameters->prch_init[res_spec - 1] >> (p - (res_spec - 1));
+
+ if (size_prcw < 1) {
+ tccp->prcw[it_res] = 1;
+ } else {
+ tccp->prcw[it_res] = int_floorlog2(size_prcw);
+ }
+
+ if (size_prch < 1) {
+ tccp->prch[it_res] = 1;
+ } else {
+ tccp->prch[it_res] = int_floorlog2(size_prch);
+ }
+ }
+ p++;
+ /*printf("\nsize precinct for level %d : %d,%d\n", it_res,tccp->prcw[it_res], tccp->prch[it_res]); */
+ } //end for
+ } else {
+ for (j = 0; j < tccp->numresolutions; j++) {
+ tccp->prcw[j] = 15;
+ tccp->prch[j] = 15;
+ }
+ }
+ }
+
+ dwt_calc_explicit_stepsizes(tccp, image->comps[i].prec);
+ }
+ }
+
+ if (parameters->mct_data) {
+ opj_free(parameters->mct_data);
+ parameters->mct_data = 00;
+ }
+}
+
+
opj_bool j2k_encode(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info) {
- int tileno, compno;
+ int tileno;
+ OPJ_UINT32 compno;
opj_cp_t *cp = NULL;
opj_tcd_t *tcd = NULL; /* TCD component */
/* INDEX >> */
j2k->cstr_info = cstr_info;
if (cstr_info) {
- int compno;
+ OPJ_UINT32 compno;
cstr_info->tile = (opj_tile_info_t *) opj_malloc(cp->tw * cp->th * sizeof(opj_tile_info_t));
cstr_info->image_w = image->x1 - image->x0;
cstr_info->image_h = image->y1 - image->y0;
opj_stream_private_t *p_stream,
opj_event_mgr_t * p_manager)
{
+ (void)p_j2k;
+ (void)p_stream;
+ (void)p_manager;
return OPJ_TRUE;
}
/* Copy codestream image information to the output image */
opj_copy_image_header(p_j2k->m_private_image, *p_image);
+ /*Allocate and initialize some elements of codestrem index*/
+ if (!j2k_allocate_tile_element_cstr_index(p_j2k)){
+ return OPJ_FALSE;
+ }
return OPJ_TRUE;
}
/* preconditions*/
assert(p_j2k != 00);
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_read_header_procedure);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_read_header_procedure);
/* DEVELOPER CORNER, add your custom procedures */
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_copy_default_tcp_and_create_tcd);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_copy_default_tcp_and_create_tcd);
}
/* preconditions*/
assert(p_j2k != 00);
- opj_procedure_list_add_procedure(p_j2k->m_validation_list, (void*)j2k_build_decoder);
- opj_procedure_list_add_procedure(p_j2k->m_validation_list, (void*)j2k_decoding_validation);
+ opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)j2k_build_decoder);
+ opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)j2k_decoding_validation);
/* DEVELOPER CORNER, add your custom validation procedure */
}
return l_is_valid;
}
+opj_bool j2k_setup_mct_encoding(opj_tcp_v2_t * p_tcp, opj_image_t * p_image)
+{
+ OPJ_UINT32 i;
+ OPJ_UINT32 l_indix = 1;
+ opj_mct_data_t * l_mct_deco_data = 00,* l_mct_offset_data = 00;
+ opj_simple_mcc_decorrelation_data_t * l_mcc_data;
+ OPJ_UINT32 l_mct_size,l_nb_elem;
+ OPJ_FLOAT32 * l_data, * l_current_data;
+ opj_tccp_t * l_tccp;
+
+ // preconditions
+ assert(p_tcp != 00);
+
+ if (p_tcp->mct != 2) {
+ return OPJ_TRUE;
+ }
+
+ if (p_tcp->m_mct_decoding_matrix) {
+ if (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records) {
+ p_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS;
+
+ p_tcp->m_mct_records = (opj_mct_data_t*)opj_realloc(p_tcp->m_mct_records,p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
+ if (! p_tcp->m_mct_records) {
+ return OPJ_FALSE;
+ }
+ l_mct_deco_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
+
+ memset(l_mct_deco_data ,0,(p_tcp->m_nb_max_mct_records - p_tcp->m_nb_mct_records) * sizeof(opj_mct_data_t));
+ }
+ l_mct_deco_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
+
+ if (l_mct_deco_data->m_data) {
+ opj_free(l_mct_deco_data->m_data);
+ l_mct_deco_data->m_data = 00;
+ }
+
+ l_mct_deco_data->m_index = l_indix++;
+ l_mct_deco_data->m_array_type = MCT_TYPE_DECORRELATION;
+ l_mct_deco_data->m_element_type = MCT_TYPE_FLOAT;
+ l_nb_elem = p_image->numcomps * p_image->numcomps;
+ l_mct_size = l_nb_elem * MCT_ELEMENT_SIZE[l_mct_deco_data->m_element_type];
+ l_mct_deco_data->m_data = (OPJ_BYTE*)opj_malloc(l_mct_size );
+
+ if (! l_mct_deco_data->m_data) {
+ return OPJ_FALSE;
+ }
+
+ j2k_mct_write_functions_from_float[l_mct_deco_data->m_element_type](p_tcp->m_mct_decoding_matrix,l_mct_deco_data->m_data,l_nb_elem);
+
+ l_mct_deco_data->m_data_size = l_mct_size;
+ ++p_tcp->m_nb_mct_records;
+ }
+
+ if (p_tcp->m_nb_mct_records == p_tcp->m_nb_max_mct_records) {
+ p_tcp->m_nb_max_mct_records += J2K_MCT_DEFAULT_NB_RECORDS;
+ p_tcp->m_mct_records = (opj_mct_data_t*)opj_realloc(p_tcp->m_mct_records,p_tcp->m_nb_max_mct_records * sizeof(opj_mct_data_t));
+
+ if (! p_tcp->m_mct_records) {
+ return OPJ_FALSE;
+ }
+
+ l_mct_offset_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
+ memset(l_mct_offset_data ,0,(p_tcp->m_nb_max_mct_records - p_tcp->m_nb_mct_records) * sizeof(opj_mct_data_t));
+
+ if (l_mct_deco_data) {
+ l_mct_deco_data = l_mct_offset_data - 1;
+ }
+ }
+
+ l_mct_offset_data = p_tcp->m_mct_records + p_tcp->m_nb_mct_records;
+
+ if (l_mct_offset_data->m_data) {
+ opj_free(l_mct_offset_data->m_data);
+ l_mct_offset_data->m_data = 00;
+ }
+
+ l_mct_offset_data->m_index = l_indix++;
+ l_mct_offset_data->m_array_type = MCT_TYPE_OFFSET;
+ l_mct_offset_data->m_element_type = MCT_TYPE_FLOAT;
+ l_nb_elem = p_image->numcomps;
+ l_mct_size = l_nb_elem * MCT_ELEMENT_SIZE[l_mct_offset_data->m_element_type];
+ l_mct_offset_data->m_data = (OPJ_BYTE*)opj_malloc(l_mct_size );
+
+ if (! l_mct_offset_data->m_data) {
+ return OPJ_FALSE;
+ }
+
+ l_data = (OPJ_FLOAT32*)opj_malloc(l_nb_elem * sizeof(OPJ_FLOAT32));
+ if (! l_data) {
+ opj_free(l_mct_offset_data->m_data);
+ l_mct_offset_data->m_data = 00;
+ return OPJ_FALSE;
+ }
+
+ l_tccp = p_tcp->tccps;
+ l_current_data = l_data;
+
+ for (i=0;i<l_nb_elem;++i) {
+ *(l_current_data++) = (OPJ_FLOAT32) (l_tccp->m_dc_level_shift);
+ ++l_tccp;
+ }
+
+ j2k_mct_write_functions_from_float[l_mct_offset_data->m_element_type](l_data,l_mct_offset_data->m_data,l_nb_elem);
+
+ opj_free(l_data);
+
+ l_mct_offset_data->m_data_size = l_mct_size;
+
+ ++p_tcp->m_nb_mct_records;
+
+ if (p_tcp->m_nb_mcc_records == p_tcp->m_nb_max_mcc_records) {
+ p_tcp->m_nb_max_mcc_records += J2K_MCT_DEFAULT_NB_RECORDS;
+ p_tcp->m_mcc_records = (opj_simple_mcc_decorrelation_data_t*)
+ opj_realloc(p_tcp->m_mcc_records,p_tcp->m_nb_max_mcc_records * sizeof(opj_simple_mcc_decorrelation_data_t));
+
+ if (! p_tcp->m_mcc_records) {
+ return OPJ_FALSE;
+ }
+ l_mcc_data = p_tcp->m_mcc_records + p_tcp->m_nb_mcc_records;
+ memset(l_mcc_data ,0,(p_tcp->m_nb_max_mcc_records - p_tcp->m_nb_mcc_records) * sizeof(opj_simple_mcc_decorrelation_data_t));
+
+ }
+
+ l_mcc_data = p_tcp->m_mcc_records + p_tcp->m_nb_mcc_records;
+ l_mcc_data->m_decorrelation_array = l_mct_deco_data;
+ l_mcc_data->m_is_irreversible = 1;
+ l_mcc_data->m_nb_comps = p_image->numcomps;
+ l_mcc_data->m_index = l_indix++;
+ l_mcc_data->m_offset_array = l_mct_offset_data;
+ ++p_tcp->m_nb_mcc_records;
+
+ return OPJ_TRUE;
+}
+
/**
* Builds the cp decoder parameters to use to decode tile.
*/
{
/* add here initialization of cp
copy paste of setup_decoder */
+ (void)p_j2k;
+ (void)p_stream;
+ (void)p_manager;
return OPJ_TRUE;
}
{
/* add here initialization of cp
copy paste of setup_encoder */
+ (void)p_j2k;
+ (void)p_stream;
+ (void)p_manager;
return OPJ_TRUE;
}
* l_start_y_dest, l_width_dest, l_height_dest) which will be modified
* by this input area.
* */
- if ( l_x0_dest < l_res->x0 ) {
+ assert( l_res->x0 >= 0);
+ assert( l_res->x1 >= 0);
+ if ( l_x0_dest < (OPJ_UINT32)l_res->x0 ) {
l_start_x_dest = l_res->x0 - l_x0_dest;
l_offset_x0_src = 0;
- if ( l_x1_dest >= l_res->x1 ) {
+ if ( l_x1_dest >= (OPJ_UINT32)l_res->x1 ) {
l_width_dest = l_width_src;
l_offset_x1_src = 0;
}
l_start_x_dest = 0 ;
l_offset_x0_src = l_x0_dest - l_res->x0;
- if ( l_x1_dest >= l_res->x1 ) {
+ if ( l_x1_dest >= (OPJ_UINT32)l_res->x1 ) {
l_width_dest = l_width_src - l_offset_x0_src;
l_offset_x1_src = 0;
}
}
}
- if ( l_y0_dest < l_res->y0 ) {
+ if ( l_y0_dest < (OPJ_UINT32)l_res->y0 ) {
l_start_y_dest = l_res->y0 - l_y0_dest;
l_offset_y0_src = 0;
- if ( l_y1_dest >= l_res->y1 ) {
+ if ( l_y1_dest >= (OPJ_UINT32)l_res->y1 ) {
l_height_dest = l_height_src;
l_offset_y1_src = 0;
}
l_start_y_dest = 0 ;
l_offset_y0_src = l_y0_dest - l_res->y0;
- if ( l_y1_dest >= l_res->y1 ) {
+ if ( l_y1_dest >= (OPJ_UINT32)l_res->y1 ) {
l_height_dest = l_height_src - l_offset_y0_src;
l_offset_y1_src = 0;
}
/* Check if the positions provided by the user are correct */
/* Left */
- if (p_start_x > l_image->x1 ) {
+ assert(p_start_x >= 0 );
+ assert(p_start_y >= 0 );
+
+ if ((OPJ_UINT32)p_start_x > l_image->x1 ) {
opj_event_msg_v2(p_manager, EVT_ERROR,
"Left position of the decoded area (region_x0=%d) is outside the image area (Xsiz=%d).\n",
p_start_x, l_image->x1);
return OPJ_FALSE;
}
- else if (p_start_x < l_image->x0){
+ else if ((OPJ_UINT32)p_start_x < l_image->x0){
opj_event_msg_v2(p_manager, EVT_WARNING,
"Left position of the decoded area (region_x0=%d) is outside the image area (XOsiz=%d).\n",
p_start_x, l_image->x0);
}
/* Up */
- if (p_start_y > l_image->y1){
+ if ((OPJ_UINT32)p_start_y > l_image->y1){
opj_event_msg_v2(p_manager, EVT_ERROR,
"Up position of the decoded area (region_y0=%d) is outside the image area (Ysiz=%d).\n",
p_start_y, l_image->y1);
return OPJ_FALSE;
}
- else if (p_start_y < l_image->y0){
+ else if ((OPJ_UINT32)p_start_y < l_image->y0){
opj_event_msg_v2(p_manager, EVT_WARNING,
"Up position of the decoded area (region_y0=%d) is outside the image area (YOsiz=%d).\n",
p_start_y, l_image->y0);
}
/* Right */
- if (p_end_x < l_image->x0) {
+ assert((OPJ_UINT32)p_end_x > 0);
+ assert((OPJ_UINT32)p_end_y > 0);
+ if ((OPJ_UINT32)p_end_x < l_image->x0) {
opj_event_msg_v2(p_manager, EVT_ERROR,
"Right position of the decoded area (region_x1=%d) is outside the image area (XOsiz=%d).\n",
p_end_x, l_image->x0);
return OPJ_FALSE;
}
- else if (p_end_x > l_image->x1) {
+ else if ((OPJ_UINT32)p_end_x > l_image->x1) {
opj_event_msg_v2(p_manager, EVT_WARNING,
"Right position of the decoded area (region_x1=%d) is outside the image area (Xsiz=%d).\n",
p_end_x, l_image->x1);
}
/* Bottom */
- if (p_end_y < l_image->y0) {
+ if ((OPJ_UINT32)p_end_y < l_image->y0) {
opj_event_msg_v2(p_manager, EVT_ERROR,
"Bottom position of the decoded area (region_y1=%d) is outside the image area (YOsiz=%d).\n",
p_end_y, l_image->y0);
return OPJ_FALSE;
}
- if (p_end_y > l_image->y1){
+ if ((OPJ_UINT32)p_end_y > l_image->y1){
opj_event_msg_v2(p_manager, EVT_WARNING,
"Bottom position of the decoded area (region_y1=%d) is outside the image area (Ysiz=%d).\n",
p_end_y, l_image->y1);
*
* @return a handle to a J2K decompressor if successful, NULL otherwise.
*/
-opj_j2k_v2_t* j2k_create_decompress_v2()
+opj_j2k_v2_t* opj_j2k_create_decompress(void)
{
opj_j2k_v2_t *l_j2k = (opj_j2k_v2_t*) opj_malloc(sizeof(opj_j2k_v2_t));
if (!l_j2k) {
if (l_cp->correct) {
/* if JPWL is on, we check whether there are too many subbands */
- if ((l_num_band < 0) || (l_num_band >= J2K_MAXBANDS)) {
+ if (/*(l_num_band < 0) ||*/ (l_num_band >= J2K_MAXBANDS)) {
opj_event_msg_v2(p_manager, JPWL_ASSUME ? EVT_WARNING : EVT_ERROR,
"JPWL: bad number of subbands in Sqcx (%d)\n",
l_num_band);
fprintf(out_stream, "Codestream index from main header: {\n");
- fprintf(out_stream, "\t Main header start position=%" OPJ_OFF_F "d\n"
- "\t Main header end position=%" OPJ_OFF_F "d\n",
+ fprintf(out_stream, "\t Main header start position=%" PRIi64 "\n"
+ "\t Main header end position=%" PRIi64 "\n",
cstr_index->main_head_start, cstr_index->main_head_end);
fprintf(out_stream, "\t Marker list: {\n");
if (cstr_index->marker){
for (it_marker=0; it_marker < cstr_index->marknum ; it_marker++){
- fprintf(out_stream, "\t\t type=%#x, pos=%" OPJ_OFF_F "d, len=%d\n",
+ fprintf(out_stream, "\t\t type=%#x, pos=%" PRIi64 ", len=%d\n",
cstr_index->marker[it_marker].type,
cstr_index->marker[it_marker].pos,
cstr_index->marker[it_marker].len );
if (cstr_index->tile_index){
- fprintf(out_stream, "\t Tile index: {\n");
-
- for (it_tile=0; it_tile < cstr_index->nb_of_tiles ; it_tile++){
- OPJ_UINT32 nb_of_tile_part = cstr_index->tile_index[it_tile].nb_tps;
- fprintf(out_stream, "\t\t nb of tile-part in tile [%d]=%d\n", it_tile, nb_of_tile_part);
-
- if (cstr_index->tile_index[it_tile].tp_index){
- for (it_tile_part =0; it_tile_part < nb_of_tile_part; it_tile_part++){
- fprintf(out_stream, "\t\t\t tile-part[%d]: star_pos=%" OPJ_OFF_F "d, end_header=%" OPJ_OFF_F "d, end_pos=%" OPJ_OFF_F "d.\n",
- it_tile_part,
- cstr_index->tile_index[it_tile].tp_index[it_tile_part].start_pos,
- cstr_index->tile_index[it_tile].tp_index[it_tile_part].end_header,
- cstr_index->tile_index[it_tile].tp_index[it_tile_part].end_pos);
- }
- }
-
- if (cstr_index->tile_index[it_tile].marker){
- for (it_marker=0; it_marker < cstr_index->tile_index[it_tile].marknum ; it_marker++){
- fprintf(out_stream, "\t\t type=%#x, pos=%" OPJ_OFF_F "d, len=%d\n",
- cstr_index->tile_index[it_tile].marker[it_marker].type,
- cstr_index->tile_index[it_tile].marker[it_marker].pos,
- cstr_index->tile_index[it_tile].marker[it_marker].len );
- }
- }
- }
- fprintf(out_stream,"\t }\n");
+ /* Simple test to avoid to write empty information*/
+ OPJ_UINT32 l_acc_nb_of_tile_part = 0;
+ for (it_tile=0; it_tile < cstr_index->nb_of_tiles ; it_tile++){
+ l_acc_nb_of_tile_part += cstr_index->tile_index[it_tile].nb_tps;
+ }
+
+ if (l_acc_nb_of_tile_part)
+ {
+ fprintf(out_stream, "\t Tile index: {\n");
+
+ for (it_tile=0; it_tile < cstr_index->nb_of_tiles ; it_tile++){
+ OPJ_UINT32 nb_of_tile_part = cstr_index->tile_index[it_tile].nb_tps;
+
+ fprintf(out_stream, "\t\t nb of tile-part in tile [%d]=%d\n", it_tile, nb_of_tile_part);
+
+ if (cstr_index->tile_index[it_tile].tp_index){
+ for (it_tile_part =0; it_tile_part < nb_of_tile_part; it_tile_part++){
+ fprintf(out_stream, "\t\t\t tile-part[%d]: star_pos=%" PRIi64 ", end_header=%" PRIi64 ", end_pos=%" PRIi64 ".\n",
+ it_tile_part,
+ cstr_index->tile_index[it_tile].tp_index[it_tile_part].start_pos,
+ cstr_index->tile_index[it_tile].tp_index[it_tile_part].end_header,
+ cstr_index->tile_index[it_tile].tp_index[it_tile_part].end_pos);
+ }
+ }
+
+ if (cstr_index->tile_index[it_tile].marker){
+ for (it_marker=0; it_marker < cstr_index->tile_index[it_tile].marknum ; it_marker++){
+ fprintf(out_stream, "\t\t type=%#x, pos=%" PRIi64 ", len=%d\n",
+ cstr_index->tile_index[it_tile].marker[it_marker].type,
+ cstr_index->tile_index[it_tile].marker[it_marker].pos,
+ cstr_index->tile_index[it_tile].marker[it_marker].len );
+ }
+ }
+ }
+ fprintf(out_stream,"\t }\n");
+ }
}
fprintf(out_stream,"}\n");
for (compno = 0; compno < numcomps; compno++) {
opj_tccp_t *l_tccp = &(l_default_tile->tccps[compno]);
- OPJ_INT32 resno, bandno, numbands;
+ OPJ_UINT32 resno;
+ OPJ_INT32 bandno, numbands;
/* coding style*/
fprintf(out_stream, "\t\t comp %d {\n", compno);
fprintf(out_stream, "%s numcomps=%d\n", tab, img_header->numcomps);
if (img_header->comps){
- int compno;
+ OPJ_UINT32 compno;
for (compno = 0; compno < img_header->numcomps; compno++) {
fprintf(out_stream, "%s\t component %d {\n", tab, compno);
j2k_dump_image_comp_header(&(img_header->comps[compno]), dev_dump_flag, out_stream);
return l_cstr_index;
}
-opj_bool j2k_allocate_tile_element_cstr_index(opj_j2k_v2_t *p_j2k)
+static opj_bool j2k_allocate_tile_element_cstr_index(opj_j2k_v2_t *p_j2k)
{
OPJ_UINT32 it_tile=0;
}
l_max_data_size = 1000;
- /*Allocate and initialize some elements of codestrem index*/
- if (!j2k_allocate_tile_element_cstr_index(p_j2k)){
- opj_free(l_current_data);
- return OPJ_FALSE;
- }
+
while (OPJ_TRUE) {
if (! j2k_read_tile_header( p_j2k,
/**
* 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)
+static 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);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_decode_tiles);
/* DEVELOPER CORNER, add your custom procedures */
}
/*
* Read and decode one tile.
*/
-opj_bool j2k_decode_one_tile ( opj_j2k_v2_t *p_j2k,
+static opj_bool j2k_decode_one_tile ( opj_j2k_v2_t *p_j2k,
opj_stream_private_t *p_stream,
opj_event_mgr_t * p_manager)
{
if(l_current_tile_no == l_tile_no_to_dec)
{
/* move into the codestream to the the first SOT (FIXME or not move?)*/
- if (opj_stream_read_seek(p_stream, p_j2k->cstr_index->main_head_end + 2, p_manager) ) {
+ if (!(opj_stream_read_seek(p_stream, p_j2k->cstr_index->main_head_end + 2, p_manager) ) ) {
opj_event_msg_v2(p_manager, EVT_ERROR, "Problem with seek function\n");
return OPJ_FALSE;
}
/**
* Sets up the procedures to do on decoding one tile. Developpers wanting to extend the library can add their own reading procedures.
*/
-void j2k_setup_decoding_tile (opj_j2k_v2_t *p_j2k)
+static void j2k_setup_decoding_tile (opj_j2k_v2_t *p_j2k)
{
/* preconditions*/
assert(p_j2k != 00);
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_decode_one_tile);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_decode_one_tile);
/* DEVELOPER CORNER, add your custom procedures */
}
return OPJ_FALSE;
}
- if ( (tile_index < 0) && (tile_index >= p_j2k->m_cp.tw * p_j2k->m_cp.th) ){
+ if ( /*(tile_index < 0) &&*/ (tile_index >= p_j2k->m_cp.tw * p_j2k->m_cp.th) ){
opj_event_msg_v2(p_manager, EVT_ERROR, "Tile index provided by the user is incorrect %d (max = %d) \n", tile_index, (p_j2k->m_cp.tw * p_j2k->m_cp.th) - 1);
return OPJ_FALSE;
}
opj_image_t * p_image,
opj_event_mgr_t * p_manager)
{
- // preconditions
+ /* preconditions */
assert(p_j2k != 00);
assert(p_stream != 00);
assert(p_manager != 00);
- p_j2k->m_private_image = p_image;
+ p_j2k->m_private_image = opj_image_create0();
+ opj_copy_image_header(p_image, p_j2k->m_private_image);
+
+ // TODO_MSD: Find a better way
+ if (p_image->comps) {
+ OPJ_UINT32 it_comp;
+ for (it_comp = 0 ; it_comp < p_image->numcomps; it_comp++) {
+ if (p_image->comps[it_comp].data) {
+ p_j2k->m_private_image->comps[it_comp].data =p_image->comps[it_comp].data;
+ p_image->comps[it_comp].data = NULL;
+
+ }
+ }
+ }
/* customization of the validation */
j2k_setup_encoding_validation (p_j2k);
opj_stream_private_t *p_stream,
opj_event_mgr_t * p_manager )
{
+ (void)p_stream;
if (p_tile_index != p_j2k->m_current_tile_number) {
opj_event_msg_v2(p_manager, EVT_ERROR, "The given tile index does not match." );
return OPJ_FALSE;
l_current_data = p_j2k->m_specific_param.m_encoder.m_encoded_tile_data;
if (! tcd_copy_tile_data(l_tcd,p_data,p_data_size)) {
- opj_event_msg_v2(p_manager, EVT_ERROR, "Size mismtach between tile data and sent data." );
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Size mismatch between tile data and sent data." );
return OPJ_FALSE;
}
l_available_data -= l_nb_bytes_written;
l_nb_bytes_written = l_tile_size - l_available_data;
- if (opj_stream_write_data(p_stream,p_j2k->m_specific_param.m_encoder.m_encoded_tile_data,l_nb_bytes_written,p_manager) != l_nb_bytes_written) {
+ if ( opj_stream_write_data( p_stream,
+ p_j2k->m_specific_param.m_encoder.m_encoded_tile_data,
+ l_nb_bytes_written,p_manager) != l_nb_bytes_written) {
return OPJ_FALSE;
}
assert(p_j2k != 00);
/* DEVELOPER CORNER, insert your custom procedures */
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_eoc );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_eoc_v2 );
if (p_j2k->m_cp.m_specific_param.m_enc.m_cinema) {
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_updated_tlm);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_updated_tlm);
}
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_epc );
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_end_encoding );
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_destroy_header_memory);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_epc );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_end_encoding );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_destroy_header_memory);
}
/**
/* preconditions */
assert(p_j2k != 00);
- opj_procedure_list_add_procedure(p_j2k->m_validation_list, (void*)j2k_build_encoder);
- opj_procedure_list_add_procedure(p_j2k->m_validation_list, (void*)j2k_encoding_validation);
+ opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)j2k_build_encoder);
+ opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)j2k_encoding_validation);
/* DEVELOPER CORNER, add your custom validation procedure */
- opj_procedure_list_add_procedure(p_j2k->m_validation_list, (void*)j2k_mct_validation);
+ opj_procedure_list_add_procedure(p_j2k->m_validation_list, (opj_procedure)j2k_mct_validation);
}
/* preconditions */
assert(p_j2k != 00);
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_init_info );
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_soc_v2 );
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_siz_v2 );
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_cod_v2 );
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_qcd_v2 );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_init_info );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_soc_v2 );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_siz_v2 );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_cod_v2 );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_qcd_v2 );
if (p_j2k->m_cp.m_specific_param.m_enc.m_cinema) {
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_image_components );
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_tlm );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_image_components );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_tlm_v2 );
if (p_j2k->m_cp.m_specific_param.m_enc.m_cinema == CINEMA4K_24) {
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_poc );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_poc_v2 );
}
}
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_regions);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_regions);
if (p_j2k->m_cp.comment != 00) {
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_com);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_com_v2);
}
/* DEVELOPER CORNER, insert your custom procedures */
if (p_j2k->m_cp.rsiz & MCT) {
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_write_mct_data_group );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_write_mct_data_group );
}
/* End of Developer Corner */
if (p_j2k->cstr_index) {
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_get_end_header );
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_get_end_header );
}
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_create_tcd);
- opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(void*)j2k_update_rates);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_create_tcd);
+ opj_procedure_list_add_procedure(p_j2k->m_procedure_list,(opj_procedure)j2k_update_rates);
}
assert(p_j2k != 00);
assert(p_manager != 00);
assert(p_stream != 00);
+ (void)l_cstr_info;
/* TODO mergeV2: check this part which use cstr_info */
/*l_cstr_info = p_j2k->cstr_info;
opj_event_mgr_t * p_manager )
{
if (! j2k_pre_write_tile(p_j2k,p_tile_index,p_stream,p_manager)) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error while j2k_pre_write_tile with tile index = %d\n", p_tile_index);
return OPJ_FALSE;
}
+ else {
+ if (! j2k_post_write_tile(p_j2k,p_data,p_data_size,p_stream,p_manager)) {
+ opj_event_msg_v2(p_manager, EVT_ERROR, "Error while j2k_post_write_tile with tile index = %d\n", p_tile_index);
+ return OPJ_FALSE;
+ }
+ }
- return j2k_post_write_tile(p_j2k,p_data,p_data_size,p_stream,p_manager);
+ return OPJ_TRUE;
}
projects / openjpeg.git / blobdiff