[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

18 files changed, 1790 insertions, 161 deletions

diff --git a/src/lib/openjpip/cachemodel_manager.c b/src/lib/openjpip/cachemodel_manager.c
index 1a84a6b8..70bbb2c3 100644
--- a/src/lib/openjpip/cachemodel_manager.c
+++ b/src/lib/openjpip/cachemodel_manager.c
@@ -48,7 +48,7 @@ cachemodellist_param_t * gene_cachemodellist(void)
 {
   cachemodellist_param_t *cachemodellist;
 
-  cachemodellist = (cachemodellist_param_t *)malloc( sizeof(cachemodellist_param_t));
+  cachemodellist = (cachemodellist_param_t *)opj_malloc( sizeof(cachemodellist_param_t));
   
   cachemodellist->first = NULL;
   cachemodellist->last  = NULL;
@@ -65,7 +65,7 @@ cachemodel_param_t * gene_cachemodel( cachemodellist_param_t *cachemodellist, ta
   Byte8_t numOftiles;
   int i;
 
-  cachemodel = (cachemodel_param_t *)malloc( sizeof(cachemodel_param_t));
+  cachemodel = (cachemodel_param_t *)opj_malloc( sizeof(cachemodel_param_t));
 
   refer_target( target, &cachemodel->target);
   
@@ -86,12 +86,12 @@ cachemodel_param_t * gene_cachemodel( cachemodellist_param_t *cachemodellist, ta
   tilepart = target->codeidx->tilepart;
   numOftiles = get_m( tilepart);
   numOfelem = get_nmax( tilepart)*numOftiles;
-  cachemodel->tp_model = (bool *)calloc( 1, numOfelem*sizeof(bool));
-  cachemodel->th_model = (bool *)calloc( 1, numOftiles*sizeof(bool));
-  cachemodel->pp_model = (bool **)malloc( target->codeidx->SIZ.Csiz*sizeof(bool *));
+  cachemodel->tp_model = (bool *)opj_calloc( 1, numOfelem*sizeof(bool));
+  cachemodel->th_model = (bool *)opj_calloc( 1, numOftiles*sizeof(bool));
+  cachemodel->pp_model = (bool **)opj_malloc( target->codeidx->SIZ.Csiz*sizeof(bool *));
   for( i=0; i<target->codeidx->SIZ.Csiz; i++){
     precpacket = target->codeidx->precpacket[i];
-    cachemodel->pp_model[i] = (bool *)calloc( 1, get_nmax(precpacket)*get_m(precpacket)*sizeof(bool));
+    cachemodel->pp_model[i] = (bool *)opj_calloc( 1, get_nmax(precpacket)*get_m(precpacket)*sizeof(bool));
   }
   cachemodel->next = NULL;
   
@@ -174,7 +174,7 @@ void delete_cachemodellist( cachemodellist_param_t **cachemodellist)
     delete_cachemodel( &cachemodelPtr);
     cachemodelPtr=cachemodelNext;
   }
-  free(*cachemodellist);
+  opj_free(*cachemodellist);
 }
 
 void delete_cachemodel( cachemodel_param_t **cachemodel)
@@ -183,17 +183,17 @@ void delete_cachemodel( cachemodel_param_t **cachemodel)
 
   unrefer_target( (*cachemodel)->target);
   
-  free( (*cachemodel)->tp_model);
-  free( (*cachemodel)->th_model);
+  opj_free( (*cachemodel)->tp_model);
+  opj_free( (*cachemodel)->th_model);
   
   for( i=0; i<(*cachemodel)->target->codeidx->SIZ.Csiz; i++)
-    free( (*cachemodel)->pp_model[i]);
-  free( (*cachemodel)->pp_model);
+    opj_free( (*cachemodel)->pp_model[i]);
+  opj_free( (*cachemodel)->pp_model);
 
 #ifndef SERVER
   fprintf( logstream, "local log: cachemodel deleted\n");
 #endif
-  free( *cachemodel);
+  opj_free( *cachemodel);
 }
 
 bool is_allsent( cachemodel_param_t cachemodel)
diff --git a/src/lib/openjpip/channel_manager.c b/src/lib/openjpip/channel_manager.c
index 8060d680..d422b396 100644
--- a/src/lib/openjpip/channel_manager.c
+++ b/src/lib/openjpip/channel_manager.c
@@ -49,7 +49,7 @@ channellist_param_t * gene_channellist(void)
 {
   channellist_param_t *channellist;
 
-  channellist = (channellist_param_t *)malloc( sizeof(channellist_param_t));
+  channellist = (channellist_param_t *)opj_malloc( sizeof(channellist_param_t));
   
   channellist->first = NULL;
   channellist->last  = NULL;
@@ -68,7 +68,7 @@ channel_param_t * gene_channel( query_param_t query_param, auxtrans_param_t auxt
     return NULL;
   }
 
-  channel = (channel_param_t *)malloc( sizeof(channel_param_t));
+  channel = (channel_param_t *)opj_malloc( sizeof(channel_param_t));
   channel->cachemodel = cachemodel;
 
   /* set channel ID and get present time */
@@ -130,7 +130,7 @@ void delete_channel( channel_param_t **channel, channellist_param_t *channellist
 #ifndef SERVER
   fprintf( logstream, "local log: channel: %s deleted\n", (*channel)->cid);
 #endif
-  free(*channel);
+  opj_free(*channel);
 }
 
 void delete_channellist( channellist_param_t **channellist)
@@ -143,10 +143,10 @@ void delete_channellist( channellist_param_t **channellist)
 #ifndef SERVER
       fprintf( logstream, "local log: channel %s deleted!\n", channelPtr->cid);
 #endif
-      free(channelPtr);
+      opj_free(channelPtr);
       channelPtr=channelNext;
   }
-  free( *channellist);
+  opj_free( *channellist);
 }
 
 void print_allchannel( channellist_param_t *channellist)
diff --git a/src/lib/openjpip/cidx_manager.c b/src/lib/openjpip/cidx_manager.c
index f3b251ff..a66358ac 100644
--- a/src/lib/openjpip/cidx_manager.c
+++ b/src/lib/openjpip/cidx_manager.c
@@ -41,6 +41,11 @@
  */
 void write_cptr(int coff, int clen, opj_cio_t *cio);
 
+void write_cptr_v2(int coff, int clen, opj_stream_private_t *cio,
+              opj_event_mgr_t * p_manager );
+
+void write_manf_v2(int second, int v, opj_jp2_box_t *box, opj_stream_private_t *cio,
+              opj_event_mgr_t * p_manager );
 
 /* 
  * Write main header index table (box)
@@ -123,6 +128,79 @@ int write_cidx( int offset, opj_cio_t *cio, opj_image_t *image, opj_codestream_i
   return len;
 }
 
+int write_cidx_v2( int offset, opj_stream_private_t *cio, opj_codestream_info_t cstr_info, int j2klen,
+              opj_event_mgr_t * p_manager )
+{
+  int len, i, lenp;
+  opj_jp2_box_t *box;
+  int num_box = 0;
+  opj_bool  EPHused;
+  OPJ_BYTE l_data_header [4];
+
+  lenp = -1;
+  box = (opj_jp2_box_t *)opj_calloc( 32, sizeof(opj_jp2_box_t));
+
+  for (i=0;i<2;i++){
+  
+    if(i)
+      opj_stream_seek(cio,lenp,p_manager);
+
+
+    lenp = opj_stream_tell (cio);
+
+    opj_stream_skip(cio, 4, p_manager); /* L [at the end] */
+#if 0
+    cio_write( cio, JPIP_CIDX, 4);  /* CIDX           */
+#else
+    opj_write_bytes(l_data_header,JPIP_CIDX,4); /* CIDX */
+    opj_stream_write_data(cio,l_data_header,4,p_manager);
+#endif
+    write_cptr_v2( offset, cstr_info.codestream_size, cio,p_manager);
+
+    write_manf_v2( i, num_box, box, cio,p_manager);
+    
+    num_box = 0;
+    box[num_box].length = write_mainmhix_v2( offset, cstr_info, cio,p_manager);
+    box[num_box].type = JPIP_MHIX;
+    num_box++;
+
+    box[num_box].length = write_tpix_v2( offset, cstr_info, j2klen, cio);
+    box[num_box].type = JPIP_TPIX;
+    num_box++;
+      
+    box[num_box].length = write_thix_v2( offset, cstr_info, cio);
+    box[num_box].type = JPIP_THIX;
+    num_box++;
+
+    EPHused = check_EPHuse_v2( offset, cstr_info.marker, cstr_info.marknum, cio);
+      
+    box[num_box].length = write_ppix_v2( offset, cstr_info, EPHused, j2klen, cio);
+    box[num_box].type = JPIP_PPIX;
+    num_box++;
+    
+    box[num_box].length = write_phix_v2( offset, cstr_info, EPHused, j2klen, cio);
+    box[num_box].type = JPIP_PHIX;
+    num_box++;
+      
+#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_seek(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
+  }
+
+  opj_free( box);
+  
+  return len;
+}
+
 void write_cptr(int coff, int clen, opj_cio_t *cio)
 {
   int len, lenp;
@@ -140,6 +218,42 @@ void write_cptr(int coff, int clen, opj_cio_t *cio)
   cio_seek( cio, lenp+len);
 }
 
+void write_cptr_v2(int coff, int clen, opj_stream_private_t *cio,
+              opj_event_mgr_t * p_manager )
+{
+  OPJ_BYTE l_data_header [3*8];
+  int len, lenp;
+
+#if 0
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);               /* L [at the end]     */
+  cio_write( cio, JPIP_CPTR, 4);   /* T                  */
+  cio_write( cio, 0, 2);           /* DR  A PRECISER !!  */
+  cio_write( cio, 0, 2);           /* CONT               */
+  cio_write( cio, coff, 8);    /* COFF A PRECISER !! */
+  cio_write( cio, clen, 8);    /* CLEN               */
+  len = cio_tell( cio) - lenp;
+  cio_seek( cio, lenp);
+  cio_write( cio, len, 4);         /* L                  */
+  cio_seek( cio, lenp+len);
+#else
+  lenp = opj_stream_tell(cio);
+  opj_stream_skip( cio, 4, p_manager);               /* L [at the end]     */
+  opj_write_bytes( l_data_header, JPIP_CPTR, 4);   /* T                  */
+  opj_write_bytes( l_data_header+4, 0, 2);           /* DR  A PRECISER !!  */
+  opj_write_bytes( l_data_header+6, 0, 2);           /* CONT               */
+  opj_write_bytes( l_data_header+8, coff, 8);    /* COFF A PRECISER !! */
+  opj_write_bytes( l_data_header+16, clen, 8);    /* CLEN               */
+  opj_stream_write_data(cio,l_data_header,3*8,p_manager);
+
+  len = opj_stream_tell(cio) - lenp;
+  opj_stream_seek(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
+}
+
 void write_manf(int second, int v, opj_jp2_box_t *box, opj_cio_t *cio)
 {
   int len, lenp, i;
@@ -161,6 +275,51 @@ void write_manf(int second, int v, opj_jp2_box_t *box, opj_cio_t *cio)
   cio_seek( cio, lenp+len);
 }
 
