applications/jpip/libopenjpip/jp2k_encoder.c

   1 /*
   2  * $Id$
   3  *
   4  * Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
   5  * Copyright (c) 2002-2011, Professor Benoit Macq
   6  * Copyright (c) 2010-2011, Kaori Hagihara
   7  * Copyright (c) 2011,      Lucian Corlaciu, GSoC
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  20  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  23  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <math.h>
  36 #include "jp2k_encoder.h"
  37 #include "j2kheader_manager.h"
  38 #include "imgreg_manager.h"
  39
  40
  41 #ifdef SERVER
  42 #include "fcgi_stdio.h"
  43 #define logstream FCGI_stdout
  44 #else
  45 #define FCGI_stdout stdout
  46 #define FCGI_stderr stderr
  47 #define logstream stderr
  48 #endif //SERVER
  49
  50
  51 /**
  52  * search a message by class_id
  53  *
  54  * @param[in] class_id    class identifiers
  55  * @param[in] in_class_id in-class identifiers, -1 means any
  56  * @param[in] csn         codestream number
  57  * @param[in] msg         first message pointer of the searching list
  58  * @return                found message pointer
  59  */
  60 message_param_t * search_message( Byte8_t class_id, Byte8_t in_class_id, Byte8_t csn, message_param_t *msg);
  61
  62 /**
  63  * reconstruct j2k codestream from JPT- (in future, JPP-) stream
  64  *
  65  * @param[in]  msgqueue   message queue pointer
  66  * @param[in]  jpipstream original JPT- JPP- stream
  67  * @param[in]  csn        codestream number
  68  * @param[in]  fw         reconstructing image frame width
  69  * @param[in]  fh         reconstructing image frame height
  70  * @param[out] codelen   codestream length
  71  * @return               generated reconstructed j2k codestream
  72  */
  73 Byte_t * recons_codestream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte8_t csn, int fw, int fh, Byte8_t *codelen);
  74
  75 Byte_t * recons_j2k( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte8_t csn, int fw, int fh, Byte8_t *j2klen)
  76 {
  77   Byte_t *j2kstream = NULL;
  78
  79   if( !msgqueue)
  80     return NULL;
  81
  82   j2kstream = recons_codestream( msgqueue, jpipstream, csn, fw, fh, j2klen);
  83
  84   return j2kstream;
  85 }
  86
  87 Byte_t * add_emptyboxstream( placeholder_param_t *phld, Byte_t *jp2stream, Byte8_t *jp2len);
  88 Byte_t * add_msgstream( message_param_t *message, Byte_t *origstream, Byte_t *j2kstream, Byte8_t *j2klen);
  89
  90 Byte_t * recons_jp2( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte8_t csn, Byte8_t *jp2len)
  91 {
  92   message_param_t *ptr;
  93   Byte_t *jp2stream = NULL;
  94   Byte_t *codestream = NULL;
  95   Byte8_t codelen;
  96   Byte8_t jp2cDBoxOffset = 0, jp2cDBoxlen = 0;
  97
  98   *jp2len = 0;
  99
 100   if( !msgqueue)
 101     return NULL;
 102
 103   ptr = msgqueue->first;
 104   while(( ptr = search_message( METADATA_MSG, -1, csn, ptr))!=NULL){
 105     if( ptr->phld){
 106       if( strncmp( (char *)ptr->phld->OrigBH+4, "jp2c", 4) == 0){
 107         jp2cDBoxOffset = *jp2len + ptr->phld->OrigBHlen;
 108         jp2stream = add_emptyboxstream( ptr->phld, jp2stream, jp2len); // header only
 109         jp2cDBoxlen = *jp2len - jp2cDBoxOffset;
 110       }
 111       else
 112         jp2stream = add_emptyboxstream( ptr->phld, jp2stream, jp2len); // header only
 113     }
 114     jp2stream = add_msgstream( ptr, jpipstream, jp2stream, jp2len);
 115     ptr = ptr->next;
 116   }
 117
 118   codestream = recons_codestream( msgqueue, jpipstream, csn, 0, 0, &codelen);
 119
 120   if( jp2cDBoxOffset != 0 && codelen <= jp2cDBoxlen)
 121     memcpy( jp2stream+jp2cDBoxOffset, codestream, codelen);
 122
 123   free( codestream);
 124
 125   return jp2stream;
 126 }
 127
 128 bool isJPPstream( Byte8_t csn, msgqueue_param_t *msgqueue);
 129
 130 Byte_t * recons_codestream_from_JPTstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte8_t csn, int fw, int fh,  Byte8_t *j2klen);
 131 Byte_t * recons_codestream_from_JPPstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte8_t csn, int fw, int fh, Byte8_t *j2klen);
 132
 133 Byte_t * add_EOC( Byte_t *j2kstream, Byte8_t *j2klen);
 134
 135 Byte_t * recons_codestream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte8_t csn, int fw, int fh, Byte8_t *codelen)
 136 {
 137   if( isJPPstream( csn, msgqueue))
 138     return recons_codestream_from_JPPstream( msgqueue, jpipstream, csn, fw, fh, codelen);
 139   else
 140     return recons_codestream_from_JPTstream( msgqueue, jpipstream, csn, fw, fh, codelen);
 141 }
 142
 143 bool isJPPstream( Byte8_t csn, msgqueue_param_t *msgqueue)
 144 {
 145   message_param_t *msg;
 146
 147   msg = msgqueue->first;
 148   while( msg){
 149     if( msg->csn == csn){
 150       if( msg->class_id <= 2)
 151         return true;
 152       else
 153         if( msg->class_id == 4 || msg->class_id == 5)
 154           return false;
 155     }
 156     msg = msg->next;
 157   }
 158
 159   fprintf( FCGI_stderr, "Error, message of csn %lld not found\n", csn);
 160
 161   return false;
 162 }
 163
 164 Byte_t * add_mainhead_msgstream( msgqueue_param_t *msgqueue, Byte_t *origstream, Byte_t *j2kstream, Byte8_t csn, Byte8_t *j2klen);
 165 Byte8_t get_last_tileID( msgqueue_param_t *msgqueue, Byte8_t csn, bool isJPPstream);
 166 Byte_t * add_emptytilestream( const Byte8_t tileID, Byte_t *j2kstream, Byte8_t *j2klen);
 167
 168 Byte_t * recons_codestream_from_JPTstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte8_t csn, int fw, int fh,  Byte8_t *j2klen)
 169 {
 170   Byte_t *j2kstream = NULL;
 171   Byte8_t last_tileID, tileID;
 172   bool found;
 173   Byte8_t binOffset;
 174   message_param_t *ptr;
 175   SIZmarker_param_t SIZ;
 176   int mindeclev;
 177
 178   *j2klen = 0;
 179   j2kstream = add_mainhead_msgstream( msgqueue, jpipstream, j2kstream, csn, j2klen);
 180
 181   if( !get_mainheader_from_j2kstream( j2kstream, &SIZ, NULL))
 182     return j2kstream;
 183
 184   if( fw <= 0 || fh <= 0)
 185     mindeclev = 0;
 186   else
 187     mindeclev = comp_decomplev( fw, fh, SIZ.Xsiz, SIZ.Ysiz);
 188
 189   last_tileID = get_last_tileID( msgqueue, csn, false);
 190
 191   for( tileID=0; tileID <= last_tileID; tileID++){
 192     found = false;
 193     binOffset = 0;
 194
 195     ptr = msgqueue->first;
 196     while(( ptr = search_message( TILE_MSG, tileID, csn, ptr))!=NULL){
 197       if( ptr->bin_offset == binOffset){
 198         found = true;
 199         j2kstream = add_msgstream( ptr, jpipstream, j2kstream, j2klen);
 200         binOffset += ptr->length;
 201       }
 202       ptr = ptr->next;
 203     }
 204     ptr = msgqueue->first;
 205     while(( ptr = search_message( EXT_TILE_MSG, tileID, csn, ptr))!=NULL){
 206       if( ptr->aux > mindeclev){
 207         if( ptr->bin_offset == binOffset){
 208           found = true;
 209           j2kstream = add_msgstream( ptr, jpipstream, j2kstream, j2klen);
 210           binOffset += ptr->length;
 211         }
 212       }
 213       ptr = ptr->next;
 214     }
 215     if(!found)
 216       j2kstream = add_emptytilestream( tileID, j2kstream, j2klen);
 217   }
 218
 219   j2kstream = add_EOC( j2kstream, j2klen);
 220
 221   return j2kstream;
 222 }
 223
 224 Byte_t * add_SOTmkr( Byte_t *j2kstream, Byte8_t *j2klen);
 225
 226 Byte_t * recons_bitstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 227                            Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int mindeclev,
 228                            int *max_reslev, Byte8_t *j2klen);
 229
 230 Byte_t * recons_codestream_from_JPPstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte8_t csn, int fw, int fh, Byte8_t *j2klen)
 231 {
 232   Byte_t *j2kstream = NULL;
 233   Byte8_t tileID, last_tileID;
 234   Byte8_t SOToffset;
 235   bool foundTH;
 236   Byte8_t binOffset;
 237   message_param_t *ptr;
 238   SIZmarker_param_t SIZ;
 239   CODmarker_param_t COD;
 240   int max_reslev, mindeclev;
 241
 242   *j2klen = 0;
 243   j2kstream = add_mainhead_msgstream( msgqueue, jpipstream, j2kstream, csn, j2klen);
 244
 245   if( !get_mainheader_from_j2kstream( j2kstream, &SIZ, &COD))
 246     return j2kstream;
 247
 248   if( fw == 0 || fh == 0)
 249     mindeclev = 0;
 250   else
 251     mindeclev = comp_decomplev( fw, fh, SIZ.Xsiz, SIZ.Ysiz);
 252
 253   max_reslev = -1;
 254   last_tileID = get_last_tileID( msgqueue, csn, true);
 255
 256   for( tileID=0; tileID <= last_tileID; tileID++){
 257
 258     ptr = msgqueue->first;
 259     binOffset = 0;
 260     foundTH = false;
 261     SOToffset = *j2klen;
 262     while(( ptr = search_message( TILE_HEADER_MSG, tileID, csn, ptr))!=NULL){
 263       if( ptr->bin_offset == binOffset){
 264         j2kstream = add_SOTmkr( j2kstream, j2klen);
 265         j2kstream = add_msgstream( ptr, jpipstream, j2kstream, j2klen);
 266         foundTH = true;
 267         binOffset += ptr->length;
 268       }
 269       ptr = ptr->next;
 270     }
 271
 272     if( foundTH){
 273       j2kstream = recons_bitstream( msgqueue, jpipstream, j2kstream, csn, tileID, SIZ, COD, mindeclev, &max_reslev, j2klen);
 274       modify_tileheader( j2kstream, SOToffset, (max_reslev<COD.numOfdecomp ? max_reslev : -1), SIZ.Csiz, j2klen);
 275     }
 276     else
 277       j2kstream = add_emptytilestream( tileID, j2kstream, j2klen);
 278   }
 279
 280   if( max_reslev < COD.numOfdecomp)
 281     if( !modify_mainheader( j2kstream, max_reslev, SIZ, COD, j2klen)){
 282       delete_COD( COD);
 283       return j2kstream;
 284     }
 285
 286   j2kstream = add_EOC( j2kstream, j2klen);
 287   delete_COD( COD);
 288
 289   return j2kstream;
 290 }
 291
 292 Byte_t * add_mainhead_msgstream( msgqueue_param_t *msgqueue, Byte_t *origstream, Byte_t *j2kstream, Byte8_t csn, Byte8_t *j2klen)
 293 {
 294   message_param_t *ptr;
 295   Byte8_t binOffset;
 296
 297   ptr = msgqueue->first;
 298   binOffset = 0;
 299
 300   while(( ptr = search_message( MAINHEADER_MSG, -1, csn, ptr))!=NULL){
 301     if( ptr->bin_offset == binOffset){
 302       j2kstream = add_msgstream( ptr, origstream, j2kstream, j2klen);
 303       binOffset += ptr->length;
 304     }
 305     ptr = ptr->next;
 306   }
 307   return j2kstream;
 308 }
 309
 310 Byte_t * add_SOTmkr( Byte_t *j2kstream, Byte8_t *j2klen)
 311 {
 312   Byte_t *buf;
 313   const Byte2_t SOT = 0x90ff;
 314
 315   buf = (Byte_t *)malloc(( *j2klen)+2);
 316
 317   memcpy( buf, j2kstream, *j2klen);
 318   memcpy( buf+(*j2klen), &SOT, 2);
 319
 320   *j2klen += 2;
 321
 322   if(j2kstream) free(j2kstream);
 323
 324   return buf;
 325 }
 326
 327 Byte_t * recons_LRCPbitstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 328                                Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int mindeclev,
 329                                int *max_reslev, Byte8_t *j2klen);
 330
 331 Byte_t * recons_RLCPbitstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 332                                Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int mindeclev,
 333                                int *max_reslev, Byte8_t *j2klen);
 334
 335 Byte_t * recons_RPCLbitstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 336                                Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int mindeclev,
 337                                int *max_reslev, Byte8_t *j2klen);
 338
 339 Byte_t * recons_PCRLbitstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 340                                Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int mindeclev,
 341                                int *max_reslev, Byte8_t *j2klen);
 342
 343 Byte_t * recons_CPRLbitstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 344                                Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int mindeclev,
 345                                int *max_reslev, Byte8_t *j2klen);
 346
 347 Byte_t * recons_bitstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 348                            Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int mindeclev,
 349                            int *max_reslev, Byte8_t *j2klen)
 350 {
 351   switch( COD.prog_order){
 352   case LRCP:
 353     return recons_LRCPbitstream( msgqueue, jpipstream, j2kstream, csn, tileID, SIZ, COD, mindeclev, max_reslev, j2klen);
 354   case RLCP:
 355     return recons_RLCPbitstream( msgqueue, jpipstream, j2kstream, csn, tileID, SIZ, COD, mindeclev, max_reslev, j2klen);
 356   case RPCL:
 357     return recons_RPCLbitstream( msgqueue, jpipstream, j2kstream, csn, tileID, SIZ, COD, mindeclev, max_reslev, j2klen);
 358   case PCRL:
 359     return recons_PCRLbitstream( msgqueue, jpipstream, j2kstream, csn, tileID, SIZ, COD, mindeclev, max_reslev, j2klen);
 360   case CPRL:
 361     return recons_CPRLbitstream( msgqueue, jpipstream, j2kstream, csn, tileID, SIZ, COD, mindeclev, max_reslev, j2klen);
 362   default:
 363     fprintf( FCGI_stderr, "Error, progression order not supported\n");
 364   }
 365   return j2kstream;
 366 }
 367
 368 int comp_numOfprcts( Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int r);
 369 Byte8_t comp_seqID( Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int r, int p);
 370
 371 Byte_t * recons_packet( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 372                         Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int *max_reslev,
 373                         int comp_idx, int res_idx, int prct_idx, int lay_idx, Byte8_t *j2klen);
 374
 375 Byte_t * recons_LRCPbitstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 376                                Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int mindeclev,
 377                                int *max_reslev, Byte8_t *j2klen)
 378 {
 379   int r, p, c, l, numOfprcts;
 380
 381   for( l=0; l<COD.numOflayers; l++)
 382     for( r=0; r<=(COD.numOfdecomp-mindeclev); r++){
 383       if( COD.Scod & 0x01)
 384         numOfprcts = comp_numOfprcts( tileID, SIZ, COD, r);
 385       else
 386         numOfprcts = 1;
 387
 388       for( c=0; c<SIZ.Csiz; c++)
 389         for( p=0; p<numOfprcts; p++)
 390           j2kstream = recons_packet( msgqueue, jpipstream, j2kstream, csn, tileID, SIZ, COD, max_reslev, c, r, p, l, j2klen);
 391     }
 392
 393   return j2kstream;
 394 }
 395
 396 Byte_t * recons_RLCPbitstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 397                                Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int mindeclev,
 398                                int *max_reslev, Byte8_t *j2klen)
 399 {
 400   int r, p, c, l, numOfprcts;
 401
 402   for( r=0; r<=(COD.numOfdecomp-mindeclev); r++){
 403     if( COD.Scod & 0x01)
 404       numOfprcts = comp_numOfprcts( tileID, SIZ, COD, r);
 405     else
 406       numOfprcts = 1;
 407
 408     for( l=0; l<COD.numOflayers; l++)
 409       for( c=0; c<SIZ.Csiz; c++)
 410         for( p=0; p<numOfprcts; p++)
 411           j2kstream = recons_packet( msgqueue, jpipstream, j2kstream, csn, tileID, SIZ, COD, max_reslev, c, r, p, l, j2klen);
 412   }
 413
 414   return j2kstream;
 415 }
 416
 417 Byte_t * recons_precinct( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 418                           Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int *max_reslev,
 419                           int comp_idx, int res_idx, Byte8_t seqID, Byte8_t *j2klen);
 420
 421 Byte_t * recons_RPCLbitstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 422                                Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int mindeclev,
 423                                int *max_reslev, Byte8_t *j2klen)
 424 {
 425   int r, p, c, numOfprcts;
 426   Byte8_t seqID;
 427
 428   for( r=0, seqID=0; r<=(COD.numOfdecomp-mindeclev); r++){
 429
 430     if( COD.Scod & 0x01)
 431       numOfprcts = comp_numOfprcts( tileID, SIZ, COD, r);
 432     else
 433       numOfprcts = 1;
 434
 435     for( p=0; p<numOfprcts; p++, seqID++)
 436       for( c=0; c<SIZ.Csiz; c++)
 437         j2kstream = recons_precinct( msgqueue, jpipstream, j2kstream, csn, tileID, SIZ, COD, max_reslev, c, r, seqID, j2klen);
 438   }
 439
 440   return j2kstream;
 441 }
 442
 443 Byte_t * recons_PCRLbitstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 444                                Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int mindeclev,
 445                                int *max_reslev, Byte8_t *j2klen)
 446 {
 447   int r, p, c, min_numOfprcts, numOfprcts, min_numOfres;
 448   Byte8_t seqID;
 449
 450   min_numOfres = COD.numOfdecomp-mindeclev + 1;
 451
 452   if( COD.Scod & 0x01){
 453     min_numOfprcts = 0;
 454     for( r=0; r<min_numOfres; r++){
 455       numOfprcts = comp_numOfprcts( tileID, SIZ, COD, r);
 456
 457       if( numOfprcts < min_numOfprcts || min_numOfprcts == 0)
 458         min_numOfprcts = numOfprcts;
 459     }
 460   }
 461   else
 462     min_numOfprcts = 1;
 463
 464   for( p=0; p<min_numOfprcts; p++)
 465     for( c=0; c<SIZ.Csiz; c++)
 466       for( r=0; r<min_numOfres; r++){
 467         seqID = comp_seqID( tileID, SIZ, COD, r, p);
 468         j2kstream = recons_precinct( msgqueue, jpipstream, j2kstream, csn, tileID, SIZ, COD, max_reslev, c, r, seqID, j2klen);
 469       }
 470
 471   return j2kstream;
 472 }
 473
 474
 475 Byte_t * recons_CPRLbitstream( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 476                                Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int mindeclev,
 477                                int *max_reslev, Byte8_t *j2klen)
 478 {
 479   int r, p, c, min_numOfprcts, numOfprcts, min_numOfres;
 480   Byte8_t seqID;
 481
 482   min_numOfres = COD.numOfdecomp-mindeclev + 1;
 483
 484   if( COD.Scod & 0x01){
 485     min_numOfprcts = 0;
 486     for( r=0; r<min_numOfres; r++){
 487       numOfprcts = comp_numOfprcts( tileID, SIZ, COD, r);
 488
 489       if( numOfprcts < min_numOfprcts || min_numOfprcts == 0)
 490         min_numOfprcts = numOfprcts;
 491     }
 492   }
 493   else
 494     min_numOfprcts = 1;
 495
 496   for( c=0; c<SIZ.Csiz; c++)
 497     for( p=0; p<min_numOfprcts; p++)
 498       for( r=0; r<min_numOfres; r++){
 499         seqID = comp_seqID( tileID, SIZ, COD, r, p);
 500         j2kstream = recons_precinct( msgqueue, jpipstream, j2kstream, csn, tileID, SIZ, COD, max_reslev, c, r, seqID, j2klen);
 501       }
 502
 503   return j2kstream;
 504 }
 505
 506 int comp_numOfprcts( Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int r)
 507 {
 508   Byte4_t XTsiz, YTsiz;
 509
 510   XTsiz = get_tile_XSiz( SIZ, tileID, COD.numOfdecomp-r);
 511   YTsiz = get_tile_YSiz( SIZ, tileID, COD.numOfdecomp-r);
 512
 513   return ceil((double)XTsiz/(double)COD.XPsiz[r])*ceil((double)YTsiz/(double)COD.YPsiz[r]);
 514 }
 515
 516 Byte_t * add_padding( Byte8_t padding, Byte_t *j2kstream, Byte8_t *j2klen);
 517
 518 Byte_t * recons_packet( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 519                         Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int *max_reslev,
 520                         int comp_idx, int res_idx, int prct_idx, int lay_idx, Byte8_t *j2klen)
 521 {
 522   Byte8_t seqID, precID, binOffset;
 523   message_param_t *ptr;
 524   bool foundPrec;
 525   int l;
 526
 527   seqID = comp_seqID( tileID, SIZ, COD, res_idx, prct_idx);
 528   precID = comp_precinct_id( tileID, comp_idx, seqID, SIZ.Csiz, SIZ.XTnum*SIZ.YTnum);
 529
 530   ptr = msgqueue->first;
 531   binOffset = 0;
 532   foundPrec = false;
 533   l = 0;
 534
 535   while(( ptr = search_message( PRECINCT_MSG, precID, csn, ptr))!=NULL){
 536     if( ptr->bin_offset == binOffset){
 537       if( lay_idx == l){
 538         j2kstream = add_msgstream( ptr, jpipstream, j2kstream, j2klen);
 539         foundPrec = true;
 540         if( *max_reslev < res_idx)
 541           *max_reslev = res_idx;
 542
 543         break;
 544       }
 545       binOffset += ptr->length;
 546       l++;
 547     }
 548     ptr = ptr->next;
 549   }
 550   if( !foundPrec && COD.Scod & 0x01)
 551     j2kstream = add_padding( 1, j2kstream, j2klen);
 552
 553   return j2kstream;
 554 }
 555
 556
 557 Byte_t * recons_precinct( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte_t *j2kstream, Byte8_t csn,
 558                           Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int *max_reslev,
 559                           int comp_idx, int res_idx, Byte8_t seqID, Byte8_t *j2klen)
 560 {
 561   Byte8_t precID, binOffset;
 562   message_param_t *ptr;
 563   bool foundPrec;
 564
 565   precID = comp_precinct_id( tileID, comp_idx, seqID, SIZ.Csiz, SIZ.XTnum*SIZ.YTnum);
 566
 567   ptr = msgqueue->first;
 568   binOffset = 0;
 569   foundPrec = false;
 570
 571   while(( ptr = search_message( PRECINCT_MSG, precID, csn, ptr))!=NULL){
 572     if( ptr->bin_offset == binOffset){
 573       j2kstream = add_msgstream( ptr, jpipstream, j2kstream, j2klen);
 574
 575       foundPrec = true;
 576       binOffset += ptr->length;
 577       if( *max_reslev < res_idx)
 578         *max_reslev = res_idx;
 579
 580       if( ptr->last_byte)
 581         break;
 582     }
 583     ptr = ptr->next;
 584   }
 585   if(!foundPrec && COD.Scod & 0x01)
 586     j2kstream = add_padding( COD.numOflayers, j2kstream, j2klen);
 587
 588   return j2kstream;
 589 }
 590
 591 Byte8_t comp_seqID( Byte8_t tileID, SIZmarker_param_t SIZ, CODmarker_param_t COD, int r, int p)
 592 {
 593   Byte8_t seqID = 0;
 594   int rr;
 595
 596   for( rr=0; rr<r; rr++)
 597     seqID += comp_numOfprcts( tileID, SIZ, COD, rr);
 598
 599   seqID += p;
 600
 601   return seqID;
 602 }
 603
 604 Byte8_t get_last_tileID( msgqueue_param_t *msgqueue, Byte8_t csn, bool isJPPstream)
 605 {
 606   Byte8_t last_tileID = 0;
 607   message_param_t *msg;
 608
 609   msg = msgqueue->first;
 610   while( msg){
 611     if( isJPPstream){
 612       if((msg->class_id == TILE_HEADER_MSG) && msg->csn == csn && last_tileID < msg->in_class_id)
 613         last_tileID = msg->in_class_id;
 614     }
 615     else{
 616       if((msg->class_id == TILE_MSG || msg->class_id == EXT_TILE_MSG) && msg->csn == csn && last_tileID < msg->in_class_id)
 617         last_tileID = msg->in_class_id;
 618     }
 619     msg = msg->next;
 620   }
 621   return last_tileID;
 622 }
 623
 624
 625 message_param_t * search_message( Byte8_t class_id, Byte8_t in_class_id, Byte8_t csn, message_param_t *msg)
 626 {
 627   while( msg != NULL){
 628     if( in_class_id == -1){
 629       if( msg->class_id == class_id && msg->csn == csn)
 630         return msg;
 631     }
 632     else{
 633       if( msg->class_id == class_id && msg->in_class_id == in_class_id && msg->csn == csn)
 634         return msg;
 635     }
 636     msg = msg->next;
 637   }
 638   return NULL;
 639 }
 640
 641
 642 Byte_t * gene_msgstream( message_param_t *message, Byte_t *stream, Byte8_t *length);
 643 Byte_t * gene_emptytilestream( const Byte8_t tileID, Byte8_t *length);
 644
 645 Byte_t * add_msgstream( message_param_t *message, Byte_t *origstream, Byte_t *j2kstream, Byte8_t *j2klen)
 646 {
 647   Byte_t *newstream;
 648   Byte8_t newlen;
 649   Byte_t *buf;
 650
 651   if( !message)
 652     return NULL;
 653
 654   newstream = gene_msgstream( message, origstream, &newlen);
 655
 656   buf = (Byte_t *)malloc(( *j2klen)+newlen);
 657
 658   memcpy( buf, j2kstream, *j2klen);
 659   memcpy( buf+(*j2klen), newstream, newlen);
 660
 661   *j2klen += newlen;
 662
 663   free( newstream);
 664   if(j2kstream) free(j2kstream);
 665
 666   return buf;
 667 }
 668
 669
 670 Byte_t * add_emptyboxstream( placeholder_param_t *phld, Byte_t *jp2stream, Byte8_t *jp2len)
 671 {
 672   Byte_t *newstream;
 673   Byte8_t newlen;
 674   Byte_t *buf;
 675
 676   if( phld->OrigBHlen == 8)
 677     newlen = big4(phld->OrigBH);
 678   else
 679     newlen = big8(phld->OrigBH+8);
 680
 681   newstream = (Byte_t *)malloc( newlen);
 682   memset( newstream, 0, newlen);
 683   memcpy( newstream, phld->OrigBH, phld->OrigBHlen);
 684
 685   buf = (Byte_t *)malloc(( *jp2len)+newlen);
 686
 687   memcpy( buf, jp2stream, *jp2len);
 688   memcpy( buf+(*jp2len), newstream, newlen);
 689
 690   *jp2len += newlen;
 691
 692   free( newstream);
 693   if(jp2stream) free(jp2stream);
 694
 695   return buf;
 696 }
 697
 698 Byte_t * add_emptytilestream( const Byte8_t tileID, Byte_t *j2kstream, Byte8_t *j2klen)
 699 {
 700   Byte_t *newstream;
 701   Byte8_t newlen;
 702   Byte_t *buf;
 703
 704   newstream = gene_emptytilestream( tileID, &newlen);
 705
 706   buf = (Byte_t *)malloc(( *j2klen)+newlen);
 707
 708   memcpy( buf, j2kstream, *j2klen);
 709   memcpy( buf+(*j2klen), newstream, newlen);
 710
 711   *j2klen += newlen;
 712
 713   free( newstream);
 714   if(j2kstream) free(j2kstream);
 715
 716   return buf;
 717 }
 718
 719 Byte_t * add_padding( Byte8_t padding, Byte_t *j2kstream, Byte8_t *j2klen)
 720 {
 721   Byte_t *buf;
 722
 723   buf = (Byte_t *)malloc(( *j2klen)+padding);
 724
 725   memcpy( buf, j2kstream, *j2klen);
 726   memset( buf+(*j2klen), 0, padding);
 727
 728   *j2klen += padding;
 729
 730   if(j2kstream) free(j2kstream);
 731
 732   return buf;
 733 }
 734
 735 Byte_t * add_EOC( Byte_t *j2kstream, Byte8_t *j2klen)
 736 {
 737   Byte2_t EOC = 0xd9ff;
 738
 739   Byte_t *buf;
 740
 741   buf = (Byte_t *)malloc(( *j2klen)+2);
 742
 743   memcpy( buf, j2kstream, *j2klen);
 744   memcpy( buf+(*j2klen), &EOC, 2);
 745
 746   *j2klen += 2;
 747
 748   if(j2kstream) free(j2kstream);
 749
 750   return buf;
 751 }
 752
 753 Byte_t * gene_msgstream( message_param_t *message, Byte_t *stream, Byte8_t *length)
 754 {
 755   Byte_t *buf;
 756
 757   if( !message)
 758     return NULL;
 759
 760   *length = message->length;
 761   buf = (Byte_t *)malloc( *length);
 762   memcpy( buf, stream+message->res_offset,  *length);
 763
 764   return buf;
 765 }
 766
 767 Byte_t * gene_emptytilestream( const Byte8_t tileID, Byte8_t *length)
 768 {
 769   Byte_t *buf;
 770   const Byte2_t SOT = 0x90ff;
 771   const Byte2_t Lsot = 0xa << 8;
 772   Byte2_t Isot;
 773   const Byte4_t Psot = 0xe << 24;
 774   const Byte_t TPsot = 0, TNsot = 1;
 775   const Byte2_t SOD = 0x93ff;
 776
 777   *length = 14;
 778   buf = (Byte_t *)malloc(*length);
 779
 780   Isot = (((Byte2_t)tileID) << 8) | ((((Byte2_t)tileID) & 0xf0) >> 8);
 781
 782   memcpy( buf, &SOT, 2);
 783   memcpy( buf+2, &Lsot, 2);
 784   memcpy( buf+4, &Isot, 2);
 785   memcpy( buf+6, &Psot, 4);
 786   memcpy( buf+10, &TPsot, 1);
 787   memcpy( buf+11, &TNsot, 1);
 788   memcpy( buf+12, &SOD, 2);
 789
 790   return buf;
 791 }
 792
 793 Byte_t * recons_j2kmainhead( msgqueue_param_t *msgqueue, Byte_t *jpipstream, Byte8_t csn, Byte8_t *j2klen)
 794 {
 795   *j2klen = 0;
 796   return add_mainhead_msgstream( msgqueue, jpipstream, NULL, csn, j2klen);
 797 }