libopenjpeg/jp2.c

   1 /*
   2  * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
   3  * Copyright (c) 2002-2007, Professor Benoit Macq
   4  * Copyright (c) 2001-2003, David Janssens
   5  * Copyright (c) 2002-2003, Yannick Verschueren
   6  * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
   7  * Copyright (c) 2005, Herve Drolon, FreeImage Team
   8  * Copyright (c) 2010-2011, Kaori Hagihara
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32 #include "opj_includes.h"
  33 #include <assert.h>
  34
  35 /** @defgroup JP2 JP2 - JPEG-2000 file format reader/writer */
  36 /*@{*/
  37
  38 /** @name Local static functions */
  39 /*@{*/
  40
  41 /**
  42 Read box headers
  43 @param cinfo Codec context info
  44 @param cio Input stream
  45 @param box
  46 @return Returns true if successful, returns false otherwise
  47 */
  48 static opj_bool jp2_read_boxhdr(opj_common_ptr cinfo, opj_cio_t *cio, opj_jp2_box_t *box);
  49 /*static void jp2_write_url(opj_cio_t *cio, char *Idx_file);*/
  50 /**
  51 Read the IHDR box - Image Header box
  52 @param jp2 JP2 handle
  53 @param cio Input buffer stream
  54 @return Returns true if successful, returns false otherwise
  55 */
  56 static opj_bool jp2_read_ihdr(opj_jp2_t *jp2, opj_cio_t *cio);
  57 static void jp2_write_ihdr(opj_jp2_t *jp2, opj_cio_t *cio);
  58 static void jp2_write_bpcc(opj_jp2_t *jp2, opj_cio_t *cio);
  59 static opj_bool jp2_read_bpcc(opj_jp2_t *jp2, opj_cio_t *cio);
  60 static void jp2_write_colr(opj_jp2_t *jp2, opj_cio_t *cio);
  61 /**
  62 Write the FTYP box - File type box
  63 @param jp2 JP2 handle
  64 @param cio Output buffer stream
  65 */
  66 static void jp2_write_ftyp(opj_jp2_t *jp2, opj_cio_t *cio);
  67 /**
  68 Read the FTYP box - File type box
  69 @param jp2 JP2 handle
  70 @param cio Input buffer stream
  71 @return Returns true if successful, returns false otherwise
  72 */
  73 static opj_bool jp2_read_ftyp(opj_jp2_t *jp2, opj_cio_t *cio);
  74 static int jp2_write_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info);
  75 static opj_bool jp2_read_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, unsigned int *j2k_codestream_length, unsigned int *j2k_codestream_offset);
  76 static void jp2_write_jp(opj_cio_t *cio);
  77 /**
  78 Read the JP box - JPEG 2000 signature
  79 @param jp2 JP2 handle
  80 @param cio Input buffer stream
  81 @return Returns true if successful, returns false otherwise
  82 */
  83 static opj_bool jp2_read_jp(opj_jp2_t *jp2, opj_cio_t *cio);
  84 /**
  85 Decode the structure of a JP2 file
  86 @param jp2 JP2 handle
  87 @param cio Input buffer stream
  88 @param color Collector for profile, cdef and pclr data
  89 @return Returns true if successful, returns false otherwise
  90 */
  91 static opj_bool jp2_read_struct(opj_jp2_t *jp2, opj_cio_t *cio,
  92         opj_jp2_color_t *color);
  93 /**
  94 Apply collected palette data
  95 @param color Collector for profile, cdef and pclr data
  96 @param image
  97 */
  98 static void jp2_apply_pclr(opj_jp2_color_t *color, opj_image_t *image, opj_common_ptr cinfo);
  99 /**
 100 Collect palette data
 101 @param jp2 JP2 handle
 102 @param cio Input buffer stream
 103 @param box
 104 @param color Collector for profile, cdef and pclr data
 105 @return Returns true if successful, returns false otherwise
 106 */
 107 static opj_bool jp2_read_pclr(opj_jp2_t *jp2, opj_cio_t *cio,
 108     opj_jp2_box_t *box, opj_jp2_color_t *color);
 109 /**
 110 Collect component mapping data
 111 @param jp2 JP2 handle
 112 @param cio Input buffer stream
 113 @param box
 114 @param color Collector for profile, cdef and pclr data
 115 @return Returns true if successful, returns false otherwise
 116 */
 117 static opj_bool jp2_read_cmap(opj_jp2_t *jp2, opj_cio_t *cio,
 118     opj_jp2_box_t *box, opj_jp2_color_t *color);
 119 /**
 120 Collect colour specification data
 121 @param jp2 JP2 handle
 122 @param cio Input buffer stream
 123 @param box
 124 @param color Collector for profile, cdef and pclr data
 125 @return Returns true if successful, returns false otherwise
 126 */
 127 static opj_bool jp2_read_colr(opj_jp2_t *jp2, opj_cio_t *cio,
 128     opj_jp2_box_t *box, opj_jp2_color_t *color);
 129 /**
 130 Write file Index (superbox)
 131 @param[in] offset_jp2c offset of jp2c box
 132 @param[in] length_jp2c length of jp2c box
 133 @param[in] offset_idx  offset of cidx box
 134 @param[in] length_idx  length of cidx box
 135 @param[in] cio         file output handle
 136 @return                length of fidx box
 137 */
 138 static int write_fidx( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio);
 139 /**
 140 Write index Finder box
 141 @param[in] offset offset of fidx box
 142 @param[in] length length of fidx box
 143 @param[in] cio         file output handle
 144 */
 145 static void write_iptr( int offset, int length, opj_cio_t *cio);
 146 /**
 147 Write proxy box
 148 @param[in] offset_jp2c offset of jp2c box
 149 @param[in] length_jp2c length of jp2c box
 150 @param[in] offset_idx  offset of cidx box
 151 @param[in] length_idx  length of cidx box
 152 @param[in] cio         file output handle
 153 */
 154 static void write_prxy( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio);
 155 /*@}*/
 156
 157 /*@}*/
 158
 159 /* ----------------------------------------------------------------------- */
 160
 161 static opj_bool jp2_read_boxhdr(opj_common_ptr cinfo, opj_cio_t *cio, opj_jp2_box_t *box) {
 162         box->init_pos = cio_tell(cio);
 163         box->length = cio_read(cio, 4);
 164         box->type = cio_read(cio, 4);
 165         if (box->length == 1) {
 166                 if (cio_read(cio, 4) != 0) {
 167                         opj_event_msg(cinfo, EVT_ERROR, "Cannot handle box sizes higher than 2^32\n");
 168                         return OPJ_FALSE;
 169                 }
 170                 box->length = cio_read(cio, 4);
 171                 if (box->length == 0)
 172                         box->length = cio_numbytesleft(cio) + 12;
 173         }
 174         else if (box->length == 0) {
 175                 box->length = cio_numbytesleft(cio) + 8;
 176         } else if (box->length < 0) {
 177                 opj_event_msg(cinfo, EVT_ERROR, "Integer overflow in box->length\n");
 178                 return OPJ_FALSE; /* TODO: actually check jp2_read_boxhdr's return value */
 179         }
 180
 181         return OPJ_TRUE;
 182 }
 183
 184 #if 0
 185 static void jp2_write_url(opj_cio_t *cio, char *Idx_file) {
 186         unsigned int i;
 187         opj_jp2_box_t box;
 188
 189         box.init_pos = cio_tell(cio);
 190         cio_skip(cio, 4);
 191         cio_write(cio, JP2_URL, 4);     /* DBTL */
 192         cio_write(cio, 0, 1);           /* VERS */
 193         cio_write(cio, 0, 3);           /* FLAG */
 194
 195         if(Idx_file) {
 196                 for (i = 0; i < strlen(Idx_file); i++) {
 197                         cio_write(cio, Idx_file[i], 1);
 198                 }
 199         }
 200
 201         box.length = cio_tell(cio) - box.init_pos;
 202         cio_seek(cio, box.init_pos);
 203         cio_write(cio, box.length, 4);  /* L */
 204         cio_seek(cio, box.init_pos + box.length);
 205 }
 206 #endif
 207
 208 static opj_bool jp2_read_ihdr(opj_jp2_t *jp2, opj_cio_t *cio) {
 209         opj_jp2_box_t box;
 210
 211         opj_common_ptr cinfo = jp2->cinfo;
 212
 213   if(jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) {
 214     opj_event_msg(cinfo, EVT_ERROR, "Failed to read boxhdr\n");
 215     return OPJ_FALSE;
 216   }
 217         if (JP2_IHDR != box.type) {
 218                 opj_event_msg(cinfo, EVT_ERROR, "Expected IHDR Marker\n");
 219                 return OPJ_FALSE;
 220         }
 221
 222         jp2->h = cio_read(cio, 4);                      /* HEIGHT */
 223         jp2->w = cio_read(cio, 4);                      /* WIDTH */
 224         jp2->numcomps = cio_read(cio, 2);       /* NC */
 225         jp2->comps = (opj_jp2_comps_t*) opj_malloc(jp2->numcomps * sizeof(opj_jp2_comps_t));
 226
 227         jp2->bpc = cio_read(cio, 1);            /* BPC */
 228
 229         jp2->C = cio_read(cio, 1);                      /* C */
 230         jp2->UnkC = cio_read(cio, 1);           /* UnkC */
 231         jp2->IPR = cio_read(cio, 1);            /* IPR */
 232
 233         if (cio_tell(cio) - box.init_pos != box.length) {
 234                 opj_event_msg(cinfo, EVT_ERROR, "Error with IHDR Box\n");
 235                 return OPJ_FALSE;
 236         }
 237
 238         return OPJ_TRUE;
 239 }
 240
 241 static void jp2_write_ihdr(opj_jp2_t *jp2, opj_cio_t *cio) {
 242         opj_jp2_box_t box;
 243
 244         box.init_pos = cio_tell(cio);
 245         cio_skip(cio, 4);
 246         cio_write(cio, JP2_IHDR, 4);            /* IHDR */
 247
 248         cio_write(cio, jp2->h, 4);                      /* HEIGHT */
 249         cio_write(cio, jp2->w, 4);                      /* WIDTH */
 250         cio_write(cio, jp2->numcomps, 2);       /* NC */
 251
 252         cio_write(cio, jp2->bpc, 1);            /* BPC */
 253
 254         cio_write(cio, jp2->C, 1);                      /* C : Always 7 */
 255         cio_write(cio, jp2->UnkC, 1);           /* UnkC, colorspace unknown */
 256         cio_write(cio, jp2->IPR, 1);            /* IPR, no intellectual property */
 257
 258         box.length = cio_tell(cio) - box.init_pos;
 259         cio_seek(cio, box.init_pos);
 260         cio_write(cio, box.length, 4);  /* L */
 261         cio_seek(cio, box.init_pos + box.length);
 262 }
 263
 264 static void jp2_write_bpcc(opj_jp2_t *jp2, opj_cio_t *cio) {
 265         unsigned int i;
 266         opj_jp2_box_t box;
 267
 268         box.init_pos = cio_tell(cio);
 269         cio_skip(cio, 4);
 270         cio_write(cio, JP2_BPCC, 4);    /* BPCC */
 271
 272         for (i = 0; i < jp2->numcomps; i++) {
 273                 cio_write(cio, jp2->comps[i].bpcc, 1);
 274         }
 275
 276         box.length = cio_tell(cio) - box.init_pos;
 277         cio_seek(cio, box.init_pos);
 278         cio_write(cio, box.length, 4);  /* L */
 279         cio_seek(cio, box.init_pos + box.length);
 280 }
 281
 282
 283 static opj_bool jp2_read_bpcc(opj_jp2_t *jp2, opj_cio_t *cio) {
 284         unsigned int i;
 285         opj_jp2_box_t box;
 286
 287         opj_common_ptr cinfo = jp2->cinfo;
 288
 289   if( jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) {
 290     opj_event_msg(cinfo, EVT_ERROR, "Failed to read boxhdr\n");
 291     return OPJ_FALSE;
 292   }
 293         if (JP2_BPCC != box.type) {
 294                 opj_event_msg(cinfo, EVT_ERROR, "Expected BPCC Marker\n");
 295                 return OPJ_FALSE;
 296         }
 297
 298         for (i = 0; i < jp2->numcomps; i++) {
 299                 jp2->comps[i].bpcc = cio_read(cio, 1);
 300         }
 301
 302         if (cio_tell(cio) - box.init_pos != box.length) {
 303                 opj_event_msg(cinfo, EVT_ERROR, "Error with BPCC Box\n");
 304                 return OPJ_FALSE;
 305         }
 306
 307         return OPJ_TRUE;
 308 }
 309
 310 static void jp2_write_colr(opj_jp2_t *jp2, opj_cio_t *cio) {
 311         opj_jp2_box_t box;
 312
 313         box.init_pos = cio_tell(cio);
 314         cio_skip(cio, 4);
 315         cio_write(cio, JP2_COLR, 4);            /* COLR */
 316
 317         cio_write(cio, jp2->meth, 1);           /* METH */
 318         cio_write(cio, jp2->precedence, 1);     /* PRECEDENCE */
 319         cio_write(cio, jp2->approx, 1);         /* APPROX */
 320
 321         if(jp2->meth == 2)
 322          jp2->enumcs = 0;
 323
 324         cio_write(cio, jp2->enumcs, 4); /* EnumCS */
 325
 326         box.length = cio_tell(cio) - box.init_pos;
 327         cio_seek(cio, box.init_pos);
 328         cio_write(cio, box.length, 4);  /* L */
 329         cio_seek(cio, box.init_pos + box.length);
 330 }
 331
 332 static void jp2_free_pclr(opj_jp2_color_t *color)
 333 {
 334     opj_free(color->jp2_pclr->channel_sign);
 335     opj_free(color->jp2_pclr->channel_size);
 336     opj_free(color->jp2_pclr->entries);
 337
 338         if(color->jp2_pclr->cmap) opj_free(color->jp2_pclr->cmap);
 339
 340     opj_free(color->jp2_pclr); color->jp2_pclr = NULL;
 341 }
 342
 343 static void free_color_data(opj_jp2_color_t *color)
 344 {
 345         if(color->jp2_pclr)
 346    {
 347         jp2_free_pclr(color);
 348    }
 349         if(color->jp2_cdef)
 350    {
 351         if(color->jp2_cdef->info) opj_free(color->jp2_cdef->info);
 352         opj_free(color->jp2_cdef);
 353    }
 354         if(color->icc_profile_buf) opj_free(color->icc_profile_buf);
 355 }
 356
 357 static void jp2_apply_pclr(opj_jp2_color_t *color, opj_image_t *image, opj_common_ptr cinfo)
 358 {
 359         opj_image_comp_t *old_comps, *new_comps;
 360         unsigned char *channel_size, *channel_sign;
 361         unsigned int *entries;
 362         opj_jp2_cmap_comp_t *cmap;
 363         int *src, *dst;
 364         unsigned int j, max;
 365         unsigned short i, nr_channels, cmp, pcol;
 366         int k, top_k;
 367
 368         channel_size = color->jp2_pclr->channel_size;
 369         channel_sign = color->jp2_pclr->channel_sign;
 370         entries = color->jp2_pclr->entries;
 371         cmap = color->jp2_pclr->cmap;
 372         nr_channels = color->jp2_pclr->nr_channels;
 373
 374         old_comps = image->comps;
 375         new_comps = (opj_image_comp_t*)
 376          opj_malloc(nr_channels * sizeof(opj_image_comp_t));
 377
 378         for(i = 0; i < nr_channels; ++i)
 379    {
 380         pcol = cmap[i].pcol; cmp = cmap[i].cmp;
 381
 382   if( pcol < nr_channels )
 383     new_comps[pcol] = old_comps[cmp];
 384   else
 385     {
 386     opj_event_msg(cinfo, EVT_ERROR, "Error with pcol value %d (max: %d). skipping\n", pcol, nr_channels);
 387     continue;
 388     }
 389
 390         if(cmap[i].mtyp == 0) /* Direct use */
 391   {
 392         old_comps[cmp].data = NULL; continue;
 393   }
 394 /* Palette mapping: */
 395         new_comps[pcol].data = (int*)
 396          opj_malloc(old_comps[cmp].w * old_comps[cmp].h * sizeof(int));
 397         new_comps[pcol].prec = channel_size[i];
 398         new_comps[pcol].sgnd = channel_sign[i];
 399    }
 400         top_k = color->jp2_pclr->nr_entries - 1;
 401
 402         for(i = 0; i < nr_channels; ++i)
 403    {
 404 /* Direct use: */
 405         if(cmap[i].mtyp == 0) continue;
 406
 407 /* Palette mapping: */
 408         cmp = cmap[i].cmp; pcol = cmap[i].pcol;
 409         src = old_comps[cmp].data;
 410         dst = new_comps[pcol].data;
 411         max = new_comps[pcol].w * new_comps[pcol].h;
 412
 413         for(j = 0; j < max; ++j)
 414   {
 415 /* The index */
 416         if((k = src[j]) < 0) k = 0; else if(k > top_k) k = top_k;
 417 /* The colour */
 418         dst[j] = entries[k * nr_channels + pcol];
 419   }
 420    }
 421         max = image->numcomps;
 422         for(i = 0; i < max; ++i)
 423    {
 424         if(old_comps[i].data) opj_free(old_comps[i].data);
 425    }
 426         opj_free(old_comps);
 427         image->comps = new_comps;
 428         image->numcomps = nr_channels;
 429
 430         jp2_free_pclr(color);
 431
 432 }/* apply_pclr() */
 433
 434 static opj_bool jp2_read_pclr(opj_jp2_t *jp2, opj_cio_t *cio,
 435         opj_jp2_box_t *box, opj_jp2_color_t *color)
 436 {
 437         opj_jp2_pclr_t *jp2_pclr;
 438         unsigned char *channel_size, *channel_sign;
 439         unsigned int *entries;
 440         unsigned short nr_entries, nr_channels;
 441         unsigned short i, j;
 442         unsigned char uc;
 443
 444         OPJ_ARG_NOT_USED(box);
 445         OPJ_ARG_NOT_USED(jp2);
 446
 447 /* Part 1, I.5.3.4: 'There shall be at most one Palette box inside
 448  * a JP2 Header box' :
 449 */
 450         if(color->jp2_pclr) return OPJ_FALSE;
 451
 452         nr_entries = (unsigned short)cio_read(cio, 2); /* NE */
 453         nr_channels = (unsigned short)cio_read(cio, 1);/* NPC */
 454
 455         entries = (unsigned int*)
 456          opj_malloc(nr_channels * nr_entries * sizeof(unsigned int));
 457         channel_size = (unsigned char*)opj_malloc(nr_channels);
 458         channel_sign = (unsigned char*)opj_malloc(nr_channels);
 459
 460         jp2_pclr = (opj_jp2_pclr_t*)opj_malloc(sizeof(opj_jp2_pclr_t));
 461         jp2_pclr->channel_sign = channel_sign;
 462         jp2_pclr->channel_size = channel_size;
 463         jp2_pclr->entries = entries;
 464         jp2_pclr->nr_entries = nr_entries;
 465         jp2_pclr->nr_channels = nr_channels;
 466         jp2_pclr->cmap = NULL;
 467
 468         color->jp2_pclr = jp2_pclr;
 469
 470         for(i = 0; i < nr_channels; ++i)
 471    {
 472         uc = cio_read(cio, 1); /* Bi */
 473         channel_size[i] = (uc & 0x7f) + 1;
 474         channel_sign[i] = (uc & 0x80)?1:0;
 475    }
 476
 477         for(j = 0; j < nr_entries; ++j)
 478    {
 479         for(i = 0; i < nr_channels; ++i)
 480   {
 481 /* Cji */
 482         *entries++ = cio_read(cio, (channel_size[i]+7)>>3);
 483   }
 484    }
 485
 486         return OPJ_TRUE;
 487 }/* jp2_read_pclr() */
 488
 489 static opj_bool jp2_read_cmap(opj_jp2_t *jp2, opj_cio_t *cio,
 490         opj_jp2_box_t *box, opj_jp2_color_t *color)
 491 {
 492         opj_jp2_cmap_comp_t *cmap;
 493         unsigned short i, nr_channels;
 494
 495         OPJ_ARG_NOT_USED(box);
 496         OPJ_ARG_NOT_USED(jp2);
 497
 498 /* Need nr_channels: */
 499         if(color->jp2_pclr == NULL) return OPJ_FALSE;
 500
 501 /* Part 1, I.5.3.5: 'There shall be at most one Component Mapping box
 502  * inside a JP2 Header box' :
 503 */
 504         if(color->jp2_pclr->cmap) return OPJ_FALSE;
 505
 506         nr_channels = color->jp2_pclr->nr_channels;
 507         cmap = (opj_jp2_cmap_comp_t*)
 508          opj_malloc(nr_channels * sizeof(opj_jp2_cmap_comp_t));
 509
 510         for(i = 0; i < nr_channels; ++i)
 511    {
 512         cmap[i].cmp = (unsigned short)cio_read(cio, 2);
 513         cmap[i].mtyp = cio_read(cio, 1);
 514         cmap[i].pcol = cio_read(cio, 1);
 515
 516    }
 517         color->jp2_pclr->cmap = cmap;
 518
 519         return OPJ_TRUE;
 520 }/* jp2_read_cmap() */
 521
 522 static void jp2_apply_cdef(opj_image_t *image, opj_jp2_color_t *color)
 523 {
 524         opj_jp2_cdef_info_t *info;
 525         unsigned short i, n, cn, typ, asoc, acn;
 526
 527         info = color->jp2_cdef->info;
 528         n = color->jp2_cdef->n;
 529
 530         for(i = 0; i < n; ++i)
 531    {
 532 /* WATCH: acn = asoc - 1 ! */
 533         if((asoc = info[i].asoc) == 0) continue;
 534
 535         cn = info[i].cn; typ = info[i].typ; acn = asoc - 1;
 536   (void)typ;
 537
 538         if(cn != acn)
 539   {
 540         opj_image_comp_t saved;
 541
 542         memcpy(&saved, &image->comps[cn], sizeof(opj_image_comp_t));
 543         memcpy(&image->comps[cn], &image->comps[acn], sizeof(opj_image_comp_t));
 544         memcpy(&image->comps[acn], &saved, sizeof(opj_image_comp_t));
 545
 546         info[i].asoc = cn + 1;
 547         info[acn].asoc = info[acn].cn + 1;
 548   }
 549    }
 550         if(color->jp2_cdef->info) opj_free(color->jp2_cdef->info);
 551
 552         opj_free(color->jp2_cdef); color->jp2_cdef = NULL;
 553
 554 }/* jp2_apply_cdef() */
 555
 556 static opj_bool jp2_read_cdef(opj_jp2_t *jp2, opj_cio_t *cio,
 557         opj_jp2_box_t *box, opj_jp2_color_t *color)
 558 {
 559         opj_jp2_cdef_info_t *info;
 560         unsigned short i, n;
 561
 562         OPJ_ARG_NOT_USED(box);
 563         OPJ_ARG_NOT_USED(jp2);
 564
 565 /* Part 1, I.5.3.6: 'The shall be at most one Channel Definition box
 566  * inside a JP2 Header box.'
 567 */
 568         if(color->jp2_cdef) return OPJ_FALSE;
 569
 570         if((n = (unsigned short)cio_read(cio, 2)) == 0) return OPJ_FALSE; /* szukw000: FIXME */
 571
 572         info = (opj_jp2_cdef_info_t*)
 573          opj_malloc(n * sizeof(opj_jp2_cdef_info_t));
 574
 575         color->jp2_cdef = (opj_jp2_cdef_t*)opj_malloc(sizeof(opj_jp2_cdef_t));
 576         color->jp2_cdef->info = info;
 577         color->jp2_cdef->n = n;
 578
 579         for(i = 0; i < n; ++i)
 580    {
 581         info[i].cn = (unsigned short)cio_read(cio, 2);
 582         info[i].typ = (unsigned short)cio_read(cio, 2);
 583         info[i].asoc = (unsigned short)cio_read(cio, 2);
 584
 585    }
 586         return OPJ_TRUE;
 587 }/* jp2_read_cdef() */
 588
 589 static opj_bool jp2_read_colr(opj_jp2_t *jp2, opj_cio_t *cio,
 590         opj_jp2_box_t *box, opj_jp2_color_t *color)
 591 {
 592         int skip_len;
 593     opj_common_ptr cinfo;
 594
 595 /* Part 1, I.5.3.3 : 'A conforming JP2 reader shall ignore all Colour
 596  * Specification boxes after the first.'
 597 */
 598         if(color->jp2_has_colr) return OPJ_FALSE;
 599
 600         cinfo = jp2->cinfo;
 601
 602         jp2->meth = cio_read(cio, 1);           /* METH */
 603         jp2->precedence = cio_read(cio, 1);     /* PRECEDENCE */
 604         jp2->approx = cio_read(cio, 1);         /* APPROX */
 605
 606         if (jp2->meth == 1)
 607    {
 608         jp2->enumcs = cio_read(cio, 4); /* EnumCS */
 609    }
 610         else
 611         if (jp2->meth == 2)
 612    {
 613 /* skip PROFILE */
 614         skip_len = box->init_pos + box->length - cio_tell(cio);
 615         if (skip_len < 0)
 616   {
 617         opj_event_msg(cinfo, EVT_ERROR, "Error with COLR box size\n");
 618         return OPJ_FALSE;
 619   }
 620         if(skip_len > 0)
 621   {
 622         unsigned char *start;
 623
 624         start = cio_getbp(cio);
 625         color->icc_profile_buf = (unsigned char*)opj_malloc(skip_len);
 626         color->icc_profile_len = skip_len;
 627
 628         cio_skip(cio, box->init_pos + box->length - cio_tell(cio));
 629
 630         memcpy(color->icc_profile_buf, start, skip_len);
 631   }
 632    }
 633
 634         if (cio_tell(cio) - box->init_pos != box->length)
 635    {
 636         opj_event_msg(cinfo, EVT_ERROR, "Error with COLR Box\n");
 637         return OPJ_FALSE;
 638    }
 639         color->jp2_has_colr = 1;
 640
 641         return OPJ_TRUE;
 642 }/* jp2_read_colr() */
 643
 644 opj_bool jp2_read_jp2h(opj_jp2_t *jp2, opj_cio_t *cio, opj_jp2_color_t *color)
 645 {
 646         opj_jp2_box_t box;
 647         int jp2h_end;
 648
 649         opj_common_ptr cinfo = jp2->cinfo;
 650
 651   if( jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) return OPJ_FALSE;
 652   do {
 653     if (JP2_JP2H != box.type)
 654       {
 655       if (box.type == JP2_JP2C)
 656         {
 657         opj_event_msg(cinfo, EVT_ERROR, "Expected JP2H Marker\n");
 658         return OPJ_FALSE;
 659         }
 660           if (box.length <= 8) return OPJ_FALSE;
 661       cio_skip(cio, box.length - 8);
 662
 663       if(cio->bp >= cio->end) return OPJ_FALSE;
 664
 665       if( jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) return OPJ_FALSE;
 666       }
 667   } while(JP2_JP2H != box.type);
 668
 669         if (!jp2_read_ihdr(jp2, cio))
 670                 return OPJ_FALSE;
 671         jp2h_end = box.init_pos + box.length;
 672
 673   if (jp2->bpc == 255)
 674     {
 675     if (!jp2_read_bpcc(jp2, cio))
 676       return OPJ_FALSE;
 677     }
 678   if( jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) return OPJ_FALSE;
 679
 680   while(cio_tell(cio) < jp2h_end)
 681     {
 682     if(box.type == JP2_COLR)
 683       {
 684       if( !jp2_read_colr(jp2, cio, &box, color))
 685         {
 686         if (box.length <= 8) return OPJ_FALSE;
 687         cio_seek(cio, box.init_pos + 8);
 688         cio_skip(cio, box.length - 8);
 689         }
 690       if( jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) return OPJ_FALSE;
 691       continue;
 692       }
 693     if(box.type == JP2_CDEF && !jp2->ignore_pclr_cmap_cdef)
 694       {
 695       if( !jp2_read_cdef(jp2, cio, &box, color))
 696         {
 697         if (box.length <= 8) return OPJ_FALSE;
 698         cio_seek(cio, box.init_pos + 8);
 699         cio_skip(cio, box.length - 8);
 700         }
 701       if( jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) return OPJ_FALSE;
 702       continue;
 703       }
 704     if(box.type == JP2_PCLR && !jp2->ignore_pclr_cmap_cdef)
 705       {
 706       if( !jp2_read_pclr(jp2, cio, &box, color))
 707         {
 708         if (box.length <= 8) return OPJ_FALSE;
 709         cio_seek(cio, box.init_pos + 8);
 710         cio_skip(cio, box.length - 8);
 711         }
 712       if( jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) return OPJ_FALSE;
 713       continue;
 714       }
 715     if(box.type == JP2_CMAP && !jp2->ignore_pclr_cmap_cdef)
 716       {
 717       if( !jp2_read_cmap(jp2, cio, &box, color))
 718         {
 719         if (box.length <= 8) return OPJ_FALSE;
 720         cio_seek(cio, box.init_pos + 8);
 721         cio_skip(cio, box.length - 8);
 722         }
 723       if( jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) return OPJ_FALSE;
 724       continue;
 725       }
 726     if (box.length <= 8) return OPJ_FALSE;
 727     cio_seek(cio, box.init_pos + 8);
 728     cio_skip(cio, box.length - 8);
 729     if( jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) return OPJ_FALSE;
 730
 731     }/* while(cio_tell(cio) < box_end) */
 732
 733   cio_seek(cio, jp2h_end);
 734
 735   /* Part 1, I.5.3.3 : 'must contain at least one' */
 736   return (color->jp2_has_colr == 1);
 737
 738 }/* jp2_read_jp2h() */
 739
 740 static opj_bool opj_jp2_check_color(opj_image_t *image, opj_jp2_color_t *color, opj_common_ptr cinfo)
 741 {
 742         int i;
 743
 744         /* testcase 4149.pdf.SIGSEGV.cf7.3501 */
 745         if (color->jp2_cdef) {
 746                 opj_jp2_cdef_info_t *info = color->jp2_cdef->info;
 747                 int n = color->jp2_cdef->n;
 748
 749                 for (i = 0; i < n; i++) {
 750                         if (info[i].cn >= image->numcomps) {
 751                                 opj_event_msg(cinfo, EVT_ERROR, "Invalid component index %d (>= %d).\n", info[i].cn, image->numcomps);
 752                                 return OPJ_FALSE;
 753                         }
 754                         if (info[i].asoc > 0 && (info[i].asoc - 1) >= image->numcomps) {
 755                                 opj_event_msg(cinfo, EVT_ERROR, "Invalid component index %d (>= %d).\n", info[i].asoc - 1, image->numcomps);
 756                                 return OPJ_FALSE;
 757                         }
 758                 }
 759         }
 760
 761         /* testcases 451.pdf.SIGSEGV.f4c.3723, 451.pdf.SIGSEGV.5b5.3723 and
 762            66ea31acbb0f23a2bbc91f64d69a03f5_signal_sigsegv_13937c0_7030_5725.pdf */
 763         if (color->jp2_pclr && color->jp2_pclr->cmap) {
 764                 int nr_channels = color->jp2_pclr->nr_channels;
 765                 opj_jp2_cmap_comp_t *cmap = color->jp2_pclr->cmap;
 766                 opj_bool *pcol_usage, is_sane = OPJ_TRUE;
 767
 768                 /* verify that all original components match an existing one */
 769                 for (i = 0; i < nr_channels; i++) {
 770                         if (cmap[i].cmp >= image->numcomps) {
 771                                 opj_event_msg(cinfo, EVT_ERROR, "Invalid component index %d (>= %d).\n", cmap[i].cmp, image->numcomps);
 772                                 is_sane = OPJ_FALSE;
 773                         }
 774                 }
 775
 776                 pcol_usage = opj_calloc(nr_channels, sizeof(opj_bool));
 777                 if (!pcol_usage) {
 778                         opj_event_msg(cinfo, EVT_ERROR, "Unexpected OOM.\n");
 779                         return OPJ_FALSE;
 780                 }
 781                 /* verify that no component is targeted more than once */
 782                 for (i = 0; i < nr_channels; i++) {
 783       int pcol = cmap[i].pcol;
 784       assert(cmap[i].mtyp == 0 || cmap[i].mtyp == 1);
 785                         if (pcol >= nr_channels) {
 786                                 opj_event_msg(cinfo, EVT_ERROR, "Invalid component/palette index for direct mapping %d.\n", pcol);
 787                                 is_sane = OPJ_FALSE;
 788                         }
 789                         else if (pcol_usage[pcol] && cmap[i].mtyp == 1) {
 790                                 opj_event_msg(cinfo, EVT_ERROR, "Component %d is mapped twice.\n", pcol);
 791                                 is_sane = OPJ_FALSE;
 792                         }
 793       else if (cmap[i].mtyp == 0 && cmap[i].pcol != 0) {
 794         /* I.5.3.5 PCOL: If the value of the MTYP field for this channel is 0, then
 795          * the value of this field shall be 0. */
 796                                 opj_event_msg(cinfo, EVT_ERROR, "Direct use at #%d however pcol=%d.\n", i, pcol);
 797                                 is_sane = OPJ_FALSE;
 798       }
 799                         else
 800                                 pcol_usage[pcol] = OPJ_TRUE;
 801                 }
 802                 /* verify that all components are targeted at least once */
 803                 for (i = 0; i < nr_channels; i++) {
 804                         if (!pcol_usage[i] && cmap[i].mtyp != 0) {
 805                                 opj_event_msg(cinfo, EVT_ERROR, "Component %d doesn't have a mapping.\n", i);
 806                                 is_sane = OPJ_FALSE;
 807                         }
 808                 }
 809                 opj_free(pcol_usage);
 810                 if (!is_sane) {
 811                         return OPJ_FALSE;
 812                 }
 813         }
 814
 815         return OPJ_TRUE;
 816 }
 817
 818 opj_image_t* opj_jp2_decode(opj_jp2_t *jp2, opj_cio_t *cio,
 819         opj_codestream_info_t *cstr_info)
 820 {
 821         opj_common_ptr cinfo;
 822         opj_image_t *image = NULL;
 823         opj_jp2_color_t color;
 824
 825         if(!jp2 || !cio)
 826    {
 827         return NULL;
 828    }
 829         memset(&color, 0, sizeof(opj_jp2_color_t));
 830         cinfo = jp2->cinfo;
 831
 832 /* JP2 decoding */
 833         if(!jp2_read_struct(jp2, cio, &color))
 834    {
 835         free_color_data(&color);
 836         opj_event_msg(cinfo, EVT_ERROR, "Failed to decode jp2 structure\n");
 837         return NULL;
 838    }
 839
 840 /* J2K decoding */
 841         image = j2k_decode(jp2->j2k, cio, cstr_info);
 842
 843         if(!image)
 844    {
 845         free_color_data(&color);
 846         opj_event_msg(cinfo, EVT_ERROR, "Failed to decode J2K image\n");
 847         return NULL;
 848    }
 849
 850     if (!jp2->ignore_pclr_cmap_cdef){
 851             if (!opj_jp2_check_color(image, &color, cinfo)) {
 852         opj_event_msg(cinfo, EVT_ERROR, "Failed to decode PCRL box\n");
 853                     return NULL;
 854             }
 855
 856     /* Set Image Color Space */
 857         if (jp2->enumcs == 16)
 858                 image->color_space = CLRSPC_SRGB;
 859         else if (jp2->enumcs == 17)
 860                 image->color_space = CLRSPC_GRAY;
 861         else if (jp2->enumcs == 18)
 862                 image->color_space = CLRSPC_SYCC;
 863         else
 864                 image->color_space = CLRSPC_UNKNOWN;
 865
 866         if(color.jp2_cdef)
 867    {
 868         jp2_apply_cdef(image, &color);
 869    }
 870         if(color.jp2_pclr)
 871    {
 872 /* Part 1, I.5.3.4: Either both or none : */
 873         if( !color.jp2_pclr->cmap)
 874          jp2_free_pclr(&color);
 875         else
 876          jp2_apply_pclr(&color, image, cinfo);
 877    }
 878         if(color.icc_profile_buf)
 879    {
 880         image->icc_profile_buf = color.icc_profile_buf;
 881         color.icc_profile_buf = NULL;
 882         image->icc_profile_len = color.icc_profile_len;
 883    }
 884    }
 885
 886         return image;
 887
 888 }/* opj_jp2_decode() */
 889
 890
 891 void jp2_write_jp2h(opj_jp2_t *jp2, opj_cio_t *cio) {
 892         opj_jp2_box_t box;
 893
 894         box.init_pos = cio_tell(cio);
 895         cio_skip(cio, 4);
 896         cio_write(cio, JP2_JP2H, 4);    /* JP2H */
 897
 898         jp2_write_ihdr(jp2, cio);
 899
 900         if (jp2->bpc == 255) {
 901                 jp2_write_bpcc(jp2, cio);
 902         }
 903         jp2_write_colr(jp2, cio);
 904
 905         box.length = cio_tell(cio) - box.init_pos;
 906         cio_seek(cio, box.init_pos);
 907         cio_write(cio, box.length, 4);  /* L */
 908         cio_seek(cio, box.init_pos + box.length);
 909 }
 910
 911 static void jp2_write_ftyp(opj_jp2_t *jp2, opj_cio_t *cio) {
 912         unsigned int i;
 913         opj_jp2_box_t box;
 914
 915         box.init_pos = cio_tell(cio);
 916         cio_skip(cio, 4);
 917         cio_write(cio, JP2_FTYP, 4);            /* FTYP */
 918
 919         cio_write(cio, jp2->brand, 4);          /* BR */
 920         cio_write(cio, jp2->minversion, 4);     /* MinV */
 921
 922         for (i = 0; i < jp2->numcl; i++) {
 923                 cio_write(cio, jp2->cl[i], 4);  /* CL */
 924         }
 925
 926         box.length = cio_tell(cio) - box.init_pos;
 927         cio_seek(cio, box.init_pos);
 928         cio_write(cio, box.length, 4);  /* L */
 929         cio_seek(cio, box.init_pos + box.length);
 930 }
 931
 932 static opj_bool jp2_read_ftyp(opj_jp2_t *jp2, opj_cio_t *cio) {
 933         int i;
 934         opj_jp2_box_t box;
 935
 936         opj_common_ptr cinfo = jp2->cinfo;
 937
 938   if( jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) {
 939     opj_event_msg(cinfo, EVT_ERROR, "Failed to read boxhdr\n");
 940     return OPJ_FALSE;
 941   }
 942         if (JP2_FTYP != box.type) {
 943                 opj_event_msg(cinfo, EVT_ERROR, "Expected FTYP Marker\n");
 944                 return OPJ_FALSE;
 945         }
 946
 947         jp2->brand = cio_read(cio, 4);          /* BR */
 948         jp2->minversion = cio_read(cio, 4);     /* MinV */
 949         jp2->numcl = (box.length - 16) / 4;
 950
 951   /* edf_c2_1673169.jp2 */
 952         if (cio_numbytesleft(cio) < ((int)jp2->numcl * 4)) {
 953                 opj_event_msg(cinfo, EVT_ERROR, "Not enough bytes in FTYP Box "
 954                                 "(expected %d, but only %d left)\n",
 955                                 ((int)jp2->numcl * 4), cio_numbytesleft(cio));
 956                 return OPJ_FALSE;
 957         }
 958         jp2->cl = (unsigned int *) opj_malloc(jp2->numcl * sizeof(unsigned int));
 959
 960         for (i = 0; i < (int)jp2->numcl; i++) {
 961                 jp2->cl[i] = cio_read(cio, 4);  /* CLi */
 962         }
 963
 964         if (cio_tell(cio) - box.init_pos != box.length) {
 965                 opj_event_msg(cinfo, EVT_ERROR, "Error with FTYP Box\n");
 966                 return OPJ_FALSE;
 967         }
 968
 969         return OPJ_TRUE;
 970 }
 971
 972 static int jp2_write_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info) {
 973         unsigned int j2k_codestream_offset, j2k_codestream_length;
 974         opj_jp2_box_t box;
 975
 976         opj_j2k_t *j2k = jp2->j2k;
 977
 978         box.init_pos = cio_tell(cio);
 979         cio_skip(cio, 4);
 980         cio_write(cio, JP2_JP2C, 4);    /* JP2C */
 981
 982         /* J2K encoding */
 983         j2k_codestream_offset = cio_tell(cio);
 984         if(!j2k_encode(j2k, cio, image, cstr_info)) {
 985                 opj_event_msg(j2k->cinfo, EVT_ERROR, "Failed to encode image\n");
 986                 return 0;
 987         }
 988         j2k_codestream_length = cio_tell(cio) - j2k_codestream_offset;
 989
 990         jp2->j2k_codestream_offset = j2k_codestream_offset;
 991         jp2->j2k_codestream_length = j2k_codestream_length;
 992
 993         box.length = 8 + jp2->j2k_codestream_length;
 994         cio_seek(cio, box.init_pos);
 995         cio_write(cio, box.length, 4);  /* L */
 996         cio_seek(cio, box.init_pos + box.length);
 997
 998         return box.length;
 999 }