+void write_manf_v2(int second, int v, opj_jp2_box_t *box, opj_stream_private_t *cio,
+              opj_event_mgr_t * p_manager )
+{
+  OPJ_BYTE l_data_header [4];
+  int len, lenp, i;
+  
+#if 0
+  lenp = cio_tell( cio); 
+  cio_skip( cio, 4);                         /* L [at the end]                    */
+  cio_write( cio, JPIP_MANF,4);              /* T                                 */
+#else
+  lenp = opj_stream_tell(cio);
+  opj_stream_skip( cio, 4, p_manager);             /* L [at the end]     */
+  opj_write_bytes( l_data_header, JPIP_MANF, 4);   /* T                  */
+  opj_stream_write_data(cio,l_data_header,4,p_manager);
+#endif
+
+  if (second){                          /* Write only during the second pass */
+    for( i=0; i<v; i++){
+#if 0
+      cio_write( cio, box[i].length, 4);  /* Box length                     */ 
+      cio_write( cio, box[i].type, 4); /* Box type                       */
+#else
+      opj_write_bytes( l_data_header, box[i].length, 4); /* Box length                     */
+      opj_stream_write_data(cio,l_data_header,4,p_manager);
+      opj_write_bytes( l_data_header, box[i].type, 4); /* Box type                       */
+      opj_stream_write_data(cio,l_data_header,4,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_seek(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
+}
+
 int write_mainmhix( int coff, opj_codestream_info_t cstr_info, opj_cio_t *cio)
 {
   int i;
@@ -187,6 +346,64 @@ int write_mainmhix( int coff, opj_codestream_info_t cstr_info, opj_cio_t *cio)
   return len;
 }
 
+int write_mainmhix_v2( int coff, opj_codestream_info_t cstr_info, opj_stream_private_t *cio,
+              opj_event_mgr_t * p_manager )
+{
+  OPJ_BYTE l_data_header [8];
+  int i;
+  int len, lenp;
+  
+#if 0
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);                               /* L [at the end]                    */
+  cio_write( cio, JPIP_MHIX, 4);                   /* MHIX                              */
+#else
+  lenp = opj_stream_tell (cio);
+  opj_stream_skip(cio, 4, p_manager);               /* L [at the end]                    */
+  opj_write_bytes(l_data_header,JPIP_MHIX,4);       /* MHIX                              */
+  opj_stream_write_data(cio,l_data_header,4,p_manager);
+#endif
+
+#if 0
+  cio_write( cio, cstr_info.main_head_end-cstr_info.main_head_start+1, 8);        /* TLEN                              */
+#else
+  opj_write_bytes(l_data_header, cstr_info.main_head_end-cstr_info.main_head_start+1, 8);        /* TLEN                              */
+  opj_stream_write_data(cio,l_data_header,8,p_manager);
+#endif
+
+  for(i = 1; i < cstr_info.marknum; i++){    /* Marker restricted to 1 apparition, skip SOC marker */
+#if 0
+    cio_write( cio, cstr_info.marker[i].type, 2);
+    cio_write( cio, 0, 2);
+    cio_write( cio, cstr_info.marker[i].pos-coff, 8);
+    cio_write( cio, cstr_info.marker[i].len, 2);
+#else
+    opj_write_bytes( l_data_header, cstr_info.marker[i].type, 2);
+    opj_write_bytes( l_data_header+2, 0, 2);
+    opj_stream_write_data(cio,l_data_header,4,p_manager);
+    opj_write_bytes( l_data_header, cstr_info.marker[i].pos-coff, 8);
+    opj_stream_write_data(cio,l_data_header,8,p_manager);
+    opj_write_bytes( l_data_header, cstr_info.marker[i].len, 2);
+    opj_stream_write_data(cio,l_data_header,2,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_seek(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;
+}
+
 opj_bool check_EPHuse( int coff, opj_marker_info_t *markers, int marknum, opj_cio_t *cio)
 {
   opj_bool EPHused = OPJ_FALSE;
@@ -201,7 +418,7 @@ opj_bool check_EPHuse( int coff, opj_marker_info_t *markers, int marknum, opj_ci
       
       Scod = cio_read( cio, 1);
       if( ((Scod >> 2) & 1))
-	EPHused = OPJ_TRUE;
+  EPHused = OPJ_TRUE;
       cio_seek( cio, org_pos);
 
       break;
@@ -209,3 +426,44 @@ opj_bool check_EPHuse( int coff, opj_marker_info_t *markers, int marknum, opj_ci
   }    
   return EPHused;
 }
+
+opj_bool check_EPHuse_v2( int coff, opj_marker_info_t *markers, int marknum, opj_stream_private_t *cio,
+              opj_event_mgr_t * p_manager )
+{
+  OPJ_BYTE l_data_header [4];
+  opj_bool EPHused = OPJ_FALSE;
+  int i=0;
+  int org_pos;
+  unsigned int Scod;
+
+  for(i = 0; i < marknum; i++)
+    {
+    if( markers[i].type == J2K_MS_COD)
+      {
+#if 0
+      org_pos = cio_tell( cio);
+      cio_seek( cio, coff+markers[i].pos+2);
+#else
+      org_pos = opj_stream_tell(cio);
+      opj_stream_seek(cio, coff+markers[i].pos+2,p_manager);
+#endif
+
+#if 0
+      Scod = cio_read( cio, 1);
+#else
+      opj_stream_read_data(cio,l_data_header,1,p_manager);
+      opj_read_bytes(l_data_header,&Scod,1);
+#endif
+      if( ((Scod >> 2) & 1))
+        EPHused = OPJ_TRUE;
+#if 0
+      cio_seek( cio, org_pos);
+#else
+      opj_stream_seek( cio, org_pos, p_manager);
+#endif
+
+      break;
+      }
+    }    
+  return EPHused;
+}
diff --git a/src/lib/openjpip/dec_clientmsg_handler.c b/src/lib/openjpip/dec_clientmsg_handler.c
index 20bd4f2b..ee729228 100644
--- a/src/lib/openjpip/dec_clientmsg_handler.c
+++ b/src/lib/openjpip/dec_clientmsg_handler.c
@@ -55,7 +55,7 @@ void handle_JPIPstreamMSG( SOCKET connected_socket, cachelist_param_t *cachelist
   parse_JPIPstream( newjpipstream, newstreamlen, (OPJ_OFF_T)*streamlen, msgqueue);
 
   *jpipstream = update_JPIPstream( newjpipstream, newstreamlen, *jpipstream, streamlen);
-  free( newjpipstream);
+  opj_free( newjpipstream);
 
   metadatalist = gene_metadatalist();
   parse_metamsg( msgqueue, *jpipstream, *streamlen, metadatalist);
@@ -82,9 +82,9 @@ void handle_JPIPstreamMSG( SOCKET connected_socket, cachelist_param_t *cachelist
     delete_metadatalist( &cache->metadatalist);
   cache->metadatalist = metadatalist;
 
-  if( target)    free( target);
-  if( tid)    free( tid);
-  if( cid)    free( cid);
+  if( target)    opj_free( target);
+  if( tid)    opj_free( tid);
+  if( cid)    opj_free( cid);
 
   response_signal( connected_socket, true);
 }
@@ -102,11 +102,11 @@ void handle_PNMreqMSG( SOCKET connected_socket, Byte_t *jpipstream, msgqueue_par
   
   if(!(cache = search_cacheBycid( CIDorTID, cachelist)))
     if(!(cache = search_cacheBytid( CIDorTID, cachelist))){
-      free( CIDorTID);
+      opj_free( CIDorTID);
       return;
     }
   
-  free( CIDorTID);
+  opj_free( CIDorTID);
 
   receive_line( connected_socket, tmp);
   fw = atoi( tmp);
@@ -121,8 +121,8 @@ void handle_PNMreqMSG( SOCKET connected_socket, Byte_t *jpipstream, msgqueue_par
   maxval = ihdrbox->bpc > 8 ? 255 : (1 << ihdrbox->bpc) - 1;
   send_PNMstream( connected_socket, pnmstream, ihdrbox->width, ihdrbox->height, ihdrbox->nc, (Byte_t)maxval );
 
-  free( ihdrbox);
-  free( pnmstream);
+  opj_free( ihdrbox);
+  opj_free( pnmstream);
 }
 
 void handle_XMLreqMSG( SOCKET connected_socket, Byte_t *jpipstream, cachelist_param_t *cachelist)
@@ -135,17 +135,17 @@ void handle_XMLreqMSG( SOCKET connected_socket, Byte_t *jpipstream, cachelist_pa
   cid = receive_string( connected_socket);
 
   if(!(cache = search_cacheBycid( cid, cachelist))){
-    free( cid);
+    opj_free( cid);
     return;
   }
 
-  free( cid);
+  opj_free( cid);
   
   boxcontents = cache->metadatalist->last->boxcontents;
-  xmlstream = (Byte_t *)malloc( boxcontents->length);
+  xmlstream = (Byte_t *)opj_malloc( boxcontents->length);
   memcpy( xmlstream, jpipstream+boxcontents->offset, boxcontents->length);
   send_XMLstream( connected_socket, xmlstream, boxcontents->length);
-  free( xmlstream);
+  opj_free( xmlstream);
 }
 
 void handle_TIDreqMSG( SOCKET connected_socket, cachelist_param_t *cachelist)
@@ -157,7 +157,7 @@ void handle_TIDreqMSG( SOCKET connected_socket, cachelist_param_t *cachelist)
   target = receive_string( connected_socket);
   cache = search_cache( target, cachelist);
 
-  free( target);
+  opj_free( target);
   
   if( cache){
     tid = cache->tid;
@@ -175,7 +175,7 @@ void handle_CIDreqMSG( SOCKET connected_socket, cachelist_param_t *cachelist)
   target = receive_string( connected_socket);
   cache = search_cache( target, cachelist);
   
-  free( target);
+  opj_free( target);
 
   if( cache){
     if( cache->numOfcid > 0){
@@ -194,7 +194,7 @@ void handle_dstCIDreqMSG( SOCKET connected_socket, cachelist_param_t *cachelist)
   remove_cachecid( cid, cachelist);
   response_signal( connected_socket, true);
   
-  free( cid);
+  opj_free( cid);
 }
 
 void handle_SIZreqMSG( SOCKET connected_socket, Byte_t *jpipstream, msgqueue_param_t *msgqueue, cachelist_param_t *cachelist)
@@ -214,8 +214,8 @@ void handle_SIZreqMSG( SOCKET connected_socket, Byte_t *jpipstream, msgqueue_par
   if( !cache && cid[0] != '0')
     cache = search_cacheBycid( cid, cachelist);
 
-  free( tid);
-  free( cid);
+  opj_free( tid);
+  opj_free( cid);
   
   width = height = 0;
   if( cache){
@@ -237,17 +237,17 @@ void handle_JP2saveMSG( SOCKET connected_socket, cachelist_param_t *cachelist, m
 
   cid = receive_string( connected_socket);
   if(!(cache = search_cacheBycid( cid, cachelist))){
-    free( cid);
+    opj_free( cid);
     return;
   }
   
-  free( cid);
+  opj_free( cid);
   
   assert( cache->csn >= 0);
   jp2stream = recons_jp2( msgqueue, jpipstream, (Byte8_t)cache->csn, &jp2len);
 
   if( jp2stream){
     save_codestream( jp2stream, jp2len, "jp2");
-    free( jp2stream);
+    opj_free( jp2stream);
   }
 }
diff --git a/src/lib/openjpip/index_manager.c b/src/lib/openjpip/index_manager.c
index e4812226..b15d0b40 100644
--- a/src/lib/openjpip/index_manager.c
+++ b/src/lib/openjpip/index_manager.c
@@ -99,11 +99,11 @@ index_param_t * parse_jp2file( int fd)
     return NULL;
   }
 
-  jp2idx = (index_param_t *)malloc( sizeof(index_param_t));
+  jp2idx = (index_param_t *)opj_malloc( sizeof(index_param_t));
   
   if( !set_cidxdata( cidx, jp2idx)){
     fprintf( FCGI_stderr, "Error: Not correctl format in cidx box\n");
-    free(jp2idx);
+    opj_free(jp2idx);
     delete_boxlist( &toplev_boxlist);
     return NULL;
   }
@@ -190,19 +190,19 @@ void delete_index( index_param_t **index)
 
   for( i=0; i< (int)((*index)->SIZ.XTnum*(*index)->SIZ.YTnum);i++)
     delete_mhixbox( &((*index)->tileheader[i]));
-  free( (*index)->tileheader);
+  opj_free( (*index)->tileheader);
   
   for( i=0; i<(*index)->SIZ.Csiz; i++)
     delete_faixbox( &((*index)->precpacket[i]));
-  free( (*index)->precpacket);
+  opj_free( (*index)->precpacket);
   
-  free(*index);
+  opj_free(*index);
 }
 
 void delete_COD( CODmarker_param_t COD)
 {
-  if( COD.XPsiz)    free( COD.XPsiz);
-  if( COD.YPsiz)    free( COD.YPsiz);
+  if( COD.XPsiz)    opj_free( COD.XPsiz);
+  if( COD.YPsiz)    opj_free( COD.YPsiz);
 }
 
 bool check_JP2boxidx( boxlist_param_t *toplev_boxlist)
@@ -242,7 +242,7 @@ bool check_JP2boxidx( boxlist_param_t *toplev_boxlist)
   if( obh->length != jp2c->length || strncmp( obh->type, "jp2c",4)!=0)
     fprintf( FCGI_stderr, "Reference jp2c header in prxy box not correct\n");
   pos += obh->headlen;
-  free(obh);
+  opj_free(obh);
   
   ni = fetch_DBox1byte( prxy, pos);
   if( ni != 1){
@@ -260,9 +260,9 @@ bool check_JP2boxidx( boxlist_param_t *toplev_boxlist)
   if( ibh->length != cidx->length || strncmp( ibh->type, "cidx",4)!=0)
     fprintf( FCGI_stderr, "Reference cidx header in prxy box not correct\n");
   pos += ibh->headlen;
-  free(ibh);
+  opj_free(ibh);
   
-  free(prxy);
+  opj_free(prxy);
 
   return true;
 }
@@ -333,34 +333,34 @@ bool set_cidxdata( box_param_t *cidx_box, index_param_t *jp2idx)
 
   if( !search_boxheader( "mhix", manf)){
     fprintf( FCGI_stderr, "Error: mhix box not present in manfbox\n");
-    free(jp2idx);
+    opj_free(jp2idx);
     return false;
   }
   set_mainmhixdata( cidx_box, codestream, jp2idx);
 
   if( !search_boxheader( "tpix", manf)){
     fprintf( FCGI_stderr, "Error: tpix box not present in manfbox\n");
-    free(jp2idx);
+    opj_free(jp2idx);
     return false;
   }
   set_tpixdata( cidx_box, jp2idx);
 
   if( !search_boxheader( "thix", manf)){
     fprintf( FCGI_stderr, "Error: thix box not present in manfbox\n");
-    free(jp2idx);
+    opj_free(jp2idx);
     return false;
   }
   set_thixdata( cidx_box, jp2idx);
 
   if( !search_boxheader( "ppix", manf)){
     fprintf( FCGI_stderr, "Error: ppix box not present in manfbox\n");
-    free(jp2idx);
+    opj_free(jp2idx);
     return false;
   }
   set_ppixdata( cidx_box, jp2idx);
 
   delete_manfbox( &manf);
-  free( manf_box);
+  opj_free( manf_box);
 
   return true;
 }
@@ -377,7 +377,7 @@ bool set_cptrdata( box_param_t *cidx_box, index_param_t *jp2idx)
   /* If 0, the codestream or its Fragment Table box exists in the current file*/
   if(( dr = fetch_DBox2bytebigendian( box, 0))){
     fprintf( FCGI_stderr, "Error: Codestream not present in current file\n");
-    free( box);
+    opj_free( box);
     return false;  
   }
   
@@ -386,14 +386,14 @@ bool set_cptrdata( box_param_t *cidx_box, index_param_t *jp2idx)
   /* bytes within its file or resource.*/
   if(( cont = fetch_DBox2bytebigendian( box, 2))){
     fprintf( FCGI_stderr, "Error: Can't cope with fragmented codestreams yet\n");
-    free( box);
+    opj_free( box);
     return false;  
   }
     
   jp2idx->offset = (OPJ_OFF_T)fetch_DBox8bytebigendian( box, 4);
   jp2idx->length = fetch_DBox8bytebigendian( box, 12);
 
-  free( box);
+  opj_free( box);
 
   return true;
 }
@@ -436,7 +436,7 @@ bool set_mainmhixdata( box_param_t *cidx_box, codestream_param_t codestream, ind
   jp2idx->mhead_length = fetch_DBox8bytebigendian( mhix_box, 0);
 
   mhix = gene_mhixbox( mhix_box);
-  free( mhix_box);
+  opj_free( mhix_box);
 
   sizmkidx = search_markeridx( 0xff51, mhix);
   set_SIZmkrdata( sizmkidx, codestream, &(jp2idx->SIZ));
@@ -466,8 +466,8 @@ bool set_tpixdata( box_param_t *cidx_box, index_param_t *jp2idx)
 
   jp2idx->tilepart = gene_faixbox( faix_box);
   
-  free( tpix_box);
-  free( faix_box);
+  opj_free( tpix_box);
+  opj_free( faix_box);
 
   return true;
 }
@@ -489,7 +489,7 @@ bool set_thixdata( box_param_t *cidx_box, index_param_t *jp2idx)
   
   if( !(manf_box = gene_boxbyType( thix_box->fd, get_DBoxoff( thix_box), get_DBoxlen( thix_box), "manf"))){
     fprintf( FCGI_stderr, "Error: manf box not present in thix box\n");
-    free( thix_box);
+    opj_free( thix_box);
     return false;
   }
   
@@ -498,14 +498,14 @@ bool set_thixdata( box_param_t *cidx_box, index_param_t *jp2idx)
   mhixseqoff = manf_box->offset+(OPJ_OFF_T)manf_box->length;
   pos = 0;
   tile_no = 0;
-  jp2idx->tileheader = (mhixbox_param_t **)malloc( jp2idx->SIZ.XTnum*jp2idx->SIZ.YTnum*sizeof(mhixbox_param_t *));
+  jp2idx->tileheader = (mhixbox_param_t **)opj_malloc( jp2idx->SIZ.XTnum*jp2idx->SIZ.YTnum*sizeof(mhixbox_param_t *));
     
   while( ptr){
     if( !(mhix_box = gene_boxbyType( thix_box->fd, mhixseqoff+(OPJ_OFF_T)pos, get_DBoxlen( thix_box)-manf_box->length-pos, "mhix"))){
       fprintf( FCGI_stderr, "Error: mhix box not present in thix box\n");
       delete_manfbox( &manf);
-      free( manf_box);
-      free( thix_box);
+      opj_free( manf_box);
+      opj_free( thix_box);
       return false;
     }
     mhix = gene_mhixbox( mhix_box);
@@ -513,13 +513,13 @@ bool set_thixdata( box_param_t *cidx_box, index_param_t *jp2idx)
     pos += mhix_box->length;
     ptr = ptr->next;
 
-    free( mhix_box);
+    opj_free( mhix_box);
     jp2idx->tileheader[tile_no++] = mhix;
   }
 
   delete_manfbox( &manf);
-  free( manf_box);
-  free( thix_box);
+  opj_free( manf_box);
+  opj_free( thix_box);
 
   return true;
 }
@@ -541,19 +541,19 @@ bool set_ppixdata( box_param_t *cidx_box, index_param_t *jp2idx)
   inbox_offset = get_DBoxoff( ppix_box);
   if( !(manf_box = gene_boxbyType( ppix_box->fd, inbox_offset, get_DBoxlen( ppix_box), "manf"))){
     fprintf( FCGI_stderr, "Error: manf box not present in ppix box\n");
-    free( ppix_box);
+    opj_free( ppix_box);
     return false;
   }
 
-  free( ppix_box);
+  opj_free( ppix_box);
 
   manf = gene_manfbox( manf_box);
   bh = search_boxheader( "faix", manf);
   inbox_offset = manf_box->offset + (OPJ_OFF_T)manf_box->length;
   
-  free( manf_box);
+  opj_free( manf_box);
 
-  jp2idx->precpacket = (faixbox_param_t **)malloc( jp2idx->SIZ.Csiz*sizeof(faixbox_param_t *));
+  jp2idx->precpacket = (faixbox_param_t **)opj_malloc( jp2idx->SIZ.Csiz*sizeof(faixbox_param_t *));
 
   for( comp_idx=0; bh!=NULL; bh=bh->next, comp_idx++){
     if( jp2idx->SIZ.Csiz <= comp_idx ){
@@ -570,7 +570,7 @@ bool set_ppixdata( box_param_t *cidx_box, index_param_t *jp2idx)
     jp2idx->precpacket[comp_idx] = faix;
 
     inbox_offset = faix_box->offset + (OPJ_OFF_T)faix_box->length;
-    free( faix_box);   
+    opj_free( faix_box);   
   }
   
   delete_manfbox( &manf);
@@ -634,8 +634,8 @@ bool set_CODmkrdata( markeridx_param_t *codmkidx, codestream_param_t codestream,
   COD->numOfdecomp = fetch_marker1byte( codmkr, 7);
   
   if(COD->Scod & 0x01){
-    COD->XPsiz = (Byte4_t *)malloc( (OPJ_SIZE_T)(COD->numOfdecomp+1)*sizeof(Byte4_t));
-    COD->YPsiz = (Byte4_t *)malloc( (OPJ_SIZE_T)(COD->numOfdecomp+1)*sizeof(Byte4_t));
+    COD->XPsiz = (Byte4_t *)opj_malloc( (OPJ_SIZE_T)(COD->numOfdecomp+1)*sizeof(Byte4_t));
+    COD->YPsiz = (Byte4_t *)opj_malloc( (OPJ_SIZE_T)(COD->numOfdecomp+1)*sizeof(Byte4_t));
 
     for( i=0; i<=COD->numOfdecomp; i++){
       /*precinct size*/
@@ -644,8 +644,8 @@ bool set_CODmkrdata( markeridx_param_t *codmkidx, codestream_param_t codestream,
     }
   }
   else{
-    COD->XPsiz = (Byte4_t *)malloc( sizeof(Byte4_t));
-    COD->YPsiz = (Byte4_t *)malloc( sizeof(Byte4_t));
+    COD->XPsiz = (Byte4_t *)opj_malloc( sizeof(Byte4_t));
+    COD->YPsiz = (Byte4_t *)opj_malloc( sizeof(Byte4_t));
 
     COD->XPsiz[0] = COD->YPsiz[0] = pow(2,15);
   }
diff --git a/src/lib/openjpip/index_manager.h b/src/lib/openjpip/index_manager.h
index a9f141c8..049f0771 100644
--- a/src/lib/openjpip/index_manager.h
+++ b/src/lib/openjpip/index_manager.h
@@ -31,6 +31,9 @@
 #ifndef   	INDEX_MANAGER_H_
 # define   	INDEX_MANAGER_H_
 
+#include "opj_config.h"
+#include "opj_includes.h"
+
 #include "byte_manager.h"
 #include "faixbox_manager.h"
 #include "metadata_manager.h"
@@ -38,6 +41,7 @@
 #include "bool.h"
 
 /** progression order */
+#if 0
 typedef enum porder {
   PROG_UNKNOWN = -1,      /**< place-holder */
   LRCP = 0,               /**< layer-resolution-component-precinct order */
@@ -46,6 +50,7 @@ typedef enum porder {
   PCRL = 3,               /**< precinct-component-resolution-layer order */
   CPRL = 4                /**< component-precinct-resolution-layer order */
 } porder_t;
+#endif
 
 /** A.5.1 Image and tile size (SIZ)*/
 typedef struct SIZmarker_param{
@@ -71,7 +76,7 @@ typedef struct SIZmarker_param{
 typedef struct CODmarker_param{
   Byte2_t  Lcod;             /**< length of marker segment excluding the marker*/
   Byte_t   Scod;             /**< Coding style for all components*/
-  porder_t prog_order;       /**< progression order*/
+  OPJ_PROG_ORDER prog_order;       /**< progression order*/
   Byte2_t  numOflayers;      /**< number of layers*/
   Byte_t   numOfdecomp;      /**< number of decompositions levels*/
   Byte4_t  *XPsiz;           /**< dynamic array of precinct width  at successive resolution level in order*/
diff --git a/src/lib/openjpip/j2kheader_manager.c b/src/lib/openjpip/j2kheader_manager.c
index 5a6054cc..b61da5ef 100644
--- a/src/lib/openjpip/j2kheader_manager.c
+++ b/src/lib/openjpip/j2kheader_manager.c
@@ -127,8 +127,8 @@ CODmarker_param_t get_CODmkrdata_from_j2kstream( Byte_t *CODstream)
   COD.numOfdecomp = *( CODstream+7);
 
   if(COD.Scod & 0x01){
-    COD.XPsiz = (Byte4_t *)malloc( (OPJ_SIZE_T)(COD.numOfdecomp+1)*sizeof(Byte4_t));
-    COD.YPsiz = (Byte4_t *)malloc( (OPJ_SIZE_T)(COD.numOfdecomp+1)*sizeof(Byte4_t));
+    COD.XPsiz = (Byte4_t *)opj_malloc( (OPJ_SIZE_T)(COD.numOfdecomp+1)*sizeof(Byte4_t));
+    COD.YPsiz = (Byte4_t *)opj_malloc( (OPJ_SIZE_T)(COD.numOfdecomp+1)*sizeof(Byte4_t));
     
     for( i=0; i<=COD.numOfdecomp; i++){
       /*precinct size */
@@ -137,8 +137,8 @@ CODmarker_param_t get_CODmkrdata_from_j2kstream( Byte_t *CODstream)
     }
   }
   else{
-    COD.XPsiz = (Byte4_t *)malloc( sizeof(Byte4_t));
-    COD.YPsiz = (Byte4_t *)malloc( sizeof(Byte4_t));
+    COD.XPsiz = (Byte4_t *)opj_malloc( sizeof(Byte4_t));
+    COD.YPsiz = (Byte4_t *)opj_malloc( sizeof(Byte4_t));
     COD.XPsiz[0] = COD.YPsiz[0] = pow(2,15);
   }
   return COD;
diff --git a/src/lib/openjpip/jp2k_encoder.c b/src/lib/openjpip/jp2k_encoder.c
index 23c8b2fe..9241f713 100644
--- a/src/lib/openjpip/jp2k_encoder.c
+++ b/src/lib/openjpip/jp2k_encoder.c
@@ -122,7 +122,7 @@ Byte_t * recons_jp2( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte8_t csn
   if( jp2cDBoxOffset != 0 && codelen <= jp2cDBoxlen)
     memcpy( jp2stream+jp2cDBoxOffset, codestream, codelen);
 
-  free( codestream);
+  opj_free( codestream);
   
   return jp2stream;
 }
@@ -314,14 +314,14 @@ Byte_t * add_SOTmkr( Byte_t *j2kstream, Byte8_t *j2klen)
   Byte_t *buf;
   const Byte2_t SOT = 0x90ff;
 
-  buf = (Byte_t *)malloc(( *j2klen)+2);
+  buf = (Byte_t *)opj_malloc(( *j2klen)+2);
 
   memcpy( buf, j2kstream, *j2klen);
   memcpy( buf+(*j2klen), &SOT, 2);
   
   *j2klen += 2;
 
-  if(j2kstream) free(j2kstream);
+  if(j2kstream) opj_free(j2kstream);
 
   return buf;
 }
@@ -660,15 +660,15 @@ Byte_t * add_msgstream( message_param_t *message, Byte_t *origstream, Byte_t *j2
 
   newstream = gene_msgstream( message, origstream, &newlen);
 
-  buf = (Byte_t *)malloc(( *j2klen)+newlen);
+  buf = (Byte_t *)opj_malloc(( *j2klen)+newlen);
 
   memcpy( buf, j2kstream, *j2klen);
   memcpy( buf+(*j2klen), newstream, newlen);
   
   *j2klen += newlen;
   
-  free( newstream);
-  if(j2kstream) free(j2kstream);
+  opj_free( newstream);
+  if(j2kstream) opj_free(j2kstream);
 
   return buf;
 }
@@ -685,19 +685,19 @@ Byte_t * add_emptyboxstream( placeholder_param_t *phld, Byte_t *jp2stream, Byte8
   else
     newlen = big8(phld->OrigBH+8);
 
-  newstream = (Byte_t *)malloc( newlen);
+  newstream = (Byte_t *)opj_malloc( newlen);
   memset( newstream, 0, newlen);
   memcpy( newstream, phld->OrigBH, phld->OrigBHlen);
 
-  buf = (Byte_t *)malloc(( *jp2len)+newlen);
+  buf = (Byte_t *)opj_malloc(( *jp2len)+newlen);
 
   memcpy( buf, jp2stream, *jp2len);
   memcpy( buf+(*jp2len), newstream, newlen);
   
   *jp2len += newlen;
   
-  free( newstream);
-  if(jp2stream) free(jp2stream);
+  opj_free( newstream);
+  if(jp2stream) opj_free(jp2stream);
 
   return buf;
 }
@@ -710,15 +710,15 @@ Byte_t * add_emptytilestream( const Byte8_t tileID, Byte_t *j2kstream, Byte8_t *
 
   newstream = gene_emptytilestream( tileID, &newlen);
 
-  buf = (Byte_t *)malloc(( *j2klen)+newlen);
+  buf = (Byte_t *)opj_malloc(( *j2klen)+newlen);
 
   memcpy( buf, j2kstream, *j2klen);
   memcpy( buf+(*j2klen), newstream, newlen);
   
   *j2klen += newlen;
 
-  free( newstream);
-  if(j2kstream) free(j2kstream);
+  opj_free( newstream);
+  if(j2kstream) opj_free(j2kstream);
 
   return buf;
 }
@@ -727,14 +727,14 @@ Byte_t * add_padding( Byte8_t padding, Byte_t *j2kstream, Byte8_t *j2klen)
 {
   Byte_t *buf;
 
-  buf = (Byte_t *)malloc(( *j2klen)+padding);
+  buf = (Byte_t *)opj_malloc(( *j2klen)+padding);
 
   memcpy( buf, j2kstream, *j2klen);
   memset( buf+(*j2klen), 0, padding);
   
   *j2klen += padding;
 
-  if(j2kstream) free(j2kstream);
+  if(j2kstream) opj_free(j2kstream);
 
   return buf;
 }
@@ -745,14 +745,14 @@ Byte_t * add_EOC( Byte_t *j2kstream, Byte8_t *j2klen)
 
   Byte_t *buf;
 
-  buf = (Byte_t *)malloc(( *j2klen)+2);
+  buf = (Byte_t *)opj_malloc(( *j2klen)+2);
 
   memcpy( buf, j2kstream, *j2klen);
   memcpy( buf+(*j2klen), &EOC, 2);
 
   *j2klen += 2;
 
-  if(j2kstream) free(j2kstream);
+  if(j2kstream) opj_free(j2kstream);
 
   return buf;
 }
@@ -765,7 +765,7 @@ Byte_t * gene_msgstream( message_param_t *message, Byte_t *stream, Byte8_t *leng
     return NULL;
 
   *length = message->length;
-  buf = (Byte_t *)malloc( *length);
+  buf = (Byte_t *)opj_malloc( *length);
   memcpy( buf, stream+message->res_offset,  *length);
 
   return buf;
@@ -782,7 +782,7 @@ Byte_t * gene_emptytilestream( const Byte8_t tileID, Byte8_t *length)
   const Byte2_t SOD = 0x93ff;
 
   *length = 14;
-  buf = (Byte_t *)malloc(*length);
+  buf = (Byte_t *)opj_malloc(*length);
 
   Isot = (Byte2_t)((((Byte2_t)tileID) << 8) | ((((Byte2_t)tileID) & 0xf0) >> 8));
   
diff --git a/src/lib/openjpip/jpipstream_manager.c b/src/lib/openjpip/jpipstream_manager.c
index 8cb2a77f..3227af75 100644
--- a/src/lib/openjpip/jpipstream_manager.c
+++ b/src/lib/openjpip/jpipstream_manager.c
@@ -40,14 +40,14 @@
 
 Byte_t * update_JPIPstream( Byte_t *newstream, OPJ_SIZE_T newstreamlen, Byte_t *cache_stream, OPJ_SIZE_T *streamlen)
 {
-  Byte_t *stream = (Byte_t *)malloc( (*streamlen)+newstreamlen);
+  Byte_t *stream = (Byte_t *)opj_malloc( (*streamlen)+newstreamlen);
   if( *streamlen > 0)
     memcpy( stream, cache_stream, *streamlen);
   memcpy( stream+(*streamlen), newstream, newstreamlen);
   *streamlen += newstreamlen;
 
   if(cache_stream)
-    free( cache_stream);
+    opj_free( cache_stream);
   
   return stream;
 }
@@ -83,7 +83,7 @@ Byte_t * jpipstream_to_pnm( Byte_t *jpipstream, msgqueue_param_t *msgqueue, Byte
 
   fp = fopen( j2kfname, "w+b");
   fwrite( j2kstream, j2klen, 1, fp);
-  free( j2kstream);
+  opj_free( j2kstream);
   fseek( fp, 0, SEEK_SET);
 
   pnmstream = j2k_to_pnm( fp, ihdrbox);
@@ -103,18 +103,18 @@ ihdrbox_param_t * get_SIZ_from_jpipstream( Byte_t *jpipstream, msgqueue_param_t
 
   j2kstream = recons_j2kmainhead( msgqueue, jpipstream, csn, &j2klen);
   if( !get_mainheader_from_j2kstream( j2kstream, &SIZ, NULL)){
-    free( j2kstream);
+    opj_free( j2kstream);
     return NULL;
   }
 
-  ihdrbox = (ihdrbox_param_t *)malloc( sizeof(ihdrbox_param_t));
+  ihdrbox = (ihdrbox_param_t *)opj_malloc( sizeof(ihdrbox_param_t));
 
   ihdrbox->width = SIZ.Xsiz;
   ihdrbox->height = SIZ.Ysiz;
   ihdrbox->nc = SIZ.Csiz;
   ihdrbox->bpc = SIZ.Ssiz[0];
   
-  free( j2kstream);
+  opj_free( j2kstream);
 
   return ihdrbox;
 }
diff --git a/src/lib/openjpip/msgqueue_manager.c b/src/lib/openjpip/msgqueue_manager.c
index 31d3991f..1bc498a6 100644
--- a/src/lib/openjpip/msgqueue_manager.c
+++ b/src/lib/openjpip/msgqueue_manager.c
@@ -60,7 +60,7 @@ msgqueue_param_t * gene_msgqueue( bool stateless, cachemodel_param_t *cachemodel
 {
   msgqueue_param_t *msgqueue;
 
-  msgqueue = (msgqueue_param_t *)malloc( sizeof(msgqueue_param_t));
+  msgqueue = (msgqueue_param_t *)opj_malloc( sizeof(msgqueue_param_t));
 
   msgqueue->first = NULL;
   msgqueue->last  = NULL;
@@ -82,13 +82,13 @@ void delete_msgqueue( msgqueue_param_t **msgqueue)
 
   while( ptr){
     next = ptr->next;
-    free( ptr);
+    opj_free( ptr);
     ptr = next;
   }
   if( (*msgqueue)->stateless && (*msgqueue)->cachemodel)
     delete_cachemodel( &((*msgqueue)->cachemodel));
 
-  free(*msgqueue); 
+  opj_free(*msgqueue); 
 }
 
 void print_msgqueue( msgqueue_param_t *msgqueue)
@@ -135,7 +135,7 @@ void enqueue_mainheader( msgqueue_param_t *msgqueue)
   target = cachemodel->target;
   codeidx = target->codeidx;
   
-  msg = (message_param_t *)malloc( sizeof(message_param_t));
+  msg = (message_param_t *)opj_malloc( sizeof(message_param_t));
 
   msg->last_byte = true;
   msg->in_class_id = 0;
@@ -166,7 +166,7 @@ void enqueue_tileheader( int tile_id, msgqueue_param_t *msgqueue)
   codeidx = target->codeidx;
 
   if( !cachemodel->th_model[ tile_id]){
-    msg = (message_param_t *)malloc( sizeof(message_param_t));
+    msg = (message_param_t *)opj_malloc( sizeof(message_param_t));
     msg->last_byte = true;
     assert( tile_id >= 0 );
     msg->in_class_id = (Byte8_t)tile_id;
@@ -220,7 +220,7 @@ void enqueue_tile( Byte4_t tile_id, int level, msgqueue_param_t *msgqueue)
     binLength = get_elemLen( tilepart, i, tile_id);
     
     if( !tp_model[i]){
-      msg = (message_param_t *)malloc( sizeof(message_param_t));
+      msg = (message_param_t *)opj_malloc( sizeof(message_param_t));
       
       msg->last_byte = (i==numOftparts-1);
       msg->in_class_id = tile_id;
@@ -269,7 +269,7 @@ void enqueue_precinct( int seq_id, int tile_id, int comp_id, int layers, msgqueu
     
     if( !cachemodel->pp_model[comp_id][tile_id*(int)nmax+seq_id*numOflayers+layer_id]){
   
-      msg = (message_param_t *)malloc( sizeof(message_param_t));
+      msg = (message_param_t *)opj_malloc( sizeof(message_param_t));
       msg->last_byte = (layer_id == (numOflayers-1));
       msg->in_class_id = comp_precinct_id( tile_id, comp_id, seq_id, codeidx->SIZ.Csiz, (int)codeidx->SIZ.XTnum * (int) codeidx->SIZ.YTnum);
       msg->class_id = PRECINCT_MSG;
@@ -376,7 +376,7 @@ message_param_t * gene_metamsg( Byte8_t meta_id, Byte8_t binOffset, Byte8_t leng
 {
   message_param_t *msg;
 
-  msg = (message_param_t *)malloc( sizeof(message_param_t));
+  msg = (message_param_t *)opj_malloc( sizeof(message_param_t));
     
   msg->last_byte = false;
   msg->in_class_id = meta_id;
@@ -521,11 +521,11 @@ void add_body_stream( message_param_t *msg, int fd, int tmpfd)
   }
 
   if( write( tmpfd, data, msg->length) < 1){
-    free( data);
+    opj_free( data);
     fprintf( FCGI_stderr, "Error: fwrite in add_body_stream()\n");
     return;
   }
-  free(data);
+  opj_free(data);
 }
 
 void add_bigendian_bytestream( Byte8_t code, int bytelength, int tmpfd);
@@ -596,7 +596,7 @@ void parse_JPIPstream( Byte_t *JPIPstream, Byte8_t streamlen, OPJ_OFF_T offset,
   csn = (Byte8_t)-1;
   ptr = JPIPstream;
   while( (Byte8_t)(ptr-JPIPstream) < streamlen){
-    msg = (message_param_t *)malloc( sizeof(message_param_t));
+    msg = (message_param_t *)opj_malloc( sizeof(message_param_t));
     
     ptr = parse_bin_id_vbas( ptr, &bb, &c, &msg->in_class_id);
     
@@ -689,14 +689,14 @@ placeholder_param_t * parse_phld( Byte_t *datastream, Byte8_t metalength)
 {
   placeholder_param_t *phld;
 
-  phld = (placeholder_param_t *)malloc( sizeof(placeholder_param_t));
+  phld = (placeholder_param_t *)opj_malloc( sizeof(placeholder_param_t));
   
   phld->LBox = big4( datastream);
   strcpy( phld->TBox, "phld");
   phld->Flags = big4( datastream+8);
   phld->OrigID = big8( datastream+12);
   phld->OrigBHlen = (Byte_t)(metalength - 20);
-  phld->OrigBH = (Byte_t *)malloc(phld->OrigBHlen);
+  phld->OrigBH = (Byte_t *)opj_malloc(phld->OrigBHlen);
   memcpy( phld->OrigBH, datastream+20, phld->OrigBHlen);
   phld->next = NULL;
 
@@ -758,5 +758,5 @@ void delete_message_in_msgqueue( message_param_t **msg, msgqueue_param_t *msgque
     if( *msg == msgqueue->last)
       msgqueue->last = ptr;
   }
-  free( *msg);
+  opj_free( *msg);
 }
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*/
diff --git a/src/lib/openjpip/openjpip.h b/src/lib/openjpip/openjpip.h
index c08c3d86..5255ab9c 100644
--- a/src/lib/openjpip/openjpip.h
+++ b/src/lib/openjpip/openjpip.h
@@ -303,6 +303,8 @@ void destroy_index( index_t **idx);
  */
 void output_index( index_t *index);
 
+OPJ_API opj_codec_t* OPJ_CALLCONV opj_jpip_create_compress(OPJ_CODEC_FORMAT format);
+
 #endif /*SERVER*/
 
 #endif /* !OPENJPIP_H_ */
diff --git a/src/lib/openjpip/phix_manager.c b/src/lib/openjpip/phix_manager.c
index 0e2e5704..c37ba007 100644
--- a/src/lib/openjpip/phix_manager.c
+++ b/src/lib/openjpip/phix_manager.c
@@ -81,6 +81,60 @@ int write_phix( int coff, opj_codestream_info_t cstr_info, opj_bool EPHused, int
   return len;
 }
 
+int write_phix_v2( int coff, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_stream_private_t *cio,
+              opj_event_mgr_t * p_manager )
+{
+  OPJ_BYTE l_data_header [8];
+  int len, lenp=0, compno, i;
+  opj_jp2_box_t *box;
+
+  box = (opj_jp2_box_t *)opj_calloc( cstr_info.numcomps, sizeof(opj_jp2_box_t));
+  
+  for( i=0;i<2;i++){
+    if (i)
+#if 0
+      cio_seek( cio, lenp);
+#else
+      opj_stream_seek( cio, lenp, p_manager);
+#endif
+      
+#if 0
+    lenp = cio_tell( cio);
+    cio_skip( cio, 4);              /* L [at the end] */
+    cio_write( cio, JPIP_PHIX, 4);  /* PHIX           */
+#else
+    lenp = opj_stream_tell(cio);
+    opj_stream_skip(cio, 4, p_manager);         /* L [at the end]      */
+    opj_write_bytes(l_data_header,JPIP_PHIX,4); /* PHIX */
+    opj_stream_write_data(cio,l_data_header,4,p_manager);
+#endif
+      
+    write_manf_v2( i, cstr_info.numcomps, box, cio);
+
+    for( compno=0; compno<cstr_info.numcomps; compno++){       
+      box[compno].length = write_phixfaix_v2( coff, compno, cstr_info, EPHused, j2klen, cio);
+      box[compno].type = JPIP_FAIX;
+    }
+
+#if 0
+    len = cio_tell( cio)-lenp;
+    cio_seek( cio, lenp);
+    cio_write( cio, len, 4);        /* L              */
+    cio_seek( cio, lenp+len);
+#else
+    lenp = opj_stream_tell(cio);
+    opj_stream_seek(cio, 4, 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
+  }
+
+  opj_free(box);
+
+  return len;
+}
+
 int write_phixfaix( int coff, int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
 {
   int len, lenp, tileno, version, i, nmax, size_of_coding; /* 4 or 8 */
@@ -167,3 +221,130 @@ int write_phixfaix( int coff, int compno, opj_codestream_info_t cstr_info, opj_b
 
   return len;
 }
+
+int write_phixfaix_v2( int coff, int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_stream_private_t *cio,
+              opj_event_mgr_t * p_manager )
+{
+  int len, lenp, tileno, version, i, nmax, size_of_coding; /* 4 or 8 */
+  opj_tile_info_t *tile_Idx;
+  opj_packet_info_t packet;
+  int resno, precno, layno, num_packet;
+  int numOfres, numOfprec, numOflayers;
+  OPJ_BYTE l_data_header [8];
+  packet.end_ph_pos = packet.start_pos = -1;
+  (void)EPHused; /* unused ? */
+
+  if( j2klen > pow( 2, 32)){
+    size_of_coding =  8;
+    version = 1;
+  }
+  else{
+    size_of_coding = 4;
+    version = 0;
+  }
+
+#if 0
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end]      */
+  cio_write( cio, JPIP_FAIX, 4);  /* FAIX                */ 
+  cio_write( cio, version,1);     /* Version 0 = 4 bytes */
+#else
+  lenp = opj_stream_tell(cio);
+  opj_stream_skip(cio, 4, p_manager);         /* L [at the end]      */
+  opj_write_bytes(l_data_header,JPIP_FAIX,4); /* FAIX */
+  opj_stream_write_data(cio,l_data_header,4,p_manager);
+  opj_write_bytes(l_data_header,version,1);   /* Version 0 = 4 bytes */
+  opj_stream_write_data(cio,l_data_header,1,p_manager);
+#endif
+
+  nmax = 0;
+  for( i=0; i<=cstr_info.numdecompos[compno]; i++)
+    nmax += cstr_info.tile[0].ph[i] * cstr_info.tile[0].pw[i] * cstr_info.numlayers;
+  
+#if 0
+  cio_write( cio, nmax, size_of_coding); /* NMAX */
+  cio_write( cio, cstr_info.tw*cstr_info.th, size_of_coding);      /* M    */
+#else
+  opj_write_bytes(l_data_header,nmax,size_of_coding);         /* NMAX           */
+  opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+  opj_write_bytes(l_data_header,cstr_info.tw*cstr_info.th,size_of_coding);  /* M              */
+  opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+#endif
+  
+  for( tileno=0; tileno<cstr_info.tw*cstr_info.th; tileno++){
+    tile_Idx = &cstr_info.tile[ tileno];
+    
+    num_packet = 0;
+    numOfres = cstr_info.numdecompos[compno] + 1;
+
+    for( resno=0; resno<numOfres ; resno++){
+      numOfprec = tile_Idx->pw[resno]*tile_Idx->ph[resno];
+      for( precno=0; precno<numOfprec; precno++){
+	numOflayers = cstr_info.numlayers;
+	for( layno=0; layno<numOflayers; layno++){
+	  
+	  switch ( cstr_info.prog){
+	  case LRCP:
+	    packet = tile_Idx->packet[ ((layno*numOfres+resno)*cstr_info.numcomps+compno)*numOfprec+precno];
+	    break;
+	  case RLCP:
+	    packet = tile_Idx->packet[ ((resno*numOflayers+layno)*cstr_info.numcomps+compno)*numOfprec+precno];
+	    break;
+	  case RPCL:
+	    packet = tile_Idx->packet[ ((resno*numOfprec+precno)*cstr_info.numcomps+compno)*numOflayers+layno];
+	    break;
+	  case PCRL:
+	    packet = tile_Idx->packet[ ((precno*cstr_info.numcomps+compno)*numOfres+resno)*numOflayers + layno];
+	    break;
+	  case CPRL:
+	    packet = tile_Idx->packet[ ((compno*numOfprec+precno)*numOfres+resno)*numOflayers + layno];
+	    break;
+	  default:
+	    fprintf( stderr, "failed to ppix indexing\n");
+	  }
+
+#if 0
+	  cio_write( cio, packet.start_pos-coff, size_of_coding);                /* start position */
+	  cio_write( cio, packet.end_ph_pos-packet.start_pos+1, size_of_coding); /* length         */
+#else
+    opj_write_bytes(l_data_header,packet.start_pos-coff,size_of_coding);            /* start position */
+    opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+    opj_write_bytes(l_data_header,packet.end_ph_pos-packet.start_pos+1,size_of_coding); /* length         */
+    opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+#endif
+	  
+	  num_packet++;
+	}
+      }
+    }
+
+    /* PADDING */
+    while( num_packet < nmax){
+#if 0
+      cio_write( cio, 0, size_of_coding); /* start position            */
+      cio_write( cio, 0, size_of_coding); /* length                    */
+#else
+      opj_write_bytes(l_data_header,0,size_of_coding);/* start position            */
+      opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+      opj_write_bytes(l_data_header,0,size_of_coding);/* length                    */
+      opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+#endif
+      num_packet++;
+    }
+  }
+
+#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_seek(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;
+}
diff --git a/src/lib/openjpip/ppix_manager.c b/src/lib/openjpip/ppix_manager.c
index 5afbbfd7..6eb70bcc 100644
--- a/src/lib/openjpip/ppix_manager.c
+++ b/src/lib/openjpip/ppix_manager.c
@@ -83,6 +83,63 @@ int write_ppix( int coff, opj_codestream_info_t cstr_info, opj_bool EPHused, int
   return len;
 }
 
+int write_ppix_v2( int coff, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_stream_private_t *cio,
+              opj_event_mgr_t * p_manager )
+{
+  OPJ_BYTE l_data_header [4];
+  int len, lenp, compno, i;
+  opj_jp2_box_t *box;
+
+  /*  printf("cstr_info.packno %d\n", cstr_info.packno); //NMAX? */
+
+  lenp = -1;
+  box = (opj_jp2_box_t *)opj_calloc( cstr_info.numcomps, sizeof(opj_jp2_box_t));
+  
+  for (i=0;i<2;i++){
+    if (i)
+#if 0
+      cio_seek( cio, lenp);
+#else
+      opj_stream_seek( cio, lenp, p_manager);
+#endif
+    
+#if 0
+    lenp = cio_tell( cio);
+    cio_skip( cio, 4);              /* L [at the end] */
+    cio_write( cio, JPIP_PPIX, 4);  /* PPIX           */
+#else
+    lenp = opj_stream_tell(cio);
+    opj_stream_skip( cio, 4, p_manager);       /* L [at the end] */
+    opj_write_bytes(l_data_header,JPIP_PPIX,4);/* PPIX           */
+    opj_stream_write_data(cio,l_data_header,4,p_manager);
+#endif
+
+    write_manf_v2( i, cstr_info.numcomps, box, cio);
+    
+    for (compno=0; compno<cstr_info.numcomps; compno++){
+      box[compno].length = write_ppixfaix_v2( coff, compno, cstr_info, EPHused, j2klen, cio);
+      box[compno].type = JPIP_FAIX;
+    }
+   
+#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_seek(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
+  }
+  
+  opj_free(box);
+
+  return len;
+}
+
 int write_ppixfaix( int coff, int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
 {
   int len, lenp, tileno, version, i, nmax, size_of_coding; /* 4 or 8*/
@@ -168,3 +225,128 @@ int write_ppixfaix( int coff, int compno, opj_codestream_info_t cstr_info, opj_b
 
   return len;
 }
+
+int write_ppixfaix_v2( int coff, int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_stream_private_t *cio,
+              opj_event_mgr_t * p_manager )
+{
+  OPJ_BYTE l_data_header [8];
+  int len, lenp, tileno, version, i, nmax, size_of_coding; /* 4 or 8*/
+  opj_tile_info_t *tile_Idx;
+  opj_packet_info_t packet;
+  int resno, precno, layno, num_packet;
+  int numOfres, numOfprec, numOflayers;
+  packet.end_pos = packet.end_ph_pos = packet.start_pos = -1;
+  (void)EPHused; /* unused ? */
+
+  if( j2klen > pow( 2, 32)){
+    size_of_coding =  8;
+    version = 1;
+  }
+  else{
+    size_of_coding = 4;
+    version = 0;
+  }
+  
+#if 0
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end]      */
+  cio_write( cio, JPIP_FAIX, 4);  /* FAIX                */ 
+  cio_write( cio, version, 1);     /* Version 0 = 4 bytes */
+#else
+  lenp = opj_stream_tell(cio);
+  opj_stream_skip(cio, 4, p_manager);         /* L [at the end]      */
+  opj_write_bytes(l_data_header,JPIP_FAIX,4); /* FAIX */
+  opj_write_bytes(l_data_header,version,1);
+  opj_stream_write_data(cio,l_data_header,1,p_manager);/* Version 0 = 4 bytes */
+#endif
+
+  nmax = 0;
+  for( i=0; i<=cstr_info.numdecompos[compno]; i++)
+    nmax += cstr_info.tile[0].ph[i] * cstr_info.tile[0].pw[i] * cstr_info.numlayers;
+  
+#if 0
+  cio_write( cio, nmax, size_of_coding); /* NMAX */
+  cio_write( cio, cstr_info.tw*cstr_info.th, size_of_coding);      /* M    */
+#else
+  opj_write_bytes(l_data_header,nmax,size_of_coding);         /* NMAX           */
+  opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+  opj_write_bytes(l_data_header,cstr_info.tw*cstr_info.th,size_of_coding);  /* M              */
+  opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+#endif
+
+  for( tileno=0; tileno<cstr_info.tw*cstr_info.th; tileno++){
+    tile_Idx = &cstr_info.tile[ tileno];
+ 
+    num_packet=0;
+    numOfres = cstr_info.numdecompos[compno] + 1;
+  
+    for( resno=0; resno<numOfres ; resno++){
+      numOfprec = tile_Idx->pw[resno]*tile_Idx->ph[resno];
+      for( precno=0; precno<numOfprec; precno++){
+	numOflayers = cstr_info.numlayers;
+	for( layno=0; layno<numOflayers; layno++){
+
+	  switch ( cstr_info.prog){
+	  case LRCP:
+	    packet = tile_Idx->packet[ ((layno*numOfres+resno)*cstr_info.numcomps+compno)*numOfprec+precno];
+	    break;
+	  case RLCP:
+	    packet = tile_Idx->packet[ ((resno*numOflayers+layno)*cstr_info.numcomps+compno)*numOfprec+precno];
+	    break;
+	  case RPCL:
+	    packet = tile_Idx->packet[ ((resno*numOfprec+precno)*cstr_info.numcomps+compno)*numOflayers+layno];
+	    break;
+	  case PCRL:
+	    packet = tile_Idx->packet[ ((precno*cstr_info.numcomps+compno)*numOfres+resno)*numOflayers + layno];
+	    break;
+	  case CPRL:
+	    packet = tile_Idx->packet[ ((compno*numOfprec+precno)*numOfres+resno)*numOflayers + layno];
+	    break;
+	  default:
+	    fprintf( stderr, "failed to ppix indexing\n");
+	  }
+
+#if 0
+	  cio_write( cio, packet.start_pos-coff, size_of_coding);             /* start position */
+	  cio_write( cio, packet.end_pos-packet.start_pos+1, size_of_coding); /* length         */
+#else
+    opj_write_bytes(l_data_header,packet.start_pos-coff,size_of_coding);            /* start position */
+    opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+    opj_write_bytes(l_data_header,packet.end_pos-packet.start_pos+1,size_of_coding); /* length         */
+    opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+#endif
+	  
+	  num_packet++;
+	}
+      }
+    }
+  
+    while( num_packet < nmax){     /* PADDING */
+#if 0
+      cio_write( cio, 0, size_of_coding); /* start position            */
+      cio_write( cio, 0, size_of_coding); /* length                    */
+#else
+      opj_write_bytes(l_data_header,0,size_of_coding);/* start position            */
+      opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+      opj_write_bytes(l_data_header,0,size_of_coding);/* length                    */
+      opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+#endif
+      num_packet++;
+    }   
+  }
+
+#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_seek(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;
+}
diff --git a/src/lib/openjpip/session_manager.c b/src/lib/openjpip/session_manager.c
index 5d9dd73e..24b1d0ce 100644
--- a/src/lib/openjpip/session_manager.c
+++ b/src/lib/openjpip/session_manager.c
@@ -48,7 +48,7 @@ sessionlist_param_t * gene_sessionlist(void)
 {
   sessionlist_param_t *sessionlist;
 
-  sessionlist = (sessionlist_param_t *)malloc( sizeof(sessionlist_param_t));
+  sessionlist = (sessionlist_param_t *)opj_malloc( sizeof(sessionlist_param_t));
   
   sessionlist->first = NULL;
   sessionlist->last  = NULL;
@@ -60,7 +60,7 @@ session_param_t * gene_session( sessionlist_param_t *sessionlist)
 {
   session_param_t *session;
   
-  session = (session_param_t *)malloc( sizeof(session_param_t));
+  session = (session_param_t *)opj_malloc( sizeof(session_param_t));
 
   session->channellist = gene_channellist();
   session->cachemodellist = gene_cachemodellist();
@@ -144,7 +144,7 @@ bool delete_session( session_param_t **session, sessionlist_param_t *sessionlist
 #ifndef SERVER
   fprintf( logstream, "local log: session: %p deleted!\n", (void *)(*session));
 #endif
-  free( *session);
+  opj_free( *session);
 
   return true;
 }
@@ -163,7 +163,7 @@ void delete_sessionlist( sessionlist_param_t **sessionlist)
 #ifndef SERVER
     fprintf( logstream, "local log: session: %p deleted!\n", (void *)sessionPtr);
 #endif
-    free( sessionPtr);
+    opj_free( sessionPtr);
 
     sessionPtr=sessionNext;
   }
@@ -171,7 +171,7 @@ void delete_sessionlist( sessionlist_param_t **sessionlist)
   (*sessionlist)->first = NULL;
   (*sessionlist)->last  = NULL;
 
-  free(*sessionlist);
+  opj_free(*sessionlist);
 }
 
 void print_allsession( sessionlist_param_t *sessionlist)
diff --git a/src/lib/openjpip/target_manager.c b/src/lib/openjpip/target_manager.c
index 72d2f564..92fb93cf 100644
--- a/src/lib/openjpip/target_manager.c
+++ b/src/lib/openjpip/target_manager.c
@@ -58,7 +58,7 @@ targetlist_param_t * gene_targetlist(void)
 {
   targetlist_param_t *targetlist;
 
-  targetlist = (targetlist_param_t *)malloc( sizeof(targetlist_param_t));
+  targetlist = (targetlist_param_t *)opj_malloc( sizeof(targetlist_param_t));
   
   targetlist->first = NULL;
   targetlist->last  = NULL;
@@ -99,7 +99,7 @@ target_param_t * gene_target( targetlist_param_t *targetlist, char *targetpath)
     return NULL;
   }
 
-  target = (target_param_t *)malloc( sizeof(target_param_t));
+  target = (target_param_t *)opj_malloc( sizeof(target_param_t));
   snprintf( target->tid, MAX_LENOFTID, "%x-%x", (unsigned int)time(NULL), (unsigned int)rand());
   target->targetname = strdup( targetpath); 
   target->fd = fd;
@@ -158,9 +158,9 @@ void delete_target( target_param_t **target)
   fprintf( logstream, "local log: target: %s deleted\n", (*target)->targetname);
 #endif
 
-  free( (*target)->targetname);
+  opj_free( (*target)->targetname);
 
-  free(*target);
+  opj_free(*target);
 }
 
 void delete_target_in_list( target_param_t **target, targetlist_param_t *targetlist)
@@ -193,7 +193,7 @@ void delete_targetlist(targetlist_param_t **targetlist)
     delete_target( &targetPtr);
     targetPtr=targetNext;
   }
-  free( *targetlist);
+  opj_free( *targetlist);
 }
 
 void print_target( target_param_t *target)
@@ -274,10 +274,10 @@ int open_jp2file( const char filepath[], char tmpfname[])
     return -1;
   }
   
-  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);
     close(fd);
     fprintf( FCGI_stdout, "Reason: Target %s broken (read error)\r\n", filepath);
     return -1;
@@ -285,13 +285,13 @@ int open_jp2file( const char filepath[], char tmpfname[])
     
   if( *data || *(data + 1) || *(data + 2) ||
       *(data + 3) != 12 || strncmp (data + 4, "jP  \r\n\x87\n", 8)){
-    free( data);
+    opj_free( data);
     close(fd);
     fprintf( FCGI_stdout, "Reason: No JPEG 2000 Signature box in target %s\r\n", filepath);
     return -1;
   } 
 
-  free( data);
+  opj_free( data);
 
   return fd;
 }
diff --git a/src/lib/openjpip/thix_manager.c b/src/lib/openjpip/thix_manager.c
index 38054886..a7d71a7a 100644
--- a/src/lib/openjpip/thix_manager.c
+++ b/src/lib/openjpip/thix_manager.c
@@ -80,6 +80,61 @@ int write_thix( int coff, opj_codestream_info_t cstr_info, opj_cio_t *cio)
   return len;
 }
 
+int write_thix_v2( int coff, opj_codestream_info_t cstr_info, opj_stream_private_t *cio,
+              opj_event_mgr_t * p_manager )
+{
+  OPJ_BYTE l_data_header [4];
+  int len, lenp, i;
+  int tileno;
+  opj_jp2_box_t *box;
+
+  lenp = 0;
+  box = (opj_jp2_box_t *)opj_calloc( cstr_info.tw*cstr_info.th, sizeof(opj_jp2_box_t));
+
+  for ( i = 0; i < 2 ; i++ ){
+    if (i)
+#if 0
+      cio_seek( cio, lenp);
+#else
+      opj_stream_seek( cio, lenp, p_manager);
+#endif
+
+#if 0
+    lenp = cio_tell( cio);
+    cio_skip( cio, 4);              /* L [at the end] */
+    cio_write( cio, JPIP_THIX, 4);  /* THIX           */
+#else
+    lenp = opj_stream_tell(cio);
+    opj_stream_skip(cio, 4, p_manager);             /* L [at the end] */
+    opj_write_bytes(l_data_header,JPIP_THIX,4); /* THIX */
+    opj_stream_write_data(cio,l_data_header,4,p_manager);
+#endif
+    write_manf_v2( i, cstr_info.tw*cstr_info.th, box, cio);
+    
+    for (tileno = 0; tileno < cstr_info.tw*cstr_info.th; tileno++){
+      box[tileno].length = write_tilemhix_v2( coff, cstr_info, tileno, cio);
+      box[tileno].type = JPIP_MHIX;
+    }
+ 
+#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_seek(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
+  }
+
+  opj_free(box);
+
+  return len;
+}
+
 int write_tilemhix( int coff, opj_codestream_info_t cstr_info, int tileno, opj_cio_t *cio)
 {
   int i;
@@ -116,3 +171,72 @@ int write_tilemhix( int coff, opj_codestream_info_t cstr_info, int tileno, opj_c
 
   return len;
 }
+
+int write_tilemhix_v2( int coff, opj_codestream_info_t cstr_info, int tileno, opj_stream_private_t *cio,
+              opj_event_mgr_t * p_manager )
+{
+  OPJ_BYTE l_data_header [8];
+  int i;
+  opj_tile_info_t tile;
+  opj_tp_info_t tp;
+  int marknum;
+  int len, lenp;
+  opj_marker_info_t *marker;
+
+#if 0
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);                               /* L [at the end]                    */
+  cio_write( cio, JPIP_MHIX, 4);                   /* MHIX                              */
+#else
+  lenp = opj_stream_tell (cio);
+  opj_stream_skip(cio, 4, p_manager);               /* L [at the end]                    */
+  opj_write_bytes(l_data_header,JPIP_MHIX,4);       /* MHIX                              */
+  opj_stream_write_data(cio,l_data_header,4,p_manager);
+#endif
+
+  tile = cstr_info.tile[tileno];
+  tp = tile.tp[0];
+
+#if 0
+  cio_write( cio, tp.tp_end_header-tp.tp_start_pos+1, 8);  /* TLEN                              */ 
+#else
+  opj_write_bytes(l_data_header,tp.tp_end_header-tp.tp_start_pos+1, 8);        /* TLEN                              */
+  opj_stream_write_data(cio,l_data_header,8,p_manager);
+#endif
+
+  marker = cstr_info.tile[tileno].marker;
+
+  for( i=0; i<cstr_info.tile[tileno].marknum; i++){             /* Marker restricted to 1 apparition */
+#if 0
+    cio_write( cio, marker[i].type, 2);
+    cio_write( cio, 0, 2);
+    cio_write( cio, marker[i].pos-coff, 8);
+    cio_write( cio, marker[i].len, 2);
+#else
+    opj_write_bytes( l_data_header, marker[i].type, 2);
+    opj_write_bytes( l_data_header+2, 0, 2);
+    opj_stream_write_data(cio,l_data_header,4,p_manager);
+    opj_write_bytes( l_data_header, marker[i].pos-coff, 8);
+    opj_stream_write_data(cio,l_data_header,8,p_manager);
+    opj_write_bytes( l_data_header, marker[i].len, 2);
+    opj_stream_write_data(cio,l_data_header,2,p_manager);
+#endif
+  }
+     
+  /*  free( marker);*/
+
+#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_seek(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;
+}
diff --git a/src/lib/openjpip/tpix_manager.c b/src/lib/openjpip/tpix_manager.c
index 6cc49c73..0c58a329 100644
--- a/src/lib/openjpip/tpix_manager.c
+++ b/src/lib/openjpip/tpix_manager.c
@@ -68,6 +68,39 @@ int write_tpix( int coff, opj_codestream_info_t cstr_info, int j2klen, opj_cio_t
   return len;
 }
 
+int write_tpix_v2( int coff, opj_codestream_info_t cstr_info, int j2klen, 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_TPIX, 4);  /* TPIX           */
+#else
+  lenp = opj_stream_tell(cio);
+  opj_stream_skip(cio, 4, p_manager);
+  opj_write_bytes(l_data_header,JPIP_TPIX,4); /* TPIX */
+  opj_stream_write_data(cio,l_data_header,4,p_manager);
+#endif
+  
+  write_tpixfaix_v2( coff, 0, cstr_info, j2klen, 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;
+}
 
 /* 
  * Get number of maximum tile parts per tile
@@ -111,14 +144,14 @@ int write_tpixfaix( int coff, int compno, opj_codestream_info_t cstr_info, int j
       cio_write( cio, tp.tp_start_pos-coff, size_of_coding); /* start position */
       cio_write( cio, tp.tp_end_pos-tp.tp_start_pos+1, size_of_coding);    /* length         */
       if (version & 0x02){
-	if( cstr_info.tile[i].num_tps == 1 && cstr_info.numdecompos[compno] > 1)
-	  Aux = cstr_info.numdecompos[compno] + 1;
-	else
-	  Aux = j + 1;
-		  
-	cio_write( cio, Aux,4);
-	/*cio_write(img.tile[i].tile_parts[j].num_reso_AUX,4);*/ /* Aux_i,j : Auxiliary value */
-	/* fprintf(stderr,"AUX value %d\n",Aux);*/
+  if( cstr_info.tile[i].num_tps == 1 && cstr_info.numdecompos[compno] > 1)
+    Aux = cstr_info.numdecompos[compno] + 1;
+  else
+    Aux = j + 1;
+      
+  cio_write( cio, Aux,4);
+  /*cio_write(img.tile[i].tile_parts[j].num_reso_AUX,4);*/ /* Aux_i,j : Auxiliary value */
+  /* fprintf(stderr,"AUX value %d\n",Aux);*/
       }
       /*cio_write(0,4);*/
     }
@@ -127,7 +160,7 @@ int write_tpixfaix( int coff, int compno, opj_codestream_info_t cstr_info, int j
       cio_write( cio, 0, size_of_coding); /* start position            */
       cio_write( cio, 0, size_of_coding); /* length                    */
       if (version & 0x02)
-	cio_write( cio, 0,4);                  /* Aux_i,j : Auxiliary value */
+  cio_write( cio, 0,4);                  /* Aux_i,j : Auxiliary value */
       j++;
     }
   }
@@ -141,6 +174,123 @@ int write_tpixfaix( int coff, int compno, opj_codestream_info_t cstr_info, int j
 
 }
 
+int write_tpixfaix_v2( int coff, int compno, opj_codestream_info_t cstr_info, int j2klen, opj_stream_private_t *cio,
+              opj_event_mgr_t * p_manager )
+{
+  int len, lenp;
+  int i, j;
+  int Aux;
+  int num_max_tile_parts;
+  int size_of_coding; /* 4 or 8 */
+  opj_tp_info_t tp;
+  OPJ_BYTE l_data_header [8];
+  int version;
+
+  num_max_tile_parts = get_num_max_tile_parts( cstr_info);
+
+  if( j2klen > pow( 2, 32)){
+    size_of_coding =  8;
+    version = num_max_tile_parts == 1 ? 1:3;
+  }
+  else{
+    size_of_coding = 4;
+    version = num_max_tile_parts == 1 ? 0:2;
+  }
+
+#if 0
+  lenp = cio_tell( cio);
+  cio_skip( cio, 4);              /* L [at the end]      */
+  cio_write( cio, JPIP_FAIX, 4);  /* FAIX                */ 
+  cio_write( cio, version, 1);     /* Version 0 = 4 bytes */
+#else
+  lenp = opj_stream_tell(cio);
+  opj_stream_skip(cio, 4, p_manager);         /* L [at the end]      */
+  opj_write_bytes(l_data_header,JPIP_FAIX,4); /* FAIX */
+  opj_stream_write_data(cio,l_data_header,4,p_manager);
+  opj_write_bytes(l_data_header,version,1);   /* Version 0 = 4 bytes */
+  opj_stream_write_data(cio,l_data_header,1,p_manager);
+#endif
+
+#if 0
+  cio_write( cio, num_max_tile_parts, size_of_coding);                      /* NMAX           */
+  cio_write( cio, cstr_info.tw*cstr_info.th, size_of_coding);               /* M              */
+#else
+  opj_write_bytes(l_data_header,num_max_tile_parts,size_of_coding);         /* NMAX           */
+  opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+  opj_write_bytes(l_data_header,cstr_info.tw*cstr_info.th,size_of_coding);  /* M              */
+  opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+#endif
+  for (i = 0; i < cstr_info.tw*cstr_info.th; i++)
+    {
+    for (j = 0; j < cstr_info.tile[i].num_tps; j++)
+      {
+      tp = cstr_info.tile[i].tp[j];
+#if 0
+      cio_write( cio, tp.tp_start_pos-coff, size_of_coding); /* start position */
+      cio_write( cio, tp.tp_end_pos-tp.tp_start_pos+1, size_of_coding);    /* length         */
+#else
+      opj_write_bytes(l_data_header,tp.tp_start_pos-coff,size_of_coding);            /* start position */
+      opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+      opj_write_bytes(l_data_header,tp.tp_end_pos-tp.tp_start_pos+1,size_of_coding); /* length         */
+      opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+#endif
+      if (version & 0x02)
+        {
+        if( cstr_info.tile[i].num_tps == 1 && cstr_info.numdecompos[compno] > 1)
+          Aux = cstr_info.numdecompos[compno] + 1;
+        else
+          Aux = j + 1;
+
+#if 0
+        cio_write( cio, Aux,4);
+#else
+        opj_write_bytes(l_data_header,Aux,4);
+        opj_stream_write_data(cio,l_data_header,4,p_manager);
+#endif
+        /*cio_write(img.tile[i].tile_parts[j].num_reso_AUX,4);*/ /* Aux_i,j : Auxiliary value */
+        /* fprintf(stderr,"AUX value %d\n",Aux);*/
+        }
+      /*cio_write(0,4);*/
+      }
+    /* PADDING */
+    while (j < num_max_tile_parts)
+      {
+#if 0
+      cio_write( cio, 0, size_of_coding); /* start position            */
+      cio_write( cio, 0, size_of_coding); /* length                    */
+#else
+      opj_write_bytes(l_data_header,0,size_of_coding);/* start position            */
+      opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+      opj_write_bytes(l_data_header,0,size_of_coding);/* length                    */
+      opj_stream_write_data(cio,l_data_header,size_of_coding,p_manager);
+#endif
+      if (version & 0x02)
+#if 0
+        cio_write( cio, 0,4);                  /* Aux_i,j : Auxiliary value */
+#else
+      opj_write_bytes(l_data_header,0,4);      /* Aux_i,j : Auxiliary value */
+      opj_stream_write_data(cio,l_data_header,4,p_manager);
+#endif
+      j++;
+      }
+    }
+  
+#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_seek(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;
+}
+
 int get_num_max_tile_parts( opj_codestream_info_t cstr_info)
 {
   int num_max_tp = 0, i;