src/lib/openjpip/jp2k_encoder.c

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