1000
1001 static opj_bool jp2_read_jp2c(opj_jp2_t *jp2, opj_cio_t *cio, unsigned int *j2k_codestream_length, unsigned int *j2k_codestream_offset) {
1002         opj_jp2_box_t box;
1003
1004         opj_common_ptr cinfo = jp2->cinfo;
1005
1006   if( jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) {
1007     opj_event_msg(cinfo, EVT_ERROR, "Failed to read boxhdr\n");
1008     return OPJ_FALSE;
1009   }
1010         do {
1011                 if(JP2_JP2C != box.type) {
1012                         if (box.length <= 8) return OPJ_FALSE;
1013                         cio_skip(cio, box.length - 8);
1014                         if( jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) return OPJ_FALSE;
1015                 }
1016         } while(JP2_JP2C != box.type);
1017
1018         *j2k_codestream_offset = cio_tell(cio);
1019         if (box.length <= 8) return OPJ_FALSE;
1020         *j2k_codestream_length = box.length - 8;
1021
1022         return OPJ_TRUE;
1023 }
1024
1025 static void jp2_write_jp(opj_cio_t *cio) {
1026         opj_jp2_box_t box;
1027
1028         box.init_pos = cio_tell(cio);
1029         cio_skip(cio, 4);
1030         cio_write(cio, JP2_JP, 4);              /* JP2 signature */
1031         cio_write(cio, 0x0d0a870a, 4);
1032
1033         box.length = cio_tell(cio) - box.init_pos;
1034         cio_seek(cio, box.init_pos);
1035         cio_write(cio, box.length, 4);  /* L */
1036         cio_seek(cio, box.init_pos + box.length);
1037 }
1038
1039 static opj_bool jp2_read_jp(opj_jp2_t *jp2, opj_cio_t *cio) {
1040         opj_jp2_box_t box;
1041
1042         opj_common_ptr cinfo = jp2->cinfo;
1043
1044   if( jp2_read_boxhdr(cinfo, cio, &box) == OPJ_FALSE ) {
1045     opj_event_msg(cinfo, EVT_ERROR, "Failed to read boxhdr\n");
1046     return OPJ_FALSE;
1047   }
1048         if (JP2_JP != box.type) {
1049                 opj_event_msg(cinfo, EVT_ERROR, "Expected JP Marker\n");
1050                 return OPJ_FALSE;
1051         }
1052         if (0x0d0a870a != cio_read(cio, 4)) {
1053                 opj_event_msg(cinfo, EVT_ERROR, "Error with JP Marker\n");
1054                 return OPJ_FALSE;
1055         }
1056         if (cio_tell(cio) - box.init_pos != box.length) {
1057                 opj_event_msg(cinfo, EVT_ERROR, "Error with JP Box size\n");
1058                 return OPJ_FALSE;
1059         }
1060
1061         return OPJ_TRUE;
1062 }
1063
1064
1065 static opj_bool jp2_read_struct(opj_jp2_t *jp2, opj_cio_t *cio,
1066         opj_jp2_color_t *color) {
1067         if (!jp2_read_jp(jp2, cio))
1068                 return OPJ_FALSE;
1069         if (!jp2_read_ftyp(jp2, cio))
1070                 return OPJ_FALSE;
1071         if (!jp2_read_jp2h(jp2, cio, color))
1072                 return OPJ_FALSE;
1073         if (!jp2_read_jp2c(jp2, cio, &jp2->j2k_codestream_length, &jp2->j2k_codestream_offset))
1074                 return OPJ_FALSE;
1075
1076         return OPJ_TRUE;
1077 }
1078
1079
1080 static int write_fidx( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio)
1081 {
1082   int len, lenp;
1083
1084   lenp = cio_tell( cio);
1085   cio_skip( cio, 4);              /* L [at the end] */
1086   cio_write( cio, JPIP_FIDX, 4);  /* IPTR           */
1087
1088   write_prxy( offset_jp2c, length_jp2c, offset_idx, length_idx, cio);
1089
1090   len = cio_tell( cio)-lenp;
1091   cio_seek( cio, lenp);
1092   cio_write( cio, len, 4);        /* L              */
1093   cio_seek( cio, lenp+len);
1094
1095   return len;
1096 }
1097
1098 static void write_prxy( int offset_jp2c, int length_jp2c, int offset_idx, int length_idx, opj_cio_t *cio)
1099 {
1100   int len, lenp;
1101
1102   lenp = cio_tell( cio);
1103   cio_skip( cio, 4);              /* L [at the end] */
1104   cio_write( cio, JPIP_PRXY, 4);  /* IPTR           */
1105
1106   cio_write( cio, offset_jp2c, 8); /* OOFF           */
1107   cio_write( cio, length_jp2c, 4); /* OBH part 1     */
1108   cio_write( cio, JP2_JP2C, 4);        /* OBH part 2     */
1109
1110   cio_write( cio, 1,1);           /* NI             */
1111
1112   cio_write( cio, offset_idx, 8);  /* IOFF           */
1113   cio_write( cio, length_idx, 4);  /* IBH part 1     */
1114   cio_write( cio, JPIP_CIDX, 4);   /* IBH part 2     */
1115
1116   len = cio_tell( cio)-lenp;
1117   cio_seek( cio, lenp);
1118   cio_write( cio, len, 4);        /* L              */
1119   cio_seek( cio, lenp+len);
1120 }
1121
1122 static void write_iptr( int offset, int length, opj_cio_t *cio)
1123 {
1124   int len, lenp;
1125
1126   lenp = cio_tell( cio);
1127   cio_skip( cio, 4);              /* L [at the end] */
1128   cio_write( cio, JPIP_IPTR, 4);  /* IPTR           */
1129
1130   cio_write( cio, offset, 8);
1131   cio_write( cio, length, 8);
1132
1133   len = cio_tell( cio)-lenp;
1134   cio_seek( cio, lenp);
1135   cio_write( cio, len, 4);        /* L             */
1136   cio_seek( cio, lenp+len);
1137 }
1138
1139
1140 /* ----------------------------------------------------------------------- */
1141 /* JP2 decoder interface                                             */
1142 /* ----------------------------------------------------------------------- */
1143
1144 opj_jp2_t* jp2_create_decompress(opj_common_ptr cinfo) {
1145         opj_jp2_t *jp2 = (opj_jp2_t*) opj_calloc(1, sizeof(opj_jp2_t));
1146         if(jp2) {
1147                 jp2->cinfo = cinfo;
1148                 /* create the J2K codec */
1149                 jp2->j2k = j2k_create_decompress(cinfo);
1150                 if(jp2->j2k == NULL) {
1151                         jp2_destroy_decompress(jp2);
1152                         return NULL;
1153                 }
1154         }
1155         return jp2;
1156 }
1157
1158 void jp2_destroy_decompress(opj_jp2_t *jp2) {
1159         if(jp2) {
1160                 /* destroy the J2K codec */
1161                 j2k_destroy_decompress(jp2->j2k);
1162
1163                 if(jp2->comps) {
1164                         opj_free(jp2->comps);
1165                 }
1166                 if(jp2->cl) {
1167                         opj_free(jp2->cl);
1168                 }
1169                 opj_free(jp2);
1170         }
1171 }
1172
1173 void jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters) {
1174         /* setup the J2K codec */
1175         j2k_setup_decoder(jp2->j2k, parameters);
1176         /* further JP2 initializations go here */
1177         jp2->ignore_pclr_cmap_cdef = parameters->flags & OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG;
1178 }
1179
1180 /* ----------------------------------------------------------------------- */
1181 /* JP2 encoder interface                                             */
1182 /* ----------------------------------------------------------------------- */
1183
1184 opj_jp2_t* jp2_create_compress(opj_common_ptr cinfo) {
1185         opj_jp2_t *jp2 = (opj_jp2_t*)opj_malloc(sizeof(opj_jp2_t));
1186         if(jp2) {
1187                 memset(jp2, 0, sizeof(opj_jp2_t));
1188                 jp2->cinfo = cinfo;
1189                 /* create the J2K codec */
1190                 jp2->j2k = j2k_create_compress(cinfo);
1191                 if(jp2->j2k == NULL) {
1192                         jp2_destroy_compress(jp2);
1193                         return NULL;
1194                 }
1195         }
1196         return jp2;
1197 }
1198
1199 void jp2_destroy_compress(opj_jp2_t *jp2) {
1200         if(jp2) {
1201                 /* destroy the J2K codec */
1202                 j2k_destroy_compress(jp2->j2k);
1203
1204                 if(jp2->comps) {
1205                         opj_free(jp2->comps);
1206                 }
1207                 if(jp2->cl) {
1208                         opj_free(jp2->cl);
1209                 }
1210                 opj_free(jp2);
1211         }
1212 }
1213
1214 void jp2_setup_encoder(opj_jp2_t *jp2, opj_cparameters_t *parameters, opj_image_t *image) {
1215         int i;
1216         int depth_0, sign;
1217
1218         if(!jp2 || !parameters || !image)
1219                 return;
1220
1221         /* setup the J2K codec */
1222         /* ------------------- */
1223
1224         /* Check if number of components respects standard */
1225         if (image->numcomps < 1 || image->numcomps > 16384) {
1226                 opj_event_msg(jp2->cinfo, EVT_ERROR, "Invalid number of components specified while setting up JP2 encoder\n");
1227                 return;
1228         }
1229
1230         j2k_setup_encoder(jp2->j2k, parameters, image);
1231
1232         /* setup the JP2 codec */
1233         /* ------------------- */
1234
1235         /* Profile box */
1236
1237         jp2->brand = JP2_JP2;   /* BR */
1238         jp2->minversion = 0;    /* MinV */
1239         jp2->numcl = 1;
1240         jp2->cl = (unsigned int*) opj_malloc(jp2->numcl * sizeof(unsigned int));
1241         jp2->cl[0] = JP2_JP2;   /* CL0 : JP2 */
1242
1243         /* Image Header box */
1244
1245         jp2->numcomps = image->numcomps;        /* NC */
1246         jp2->comps = (opj_jp2_comps_t*) opj_malloc(jp2->numcomps * sizeof(opj_jp2_comps_t));
1247         jp2->h = image->y1 - image->y0;         /* HEIGHT */
1248         jp2->w = image->x1 - image->x0;         /* WIDTH */
1249         /* BPC */
1250         depth_0 = image->comps[0].prec - 1;
1251         sign = image->comps[0].sgnd;
1252         jp2->bpc = depth_0 + (sign << 7);
1253         for (i = 1; i < image->numcomps; i++) {
1254                 int depth = image->comps[i].prec - 1;
1255                 sign = image->comps[i].sgnd;
1256                 if (depth_0 != depth)
1257                         jp2->bpc = 255;
1258         }
1259         jp2->C = 7;                     /* C : Always 7 */
1260         jp2->UnkC = 0;          /* UnkC, colorspace specified in colr box */
1261         jp2->IPR = 0;           /* IPR, no intellectual property */
1262
1263         /* BitsPerComponent box */
1264
1265         for (i = 0; i < image->numcomps; i++) {
1266                 jp2->comps[i].bpcc = image->comps[i].prec - 1 + (image->comps[i].sgnd << 7);
1267         }
1268         jp2->meth = 1;
1269         if (image->color_space == 1)
1270                 jp2->enumcs = 16;       /* sRGB as defined by IEC 61966-2.1 */
1271         else if (image->color_space == 2)
1272                 jp2->enumcs = 17;       /* greyscale */
1273         else if (image->color_space == 3)
1274                 jp2->enumcs = 18;       /* YUV */
1275         jp2->precedence = 0;    /* PRECEDENCE */
1276         jp2->approx = 0;                /* APPROX */
1277
1278         jp2->jpip_on = parameters->jpip_on;
1279 }
1280
1281 opj_bool opj_jp2_encode(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info) {
1282
1283         int pos_iptr, pos_cidx, pos_jp2c, len_jp2c, len_cidx, end_pos, pos_fidx, len_fidx;
1284         pos_jp2c = pos_iptr = -1; /* remove a warning */
1285
1286         /* JP2 encoding */
1287
1288         /* JPEG 2000 Signature box */
1289         jp2_write_jp(cio);
1290         /* File Type box */
1291         jp2_write_ftyp(jp2, cio);
1292         /* JP2 Header box */
1293         jp2_write_jp2h(jp2, cio);
1294
1295         if( jp2->jpip_on){
1296           pos_iptr = cio_tell( cio);
1297           cio_skip( cio, 24); /* IPTR further ! */
1298
1299           pos_jp2c = cio_tell( cio);
1300         }
1301
1302         /* J2K encoding */
1303         if(!(len_jp2c = jp2_write_jp2c( jp2, cio, image, cstr_info))){
1304             opj_event_msg(jp2->cinfo, EVT_ERROR, "Failed to encode image\n");
1305             return OPJ_FALSE;
1306         }
1307
1308         if( jp2->jpip_on){
1309           pos_cidx = cio_tell( cio);
1310
1311           len_cidx = write_cidx( pos_jp2c+8, cio, image, *cstr_info, len_jp2c-8);
1312
1313           pos_fidx = cio_tell( cio);
1314           len_fidx = write_fidx( pos_jp2c, len_jp2c, pos_cidx, len_cidx, cio);
1315
1316           end_pos = cio_tell( cio);
1317
1318           cio_seek( cio, pos_iptr);
1319           write_iptr( pos_fidx, len_fidx, cio);
1320
1321           cio_seek( cio, end_pos);
1322         }
1323
1324         return OPJ_TRUE;
1325 }