[trunk] Update JPIP (FolderReorgProposal task)

This commit does three things:
- Use opj_malloc/calloc/free instead of the default C ones.
- Update JPIP API to start using cio _v2 API
- Create a new opj_jpip_compress which is the replacement for image_to_j2k -jpip

Update issue 177

1 files changed, 746 insertions, 19 deletions

diff --git a/src/lib/openjpip/openjpip.c b/src/lib/openjpip/openjpip.c
index de6293d4..a817a466 100644
--- a/src/lib/openjpip/openjpip.c
+++ b/src/lib/openjpip/openjpip.c
@@ -57,7 +57,7 @@
 
 server_record_t * init_JPIPserver( int tcp_auxport, int udp_auxport)
 {
-  server_record_t *record = (server_record_t *)malloc( sizeof(server_record_t));
+  server_record_t *record = (server_record_t *)opj_malloc( sizeof(server_record_t));
   
   record->sessionlist = gene_sessionlist();
   record->targetlist  = gene_targetlist();
@@ -72,14 +72,14 @@ void terminate_JPIPserver( server_record_t **rec)
   delete_targetlist( &(*rec)->targetlist); 
   close_aux_transport( (*rec)->auxtrans);
    
-  free( *rec);
+  opj_free( *rec);
 }
 
 QR_t * parse_querystring( const char *query_string)
 {
   QR_t *qr;
 
-  qr = (QR_t *)malloc( sizeof(QR_t));
+  qr = (QR_t *)opj_malloc( sizeof(QR_t));
     
   qr->query = parse_query( query_string);
   qr->msgqueue = NULL;
@@ -162,7 +162,7 @@ void send_responsedata( server_record_t *rec, QR_t *qr)
       fprintf( FCGI_stderr, "Error: failed to write jpipstream\n");
   }
 
-  free( jpipstream);
+  opj_free( jpipstream);
 
   return;
 }
@@ -186,7 +186,7 @@ void end_QRprocess( server_record_t *rec, QR_t **qr)
   (void)rec; /* unused */
   delete_query( &((*qr)->query));
   delete_msgqueue( &((*qr)->msgqueue));
-  free( *qr);
+  opj_free( *qr);
 }
 
 
@@ -211,7 +211,7 @@ void local_log( bool query, bool messages, bool sessions, bool targets, QR_t *qr
 
 dec_server_record_t * init_dec_server( int port)
 {
-  dec_server_record_t *record = (dec_server_record_t *)malloc( sizeof(dec_server_record_t));
+  dec_server_record_t *record = (dec_server_record_t *)opj_malloc( sizeof(dec_server_record_t));
 
   record->cachelist = gene_cachelist();
   record->jpipstream = NULL;
@@ -225,7 +225,7 @@ dec_server_record_t * init_dec_server( int port)
 void terminate_dec_server( dec_server_record_t **rec)
 {
   delete_cachelist( &(*rec)->cachelist);  
-  free( (*rec)->jpipstream);
+  opj_free( (*rec)->jpipstream);
   
   if( (*rec)->msgqueue)
     delete_msgqueue( &((*rec)->msgqueue));
@@ -233,7 +233,7 @@ void terminate_dec_server( dec_server_record_t **rec)
   if( close_socket( (*rec)->listening_socket) != 0)
     perror("close");
   
-  free( *rec);
+  opj_free( *rec);
 }
 
 client_t accept_connection( dec_server_record_t *rec)
@@ -310,7 +310,7 @@ jpip_dec_param_t * init_jpipdecoder( bool jp2)
 {
   jpip_dec_param_t *dec;
   
-  dec = (jpip_dec_param_t *)calloc( 1, sizeof(jpip_dec_param_t));
+  dec = (jpip_dec_param_t *)opj_calloc( 1, sizeof(jpip_dec_param_t));
 
   dec->msgqueue = gene_msgqueue( true, NULL);
   
@@ -333,11 +333,11 @@ bool fread_jpip( const char fname[], jpip_dec_param_t *dec)
   if(!(dec->jpiplen = (Byte8_t)get_filesize(infd)))
     return false;
   
-  dec->jpipstream = (Byte_t *)malloc( dec->jpiplen);
+  dec->jpipstream = (Byte_t *)opj_malloc( dec->jpiplen);
 
   if( read( infd, dec->jpipstream, dec->jpiplen) != (int)dec->jpiplen){
     fprintf( stderr, "file reading error\n");
-    free( dec->jpipstream);
+    opj_free( dec->jpipstream);
     return false;
   }
 
@@ -398,15 +398,15 @@ void output_log( bool messages, bool metadata, bool ihdrbox, jpip_dec_param_t *d
 
 void destroy_jpipdecoder( jpip_dec_param_t **dec)
 {
-  free( (*dec)->jpipstream);
+  opj_free( (*dec)->jpipstream);
   delete_msgqueue( &(*dec)->msgqueue);
   if( (*dec)->metadatalist){
     delete_metadatalist( &(*dec)->metadatalist);
-    free( (*dec)->ihdrbox);
+    opj_free( (*dec)->ihdrbox);
   }
 
-  free( (*dec)->jp2kstream);
-  free( *dec);
+  opj_free( (*dec)->jp2kstream);
+  opj_free( *dec);
 }
 
 index_t * get_index_from_JP2file( int fd)
@@ -419,20 +419,20 @@ index_t * get_index_from_JP2file( int fd)
     return NULL;
   }
   
-  data = (char *)malloc( 12); /* size of header*/
+  data = (char *)opj_malloc( 12); /* size of header*/
   if( read( fd, data, 12) != 12){
-    free( data);
+    opj_free( data);
     fprintf( stderr, "Error: File broken (read error)\n");
     return NULL;
   }
     
   if( *data || *(data + 1) || *(data + 2) ||
       *(data + 3) != 12 || strncmp (data + 4, "jP  \r\n\x87\n", 8)){
-    free( data);
+    opj_free( data);
     fprintf( stderr, "Error: No JPEG 2000 Signature box in this file\n");
     return NULL;
   }
-  free( data);
+  opj_free( data);
   
   return parse_jp2file( fd);
 }
@@ -447,4 +447,731 @@ void output_index( index_t *index)
   print_index( *index);
 }
 
+/* ---------------------------------------------------------------------- */
+/* COMPRESSION FUNCTIONS*/
+typedef struct opj_decompression
+{
+	/** Main header reading function handler*/
+	opj_bool (*opj_read_header) (	struct opj_stream_private * cio,
+									void * p_codec,
+									opj_image_t **p_image,
+									struct opj_event_mgr * p_manager);
+	/** Decoding function */
+	opj_bool (*opj_decode) (	void * p_codec,
+								struct opj_stream_private *p_cio,
+								opj_image_t *p_image,
+								struct opj_event_mgr * p_manager);
+	/** FIXME DOC */
+	opj_bool (*opj_read_tile_header)(	void * p_codec,
+										OPJ_UINT32 * p_tile_index,
+										OPJ_UINT32* p_data_size,
+										OPJ_INT32 * p_tile_x0, OPJ_INT32 * p_tile_y0,
+										OPJ_INT32 * p_tile_x1, OPJ_INT32 * p_tile_y1,
+										OPJ_UINT32 * p_nb_comps,
+										opj_bool * p_should_go_on,
+										struct opj_stream_private *p_cio,
+										struct opj_event_mgr * p_manager);
+	/** FIXME DOC */
+	opj_bool (*opj_decode_tile_data)(	void * p_codec,
+										OPJ_UINT32 p_tile_index,
+										OPJ_BYTE * p_data,
+										OPJ_UINT32 p_data_size,
+										struct opj_stream_private *p_cio,
+										struct opj_event_mgr * p_manager);
+	/** Reading function used after codestream if necessary */
+	opj_bool (* opj_end_decompress) (	void *p_codec,
+										struct opj_stream_private *cio,
+										struct opj_event_mgr * p_manager);
+	/** Codec destroy function handler*/
+	void (*opj_destroy) (void * p_codec);
+	/** Setup decoder function handler */
+	void (*opj_setup_decoder) (void * p_codec, opj_dparameters_t * p_param);
+	/** Set decode area function handler */
+	opj_bool (*opj_set_decode_area) (	void * p_codec,
+										opj_image_t* p_image,
+										OPJ_INT32 p_start_x, OPJ_INT32 p_end_x,
+										OPJ_INT32 p_start_y, OPJ_INT32 p_end_y,
+										struct opj_event_mgr * p_manager);
+
+	/** Get tile function */
+	opj_bool (*opj_get_decoded_tile) (	void *p_codec,
+										opj_stream_private_t *p_cio,
+										opj_image_t *p_image,
+										struct opj_event_mgr * p_manager,
+										OPJ_UINT32 tile_index);
+
+	/** Set the decoded resolution factor */
+	opj_bool (*opj_set_decoded_resolution_factor) ( void * p_codec, 
+                                                    OPJ_UINT32 res_factor, 
+                                                    opj_event_mgr_t * p_manager);
+
+}opj_decompression_t;
+
+typedef struct opj_compression
+{
+	opj_bool (* opj_start_compress) (	void *p_codec,
+										struct opj_stream_private *cio,
+										struct opj_image * p_image,
+										struct opj_event_mgr * p_manager);
+
+	opj_bool (* opj_encode) (	void * p_codec,
+								struct opj_stream_private *p_cio,
+								struct opj_event_mgr * p_manager);
+
+	opj_bool (* opj_write_tile) (	void * p_codec,
+									OPJ_UINT32 p_tile_index,
+									OPJ_BYTE * p_data,
+									OPJ_UINT32 p_data_size,
+									struct opj_stream_private * p_cio,
+									struct opj_event_mgr * p_manager);
+
+	opj_bool (* opj_end_compress) (	void * p_codec,
+									struct opj_stream_private *p_cio,
+									struct opj_event_mgr * p_manager);
+
+	void (* opj_destroy) (void * p_codec);
+
+	void (*opj_setup_encoder) (	void * p_codec,
+								opj_cparameters_t * p_param,
+								struct opj_image * p_image,
+								struct opj_event_mgr * p_manager);
+
+}opj_compression_t;
+
+typedef struct opj_codec_private
+{
+	/** FIXME DOC */
+	union 
+    {
+        opj_decompression_t m_decompression;
+        opj_compression_t m_compression;
+    } m_codec_data;
+    /** FIXME DOC*/
+	void * m_codec;
+	/** Event handler */
+	opj_event_mgr_t m_event_mgr;
+	/** Flag to indicate if the codec is used to decode or encode*/
+	opj_bool is_decompressor;
+	void (*opj_dump_codec) (void * p_codec, OPJ_INT32 info_flag, FILE* output_stream);
+	opj_codestream_info_v2_t* (*opj_get_codec_info)(void* p_codec);
+	opj_codestream_index_t* (*opj_get_codec_index)(void* p_codec);
+}
+opj_codec_private_t;
+
+static opj_bool opj_jp2_write_jp(	opj_jp2_v2_t *jp2,
+			    		    opj_stream_private_t *cio,
+				    		opj_event_mgr_t * p_manager )
+{
+	/* 12 bytes will be read */
+	unsigned char l_signature_data [12];
+
+	/* preconditions */
+	assert(cio != 00);
+	assert(jp2 != 00);
+	assert(p_manager != 00);
+
+	/* write box length */
+	opj_write_bytes(l_signature_data,12,4);
+	/* writes box type */
+	opj_write_bytes(l_signature_data+4,JP2_JP,4);
+	/* writes magic number*/
+	opj_write_bytes(l_signature_data+8,0x0d0a870a,4);
+	
+	if (opj_stream_write_data(cio,l_signature_data,12,p_manager) != 12) {
+		return OPJ_FALSE;
+	}
+
+	return OPJ_TRUE;
+}
+
+static opj_bool opj_jp2_write_ftyp(opj_jp2_v2_t *jp2,
+							opj_stream_private_t *cio,
+							opj_event_mgr_t * p_manager )
+{
+	unsigned int i;
+	unsigned int l_ftyp_size = 16 + 4 * jp2->numcl;
+	unsigned char * l_ftyp_data, * l_current_data_ptr;
+	opj_bool l_result;
+
+	/* preconditions */
+	assert(cio != 00);
+	assert(jp2 != 00);
+	assert(p_manager != 00);
+
+	l_ftyp_data = (unsigned char *) opj_malloc(l_ftyp_size);
+	
+	if (l_ftyp_data == 00) {
+		opj_event_msg_v2(p_manager, EVT_ERROR, "Not enough memory to handle ftyp data\n");
+		return OPJ_FALSE;
+	}
+
+	memset(l_ftyp_data,0,l_ftyp_size);
+
+	l_current_data_ptr = l_ftyp_data;
+
+	opj_write_bytes(l_current_data_ptr, l_ftyp_size,4); /* box size */
+	l_current_data_ptr += 4;
+
+	opj_write_bytes(l_current_data_ptr, JP2_FTYP,4); /* FTYP */
+	l_current_data_ptr += 4;
+
+	opj_write_bytes(l_current_data_ptr, jp2->brand,4); /* BR */
+	l_current_data_ptr += 4;
+
+	opj_write_bytes(l_current_data_ptr, jp2->minversion,4); /* MinV */
+	l_current_data_ptr += 4;
+
+	for (i = 0; i < jp2->numcl; i++)  {
+		opj_write_bytes(l_current_data_ptr, jp2->cl[i],4);	/* CL */
+	}
+	
+	l_result = (opj_stream_write_data(cio,l_ftyp_data,l_ftyp_size,p_manager) == l_ftyp_size);
+	if (! l_result)
+	{
+		opj_event_msg_v2(p_manager, EVT_ERROR, "Error while writing ftyp data to stream\n");
+	}
+
+	opj_free(l_ftyp_data);
+	
+	return l_result;
+}
+
+static opj_bool opj_jp2_default_validation (	opj_jp2_v2_t * jp2,
+                                        opj_stream_private_t *cio,
+                                        opj_event_mgr_t * p_manager
+                                        )
+{
+	opj_bool l_is_valid = OPJ_TRUE;
+	unsigned int i;
+
+	/* preconditions */
+	assert(jp2 != 00);
+	assert(cio != 00);
+	assert(p_manager != 00);
+
+	/* JPEG2000 codec validation */
+	/*TODO*/
+
+	/* STATE checking */
+	/* make sure the state is at 0 */
+	l_is_valid &= (jp2->jp2_state == JP2_STATE_NONE);
+
+	/* make sure not reading a jp2h ???? WEIRD */
+	l_is_valid &= (jp2->jp2_img_state == JP2_IMG_STATE_NONE);
+
+	/* POINTER validation */
+	/* make sure a j2k codec is present */
+	l_is_valid &= (jp2->j2k != 00);
+
+	/* make sure a procedure list is present */
+	l_is_valid &= (jp2->m_procedure_list != 00);
+
+	/* make sure a validation list is present */
+	l_is_valid &= (jp2->m_validation_list != 00);
+
+	/* PARAMETER VALIDATION */
+	/* number of components */
+	l_is_valid &= (jp2->numcl > 0);
+	/* width */
+	l_is_valid &= (jp2->h > 0);
+	/* height */
+	l_is_valid &= (jp2->w > 0);
+	/* precision */
+	for (i = 0; i < jp2->numcomps; ++i)	{
+		l_is_valid &= (jp2->comps[i].bpcc > 0);
+	}
+
+	/* METH */
+	l_is_valid &= ((jp2->meth > 0) && (jp2->meth < 3));
+
+	/* stream validation */
+	/* back and forth is needed */
+	l_is_valid &= opj_stream_has_seek(cio);
+
+	return l_is_valid;
+}
+
+static void opj_jp2_setup_encoding_validation (opj_jp2_v2_t *jp2)
+{
+	/* preconditions */
+	assert(jp2 != 00);
+
+	opj_procedure_list_add_procedure(jp2->m_validation_list, (opj_procedure)opj_jp2_default_validation);
+	/* DEVELOPER CORNER, add your custom validation procedure */
+}
+
+static opj_bool opj_jp2_skip_jp2c(	opj_jp2_v2_t *jp2,
+					    	opj_stream_private_t *stream,
+					    	opj_event_mgr_t * p_manager )
+{
+	/* preconditions */
+	assert(jp2 != 00);
+	assert(stream != 00);
+	assert(p_manager != 00);
+
+	jp2->j2k_codestream_offset = opj_stream_tell(stream);
+
+	if (opj_stream_skip(stream,8,p_manager) != 8) {
+		return OPJ_FALSE;
+	}
+
+	return OPJ_TRUE;
+}
+
+static opj_bool opj_jpip_skip_iptr(	opj_jp2_v2_t *jp2,
+					    	opj_stream_private_t *stream,
+					    	opj_event_mgr_t * p_manager )
+{
+	/* preconditions */
+	assert(jp2 != 00);
+	assert(stream != 00);
+	assert(p_manager != 00);
+
+	jp2->jpip_iptr_offset = opj_stream_tell(stream);
+
+	if (opj_stream_skip(stream,24,p_manager) != 24) {
+		return OPJ_FALSE;
+	}
+
+	return OPJ_TRUE;
+}
+
+void opj_jpip_setup_header_writing (opj_jp2_v2_t *jp2)
+{
+	/* preconditions */
+	assert(jp2 != 00);
+
+	opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_write_jp );
+	opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_write_ftyp );
+	opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_write_jp2h );
+	opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_skip_iptr );
+	opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jp2_skip_jp2c );
+
+	/* DEVELOPER CORNER, insert your custom procedures */
+
+}
+
+static opj_bool opj_jp2_exec (  opj_jp2_v2_t * jp2,
+                                opj_procedure_list_t * p_procedure_list,
+                                opj_stream_private_t *stream,
+                                opj_event_mgr_t * p_manager
+                                )
+
+{
+	opj_bool (** l_procedure) (opj_jp2_v2_t * jp2, opj_stream_private_t *, opj_event_mgr_t *) = 00;
+	opj_bool l_result = OPJ_TRUE;
+	OPJ_UINT32 l_nb_proc, i;
+
+	/* preconditions */
+	assert(p_procedure_list != 00);
+	assert(jp2 != 00);
+	assert(stream != 00);
+	assert(p_manager != 00);
+
+	l_nb_proc = opj_procedure_list_get_nb_procedures(p_procedure_list);
+	l_procedure = (opj_bool (**) (opj_jp2_v2_t * jp2, opj_stream_private_t *, opj_event_mgr_t *)) opj_procedure_list_get_first_procedure(p_procedure_list);
+
+	for	(i=0;i<l_nb_proc;++i) {
+		l_result = l_result && (*l_procedure) (jp2,stream,p_manager);
+		++l_procedure;
+	}
+
+	/* and clear the procedure list at the end. */
+	opj_procedure_list_clear(p_procedure_list);
+	return l_result;
+}
+
+opj_bool opj_jpip_start_compress(opj_jp2_v2_t *jp2,
+                                opj_stream_private_t *stream,
+                                opj_image_t * p_image,
+                                opj_event_mgr_t * p_manager
+                                )
+{
+	/* preconditions */
+	assert(jp2 != 00);
+	assert(stream != 00);
+	assert(p_manager != 00);
+
+	/* customization of the validation */
+	opj_jp2_setup_encoding_validation (jp2);
+
+	/* validation of the parameters codec */
+	if (! opj_jp2_exec(jp2,jp2->m_validation_list,stream,p_manager)) {
+		return OPJ_FALSE;
+	}
+
+	/* customization of the encoding */
+	opj_jpip_setup_header_writing(jp2);
+
+	/* write header */
+	if (! opj_jp2_exec (jp2,jp2->m_procedure_list,stream,p_manager)) {
+		return OPJ_FALSE;
+	}
+
+	return opj_j2k_start_compress(jp2->j2k,stream,p_image,p_manager);
+}
+
+static opj_bool opj_jpip_write_iptr(opj_jp2_v2_t *jp2,
+							opj_stream_private_t *cio,
+							opj_event_mgr_t * p_manager )
+{
+	OPJ_OFF_T j2k_codestream_exit;
+	OPJ_BYTE l_data_header [24];
+	
+	/* preconditions */
+	assert(jp2 != 00);
+	assert(cio != 00);
+	assert(p_manager != 00);
+	assert(opj_stream_has_seek(cio));
+	
+	j2k_codestream_exit = opj_stream_tell(cio);
+	opj_write_bytes(l_data_header, 24, 4); /* size of iptr */
+	opj_write_bytes(l_data_header + 4,JPIP_IPTR,4);									   /* IPTR */
+#if 0
+	opj_write_bytes(l_data_header + 4 + 4, 0, 8); /* offset */
+	opj_write_bytes(l_data_header + 8 + 8, 0, 8); /* length */
+#else
+  opj_write_double(l_data_header + 4 + 4, 0); /* offset */
+  opj_write_double(l_data_header + 8 + 8, 0); /* length */
+#endif
+
+	if (! opj_stream_seek(cio,jp2->jpip_iptr_offset,p_manager)) {
+		opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+		return OPJ_FALSE;
+	}
+	
+	if (opj_stream_write_data(cio,l_data_header,24,p_manager) != 24) {
+		opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+		return OPJ_FALSE;
+	}
+
+	if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
+		opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+		return OPJ_FALSE;
+	}
+
+	return OPJ_TRUE;
+}
+
+static opj_bool opj_jpip_write_fidx(opj_jp2_v2_t *jp2,
+							opj_stream_private_t *cio,
+							opj_event_mgr_t * p_manager )
+{
+	OPJ_OFF_T j2k_codestream_exit;
+	OPJ_BYTE l_data_header [24];
+	
+	/* preconditions */
+	assert(jp2 != 00);
+	assert(cio != 00);
+	assert(p_manager != 00);
+	assert(opj_stream_has_seek(cio));
+	
+	opj_write_bytes(l_data_header, 24, 4); /* size of iptr */
+	opj_write_bytes(l_data_header + 4,JPIP_FIDX,4);									   /* IPTR */
+  opj_write_double(l_data_header + 4 + 4, 0); /* offset */
+  opj_write_double(l_data_header + 8 + 8, 0); /* length */
+
+	if (opj_stream_write_data(cio,l_data_header,24,p_manager) != 24) {
+		opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+		return OPJ_FALSE;
+	}
+
+	j2k_codestream_exit = opj_stream_tell(cio);
+	if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
+		opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+		return OPJ_FALSE;
+	}
+
+	return OPJ_TRUE;
+}
+
+static opj_bool opj_jpip_write_cidx(opj_jp2_v2_t *jp2,
+							opj_stream_private_t *cio,
+							opj_event_mgr_t * p_manager )
+{
+	OPJ_OFF_T j2k_codestream_exit;
+	OPJ_BYTE l_data_header [24];
+	
+	/* preconditions */
+	assert(jp2 != 00);
+	assert(cio != 00);
+	assert(p_manager != 00);
+	assert(opj_stream_has_seek(cio));
+	
+	j2k_codestream_exit = opj_stream_tell(cio);
+	opj_write_bytes(l_data_header, 24, 4); /* size of iptr */
+	opj_write_bytes(l_data_header + 4,JPIP_CIDX,4);									   /* IPTR */
+#if 0
+	opj_write_bytes(l_data_header + 4 + 4, 0, 8); /* offset */
+	opj_write_bytes(l_data_header + 8 + 8, 0, 8); /* length */
+#else
+  opj_write_double(l_data_header + 4 + 4, 0); /* offset */
+  opj_write_double(l_data_header + 8 + 8, 0); /* length */
+#endif
+
+	if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
+		opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+		return OPJ_FALSE;
+	}
+	
+	if (opj_stream_write_data(cio,l_data_header,24,p_manager) != 24) {
+		opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+		return OPJ_FALSE;
+	}
+
+	j2k_codestream_exit = opj_stream_tell(cio);
+	if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
+		opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+		return OPJ_FALSE;
+	}
+
+	return OPJ_TRUE;
+}
+
+static void write_prxy_v2( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_stream_private_t *cio,
+              opj_event_mgr_t * p_manager )
+{
+  OPJ_BYTE l_data_header [8];
+  int len, lenp;
+
+#if 0
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end] */
+  cio_write( cio, JPIP_PRXY, 4);  /* IPTR           */
+#else
+  lenp = opj_stream_tell(cio);
+  opj_stream_skip(cio, 4, p_manager);         /* L [at the end] */
+  opj_write_bytes(l_data_header,JPIP_PRXY,4); /* IPTR           */
+  opj_stream_write_data(cio,l_data_header,4,p_manager);
+#endif
+  
+#if 0
+  cio_write( cio, offset_jp2c, 8); /* OOFF           */
+  cio_write( cio, length_jp2c, 4); /* OBH part 1     */
+  cio_write( cio, JP2_JP2C, 4);    /* OBH part 2     */
+#else
+  opj_write_bytes( l_data_header, offset_jp2c, 8); /* OOFF           */
+  opj_stream_write_data(cio,l_data_header,8,p_manager);
+  opj_write_bytes( l_data_header, length_jp2c, 4); /* OBH part 1     */
+  opj_write_bytes( l_data_header+4, JP2_JP2C, 4);  /* OBH part 2     */
+  opj_stream_write_data(cio,l_data_header,8,p_manager);
+#endif
+  
+#if 0
+  cio_write( cio, 1,1);           /* NI             */
+#else
+  opj_write_bytes( l_data_header, 1, 1);/* NI             */
+  opj_stream_write_data(cio,l_data_header,1,p_manager);
+#endif
+
+#if 0
+  cio_write( cio, offset_idx, 8);  /* IOFF           */
+  cio_write( cio, length_idx, 4);  /* IBH part 1     */
+  cio_write( cio, JPIP_CIDX, 4);   /* IBH part 2     */
+#else
+  opj_write_bytes( l_data_header, offset_idx, 8);  /* IOFF           */
+  opj_stream_write_data(cio,l_data_header,8,p_manager);
+  opj_write_bytes( l_data_header, length_idx, 4);  /* IBH part 1     */
+  opj_write_bytes( l_data_header+4, JPIP_CIDX, 4);   /* IBH part 2     */
+  opj_stream_write_data(cio,l_data_header,8,p_manager);
+#endif
+
+#if 0
+  len = cio_tell( cio)-lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L              */
+  cio_seek( cio, lenp+len);
+#else
+  len = opj_stream_tell(cio)-lenp;
+  opj_stream_skip(cio, lenp, p_manager);
+  opj_write_bytes(l_data_header,len,4);/* L              */
+  opj_stream_write_data(cio,l_data_header,4,p_manager);
+  opj_stream_seek(cio, lenp+len,p_manager);
+#endif
+}
+
+
+static int write_fidx_v2( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_stream_private_t *cio,
+              opj_event_mgr_t * p_manager )
+{  
+  OPJ_BYTE l_data_header [4];
+  int len, lenp;
+  
+#if 0
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end] */
+  cio_write( cio, JPIP_FIDX, 4);  /* IPTR           */
+#else
+  lenp = opj_stream_tell(cio);
+  opj_stream_skip(cio, 4, p_manager);
+  opj_write_bytes(l_data_header,JPIP_FIDX,4); /* FIDX */
+  opj_stream_write_data(cio,l_data_header,4,p_manager);
+#endif
+  
+  write_prxy_v2( offset_jp2c, length_jp2c, offset_idx, length_idx, cio,p_manager);
+
+#if 0
+  len = cio_tell( cio)-lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);        /* L              */
+  cio_seek( cio, lenp+len);  
+#else
+  len = opj_stream_tell(cio)-lenp;
+  opj_stream_skip(cio, lenp, p_manager);
+  opj_write_bytes(l_data_header,len,4);/* L              */
+  opj_stream_write_data(cio,l_data_header,4,p_manager);
+  opj_stream_seek(cio, lenp+len,p_manager);
+#endif
+
+  return len;
+}
+
+static opj_bool opj_jpip_write_jp2c(opj_jp2_v2_t *jp2,
+							opj_stream_private_t *cio,
+							opj_event_mgr_t * p_manager )
+{
+	OPJ_OFF_T j2k_codestream_exit;
+	OPJ_BYTE l_data_header [8];
+  OPJ_UINT32 len_jp2c;
+  int len_cidx;
+  int len_fidx;
+  int pos_jp2c;
+  int pos_fidx;
+  int pos_cidx;
+	
+	/* preconditions */
+	assert(jp2 != 00);
+	assert(cio != 00);
+	assert(p_manager != 00);
+	assert(opj_stream_has_seek(cio));
+	
+	j2k_codestream_exit = opj_stream_tell(cio);
+  len_jp2c = j2k_codestream_exit - jp2->j2k_codestream_offset;
+  pos_jp2c = jp2->j2k_codestream_offset;
+	opj_write_bytes(l_data_header, len_jp2c, 4); /* size of codestream */
+	opj_write_bytes(l_data_header + 4,JP2_JP2C,4);									   /* JP2C */
+
+	if (! opj_stream_seek(cio,jp2->j2k_codestream_offset,p_manager)) {
+		opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+		return OPJ_FALSE;
+	}
+	
+	if (opj_stream_write_data(cio,l_data_header,8,p_manager) != 8) {
+		opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+		return OPJ_FALSE;
+	}
+
+	if (! opj_stream_seek(cio,j2k_codestream_exit,p_manager)) {
+		opj_event_msg_v2(p_manager, EVT_ERROR, "Failed to seek in the stream.\n");
+		return OPJ_FALSE;
+	}
+
+  /* CIDX */
+  pos_cidx = opj_stream_tell( cio);
+  len_cidx = write_cidx_v2( pos_jp2c+8, cio, jp2_get_cstr_info(jp2), len_jp2c-8);
+
+  /* FIDX */
+  pos_fidx = opj_stream_tell( cio);
+  len_fidx = write_fidx_v2( pos_jp2c, len_jp2c, pos_cidx, len_cidx, cio, p_manager);
+
+	return OPJ_TRUE;
+}
+
+static void opj_jp2_setup_end_header_writing (opj_jp2_v2_t *jp2)
+{
+	/* preconditions */
+	assert(jp2 != 00);
+
+	opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_write_iptr );
+	opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_write_jp2c );
+#if 0
+  opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_write_cidx );
+  opj_procedure_list_add_procedure(jp2->m_procedure_list,(opj_procedure)opj_jpip_write_fidx );
+#endif
+	/* DEVELOPER CORNER, add your custom procedures */
+}
+
+opj_bool opj_jpip_end_compress(	opj_jp2_v2_t *jp2,
+							    opj_stream_private_t *cio,
+							    opj_event_mgr_t * p_manager
+                                )
+{
+	/* preconditions */
+	assert(jp2 != 00);
+	assert(cio != 00);
+	assert(p_manager != 00);
+
+	/* customization of the end encoding */
+	opj_jp2_setup_end_header_writing(jp2);
+
+	if (! opj_j2k_end_compress(jp2->j2k,cio,p_manager)) {
+		return OPJ_FALSE;
+	}
+
+	/* write header */
+	return opj_jp2_exec(jp2,jp2->m_procedure_list,cio,p_manager);
+}
+
+
+opj_codec_t* OPJ_CALLCONV opj_jpip_create_compress(OPJ_CODEC_FORMAT p_format)
+{
+	opj_codec_private_t *l_codec = 00;
+
+	l_codec = (opj_codec_private_t*)opj_calloc(1, sizeof(opj_codec_private_t));
+	if (!l_codec) {
+		return 00;
+	}
+	memset(l_codec, 0, sizeof(opj_codec_private_t));
+	
+	l_codec->is_decompressor = 0;
+
+	switch(p_format) {
+		case CODEC_JP2:
+			/* get a JP2 decoder handle */
+			l_codec->m_codec_data.m_compression.opj_encode = (opj_bool (*) (void *,
+																			struct opj_stream_private *,
+																			struct opj_event_mgr * )) opj_jp2_encode;
+
+			l_codec->m_codec_data.m_compression.opj_end_compress = (opj_bool (*) (	void *,
+																					struct opj_stream_private *,
+																					struct opj_event_mgr *)) opj_jpip_end_compress;
+
+			l_codec->m_codec_data.m_compression.opj_start_compress = (opj_bool (*) (void *,
+																					struct opj_stream_private *,
+																					struct opj_image * ,
+																					struct opj_event_mgr *))  opj_jpip_start_compress;
+
+			l_codec->m_codec_data.m_compression.opj_write_tile = (opj_bool (*) (void *,
+																				OPJ_UINT32,
+																				OPJ_BYTE*,
+																				OPJ_UINT32,
+																				struct opj_stream_private *,
+																				struct opj_event_mgr *)) opj_jp2_write_tile;
+
+			l_codec->m_codec_data.m_compression.opj_destroy = (void (*) (void *)) opj_jp2_destroy;
+
+			l_codec->m_codec_data.m_compression.opj_setup_encoder = (void (*) (	void *,
+																				opj_cparameters_t *,
+																				struct opj_image *,
+																				struct opj_event_mgr * )) opj_jp2_setup_encoder;
+
+			l_codec->m_codec = opj_jp2_create(OPJ_FALSE);
+			if (! l_codec->m_codec) {
+				opj_free(l_codec);
+				return 00;
+			}
+
+			break;
+
+		case CODEC_UNKNOWN:
+		case CODEC_JPT:
+		default:
+			opj_free(l_codec);
+			return 00;
+	}
+
+	opj_set_default_event_handler(&(l_codec->m_event_mgr));
+	return (opj_codec_t*) l_codec;
+}
+
 #endif /*SERVER*/